def setup_MET_uncertainties(process, cms, options, postfix="PFlow"):
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
#runMEtUncertainties(process, doSmearJets=not options.useData, jetCollection='goodPatJetsPFlow', addToPatDefaultSequence=False)
if options.useData:
inputJetCorrLabelForMETuncertainties = 'L2L3Residual'
metSysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_data
else:
inputJetCorrLabelForMETuncertainties = 'L3Absolute'
metSysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc
process.pfMEtSysShiftCorr.parameter = metSysShiftCorrParameter
runMEtUncertainties(process,
electronCollection = cms.InputTag('cleanPatElectrons'),
muonCollection = 'cleanPatMuons',
tauCollection = 'cleanPatTaus',
jetCollection = cms.InputTag('goodPatJetsPFlow'),
jetCorrLabel = inputJetCorrLabelForMETuncertainties,
doSmearJets = not options.useData,
makeType1corrPFMEt = True,
makeType1p2corrPFMEt = True,
makePFMEtByMVA = False,
makeNoPileUpPFMEt = False,
doApplyType0corr = options.applyType0METcorrection,
sysShiftCorrParameter = metSysShiftCorrParameter,
doApplySysShiftCorr = options.applySysShiftCorrection,
addToPatDefaultSequence=False
)
def metUncertainty(process):
process.load("PhysicsTools.PatAlgos.patSequences_cff")
#process.MetSequence += process.type0PFMEtCorrection
#process.MetSequence += process.patPFMETtype0Corr
#from PhysicsTools.PatAlgos.patTemplate_cfg import *
#from PhysicsTools.PatAlgos.tools.coreTools import *
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
#from PhysicsTools.PatAlgos.tools.metTools import *
switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA=True,
doBTagging=False,
jetCorrLabel=('AK5PF',
cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute'])),
doType1MET=False,
doJetID=True,
jetIdLabel="ak5",
outputModules=[] # no PAT output module
)
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process)
def metUncertainty(process):
process.load("PhysicsTools.PatAlgos.patSequences_cff")
# process.MetSequence += process.type0PFMEtCorrection
# process.MetSequence += process.patPFMETtype0Corr
# from PhysicsTools.PatAlgos.patTemplate_cfg import *
# from PhysicsTools.PatAlgos.tools.coreTools import *
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
# from PhysicsTools.PatAlgos.tools.metTools import *
switchJetCollection(
process,
cms.InputTag("ak5PFJets"),
doJTA=True,
doBTagging=False,
jetCorrLabel=("AK5PF", cms.vstring(["L1FastJet", "L2Relative", "L3Absolute"])),
doType1MET=False,
doJetID=True,
jetIdLabel="ak5",
outputModules=[], # no PAT output module
)
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process)
def setup_MET_uncertainties(process, cms, options, postfix="PFlow"):
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
#runMEtUncertainties(process, doSmearJets=not options.useData, jetCollection='goodPatJetsPFlow', addToPatDefaultSequence=False)
if options.useData:
inputJetCorrLabelForMETuncertainties = 'L2L3Residual'
if options.centreOfMassEnergy == 8:
metSysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data
print "using pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data"
elif options.centreOfMassEnergy == 7:
metSysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2011runAplusBvsNvtx_data
print "using pfMEtSysShiftCorrParameters_2011runAplusBvsNvtx_data"
else:
inputJetCorrLabelForMETuncertainties = 'L3Absolute'
if options.centreOfMassEnergy == 8:
metSysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc
print "using pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc"
elif options.centreOfMassEnergy == 7:
metSysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2011runAplusBvsNvtx_mc
print "using pfMEtSysShiftCorrParameters_2011runAplusBvsNvtx_mc"
process.pfMEtSysShiftCorr.parameter = metSysShiftCorrParameter
runMEtUncertainties(process,
electronCollection=cms.InputTag('patElectronsPFlow'),
muonCollection='patMuonsPFlow',
tauCollection='patTausPFlow',
jetCollection=cms.InputTag('goodPatJetsPFlow'),
jetCorrLabel=inputJetCorrLabelForMETuncertainties,
doSmearJets=not options.useData,
makeType1corrPFMEt=True,
makeType1p2corrPFMEt=True,
makePFMEtByMVA=False,
makeNoPileUpPFMEt=False,
doApplyType0corr=options.applyType0METcorrection,
sysShiftCorrParameter=metSysShiftCorrParameter,
doApplySysShiftCorr=options.applySysShiftCorrection,
addToPatDefaultSequence=False)
def addInvHiggsProcess(process, iRunOnData=True, iData="PromptC2", iHLTFilter="MET", iMCSignal=False, iFile='/store/data/Run2012C/MET/AOD/PromptReco-v2/000/203/002/04BCEC26-AA02-E211-A81D-003048CF99BA.root', iMaxEvent=100):
###--------------------------------------------------------------
### Load PAT, because it insists on defining the process for you
#from PhysicsTools.PatAlgos.patTemplate_cfg import *
###--------------------------------------------------------------
###--------------------------------------------------------------
### Input
process.maxEvents.input = iMaxEvent
process.source.fileNames = [iFile]
###--------------------------------------------------------------
###--------------------------------------------------------------
### GlobalTag
if iRunOnData == True:
if (iData.find("Jul13")==0):
process.GlobalTag.globaltag = "FT_53_V6C_AN3::All"
elif (iData.find("Aug06")==0):
process.GlobalTag.globaltag = "FT_53_V6C_AN3::All"
elif (iData.find("Aug24")==0):
process.GlobalTag.globaltag = "FT53_V10A_AN3::All"
elif (iData.find("PromptC2")==0):
process.GlobalTag.globaltag = "GR_P_V42_AN3::All"
elif (iData.find("PromptD")==0):
process.GlobalTag.globaltag = "GR_P_V42_AN3::All"
elif (iData.find("Dec11")==0): #Run201191
process.GlobalTag.globaltag = "FT_P_V42C_AN3::All"
else:
process.GlobalTag.globaltag = "GR_P_V42_AN3::All"
else:
process.GlobalTag.globaltag = "START53_V7G::All"
###--------------------------------------------------------------
###--------------------------------------------------------------
### Logger
process.load("FWCore.MessageService.MessageLogger_cfi")
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport = cms.untracked.PSet(
reportEvery = cms.untracked.int32(2000),
limit = cms.untracked.int32(10000000)
)
###--------------------------------------------------------------
###--------------------------------------------------------------
### HLT Trigger(s)
# If it's MC signal, no trigger will be applied
if iRunOnData == False and iMCSignal == True:
iHLTFilter = "NoTrig"
# Load hltHighLevel
process.load('HLTrigger.HLTfilters.hltHighLevel_cfi')
process.hltHighLevel.TriggerResultsTag = cms.InputTag("TriggerResults","","HLT")
process.hltHighLevel.throw = cms.bool(False) # Tolerate if triggers not available
process.hltHighLevel.andOr = cms.bool(True) # True = OR, False = AND
if (iHLTFilter.find("MET")==0):
process.hltHighLevel.HLTPaths = cms.vstring(
"HLT_DiPFJet40_PFMETnoMu65_MJJ600VBF_LeadingJets_v*",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v*"
)
elif (iHLTFilter.find("SingleMu")==0):
process.hltHighLevel.HLTPaths = cms.vstring("HLT_IsoMu24_eta2p1_v*","HLT_Mu40_eta2p1_v*")
elif (iHLTFilter.find("DoubleMu")==0):
process.hltHighLevel.HLTPaths = cms.vstring("HLT_Mu17_Mu8_v*")
elif (iHLTFilter.find("SingleElectron")==0):
process.hltHighLevel.HLTPaths = cms.vstring("HLT_Ele27_WP80_v*")
elif (iHLTFilter.find("DoubleElectron")==0):
process.hltHighLevel.HLTPaths = cms.vstring("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v*")
elif (iHLTFilter.find("NoTrig")==0):
process.hltHighLevel.HLTPaths = cms.vstring("*")
else:
process.hltHighLevel.HLTPaths = cms.vstring(
"HLT_DiPFJet40_PFMETnoMu65_MJJ600VBF_LeadingJets_v*",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v*"
)
###--------------------------------------------------------------
###--------------------------------------------------------------
print "-----------------------------------------------"
print "INVISIBLE HIGGS: Ntuple V10"
print "-----------------------------------------------"
print "RunOnData = ", iRunOnData
if iRunOnData == True:
print "Dataset = ", iData
else:
if iMCSignal == True:
print "Dataset = MC Signal"
else:
print "Dataset = MC Background"
print "GlobalTag = ", process.GlobalTag.globaltag
print "Trigger = ", process.hltHighLevel.HLTPaths
print "Sample input file = ", iFile
print "Max events = ", iMaxEvent
print "-----------------------------------------------"
###--------------------------------------------------------------
###--------------------------------------------------------------
### Basic filters
# Track quality filter
process.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)
)
# Require a good vertex
process.primaryVertexFilter = cms.EDFilter(
"VertexSelector",
src = cms.InputTag("offlinePrimaryVertices"),
cut = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.Rho <= 2"),
filter = cms.bool(True)
)
###--------------------------------------------------------------
###--------------------------------------------------------------
### MET Filters
# The iso-based HBHE noise filter
process.load('CommonTools.RecoAlgos.HBHENoiseFilter_cfi')
# The CSC beam halo tight filter
process.load('RecoMET.METAnalyzers.CSCHaloFilter_cfi')
# The HCAL laser filter
process.load("RecoMET.METFilters.hcalLaserEventFilter_cfi")
process.load("EventFilter.HcalRawToDigi.hcallasereventfilter2012_cff")
process.hcallasereventfilter2012.eventFileName = cms.string('HCALLaser2012AllDatasets.txt.gz')
# The ECAL dead cell trigger primitive filter
process.load('RecoMET.METFilters.EcalDeadCellTriggerPrimitiveFilter_cfi')
# The EE bad SuperCrystal filter
process.load('RecoMET.METFilters.eeBadScFilter_cfi')
# The ECAL laser correction filter
process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi')
# The Good vertices collection needed by the tracking failure filter
process.goodVertices = cms.EDFilter(
"VertexSelector",
filter = cms.bool(False),
src = cms.InputTag("offlinePrimaryVertices"),
cut = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.rho < 2")
)
# The tracking failure filter
process.load('RecoMET.METFilters.trackingFailureFilter_cfi')
# The tracking POG filters
process.load('RecoMET.METFilters.trackingPOGFilters_cff')
###--------------------------------------------------------------
###--------------------------------------------------------------
### customise PAT
process.load('JetMETCorrections.Configuration.DefaultJEC_cff')
from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching,runOnData
if iRunOnData == True:
removeMCMatching(process, ['All'])
runOnData(process)
# Add the PF MET
from PhysicsTools.PatAlgos.tools.metTools import addPfMET
addPfMET(process, 'PF')
# Switch to PF jets
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
if iRunOnData == True:
switchJetCollection(process,
cms.InputTag('ak5PFJets'),
doJTA = True,
doBTagging = True,
jetCorrLabel = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']),
doType1MET = True,
doJetID = False,
jetIdLabel = "ak5"
)
else:
switchJetCollection(process,
cms.InputTag('ak5PFJets'),
doJTA = True,
doBTagging = True,
jetCorrLabel = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute']),
doType1MET = True,
genJetCollection = cms.InputTag("ak5GenJetsNoNu"),
doJetID = False,
jetIdLabel = "ak5"
)
from PhysicsTools.PatAlgos.tools.pfTools import usePFIso
usePFIso(process)
process.patMuons.isoDeposits = cms.PSet()
process.patMuons.isolationValues = cms.PSet()
process.patElectrons.isolationValues = cms.PSet(
pfChargedHadrons = cms.InputTag("elPFIsoValueCharged03PFIdPFIso"),
pfChargedAll = cms.InputTag("elPFIsoValueChargedAll03PFIdPFIso"),
pfPUChargedHadrons = cms.InputTag("elPFIsoValuePU03PFIdPFIso"),
pfNeutralHadrons = cms.InputTag("elPFIsoValueNeutral03PFIdPFIso"),
pfPhotons = cms.InputTag("elPFIsoValueGamma03PFIdPFIso")
)
process.patElectrons.isolationValuesNoPFId = cms.PSet(
pfChargedHadrons = cms.InputTag("elPFIsoValueCharged03NoPFIdPFIso"),
pfChargedAll = cms.InputTag("elPFIsoValueChargedAll03NoPFIdPFIso"),
pfPUChargedHadrons = cms.InputTag("elPFIsoValuePU03NoPFIdPFIso"),
pfNeutralHadrons = cms.InputTag("elPFIsoValueNeutral03NoPFIdPFIso"),
pfPhotons = cms.InputTag("elPFIsoValueGamma03NoPFIdPFIso")
)
process.patDefaultSequence.replace(process.patElectrons,process.eleIsoSequence+process.patElectrons)
process.cleanPatTaus.preselection = cms.string('tauID("decayModeFinding") > 0.5 & tauID("byLooseCombinedIsolationDeltaBetaCorr") > 0.5')
###--------------------------------------------------------------
###--------------------------------------------------------------
### Object (pre) selection
# Jet selection
process.selectedPatJets.cut = cms.string("pt>10. && abs(eta)<5.")
# Remove overlaps ???
# process.cleanPatJets.finalCut = "!hasOverlaps('electrons') && !hasOverlaps('muons')"
# Apply loose PF jet ID
from PhysicsTools.SelectorUtils.pfJetIDSelector_cfi import pfJetIDSelector
process.goodPatJets = cms.EDFilter("PFJetIDSelectionFunctorFilter",
filterParams = pfJetIDSelector.clone(),
src = cms.InputTag("selectedPatJets"),
filter = cms.bool(True)
)
process.selectedPatMuons.cut = cms.string("isGlobalMuon && pt>10. && abs(eta)<2.5")
process.selectedPatElectrons.cut = cms.string("pt>10. && abs(eta)<2.5")
###--------------------------------------------------------------
###--------------------------------------------------------------
### Load the PU JetID sequence
if iRunOnData == True:
process.load("CMGTools.External.pujetidsequence_cff")
process.puJetMva.jets = cms.InputTag("goodPatJets")
process.puJetId.jets = cms.InputTag("goodPatJets")
else:
process.load("CMGTools.External.pujetidsequence_cff")
process.puJetMva.jets = cms.InputTag("goodPatJets")
process.puJetId.jets = cms.InputTag("goodPatJets")
process.puJetMvaSmeared = process.puJetMva.clone()
process.puJetIdSmeared = process.puJetId.clone()
process.puJetMvaResUp = process.puJetMva.clone()
process.puJetIdResUp = process.puJetId.clone()
process.puJetMvaResDown = process.puJetMva.clone()
process.puJetIdResDown = process.puJetId.clone()
process.puJetMvaEnUp = process.puJetMva.clone()
process.puJetIdEnUp = process.puJetId.clone()
process.puJetMvaEnDown = process.puJetMva.clone()
process.puJetIdEnDown = process.puJetId.clone()
process.puJetIdSmeared.jets = cms.InputTag("smearedGoodPatJetsWithGaussian")
process.puJetMvaSmeared.jetids = cms.InputTag("puJetIdSmeared")
process.puJetMvaSmeared.jets = cms.InputTag("smearedGoodPatJetsWithGaussian")
process.puJetIdResUp.jets = cms.InputTag("smearedGoodPatJetsResUpWithGaussian")
process.puJetMvaResUp.jetids = cms.InputTag("puJetIdResUp")
process.puJetMvaResUp.jets = cms.InputTag("smearedGoodPatJetsResUpWithGaussian")
process.puJetIdResDown.jets = cms.InputTag("smearedGoodPatJetsResDownWithGaussian")
process.puJetMvaResDown.jetids = cms.InputTag("puJetIdResDown")
process.puJetMvaResDown.jets = cms.InputTag("smearedGoodPatJetsResDownWithGaussian")
process.puJetIdEnUp.jets = cms.InputTag("shiftedGoodPatJetsEnUpForCorrMEtWithGaussian")
process.puJetMvaEnUp.jetids = cms.InputTag("puJetIdEnUp")
process.puJetMvaEnUp.jets = cms.InputTag("shiftedGoodPatJetsEnUpForCorrMEtWithGaussian")
process.puJetIdEnDown.jets = cms.InputTag("shiftedGoodPatJetsEnDownForCorrMEtWithGaussian")
process.puJetMvaEnDown.jetids = cms.InputTag("puJetIdEnDown")
process.puJetMvaEnDown.jets = cms.InputTag("shiftedGoodPatJetsEnDownForCorrMEtWithGaussian")
# For jet without Gaussian smearing collection
process.puJetMvaSmearedNoGaussian = process.puJetMva.clone()
process.puJetIdSmearedNoGaussian = process.puJetId.clone()
process.puJetMvaResUpNoGaussian = process.puJetMva.clone()
process.puJetIdResUpNoGaussian = process.puJetId.clone()
process.puJetMvaResDownNoGaussian = process.puJetMva.clone()
process.puJetIdResDownNoGaussian = process.puJetId.clone()
process.puJetMvaEnUpNoGaussian = process.puJetMva.clone()
process.puJetIdEnUpNoGaussian = process.puJetId.clone()
process.puJetMvaEnDownNoGaussian = process.puJetMva.clone()
process.puJetIdEnDownNoGaussian = process.puJetId.clone()
process.puJetIdSmearedNoGaussian.jets = cms.InputTag("smearedGoodPatJetsNoGaussian")
process.puJetMvaSmearedNoGaussian.jetids = cms.InputTag("puJetIdSmearedNoGaussian")
process.puJetMvaSmearedNoGaussian.jets = cms.InputTag("smearedGoodPatJetsNoGaussian")
process.puJetIdResUpNoGaussian.jets = cms.InputTag("smearedGoodPatJetsResUpNoGaussian")
process.puJetMvaResUpNoGaussian.jetids = cms.InputTag("puJetIdResUpNoGaussian")
process.puJetMvaResUpNoGaussian.jets = cms.InputTag("smearedGoodPatJetsResUpNoGaussian")
process.puJetIdResDownNoGaussian.jets = cms.InputTag("smearedGoodPatJetsResDownNoGaussian")
process.puJetMvaResDownNoGaussian.jetids = cms.InputTag("puJetIdResDownNoGaussian")
process.puJetMvaResDownNoGaussian.jets = cms.InputTag("smearedGoodPatJetsResDownNoGaussian")
process.puJetIdEnUpNoGaussian.jets = cms.InputTag("shiftedGoodPatJetsEnUpForCorrMEtNoGaussian")
process.puJetMvaEnUpNoGaussian.jetids = cms.InputTag("puJetIdEnUpNoGaussian")
process.puJetMvaEnUpNoGaussian.jets = cms.InputTag("shiftedGoodPatJetsEnUpForCorrMEtNoGaussian")
process.puJetIdEnDownNoGaussian.jets = cms.InputTag("shiftedGoodPatJetsEnDownForCorrMEtNoGaussian")
process.puJetMvaEnDownNoGaussian.jetids = cms.InputTag("puJetIdEnDownNoGaussian")
process.puJetMvaEnDownNoGaussian.jets = cms.InputTag("shiftedGoodPatJetsEnDownForCorrMEtNoGaussian")
###--------------------------------------------------------------
###--------------------------------------------------------------
### MET
# Apply type 0 MET corrections based on PFCandidate
process.load("JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi")
process.pfType1CorrectedMet.applyType0Corrections = cms.bool(False)
process.pfType1CorrectedMet.srcType1Corrections = cms.VInputTag(
cms.InputTag('pfMETcorrType0'),
cms.InputTag('pfJetMETcorr', 'type1')
)
# Get loose ID/Iso muons and veto ID electrons
process.load("InvisibleHiggs.Ntuple.PhysicsObjectCandidates_cff")
# Get PFMET from runMEtUncertainties
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi")
if iRunOnData == True:
runMEtUncertainties(process,
electronCollection = cms.InputTag('selectVetoElectrons'),
photonCollection = '',
muonCollection = 'selectLooseMuons',
tauCollection = '',
jetCollection = cms.InputTag('goodPatJets'),
jetCorrLabel = 'L2L3Residual',
doSmearJets = False,
makeType1corrPFMEt = True,
makeType1p2corrPFMEt = False,
makePFMEtByMVA = False,
makeNoPileUpPFMEt = False,
doApplyType0corr = True,
sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_data,
doApplySysShiftCorr = False,
addToPatDefaultSequence = False,
postfix = ''
)
process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string('L2L3Residual')
process.patPFJetMETtype2Corr.jetCorrLabel = cms.string('L2L3Residual')
else:
runMEtUncertainties(process,
electronCollection = cms.InputTag('selectVetoElectrons'),
photonCollection = '',
muonCollection = 'selectLooseMuons',
tauCollection = '',
jetCollection = cms.InputTag('goodPatJets'),
jetCorrLabel = 'L3Absolute',
doSmearJets = True,
makeType1corrPFMEt = True,
makeType1p2corrPFMEt = False,
makePFMEtByMVA = False,
makeNoPileUpPFMEt = False,
doApplyType0corr = True,
sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc,
doApplySysShiftCorr = False,
addToPatDefaultSequence = False,
postfix = 'WithGaussian'
)
runMEtUncertainties(process,
electronCollection = cms.InputTag('selectVetoElectrons'),
photonCollection = '',
muonCollection = 'selectLooseMuons',
tauCollection = '',
jetCollection = cms.InputTag('goodPatJets'),
jetCorrLabel = 'L3Absolute',
doSmearJets = True,
makeType1corrPFMEt = True,
makeType1p2corrPFMEt = False,
makePFMEtByMVA = False,
makeNoPileUpPFMEt = False,
doApplyType0corr = True,
sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc,
doApplySysShiftCorr = False,
addToPatDefaultSequence = False,
postfix = 'NoGaussian'
)
# Turn off gaussian smearing
process.smearedGoodPatJetsNoGaussian.doGaussian = cms.int32(0)
process.smearedGoodPatJetsResUpNoGaussian.doGaussian = cms.int32(0)
process.smearedGoodPatJetsResDownNoGaussian.doGaussian = cms.int32(0)
# Fix Type0 correction module
process.patPFMETtype0Corr.correction.par3 = cms.double(0.909209)
process.patPFMETtype0Corr.correction.par2 = cms.double(0.0303531)
process.patPFMETtype0Corr.correction.par1 = cms.double(-0.703151)
process.patPFMETtype0Corr.correction.par0 = cms.double(0.0)
###--------------------------------------------------------------
# PAT/ntuples one step
# Z and W candidates
process.load('InvisibleHiggs/Ntuple/WCandidates_cff')
process.load('InvisibleHiggs/Ntuple/ZCandidates_cff')
# Ntuple producer
process.load('InvisibleHiggs/Ntuple/invHiggsInfo_cfi')
if iRunOnData == False:
# Jet/MET uncertainty
process.invHiggsInfo.jetTag = cms.untracked.InputTag("smearedGoodPatJetsWithGaussian")
process.invHiggsInfo.metTag = cms.untracked.InputTag("patType1CorrectedPFMetWithGaussian")
process.invHiggsInfo.puJetMvaTag = cms.untracked.InputTag("puJetMvaSmeared", "fullDiscriminant")
process.invHiggsInfo.puJetIdTag = cms.untracked.InputTag("puJetMvaSmeared", "fullId")
# PU re-weighting
process.invHiggsInfo.puMCFile = cms.untracked.string("PUHistS10.root")
process.invHiggsInfo.puDataFile = cms.untracked.string("PUHistRun2012All_forV9.root")
process.invHiggsInfo.puMCHist = cms.untracked.string("pileup")
process.invHiggsInfo.puDataHist = cms.untracked.string("pileup")
process.invHiggsInfo.mcPYTHIA = cms.untracked.bool(True)
process.invHiggsInfo.trigCorrFile = cms.untracked.string("DataMCWeight_53X_v1.root")
process.invHiggsInfo.leptCorrFile = cms.untracked.string("leptonWeights.root")
# TTree output file
process.load("CommonTools.UtilAlgos.TFileService_cfi")
process.TFileService.fileName = cms.string('invHiggsInfo_MC.root')
###--------------------------------------------------------------
###--------------------------------------------------------------
### Tau
# removeSpecificPATObjects( process, ['Taus'] )
# process.patDefaultSequence.remove( process.patTaus )
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
###--------------------------------------------------------------
###--------------------------------------------------------------
### Trigger matching
# from PhysicsTools.PatAlgos.tools.trigTools import *
# process.metTriggerMatch = cms.EDProducer(
# "PATTriggerMatcherDRLessByR" # match by DeltaR only, best match by DeltaR
# , src = cms.InputTag( 'patMETs' )
# , matched = cms.InputTag( 'patTrigger' ) # default producer label as defined in PhysicsTools/PatAlgos/python/triggerLayer1/triggerProducer_cfi.py
# , matchedCuts = cms.string( 'path( "HLT_MET100_v*" )' )
# , maxDPtRel = cms.double( 0.5 )
# , maxDeltaR = cms.double( 0.5 )
# , resolveAmbiguities = cms.bool( True ) # only one match per trigger object
# , resolveByMatchQuality = cms.bool( True ) # take best match found per reco object: by DeltaR here (s. above)
# )
# process.jetTriggerMatch = cms.EDProducer(
# "PATTriggerMatcherDRLessByR" # match by DeltaR only, best match by DeltaR
# , src = cms.InputTag( 'patJets' )
# , matched = cms.InputTag( 'patTrigger' ) # default producer label as defined in PhysicsTools/PatAlgos/python/triggerLayer1/triggerProducer_cfi.py
# , matchedCuts = cms.string( 'path( "HLT_Jet30_v*" )' )
# , maxDPtRel = cms.double( 0.5 )
# , maxDeltaR = cms.double( 0.5 )
# , resolveAmbiguities = cms.bool( True ) # only one match per trigger object
# , resolveByMatchQuality = cms.bool( True ) # take best match found per reco object: by DeltaR here (s. above)
# )
# switchOnTriggerMatchEmbedding( process, [ 'metTriggerMatch', 'jetTriggerMatch' ] )
###--------------------------------------------------------------
###--------------------------------------------------------------
### Paths
process.p0 = cms.Path( process.HBHENoiseFilter )
process.p1 = cms.Path( process.CSCTightHaloFilter )
process.p2 = cms.Path( process.hcalLaserEventFilter )
process.p3 = cms.Path( process.EcalDeadCellTriggerPrimitiveFilter )
process.p4 = cms.Path( process.eeBadScFilter )
process.p5 = cms.Path( process.ecalLaserCorrFilter )
process.p6 = cms.Path( process.goodVertices * process.trackingFailureFilter )
process.p7 = cms.Path( process.trkPOGFilters )
process.p8 = cms.Path( process.hcallLaserEvent2012Filter )
if iRunOnData == True:
process.p = cms.Path(
# Trigger filter
process.hltHighLevel *
# Basic filters
process.noscraping *
process.primaryVertexFilter *
# MET filters (Move to be flags)
# MET Correction
process.type0PFMEtCorrection *
# Tau
process.recoTauClassicHPSSequence *
# Generate PAT
process.pfParticleSelectionSequence *
process.patDefaultSequence *
process.goodPatJets *
process.PhysicsObjectSequence *
process.metUncertaintySequence *
process.puJetIdSqeuence *
process.WSequence *
process.ZSequence *
process.invHiggsInfo
)
else:
process.p = cms.Path(
# Trigger filter
process.hltHighLevel *
# Basic filters
process.noscraping *
process.primaryVertexFilter *
# MET filters (Move to be flags)
# MET Correction
process.type0PFMEtCorrection *
# Tau
process.recoTauClassicHPSSequence *
# Generate PAT
process.pfParticleSelectionSequence *
process.genParticlesForJetsNoNu *
process.ak5GenJetsNoNu *
process.patDefaultSequence *
process.goodPatJets *
process.PhysicsObjectSequence *
process.metUncertaintySequenceWithGaussian *
process.metUncertaintySequenceNoGaussian *
process.puJetIdSqeuence *
process.puJetIdSmeared *
process.puJetMvaSmeared *
process.puJetIdResUp *
process.puJetMvaResUp *
process.puJetIdResDown *
process.puJetMvaResDown *
process.puJetIdEnUp *
process.puJetMvaEnUp *
process.puJetIdEnDown *
process.puJetMvaEnDown *
process.puJetIdSmearedNoGaussian *
process.puJetMvaSmearedNoGaussian *
process.puJetIdResUpNoGaussian *
process.puJetMvaResUpNoGaussian *
process.puJetIdResDownNoGaussian *
process.puJetMvaResDownNoGaussian *
process.puJetIdEnUpNoGaussian *
process.puJetMvaEnUpNoGaussian *
process.puJetIdEnDownNoGaussian *
process.puJetMvaEnDownNoGaussian *
process.WSequence *
process.ZSequence *
process.invHiggsInfo
)
###--------------------------------------------------------------
###--------------------------------------------------------------
### Output
process.out.outputCommands += [
# trigger results
'keep edmTriggerResults_*_*_*'
,'keep *_hltTriggerSummaryAOD_*_*'
# L1
,'keep *_l1extraParticles_MET_RECO'
,'keep *_l1extraParticles_MHT_RECO'
# good jets
,'keep *_goodPatJets_*_*'
# PU jet ID
,'keep *_puJetId*_*_*'
,'keep *_puJetMva*_*_*'
# vertices
,'keep *_offlineBeamSpot_*_*'
,'keep *_offlinePrimaryVertices*_*_*'
,'keep *_goodOfflinePrimaryVertices*_*_*'
,'keep double_*_rho_*'
]
if iRunOnData == False:
process.out.outputCommands += ['keep GenEventInfoProduct_*_*_*'
,'keep recoGenParticles_*_*_*'
,'keep GenMETs_*_*_*'
,'keep *_addPileupInfo_*_*'
,'keep LHEEventProduct_*_*_*'
,'keep ak5GenJets_*_*_*'
,'keep ak5GenJetsNoNu_*_*_*'
]
process.out.fileName = 'patTuple.root'
del(process.out)
del(process.outpath)
def SingleTopStep1(
process,
):
options = VarParsing('analysis')
options.register ('isMC', True,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Run on MC"
)
options.register ('doDebug', False,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Run in debugging mode"
)
options.register ('doSkimming', True,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Preselect events"
)
options.register ('doSlimming', True,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Drop unnecessary collections"
)
options.register ('runOnFastSim', False,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"FastSim-specific processing"
)
options.register ('doSync', False,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Synchronization exercise"
)
#Tag from https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideFrontierConditions?redirectedfrom=CMS.SWGuideFrontierConditions#2012_MC_production
#Latest for "53Y Releases (MC)"
options.register ('globalTag', Config.globalTagMC,
VarParsing.multiplicity.singleton,
VarParsing.varType.string,
"Global tag"
)
options.parseArguments()
if len(options.inputFiles)==0:
options.inputFiles = cms.untracked.vstring(['/store/relval/CMSSW_5_3_6-START53_V14/RelValProdTTbar/AODSIM/v2/00000/76ED0FA6-1E2A-E211-B8F1-001A92971B72.root'])
process.source.fileNames = cms.untracked.vstring(options.inputFiles)
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(options.maxEvents)
)
process.out.fileName = cms.untracked.string(options.outputFile)
process.options = cms.untracked.PSet(wantSummary=cms.untracked.bool(options.doDebug))
if options.doDebug:
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger = cms.Service("MessageLogger",
destinations=cms.untracked.vstring('cout', 'debug'),
debugModules=cms.untracked.vstring('*'),
cout=cms.untracked.PSet(threshold=cms.untracked.string('INFO')),
debug=cms.untracked.PSet(threshold=cms.untracked.string('DEBUG')),
)
else:
process.load("FWCore.MessageService.MessageLogger_cfi")
#https://twiki.cern.ch/twiki/bin/viewauth/CMS/IntroToJEC
#https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCor2012Summer13
postfix = ""
jetCorr = ['L1FastJet', 'L2Relative', 'L3Absolute']
if not options.isMC:
jetCorr += ['L2L3Residual']
print options
usePF2PAT(process, runPF2PAT=True, jetAlgo='AK5', runOnMC=options.isMC, postfix=postfix,
jetCorrections=('AK5PFchs', jetCorr),
pvCollection=cms.InputTag('goodOfflinePrimaryVertices'),
#typeIMetCorrections = True
typeIMetCorrections = False #Type1 MET now applied later using runMETUncertainties
)
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU2012
process.pfPileUp.Enable = True
process.pfPileUp.checkClosestZVertex = False
#-------------------------------------------------
# selection step 2: vertex filter
#-------------------------------------------------
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU2012
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefEventSel#Cleaning_Filters
#process.goodOfflinePrimaryVertices = cms.EDFilter(
# "PrimaryVertexObjectFilter"
#, filterParams = cms.PSet(
# minNdof = cms.double(4.0)
# , maxZ = cms.double(24.0)
# , maxRho = cms.double(2.0)
# )
#, filter = cms.bool(True)
#, src = cms.InputTag('offlinePrimaryVertices')
#)
process.goodOfflinePrimaryVertices = cms.EDFilter("FirstVertexFilter",
src = cms.InputTag("offlinePrimaryVertices"),
cut = cms.string('!isFake & ndof >= 4. & abs(z) < 24. & position.Rho < 2.')
)
from EventFilters_cff import ApplyEventFilters
ApplyEventFilters(process, runOnFastSim=options.runOnFastSim)
#-------------------------------------------------
# Muons
#-------------------------------------------------
#process.selectedPatMuons.cut = "pt>10 && abs(eta)<3.0"
# Enable delta-beta correction for the muon isolation and set the recommended cut [1]
# [1] https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideMuonId?rev=46#Muon_Isolation
process.pfIsolatedMuons.doDeltaBetaCorrection = True
process.pfIsolatedMuons.deltaBetaFactor = -0.5
process.pfIsolatedMuons.isolationCut = 0.2
#process.pfSelectedMuons.cut = 'abs(eta)<2.5 && pt>10.'
process.pfSelectedMuons.cut = '(pt > 10.) && (abs(eta) < 2.5) && (muonRef.isAvailable) && (muonRef.isPFMuon) && (muonRef.isGlobalMuon || isTrackerMuon)'
process.patMuons.embedTrack = True
process.patMuons.usePV = False
#process.selectedPatMuons.cut = "(abs(eta) < 2.5) && (pt > 10.0) && ((chargedHadronIso+max(0.,neutralHadronIso+photonIso-0.50*puChargedHadronIso))/pt < 0.20) && (isPFMuon && (isGlobalMuon || isTrackerMu)"
# Release cuts on compatibility with the first primary vertex (similar to electrons)
process.pfMuonsFromVertex.d0Cut = 9999.
process.pfMuonsFromVertex.d0SigCut = 9999.
process.pfMuonsFromVertex.dzCut = 9999.
process.pfMuonsFromVertex.dzSigCut = 9999.
process.patMuons.pfMuonSource = cms.InputTag("pfIsolatedMuons")
process.muonMatch.src = cms.InputTag("pfIsolatedMuons")
process.muonMatchAll = process.muonMatch.clone(
src = cms.InputTag("pfMuons")
)
process.patMuonsAll = process.patMuons.clone(
pfMuonSource = cms.InputTag("pfMuons"),
genParticleMatch = cms.InputTag("muonMatchAll"),
)
process.selectedPatMuonsAll = process.selectedPatMuons.clone(
src = cms.InputTag("patMuonsAll"),
)
# muon ID production (essentially track count embedding) must be here
# because tracks get dropped from the collection after this step, resulting
# in null ptrs.
process.muonsWithID = cms.EDProducer(
'MuonIDProducer',
muonSrc = cms.InputTag("selectedPatMuons"),
primaryVertexSource = cms.InputTag("goodOfflinePrimaryVertices")
)
process.muonsWithIDAll = process.muonsWithID.clone(
muonSrc = cms.InputTag("selectedPatMuonsAll")
)
process.muonSequence = cms.Sequence()
if options.isMC:
process.muonSequence += process.muonMatchAll
process.muonSequence += (
process.patMuonsAll *
process.selectedPatMuonsAll *
process.muonsWithIDAll
)
#-------------------------------------------------
# Electrons
# Implemented as in https://indico.cern.ch/getFile.py/access?contribId=1&resId=0&materialId=slides&confId=208765
#-------------------------------------------------
#From EgammaAnalysis/ElectronTools/test/patTuple_electronId_cfg.py
process.load('EgammaAnalysis.ElectronTools.electronIdMVAProducer_cfi')
process.load('EgammaAnalysis.ElectronTools.electronIsolatorFromEffectiveArea_cfi')
process.mvaID = cms.Sequence( process.mvaTrigV0 + process.mvaTrigNoIPV0 + process.mvaNonTrigV0 )
process.patElectrons.electronIDSources = cms.PSet(
mvaTrigV0 = cms.InputTag("mvaTrigV0"),
mvaNonTrigV0 = cms.InputTag("mvaNonTrigV0"),
mvaTrigNoIPV0 = cms.InputTag("mvaTrigNoIPV0"),
)
process.patPF2PATSequence.replace(process.patElectrons, process.mvaID * process.patElectrons)
#process.selectedPatElectrons.cut = "pt>20 && abs(eta)<3.0"
process.electronsWithID = cms.EDProducer(
'ElectronIDProducer',
electronSrc = cms.InputTag("selectedPatElectrons"),
primaryVertexSource = cms.InputTag("goodOfflinePrimaryVertices")
)
process.pfElectrons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId"))
process.pfElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId"))
process.pfElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId"))
process.patElectrons.isolationValues.pfNeutralHadrons = cms.InputTag("elPFIsoValueNeutral03PFId")
process.patElectrons.isolationValues.pfChargedAll = cms.InputTag("elPFIsoValueChargedAll03PFId")
process.patElectrons.isolationValues.pfPUChargedHadrons = cms.InputTag("elPFIsoValuePU03PFId")
process.patElectrons.isolationValues.pfPhotons = cms.InputTag("elPFIsoValueGamma03PFId")
process.patElectrons.isolationValues.pfChargedHadrons = cms.InputTag("elPFIsoValueCharged03PFId")
process.pfIsolatedElectrons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId"))
process.pfIsolatedElectrons.deltaBetaIsolationValueMap = cms.InputTag('elPFIsoValueEA03')
# Define a module to produce a value map with rho correction of electron isolation. The
# configuration fragment is copied from [1] because it is not included in the current tag of
# UserCode/EGamma/EGammaAnalysisTools. General outline of configuration is inspired by [2].
# [1] http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/UserCode/EGamma/EGammaAnalysisTools/python/electronIsolatorFromEffectiveArea_cfi.py?hideattic=0&revision=1.1.2.2&view=markup
# [2] https://twiki.cern.ch/twiki/bin/viewauth/CMS/TwikiTopRefHermeticTopProjections?rev=4#Electrons
#
# In both real data and simulation an effective area derived from real data (2012 HCP dataset)
# is applied. Possible difference between data and simulation is belived to be small [3-4]
# [3] https://hypernews.cern.ch/HyperNews/CMS/get/top/1607.html
# [4] https://hypernews.cern.ch/HyperNews/CMS/get/egamma/1263/1/2/1.html
process.elPFIsoValueEA03 = cms.EDFilter('ElectronIsolatorFromEffectiveArea',
gsfElectrons = cms.InputTag('gsfElectrons'),
pfElectrons = cms.InputTag('pfSelectedElectrons'),
rhoIso = cms.InputTag('kt6PFJets', 'rho'),
EffectiveAreaType = cms.string('kEleGammaAndNeutralHadronIso03'),
EffectiveAreaTarget = cms.string('kEleEAData2012'))
process.patPF2PATSequence.replace(
process.pfIsolatedElectrons,
process.elPFIsoValueEA03 * process.pfIsolatedElectrons
)
process.pfIsolatedElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId"))
#process.pfIdentifiedElectrons = cms.EDFilter("ElectronIDPFCandidateSelector",
# recoGsfElectrons = cms.InputTag("gsfElectrons"),
# electronIdMap = cms.InputTag("mvaTrigV0"),
# electronIdCut = cms.double(0.0),
# src = cms.InputTag("pfSelectedElectrons")
#)
#process.pfSelectedElectrons.src = 'pfIdentifiedElectrons'
#process.pfSelectedElectrons.cut = 'abs(eta)<2.5 && pt>20. && gsfTrackRef.isNonnull && gsfTrackRef.trackerExpectedHitsInner.numberOfLostHits<2'
# Adjust parameters for the rho correction [1]. The cut on the isolation value is set in
# accordance with [2]
# [1] https://twiki.cern.ch/twiki/bin/viewauth/CMS/TwikiTopRefHermeticTopProjections?rev=4#Electrons
# [2] https://twiki.cern.ch/twiki/bin/view/CMS/TWikiTopRefEventSel?rev=178#Veto
process.pfIsolatedElectrons.doDeltaBetaCorrection = True
process.pfIsolatedElectrons.deltaBetaFactor = -1.
process.pfIsolatedElectrons.isolationCut = 0.15
process.patPF2PATSequence.replace(
process.pfSelectedElectrons,
process.mvaTrigV0 +
#process.pfIdentifiedElectrons +
process.pfSelectedElectrons +
process.elPFIsoValueEA03
)
process.patElectrons.isolationValues.user = cms.VInputTag(cms.InputTag("elPFIsoValueEA03"))
process.patElectrons.electronIDSources = cms.PSet( mvaTrigV0 = cms.InputTag("mvaTrigV0"))
# Release cuts on compatibility with the first primary vertex, as recommended in [1]
# [1] https://hypernews.cern.ch/HyperNews/CMS/get/egamma-elecid/72/1.html
process.pfElectronsFromVertex.d0Cut = 9999.
process.pfElectronsFromVertex.d0SigCut = 9999.
process.pfElectronsFromVertex.dzCut = 9999.
process.pfElectronsFromVertex.dzSigCut = 9999.
# Apply remaining cuts that define veto electrons as required in [1]. It is implemented via an
# additional module and not in pfSelectedElectrons, becase all the isolation maps are associated
# with the latter collection, and they will be needed also for a looser electron selection
# [1] https://twiki.cern.ch/twiki/bin/view/CMS/TWikiTopRefEventSel?rev=178#Veto
process.pfElectronsForTopProjection = process.pfSelectedElectrons.clone(
src = "pfIsolatedElectrons",
cut = "pt > 20. && abs(eta) < 2.5")
process.pfNoElectron.topCollection = 'pfElectronsForTopProjection'
process.patPF2PATSequence.replace(process.pfIsolatedElectrons,
process.pfIsolatedElectrons * process.pfElectronsForTopProjection)
#process.selectedPatElectrons.cut = "(abs(eta)<2.5) && (pt>20.) && ((chargedHadronIso + max(0.0, neutralHadronIso + photonIso - 1.0*userIsolation('User1Iso')))/pt < 0.15) && (electronID('mvaTrigV0') > 0.00)"
process.patElectronsAll = process.patElectrons.clone(
pfElectronSource=cms.InputTag("pfElectrons")
)
process.selectedPatElectronsAll = process.selectedPatElectrons.clone(
src=cms.InputTag("patElectronsAll")
)
process.electronsWithIDAll = process.electronsWithID.clone(
electronSrc = cms.InputTag("selectedPatElectronsAll")
)
process.electronSequence = cms.Sequence(
process.patElectronsAll *
process.selectedPatElectronsAll *
process.electronsWithIDAll
)
#---------------------------------------------
# Trigger matching
#---------------------------------------------
process.load('PhysicsTools.PatAlgos.triggerLayer1.triggerProducer_cfi')
process.load('PhysicsTools.PatAlgos.triggerLayer1.triggerEventProducer_cfi')
process.patTriggerSequence = cms.Sequence(
process.patTrigger *
process.patTriggerEvent
)
#-------------------------------------------------
# Jets
# MET corrections as https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMetAnalysis#Type_I_0_with_PAT
#-------------------------------------------------
#Taus are NOT removed from jets
process.pfNoTau.enable = False
# From Andrey's code
# Jet identification criteria as recommended in [1-2]. The fraction of neutral-hadron and
# HF-hadron energy is defined below differently from the formula in [2]. However, the formula
# is written for uncorrected jets, while JEC-corrected ones are used below. One can rescale the
# jet energy in the formula, but the expression below yields the same result. All accessors to
# energy fractions from PAT jets account for the effect of JEC
# [1] https://twiki.cern.ch/twiki/bin/viewauth/CMS/JetID
# [2] https://hypernews.cern.ch/HyperNews/CMS/get/JetMET/1429.html
jetQualityCut = "numberOfDaughters > 1 & (neutralHadronEnergyFraction + HFHadronEnergyFraction) < 0.99 & neutralEmEnergyFraction < 0.99 & (abs(eta) < 2.4 & chargedEmEnergyFraction < 0.99 & chargedHadronEnergyFraction > 0. & chargedMultiplicity > 0 | abs(eta) >= 2.4)"
# Apply the jet ID defined above to selected pat jets. It will be inherited by all the jet
# collections considered in the analysis, including those produced by the MET uncertainty tool.
# The latter is reasonable as we do not want to apply JEC variation, for instance, to fake jets
process.selectedPatJets.cut = jetQualityCut
process.load("CMGTools.External.pujetidsequence_cff")
process.patPF2PATSequence += process.puJetIdSqeuence
#-------------------------------------------------
# MET uncertainty step
#-------------------------------------------------
#Embed the reference to the original jet in the jets, which is constant during the propagation
process.patJetsWithOwnRef = cms.EDProducer('PatObjectOwnRefProducer<pat::Jet>',
src=cms.InputTag("selectedPatJets")
)
#Note: this module causes a large memory increase when crossing the file boundary
#Reason - unknown, solution: limit processing to ~1 file.
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
#for type 0
process.load('JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi')
if options.isMC:
corrpars = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc
else:
corrpars = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data
runMEtUncertainties(process,
electronCollection=cms.InputTag("electronsWithID"),
photonCollection=None,
muonCollection=cms.InputTag("muonsWithID"),
tauCollection="", # "" means emtpy, None means cleanPatTaus
jetCollection=cms.InputTag("patJetsWithOwnRef"),
jetCorrLabel="L3Absolute" if options.isMC else "L2L3Residual",
doSmearJets=options.isMC and not options.doSync,
#doSmearJets=False,
jetCorrPayloadName="AK5PFchs",
addToPatDefaultSequence=False,
doApplyType0corr=True,
doApplySysShiftCorr = True,
makeType1corrPFMEt = True, makeType1p2corrPFMEt = False,
sysShiftCorrParameter = corrpars
)
#process.selectedVerticesForMEtCorr.src = cms.InputTag("goodOfflinePrimaryVertices")
process.metUncertaintySequence.replace(process.patType1CorrectedPFMet,
process.type0PFMEtCorrection + process.patPFMETtype0Corr + process.pfMEtSysShiftCorrSequence + process.patType1CorrectedPFMet
)
#Switch off checking for overlaps between leptons and jets
#process.patJetsWithOwnRefNotOverlappingWithLeptonsForMEtUncertainty.checkOverlaps = cms.PSet()
#process.patJetsNotOverlappingWithLeptonsForMEtUncertainty.checkOverlaps = cms.PSet()
process.stpolMetUncertaintySequence = cms.Sequence(
process.metUncertaintySequence
)
if not options.doSlimming or options.doDebug:
process.out.outputCommands = cms.untracked.vstring('keep *')
else:
process.out.outputCommands = cms.untracked.vstring([
'drop *',
'keep edmMergeableCounter_*_*_*', # Keep the lumi-block counter information
'keep edmTriggerResults_TriggerResults__*', #Keep the trigger results
'keep *_genParticles__*', #keep all the genParticles
#'keep recoVertexs_offlinePrimaryVertices__*', #keep the offline PV-s
'keep recoVertexs_goodOfflinePrimaryVertices__*', #keep the offline PV-s
# Trigger
'keep *_patTrigger_*_*',
'keep *_patTriggerEvent_*_*',
# Jets
'keep patJets_*__*',
'keep double_*_rho_*', #For rho-corr rel iso
'keep recoGenJets_selectedPatJets_genJets_*', #For Jet MC smearing we need to keep the genJets
"keep *_puJetId_*_*", # input variables
"keep *_puJetMva_*_*", # final MVAs and working point flags
'keep *_jetClones__*',
# Muons
'keep *_muons__*', #reco muons
'keep patMuons_muonsWithID__*',
'keep patMuons_muonsWithIDAll__*',
'keep *_muonClones__*',
# Electrons
'keep patElectrons_electronsWithID__*',
'keep patElectrons_electronsWithIDAll__*',
'keep *_electronClones__*',
# METs
'keep patMETs_*__*',
#ECAL laser corr filter
'keep bool_ecalLaserCorrFilter__*',
#For flavour analyzer
'keep GenEventInfoProduct_generator__*',
#PU info
'keep PileupSummaryInfos_addPileupInfo__*',
##PFCandidates
#'keep recoPFCandidates_*_pfCandidates_PAT',
#'keep recoPFMETs_pfMET__*',
#'keep recoPFMETs_pfMet__*',
#'keep recoGenMETs_genMetTrue__*',
#'keep recoPFCandidates_particleFlow__*',
#'keep recoConversions_allConversions__*',
#'keep recoVertexCompositeCandidates_generalV0Candidates_*_*',
#'keep recoTracks_generalTracks__*',
#'keep recoBeamSpot_offlineBeamSpot__*',
#'keep recoMuons_muons__*',
'keep int_*__PAT',
'keep ints_*__PAT',
'keep double_*__PAT',
'keep doubles_*__PAT',
'keep float_*__PAT',
'keep floats_*__PAT',
])
process.out.SelectEvents = cms.untracked.PSet(
SelectEvents = cms.vstring(
["singleTopPathStep1Mu", "singleTopPathStep1Ele"] if options.doSkimming else ["*"]
)
)
#-------------------------------------------------
# Paths
#-------------------------------------------------
process.goodOfflinePVCount = cms.EDProducer(
"CollectionSizeProducer<reco::Vertex>",
src = cms.InputTag("goodOfflinePrimaryVertices")
)
process.preCalcSequences = cms.Sequence(
process.patJetsWithOwnRef *
process.goodOfflinePVCount
)
process.patPF2PATSequence.insert(process.patPF2PATSequence.index(process.selectedPatMuons) + 1, process.muonsWithID)
process.patPF2PATSequence.insert(process.patPF2PATSequence.index(process.selectedPatElectrons) + 1, process.electronsWithID)
#Need separate paths because of skimming
process.singleTopSequence = cms.Sequence(
process.goodOfflinePrimaryVertices
* process.eventFiltersSequence
* process.patPF2PATSequence
)
process.GlobalTag.globaltag = cms.string(options.globalTag)
process.singleTopSequence += process.preCalcSequences
process.singleTopSequence += process.stpolMetUncertaintySequence
process.singleTopSequence += process.patTriggerSequence
process.singleTopSequence += process.muonSequence
process.singleTopSequence += process.electronSequence
if options.isMC:
#https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration?redirectedfrom=CMS.SWGuideBTagJetProbabilityCalibration#Calibration_in_53x_Data_and_MC
process.GlobalTag.toGet = cms.VPSet(
cms.PSet(record = cms.string("BTagTrackProbability2DRcd"),
tag = cms.string("TrackProbabilityCalibration_2D_MC53X_v2"),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")),
cms.PSet(record = cms.string("BTagTrackProbability3DRcd"),
tag = cms.string("TrackProbabilityCalibration_3D_MC53X_v2"),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU"))
)
else:
#https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration?redirectedfrom=CMS.SWGuideBTagJetProbabilityCalibration#Calibration_in_53x_Data_and_MC
process.GlobalTag.toGet = cms.VPSet(
cms.PSet(record = cms.string("BTagTrackProbability2DRcd"),
tag = cms.string("TrackProbabilityCalibration_2D_Data53X_v2"),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")),
cms.PSet(record = cms.string("BTagTrackProbability3DRcd"),
tag = cms.string("TrackProbabilityCalibration_3D_Data53X_v2"),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU"))
)
#Filters added by a separate method
#process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi')
#process.ecalLaserCorrFilter.taggingMode=True
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefEventSel#Cleaning_Filters
#process.scrapingFilter = 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.singleTopSequence += process.scrapingFilter
#process.singleTopSequence += process.ecalLaserCorrFilter
if options.doSkimming:
process.out.fileName.setValue(process.out.fileName.value().replace(".root", "_Skim.root"))
else:
process.out.fileName.setValue(process.out.fileName.value().replace(".root", "_noSkim.root"))
process.singleTopPathStep1Mu = cms.Path(process.singleTopSequence)
process.singleTopPathStep1Ele = cms.Path(process.singleTopSequence)
#process.chsalgos[0].tmvaWeights = cms.string('CMGTools/External/data/TMVAClassificationCategory_JetID_53X_chs_Dec2012.weights.xml')
#process.chsalgos_5x[0].tmvaWeights = cms.string('CMGTools/External/data/TMVAClassificationCategory_JetID_53X_chs_Dec2012.weights.xml')
#-----------------------------------------------
# Skimming
#-----------------------------------------------
#Throw away events before particle flow?
if options.doSkimming:
from SingleTopPolarization.Analysis.eventSkimming_cfg import skimFilters
skimFilters(process)
process.singleTopPathStep1Mu.insert(0, process.muonSkim)
process.singleTopPathStep1Ele.insert(0, process.electronSkim)
#-----------------------------------------------
# Skim efficiency counters
#-----------------------------------------------
#count all processed events
countProcessed(process)
#count events passing mu and ele paths
countInSequence(process, process.singleTopPathStep1Mu)
countInSequence(process, process.singleTopPathStep1Ele)
if not options.doSlimming:
process.out.fileName.setValue(process.out.fileName.value().replace(".root", "_noSlim.root"))
return process
# #
# EXERCISE 3.2 #
# #
#################
## Geometry and Detector Conditions (needed for a Scaling up and down the JEC)
process.load("Configuration.StandardSequences.GeometryDB_cff")
process.load(
"Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
from Configuration.AlCa.autoCond import autoCond
process.GlobalTag.globaltag = cms.string(autoCond['startup'])
process.load("Configuration.StandardSequences.MagneticField_cff")
# load the standard PAT config
process.load("PhysicsTools.PatAlgos.patSequences_cff")
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process)
#process.shiftedPatJets=process.shiftedPatJetsEnUp.clone(src = cms.InputTag("cleanPatJets"),shiftBy=cms.double(1))
#process.jecAnalyzerEnUp=process.jecAnalyzer.clone(Jets = cms.InputTag("shiftedPatJets"))
#process.p.replace(process.jecAnalyzer, process.shiftedPatJets * process.jecAnalyzerEnUp)
#################
# #
# EXERCISE 3.3 #
# #
#################
#process.btagAnalyzer = cms.EDAnalyzer("WrappedEDAnalysisTasksAnalyzerBTag",
# Jets = cms.InputTag("cleanPatJets"),
# bTagAlgo=cms.string('trackCountingHighEffBJetTags'),
#for type 0
process.load('JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi')
if options.isMC:
corrpars = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc
else:
corrpars = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data
runMEtUncertainties(process,
electronCollection=cms.InputTag("electronsWithID"),
photonCollection=None,
muonCollection=cms.InputTag("muonsWithID"),
tauCollection="", # "" means emtpy, None means cleanPatTaus
jetCollection=cms.InputTag("patJetsWithOwnRef"),
jetCorrLabel="L3Absolute" if options.isMC else "L2L3Residual",
doSmearJets=options.isMC and not options.doSync,
#doSmearJets=False,
jetCorrPayloadName="AK5PFchs",
addToPatDefaultSequence=False,
doApplyType0corr=True,
doApplySysShiftCorr = True,
makeType1corrPFMEt = True, makeType1p2corrPFMEt = False,
sysShiftCorrParameter = corrpars
)
#from tth
###
###
###
#process.patPFMetNoPU = process.patMETs.clone(
# metSource = cms.InputTag("pfMETNoPU"),
# addMuonCorrections = cms.bool(False),
switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA = True,
doBTagging = True,
jetCorrLabel = _jetCorrections,
doType1MET = False,
doJetID = True,
jetIdLabel = "ak5"
)
# apply type I/type I + II PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process,doApplyType0corr=False,tauCollection=None)
#runMEtUncertainties(process,doApplyType0corr=False)
process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff")
from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfType1CorrectedMet
process.pfMETType0 = pfType1CorrectedMet.clone()
process.pfMETType0.applyType1Corrections = cms.bool(True)
process.pfMETType0.applyType0Corrections = cms.bool(True)
if IsPythiaShowered:
filtersequence = cms.Sequence( process.totalKinematicsFilter )
else:
filtersequence = cms.Sequence()
#----------------------------------------------------------------------------------------------------
# Use the runMetUncertainties tool here
# See https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuidePATTools#MET_Systematics_Tools
#----------------------------------------------------------------------------------------------------
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(
process,
jetCollection=cms.InputTag('analysisPatJetsAK5PF'),
doApplySysShiftCorr=True, # Apply correction for systematic x/y shift in MET
doApplyType0corr=True, # Apply correction for pileup
makeType1corrPFMEt=True, # Apply correction for jet energy scale
makeType1p2corrPFMEt=
False, # DO NOT apply correction for unclustered energy (degrades MET resolution)
makePFMEtByMVA=False, # We don't use MVA PFMET
doSmearJets=True, # Very important to smear the pfjets (MC ONLY)
addToPatDefaultSequence=True, # Add this to the PAT sequence
electronCollection=cms.InputTag('analysisPatElectrons'),
tauCollection=cms.InputTag('analysisPatTaus'),
muonCollection=cms.InputTag('analysisPatMuons'),
sysShiftCorrParameter=process.
pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc)
#----------------------------------------------------------------------------------------------------
# Available pat::MET collections for analysis
# - process.patMETsTC : raw TCMET (NO jet smearing)
#
# - process.patMETsRawCalo : raw CaloMET (NO jet smearing)
# - process.patMETs : Type1 CaloMET (NO jet smearing)
#
skipRawJetPtThreshold = cms.double(10.), # GeV
skipCorrJetPtThreshold = cms.double(1.e-2),
srcGenJets = cms.InputTag('ak5GenJetsNoNu')
)
runMEtUncertainties(process,
electronCollection = cms.InputTag('selectedPatElectrons'),
photonCollection = '',
muonCollection = cms.InputTag('selectedPatMuons'),
tauCollection = cms.InputTag('selectedPatTaus'),
jetCollection = cms.InputTag('patJets'),
jetCorrLabel = "L3Absolute",
doSmearJets = True,
makeType1corrPFMEt = True,
makeType1p2corrPFMEt = True,
makePFMEtByMVA = True,
makeNoPileUpPFMEt = False,
doApplyType0corr = False
)
##################################################
# Let it run
###################################################
process.p = cms.Path( process.VertexPresent+
# ------------------------------------------------------------------------------
# apply type I/type I + II PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
if doMetUnc:
#process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(
process,
postfix="MetUnc",
jetCollection="selectedPatJetsAK5PF",
jetCorrLabel=patJetCorrLabel,
doSmearJets=True,
makeType1corrPFMEt=True,
makeType1p2corrPFMEt=True,
makePFMEtByMVA=False,
makeNoPileUpPFMEt=False,
doApplyType0corr=False,
sysShiftCorrParameter=sysShiftCorrParam,
doApplySysShiftCorr=False,
pfCandCollection='particleFlow',
jetCorrPayloadName='AK5PF',
outputModule='',
)
process.out.outputCommands += [
'drop *_*MetUnc_*_*',
'keep selectedPatMETs_patType1CorrectedPFMet*MetUnc_*_*'
]
# ------------------------------------------------------------------------------
# MET Filters
def miniAOD_customizeCommon(process):
process.patMuons.isoDeposits = cms.PSet()
process.patElectrons.isoDeposits = cms.PSet()
process.patTaus.isoDeposits = cms.PSet()
process.patPhotons.isoDeposits = cms.PSet()
#
process.patMuons.embedTrack = True # used for IDs
process.patMuons.embedCombinedMuon = True # used for IDs
process.patMuons.embedMuonBestTrack = True # used for IDs
process.patMuons.embedStandAloneMuon = True # maybe?
process.patMuons.embedPickyMuon = False # no, use best track
process.patMuons.embedTpfmsMuon = False # no, use best track
process.patMuons.embedDytMuon = False # no, use best track
#
# disable embedding of electron and photon associated objects already stored by the ReducedEGProducer
process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core
process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster
process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters
process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters
process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters
process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters
process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer
process.patElectrons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.patElectrons.electronIDSources = cms.PSet(
# configure many IDs as InputTag <someName> = <someTag> you
# can comment out those you don't want to save some disk space
eidRobustLoose = cms.InputTag("reducedEgamma","eidRobustLoose"),
eidRobustTight = cms.InputTag("reducedEgamma","eidRobustTight"),
eidLoose = cms.InputTag("reducedEgamma","eidLoose"),
eidTight = cms.InputTag("reducedEgamma","eidTight"),
eidRobustHighEnergy = cms.InputTag("reducedEgamma","eidRobustHighEnergy"),
)
process.elPFIsoDepositCharged.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositChargedAll.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositNeutral.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositGamma.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositPU.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
#
process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster
process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster
process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters
process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters
process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer
process.patPhotons.photonSource = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.patPhotons.photonIDSources = cms.PSet(
PhotonCutBasedIDLoose = cms.InputTag('reducedEgamma',
'PhotonCutBasedIDLoose'),
PhotonCutBasedIDTight = cms.InputTag('reducedEgamma',
'PhotonCutBasedIDTight')
)
process.phPFIsoDepositCharged.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositChargedAll.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositNeutral.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositGamma.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositPU.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
#
process.selectedPatJets.cut = cms.string("pt > 10")
process.selectedPatMuons.cut = cms.string("pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))")
process.selectedPatElectrons.cut = cms.string("")
process.selectedPatTaus.cut = cms.string("pt > 18. && tauID('decayModeFinding')> 0.5")
process.selectedPatPhotons.cut = cms.string("")
#
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
#switch to AK4 for CSA14/70X release (should be default in 71X)
switchJetCollection(process, jetSource = cms.InputTag('ak4PFJetsCHS'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), ''),
btagDiscriminators = ['jetBProbabilityBJetTags', 'jetProbabilityBJetTags', 'trackCountingHighPurBJetTags', 'trackCountingHighEffBJetTags', 'simpleSecondaryVertexHighEffBJetTags',
'simpleSecondaryVertexHighPurBJetTags', 'combinedSecondaryVertexBJetTags' , 'combinedInclusiveSecondaryVertexBJetTags' ],
)
#add CA8
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
addJetCollection(process, labelName = 'AK8', jetSource = cms.InputTag('ak8PFJetsCHS'),algo= 'AK', rParam = 0.8, jetCorrections = ('AK7PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None') )
process.patJetsAK8.userData.userFloats.src = [] # start with empty list of user floats
process.selectedPatJetsAK8.cut = cms.string("pt > 100")
process.patJetGenJetMatchAK8.matched = 'slimmedGenJets'
## AK8 groomed masses
from RecoJets.Configuration.RecoPFJets_cff import ak8PFJetsCHSPruned, ak8PFJetsCHSFiltered, ak8PFJetsCHSTrimmed
process.ak8PFJetsCHSPruned = ak8PFJetsCHSPruned.clone()
process.ak8PFJetsCHSTrimmed = ak8PFJetsCHSTrimmed.clone()
process.ak8PFJetsCHSFiltered = ak8PFJetsCHSFiltered.clone()
process.load("RecoJets.JetProducers.ak8PFJetsCHS_groomingValueMaps_cfi")
process.patJetsAK8.userData.userFloats.src += ['ak8PFJetsCHSPrunedLinks','ak8PFJetsCHSTrimmedLinks','ak8PFJetsCHSFilteredLinks']
### CA8 groomed masses (for the matched jet): doesn't seem to work, it produces tons of warnings "Matched jets separated by dR greater than distMax=0.8"
# from RecoJets.Configuration.RecoPFJets_cff import ca8PFJetsCHSFiltered, ca8PFJetsCHSTrimmed # ca8PFJetsCHSPruned is already in AOD
# process.ca8PFJetsCHSTrimmed = ca8PFJetsCHSTrimmed.clone()
# process.ca8PFJetsCHSFiltered = ca8PFJetsCHSFiltered.clone()
# process.load("RecoJets.JetProducers.ca8PFJetsCHS_groomingValueMaps_cfi")
# process.ca8PFJetsCHSPrunedLinks.src = cms.InputTag("ak8PFJetsCHS")
# process.ca8PFJetsCHSTrimmedLinks.src = cms.InputTag("ak8PFJetsCHS")
# process.ca8PFJetsCHSFilteredLinks.src = cms.InputTag("ak8PFJetsCHS")
# process.patJetsAK8.userData.userFloats.src += ['ca8PFJetsCHSPrunedLinks','ca8PFJetsCHSTrimmedLinks','ca8PFJetsCHSFilteredLinks']
## cmsTopTagger (note: it is already run in RECO, we just add the value)
process.cmsTopTagPFJetsCHSLinksAK8 = process.ak8PFJetsCHSPrunedLinks.clone()
process.cmsTopTagPFJetsCHSLinksAK8.src = cms.InputTag("ak8PFJetsCHS")
process.cmsTopTagPFJetsCHSLinksAK8.matched = cms.InputTag("cmsTopTagPFJetsCHS")
process.patJetsAK8.userData.userFloats.src += ['cmsTopTagPFJetsCHSLinksAK8']
#
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone
switchOnTriggerStandAlone( process, outputModule = '' )
process.patTrigger.packTriggerPathNames = cms.bool(True)
#
# apply type I/type I + II PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
addJetCollection(process, postfix = "ForMetUnc", labelName = 'AK5PF', jetSource = cms.InputTag('ak5PFJets'), jetCorrections = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute'], ''))
runMEtUncertainties(process,jetCollection="selectedPatJetsAK5PFForMetUnc", outputModule=None)
#keep this after all addJetCollections otherwise it will attempt computing them also for stuf with no taginfos
#Some useful BTAG vars
process.patJets.userData.userFunctions = cms.vstring(
'?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().secondaryVertex(0).p4.M):(0)',
'?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().secondaryVertex(0).nTracks):(0)',
'?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().flightDistance(0).value):(0)',
'?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().flightDistance(0).significance):(0)',
)
process.patJets.userData.userFunctionLabels = cms.vstring('vtxMass','vtxNtracks','vtx3DVal','vtx3DSig')
process.patJets.tagInfoSources = cms.VInputTag(cms.InputTag("secondaryVertexTagInfos"))
process.patJets.addTagInfos = cms.bool(True)
#
## PU JetID
process.load("PhysicsTools.PatAlgos.slimming.pileupJetId_cfi")
process.patJets.userData.userFloats.src = [ cms.InputTag("pileupJetId:fullDiscriminant"), ]
### Importing skeleton ###
import sys
import os.path
sys.path.append(os.path.abspath(os.path.expandvars(os.path.join('$CMSSW_BASE','src/PhysicsTools/PatExamples/test/'))))
from analyzePatAnalysisTasks_exercise_6c_skeleton_cfg import *
#########################
process.jecAnalyzer = cms.EDAnalyzer("WrappedEDAnalysisTasksAnalyzerJEC",
Jets = cms.InputTag("cleanPatJets"),
jecLevel=cms.string("L3Absolut"),
patJetCorrFactors= cms.string('CorrFactors'),
help=cms.bool(False),
outputFileName=cms.string("jecAnalyzerOutput")
)
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process,electronCollection="selectedPatElectrons",photonCollection=None,muonCollection="selectedPatMuons",tauCollection="selectedPatTaus",jetCollection="selectedPatJets")
process.jecAnalyzerEnUp=process.jecAnalyzer.clone(Jets = cms.InputTag("shiftedPatJetsEnDownForCorrMEt"))
process.p += process.metUncertaintySequence
process.p += process.jecAnalyzerEnUp
from PhysicsTools.PatAlgos.tools.metTools import *
addTcMET(process, 'TC')
addPfMET(process, 'PF')
process.patMETsPF.metSource = cms.InputTag("pfMet")
process.patPFMETsTypeIcorrected = process.patMETs.clone(
metSource=cms.InputTag('pfType1CorrectedMet'),
addMuonCorrections=cms.bool(False),
genMETSource=cms.InputTag('genMetTrue'),
addGenMET=cms.bool(False))
process.metAnalysisSequence = cms.Sequence(process.patPFMETsTypeIcorrected)
# apply type I/type I + II PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process, doApplyType0corr=True, doSmearJets=True)
process.smearedPFType1CorrectedMet = process.patMETs.clone(
metSource=cms.InputTag('patType1CorrectedPFMet'),
addMuonCorrections=cms.bool(False),
genMETSource=cms.InputTag('genMetTrue'),
addGenMET=cms.bool(False))
process.metAnalysisSequence += process.smearedPFType1CorrectedMet
process.cleanPatPhotons.checkOverlaps.electrons.requireNoOverlaps = cms.bool(
False)
from CommonTools.ParticleFlow.Tools.pfIsolation import setupPFElectronIso, setupPFPhotonIso
process.eleIsoSequence = setupPFElectronIso(process, 'gsfElectrons')
process.phoIsoSequence = setupPFPhotonIso(process, 'photons')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff'
)
process.GlobalTag.globaltag = 'START53_V7F::All'
from Configuration.AlCa.autoCond import autoCond
process.GlobalTag.globaltag = cms.string(autoCond['startup'])
process.load('Configuration.StandardSequences.MagneticField_cff')
process.load('Configuration.Geometry.GeometryIdeal_cff')
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(
process,
electronCollection=cms.InputTag('electronsWithID'),
#electronCollection=cms.InputTag('selectedPatElectrons'),
photonCollection='',
muonCollection=cms.InputTag('muonsWithID'),
#muonCollection=cms.InputTag('selectedPatMuons'),
tauCollection='',
jetCollection=cms.InputTag('selectedPatJets'),
addToPatDefaultSequence=False,
)
process.simpleAnalyzer = cms.EDAnalyzer('SimpleEventAnalyzer',
interestingCollections=cms.untracked.VInputTag([
'smearedPatJets',
'smearedPatJetsResUp',
'smearedPatJetsResDown',
'muonsWithID',
'shiftedMuonsWithIDenDown',
'shiftedMuonsWithIDenUp',
'electronsWithID',
def setupPatMets(process, runOnMC, makeNoPUMet):
process.preMetSequence = cms.Sequence()
##Filters
process.load("RecoMET.METFilters.metFilters_cff")
process.preMetSequence += process.metFilters
##Corrections
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
#Type 0 Corrections
process.patPFMETtype0Corr.src = cms.InputTag('goodPV')
#Type 1 correction
process.patPFJetMETtype1p2Corr.skipEM = cms.bool(False)
process.patPFJetMETtype1p2Corr.skipMuons = cms.bool(False)
#SysShift correction to turn the MET flat(ter) with respect to Phi
process.load("UserCode.zbb_louvain.PATconfig.METphiCorrections_cfi")
process.selectedVerticesForMEtCorr.src = cms.InputTag('goodPV')
if runOnMC:
process.PFMETSysShiftCorr = process.pfMEtSysShiftCorr.clone(
parameter=process.
NewPFMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc, )
process.MVAMETNURSysShiftCorr = process.pfMEtSysShiftCorr.clone(
parameter=process.
NewMVAMEtNURSysShiftCorrParameters_2012runABCDvsNvtx_mc,
src=cms.InputTag(
'pfMEtMVA'
) # I think this is not mandatory for Nvtx based correction but to be safe...
)
process.MVAMETURSysShiftCorr = process.pfMEtSysShiftCorr.clone(
parameter=process.
NewMVAMEtURSysShiftCorrParameters_2012runABCDvsNvtx_mc,
src=cms.InputTag('pfMEtMVA'))
process.NoPUMETSysShiftCorr = process.pfMEtSysShiftCorr.clone(
parameter=process.
NewNoPUMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc,
src=cms.InputTag('noPileUpPFMEt'))
else:
process.PFMETSysShiftCorr = process.pfMEtSysShiftCorr.clone(
parameter=process.
NewPFMEtSysShiftCorrParameters_2012runABCDvsNvtx_data, )
process.MVAMETNURSysShiftCorr = process.pfMEtSysShiftCorr.clone(
parameter=process.
NewMVAMEtNURSysShiftCorrParameters_2012runABCDvsNvtx_data,
src=cms.InputTag('pfMEtMVA'))
process.MVAMETURSysShiftCorr = process.pfMEtSysShiftCorr.clone(
parameter=process.
NewMVAMEtURSysShiftCorrParameters_2012runABCDvsNvtx_data,
src=cms.InputTag('pfMEtMVA'))
process.NoPUMETSysShiftCorr = process.pfMEtSysShiftCorr.clone(
parameter=process.
NewNoPUMEtSysShiftCorrParameters_2012runABCDvsNvtx_data,
src=cms.InputTag('noPileUpPFMEt'))
#MVA MET !!! Based on AK5PFJets and not on AK5PFchsJets (the same holds for noPUMET)
process.load("RecoMET.METPUSubtraction.mvaPFMET_cff")
process.pfMEtMVA.srcVertices = cms.InputTag('goodPV')
process.pfMEtMVA.srcLeptons = cms.VInputTag("tightMuons", "tightElectrons")
#noPUMET
if makeNoPUMet:
process.load("RecoMET.METPUSubtraction.noPileUpPFMET_cff")
process.noPileUpPFMEt.srcLeptons = cms.VInputTag(
"tightMuons", "tightElectrons")
if not runOnMC:
process.calibratedAK5PFJetsForNoPileUpPFMEt.correctors = cms.vstring(
"ak5PFL1FastL2L3")
##Uncertainties
if runOnMC:
runMEtUncertainties(
process,
makeType1p2corrPFMEt=False,
doApplyType0corr=True,
jetCorrLabel="L3Absolute",
sysShiftCorrParameter=process.
pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc, #old phi correction for PFMET
doApplySysShiftCorr=True,
jetCorrPayloadName='AK5PFchs',
makePFMEtByMVA=True,
makeNoPileUpPFMEt=makeNoPUMet,
addToPatDefaultSequence=False,
postfix='')
else:
process.patPFMet.addGenMET = cms.bool(False)
process.calibratedAK5PFJetsForPFMEtMVA.correctors = cms.vstring(
"ak5PFL1FastL2L3Residual")
runMEtUncertainties(process,
makeType1p2corrPFMEt=False,
doApplyType0corr=True,
jetCorrLabel="L2L3Residual",
sysShiftCorrParameter=process.
pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data,
doApplySysShiftCorr=True,
jetCorrPayloadName='AK5PFchs',
makePFMEtByMVA=True,
makeNoPileUpPFMEt=makeNoPUMet,
addToPatDefaultSequence=False,
doSmearJets=False,
postfix='')
process.metUncertaintySequence.replace(
process.patType1CorrectedPFMet,
cms.Sequence(process.type0PFMEtCorrection * process.patPFMETtype0Corr *
process.patType1CorrectedPFMet))
process.pfCandsNotInJet.topCollection = cms.InputTag("pfNoTau")
#Add Met with different corrections
process.patType01SCorrectedPFMet = process.patType1CorrectedPFMet.clone(
srcType1Corrections=cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2Corr', 'type1'),
cms.InputTag('patPFMETtype0Corr'),
cms.InputTag('PFMETSysShiftCorr')), )
process.patType01CorrectedPFMet = cms.EDProducer(
"CorrectedPATMETProducer",
src=cms.InputTag('patPFMet'),
applyType1Corrections=cms.bool(True),
srcType1Corrections=cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2Corr', 'type1'),
cms.InputTag('patPFMETtype0Corr')),
applyType2Corrections=cms.bool(False))
process.patTypeOnly1CorrectedPFMet = cms.EDProducer(
"CorrectedPATMETProducer",
src=cms.InputTag('patPFMet'),
applyType1Corrections=cms.bool(True),
srcType1Corrections=cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2Corr', 'type1'), ),
applyType2Corrections=cms.bool(False))
process.patType0CorrectedPFMet = cms.EDProducer(
"CorrectedPATMETProducer",
src=cms.InputTag('patPFMet'),
applyType1Corrections=cms.bool(True),
srcType1Corrections=cms.VInputTag(cms.InputTag('patPFMETtype0Corr')),
applyType2Corrections=cms.bool(False))
process.patTypeSysCorrectedPFMet = cms.EDProducer(
"CorrectedPATMETProducer",
src=cms.InputTag('patPFMet'),
applyType1Corrections=cms.bool(True),
srcType1Corrections=cms.VInputTag(cms.InputTag('PFMETSysShiftCorr')),
applyType2Corrections=cms.bool(False))
process.patType0sysCorrectedPFMet = cms.EDProducer(
"CorrectedPATMETProducer",
src=cms.InputTag('patPFMet'),
applyType1Corrections=cms.bool(True),
srcType1Corrections=cms.VInputTag(cms.InputTag('patPFMETtype0Corr'),
cms.InputTag('PFMETSysShiftCorr')),
applyType2Corrections=cms.bool(False))
process.patType1sysCorrectedPFMet = cms.EDProducer(
"CorrectedPATMETProducer",
src=cms.InputTag('patPFMet'),
applyType1Corrections=cms.bool(True),
srcType1Corrections=cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2Corr', 'type1'),
cms.InputTag('PFMETSysShiftCorr')),
applyType2Corrections=cms.bool(False))
process.patMVAMETNURphiCorrected = cms.EDProducer(
"CorrectedPATMETProducer",
src=cms.InputTag('patPFMetMVA'),
applyType1Corrections=cms.bool(True),
srcType1Corrections=cms.VInputTag(
cms.InputTag('MVAMETNURSysShiftCorr')),
applyType2Corrections=cms.bool(False))
process.patMVAMETURphiCorrected = cms.EDProducer(
"CorrectedPATMETProducer",
src=cms.InputTag('patPFMetMVA'),
applyType1Corrections=cms.bool(True),
srcType1Corrections=cms.VInputTag(
cms.InputTag('MVAMETURSysShiftCorr')),
applyType2Corrections=cms.bool(False))
process.patNoPUMETphiCorrected = cms.EDProducer(
"CorrectedPATMETProducer",
src=cms.InputTag('patPFMetNoPileUp'),
applyType1Corrections=cms.bool(True),
srcType1Corrections=cms.VInputTag(cms.InputTag('NoPUMETSysShiftCorr')),
applyType2Corrections=cms.bool(False))
process.metUncertaintySequence += cms.Sequence(
process.PFMETSysShiftCorr + process.MVAMETNURSysShiftCorr +
process.MVAMETURSysShiftCorr + process.NoPUMETSysShiftCorr +
process.patType01SCorrectedPFMet + process.patTypeOnly1CorrectedPFMet +
process.patType0CorrectedPFMet + process.patTypeSysCorrectedPFMet +
process.patType01CorrectedPFMet + process.patType1sysCorrectedPFMet +
process.patType0sysCorrectedPFMet + process.patMVAMETNURphiCorrected +
process.patMVAMETURphiCorrected + process.patMVAMETURphiCorrected +
process.patNoPUMETphiCorrected)
#clean metUncertaintySequence
print ""
print "These modules will be removed from the metUncertaintySequence as already produced before:"
for name in process.patDefaultSequence.moduleNames():
if name in process.metUncertaintySequence.moduleNames():
print name
process.metUncertaintySequence.remove(getattr(process, name))
if name in process.metUncertaintySequence.moduleNames():
print "Error : module not removed from metUncertaintySequence"
print "...done."
print ""
#clean metUncertaintySequence for data
if not runOnMC:
print ""
print "These modules will be removed from the metUncertaintySequence as useless for data:"
for name in process.metUncertaintySequence.moduleNames():
#if name[-4:]=="EnUp" or name[-6:]=="EnDown" :
if "EnUp" in name or "EnDown" in name:
print "Run on data: remove uncertainty variation,", name
process.metUncertaintySequence.remove(getattr(process, name))
if name in process.metUncertaintySequence.moduleNames():
process.metUncertaintySequence.remove(
getattr(process, name))
if name in process.metUncertaintySequence.moduleNames():
print "Error : module not removed from metUncertaintySequence"
print "...done."
print ""
def DefineMETs(process, paths, runOnData, jecLevel):
""" The function adjusts MET reconstruction. The following corrections are included: type-I
(switched on by PF2PAT function), type-0, and phi-modulation correction.
"""
METCollections = []
#^ MET collections to store. The first one will be raw PF MET, the second one will include the
# type-I and type-0 corrections as well as the MET phi-modulation correction. Type-I correction
# is performed with selectedPatJets collection
process.load('JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi')
if runOnData:
METCollections.extend(['patPFMet', 'patMETs'])
# Include the type-0 MET correction. The code is inspired by [1]
# [1] https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMetAnalysis#Type_I_II_0_with_PF2PAT
process.patType1CorrectedPFMet.srcType1Corrections.append(
cms.InputTag('patPFMETtype0Corr'))
# Correct for MET phi modulation. The code is inspired by the implementation [1] of the
# runMEtUncertainties tool and [2]
# [1] http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/PhysicsTools/PatUtils/python/tools/metUncertaintyTools.py?revision=1.25&view=markup
# [2] https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMetAnalysis#MET_x_y_Shift_Correction_for_mod
process.pfMEtSysShiftCorr.parameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data
process.patType1CorrectedPFMet.srcType1Corrections.append(
cms.InputTag('pfMEtSysShiftCorr'))
# There is some mismatch between the python configurations and CMSSW plugins in the current
# setup (*), (**). This is corrected below
# (*) http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/JetMETCorrections/Type1MET/plugins/SysShiftMETcorrInputProducer.cc?revision=1.2&view=markup
# (**) http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/JetMETCorrections/Type1MET/plugins/SysShiftMETcorrInputProducer.cc?revision=1.3&view=markup
process.pfMEtSysShiftCorr.src = process.pfMEtSysShiftCorr.srcMEt
process.pfMEtSysShiftCorr.parameter = process.pfMEtSysShiftCorr.parameter[0]
# Insert missing modules into the sequence
process.patPF2PATSequence.replace(process.patType1CorrectedPFMet,
process.type0PFMEtCorrection + process.patPFMETtype0Corr + \
process.pfMEtSysShiftCorrSequence + process.patType1CorrectedPFMet)
else: # in case of MC the runMEtUncertainties tool takes care of the corrections
METCollections.extend(['patMETs', 'patType1CorrectedPFMet'])
# Produce the corrected MET and perform systematical shifts [1]
# [1] https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuidePATTools#METSysTools
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process,
electronCollection = 'selectedPatElectrons', muonCollection = 'selectedPatMuons',
tauCollection = '', photonCollection = '', jetCollection = 'cleanPatJets',
jetCorrLabel = jecLevel,
makeType1corrPFMEt = True, makeType1p2corrPFMEt = False,
doApplyType0corr = True, doApplySysShiftCorr = True,
sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc[0],
#dRjetCleaning = -1, # this parameter is never used by the function
addToPatDefaultSequence = False, outputModule = '')
# Switch off the lepton-jet cleaning
del(process.patJetsNotOverlappingWithLeptonsForMEtUncertainty.checkOverlaps.electrons)
del(process.patJetsNotOverlappingWithLeptonsForMEtUncertainty.checkOverlaps.muons)
# Add systematical variations
METCollections.extend(['patType1CorrectedPFMetJetEnUp', 'patType1CorrectedPFMetJetEnDown',
'patType1CorrectedPFMetJetResUp', 'patType1CorrectedPFMetJetResDown',
'patType1CorrectedPFMetUnclusteredEnUp', 'patType1CorrectedPFMetUnclusteredEnDown',
'patType1CorrectedPFMetElectronEnUp', 'patType1CorrectedPFMetElectronEnDown',
'patType1CorrectedPFMetMuonEnUp', 'patType1CorrectedPFMetMuonEnDown'])
# Update files with individual JEC uncertainty sources [1] and correct name of subtotal
# uncertainty as it is outdated in the default configuraion. There are two files with jet
# energy corrections and uncertainties: for data and for simulation; the difference
# originate from L1FastJet corrections [2]
# [1] https://twiki.cern.ch/twiki/bin/view/CMS/JECUncertaintySources?rev=17#2012_JEC
# [2] https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections?rev=115#JetEnCor2012Summer13
for moduleName in process.metUncertaintySequence.moduleNames():
module = getattr(process, moduleName)
if ['jetCorrUncertaintyTag', 'jetCorrInputFileName'] in dir(module):
module.jetCorrUncertaintyTag = 'SubTotalMC'
module.jetCorrInputFileName = cms.FileInPath(
'UserCode/SingleTop/data/Summer13_V4_MC_Uncertainty_AK5PFchs.txt')
# Correct for the mismatch between the python configurations and CMSSW plugins (similar to
# the case of the real data above)
process.pfMEtSysShiftCorr.src = process.pfMEtSysShiftCorr.srcMEt
# Insert modules to perform type-0 and phi-modulation corrections into the sequence (for
# some reason MET uncertainty tool does not do it automatically)
process.metUncertaintySequence.replace(process.patType1CorrectedPFMet,
process.type0PFMEtCorrection + process.patPFMETtype0Corr + process.pfMEtSysShiftCorr + \
process.patType1CorrectedPFMet)
#^ Some collections are created several times under different names (good primary vertices,
# for example), but it should not impose a significant overhead
paths.append(process.metUncertaintySequence)
# Return the list of produced collections
return METCollections
runPF2PAT=True,
jetAlgo=jetAlgoName,
runOnMC=runOnMC,
postfix=postfix,
jetCorrections=('AK5PFchs', jetCorrections),
pvCollection=cms.InputTag('goodOfflinePrimaryVertices'),
# jetCorrections=('AK5PFchs',jetCorrections), pvCollection=cms.InputTag('offlinePrimaryVertices'),
typeIMetCorrections=(not doRunMETUncertainties))
if doRunMETUncertainties:
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
if isData:
runMEtUncertainties(process,
electronCollection="selectedPatElectrons",
doSmearJets=False,
muonCollection="selectedPatMuons",
tauCollection="selectedPatTaus",
jetCollection="selectedPatJets",
jetCorrLabel="L2L3Residual")
process.patPFMet.addGenMET = False
process.patPFMetJetEnUp.addGenMET = False
process.patPFMetJetEnDown.addGenMET = False
process.patPFMetElectronEnUp.addGenMET = False
process.patPFMetElectronEnDown.addGenMET = False
process.patPFMetMuonEnUp.addGenMET = False
process.patPFMetMuonEnDown.addGenMET = False
process.patPFMetTauEnUp.addGenMET = False
process.patPFMetTauEnDown.addGenMET = False
process.patPFMetTauEnUp.addGenMET = False
process.patPFMetTauEnDown.addGenMET = False
else:
* process.kt6PFJets
* process.ak5PFJets
* process.pfCandsNotInJet
* process.selectedPatJetsForMETtype1p2Corr
* process.selectedPatJetsForMETtype2Corr
* process.patPFJetMETtype1p2Corr
* process.patPFJetMETtype2Corr
* process.pfCandMETcorr
* process.patType1CorrectedPFMet
* process.patType1p2CorrectedPFMet
)
# --------------------------------------------------------------------------------
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process, "selectedPatElectrons", "", "selectedPatMuons", "selectedPatTaus", "selectedPatJetsAK5PF")
### build type1/2 correction also on top of pfMETnoPU
process.patType1CorrectedPFMetNoPU = process.patType1CorrectedPFMet.clone()
from PhysicsTools.PatAlgos.producersLayer1.metProducer_cfi import patMETs
process.patPFMetNoPU = patMETs.clone(
metSource=cms.InputTag("pfMETNoPU"), addMuonCorrections=cms.bool(False), genMETSource=cms.InputTag("genMetTrue")
)
# process.patPFMetNoPU = process.patMets.clone()
# process.patPFMetNoPU.metSource = cms.InputTag('pfMETNoPU'),
process.patType1CorrectedPFMetNoPU.src = cms.InputTag("patPFMetNoPU")
process.patType1p2CorrectedPFMetNoPU = process.patType1p2CorrectedPFMet.clone()
process.patType1p2CorrectedPFMetNoPU.src = cms.InputTag("patPFMetNoPU")
def setupPatMets (process, runOnMC, makeNoPUMet):
process.preMetSequence = cms.Sequence()
##Filters
process.load("RecoMET.METFilters.metFilters_cff")
process.preMetSequence += process.metFilters
##Corrections
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
#Type 0 Corrections
process.patPFMETtype0Corr.src = cms.InputTag('goodPV')
#Type 1 correction
if runOnMC :
process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string("L3Absolute")
else :
process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string("L2L3Residual")
process.patPFMet.addGenMET = cms.bool(False)
process.patPFJetMETtype1p2Corr.skipEM = cms.bool(False)
process.patPFJetMETtype1p2Corr.skipMuons = cms.bool(False)
#SysShift correction to turn the MET flat(ter) with respect to Phi
process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi")
process.selectedVerticesForMEtCorr.src = cms.InputTag('goodPV')
#MVA MET !!! Based on AK5PFJets and not on AK5PFchsJets (the same holds for noPUMET)
process.load("RecoMET.METPUSubtraction.mvaPFMET_cff")
process.pfMEtMVA.srcVertices = cms.InputTag('goodPV')
process.pfMEtMVA.srcLeptons = cms.VInputTag("tightMuons","tightElectrons")
##Uncertainties
if makeNoPUMet :
process.load("RecoMET.METPUSubtraction.noPileUpPFMET_cff")
process.noPileUpPFMEt.srcLeptons = cms.VInputTag("tightMuons","tightElectrons")
if runOnMC :
process.calibratedAK5PFJetsForNoPileUpPFMEt.correctors = cms.vstring("ak5PFL1FastL2L3")
process.calibratedAK5PFJetsForPFMEtMVA.correctors = cms.vstring("ak5PFL1FastL2L3")
runMEtUncertainties(process,
makeType1p2corrPFMEt=False,
doApplyType0corr=True,
sysShiftCorrParameter=process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc,
doApplySysShiftCorr=True,
jetCorrPayloadName='AK5PFchs',
makePFMEtByMVA=True,
makeNoPileUpPFMEt=True,
addToPatDefaultSequence=False,
postfix='')
else :
process.calibratedAK5PFJetsForPFMEtMVA.correctors = cms.vstring("ak5PFL1FastL2L3Residual")
process.calibratedAK5PFJetsForNoPileUpPFMEt.correctors = cms.vstring("ak5PFL1FastL2L3Residual")
runMEtUncertainties(process,
makeType1p2corrPFMEt=False,
doApplyType0corr=True,
sysShiftCorrParameter=process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data,
doApplySysShiftCorr=True,
jetCorrPayloadName='AK5PFchs',
makePFMEtByMVA=True,
makeNoPileUpPFMEt=True,
addToPatDefaultSequence=False,
doSmearJets=False,
postfix='')
else :
if runOnMC :
process.calibratedAK5PFJetsForPFMEtMVA.correctors = cms.vstring("ak5PFL1FastL2L3")
runMEtUncertainties(process,
makeType1p2corrPFMEt=False,
doApplyType0corr=True,
sysShiftCorrParameter=process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_mc,
doApplySysShiftCorr=True,
jetCorrPayloadName='AK5PFchs',
makePFMEtByMVA=True,
addToPatDefaultSequence=False,
postfix='')
else :
process.calibratedAK5PFJetsForPFMEtMVA.correctors = cms.vstring("ak5PFL1FastL2L3Residual")
runMEtUncertainties(process,
makeType1p2corrPFMEt=False,
doApplyType0corr=True,
sysShiftCorrParameter=process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data,
doApplySysShiftCorr=True,
jetCorrPayloadName='AK5PFchs',
makePFMEtByMVA=True,
addToPatDefaultSequence=False,
doSmearJets=False,
postfix='')
process.patType01SCorrectedPFMet = process.patType1CorrectedPFMet.clone()
process.metUncertaintySequence.replace(process.patType1CorrectedPFMet,
cms.Sequence(process.type0PFMEtCorrection*process.patPFMETtype0Corr*process.patType1CorrectedPFMet*process.patType01SCorrectedPFMet)
)
process.pfCandsNotInJet.topCollection = cms.InputTag("pfNoTau")
#Add Met with different corrections
process.patType01CorrectedPFMet = cms.EDProducer("CorrectedPATMETProducer",
src = cms.InputTag('patPFMet'),
applyType1Corrections = cms.bool(True),
srcType1Corrections = cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2Corr', 'type1'),
cms.InputTag('patPFMETtype0Corr')
),
applyType2Corrections = cms.bool(False)
)
process.patTypeOnly1CorrectedPFMet = cms.EDProducer("CorrectedPATMETProducer",
src = cms.InputTag('patPFMet'),
applyType1Corrections = cms.bool(True),
srcType1Corrections = cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2Corr', 'type1'),
),
applyType2Corrections = cms.bool(False)
)
process.patType0CorrectedPFMet = cms.EDProducer("CorrectedPATMETProducer",
src = cms.InputTag('patPFMet'),
applyType1Corrections = cms.bool(True),
srcType1Corrections = cms.VInputTag(
cms.InputTag('patPFMETtype0Corr')
),
applyType2Corrections = cms.bool(False)
)
process.patTypeSysCorrectedPFMet = cms.EDProducer("CorrectedPATMETProducer",
src = cms.InputTag('patPFMet'),
applyType1Corrections = cms.bool(True),
srcType1Corrections = cms.VInputTag(
cms.InputTag('pfMEtSysShiftCorr')
),
applyType2Corrections = cms.bool(False)
)
process.patType0sysCorrectedPFMet = cms.EDProducer("CorrectedPATMETProducer",
src = cms.InputTag('patPFMet'),
applyType1Corrections = cms.bool(True),
srcType1Corrections = cms.VInputTag(
cms.InputTag('patPFMETtype0Corr'),
cms.InputTag('pfMEtSysShiftCorr')
),
applyType2Corrections = cms.bool(False)
)
process.patType1sysCorrectedPFMet = cms.EDProducer("CorrectedPATMETProducer",
src = cms.InputTag('patPFMet'),
applyType1Corrections = cms.bool(True),
srcType1Corrections = cms.VInputTag(
cms.InputTag('patPFJetMETtype1p2Corr', 'type1'),
cms.InputTag('pfMEtSysShiftCorr')
),
applyType2Corrections = cms.bool(False)
)
process.metUncertaintySequence += cms.Sequence(process.patTypeOnly1CorrectedPFMet+process.patType0CorrectedPFMet+process.patTypeSysCorrectedPFMet+process.patType01CorrectedPFMet+process.patType1sysCorrectedPFMet+process.patType0sysCorrectedPFMet)
#clean metUncertaintySequence
print ""
print "These modules will be removed from the metUncertaintySequence as already produced before:"
for name in process.patDefaultSequence.moduleNames() :
if name in process.metUncertaintySequence.moduleNames() :
print name
process.metUncertaintySequence.remove(getattr(process,name))
if name in process.metUncertaintySequence.moduleNames() : print "Error : module not removed from metUncertaintySequence"
print "...done."
print ""
#clean metUncertaintySequence for data
if not runOnMC:
print ""
print "These modules will be removed from the metUncertaintySequence as useless for data:"
for name in process.metUncertaintySequence.moduleNames() :
if name[-2:]=="Up" or name[-4:]=="Down" :
print "Run on data: remove uncertainty variation,", name
process.metUncertaintySequence.remove(getattr(process,name))
if name in process.metUncertaintySequence.moduleNames() :
process.metUncertaintySequence.remove(getattr(process,name))
if name in process.metUncertaintySequence.moduleNames() :
print "Error : module not removed from metUncertaintySequence"
print "...done."
print ""
process.load(
'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.GlobalTag.globaltag = 'START53_V7F::All'
from Configuration.AlCa.autoCond import autoCond
process.GlobalTag.globaltag = cms.string(autoCond['startup'])
process.load('Configuration.StandardSequences.MagneticField_cff')
process.load('Configuration.Geometry.GeometryIdeal_cff')
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(
process,
electronCollection=cms.InputTag('electronsWithID'),
#electronCollection=cms.InputTag('selectedPatElectrons'),
photonCollection='',
muonCollection=cms.InputTag('muonsWithID'),
#muonCollection=cms.InputTag('selectedPatMuons'),
tauCollection='',
jetCollection=cms.InputTag('selectedPatJets'),
addToPatDefaultSequence=False,
)
process.simpleAnalyzer = cms.EDAnalyzer(
'SimpleEventAnalyzer',
interestingCollections=cms.untracked.VInputTag([
'smearedPatJets',
'smearedPatJetsResUp',
'smearedPatJetsResDown',
'muonsWithID',
'shiftedMuonsWithIDenDown',
'shiftedMuonsWithIDenUp',
#Embed the reference to the original jet in the jets, which is constant during the propagation
process.patJetsWithOwnRef = cms.EDProducer("PatObjectOwnRefProducer<pat::Jet>",
src=cms.InputTag("selectedPatJets"))
# type 1 +2 MET corrected
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
#Note: this module causes a large memory increase when crossing the file boundary
#Reason - unknown, solution: limit processing to ~1 file.
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(
process,
electronCollection=cms.InputTag("selectedPatElectrons"),
photonCollection=None,
muonCollection=cms.InputTag("selectedPatMuons"),
#FIXME: presently tau variations disabled, results in segfault
tauCollection="", # "" means emtpy, None means cleanPatTaus
jetCollection=cms.InputTag("selectedPatJets"),
jetCorrLabel="L3Absolute" if options.isMC else "L2L3Residual",
doSmearJets=options.isMC, #Note: switch this to False for the sync!
jetCorrPayloadName="AK5PFchs",
addToPatDefaultSequence=False)
process.patPFMetNoPU = process.patMETs.clone(
metSource=cms.InputTag("pfMETNoPU"),
addMuonCorrections=cms.bool(False),
genMETSource=cms.InputTag("genMetTrue"))
process.pfMETNoPU = process.pfMET.clone()
process.pfMETNoPU.src = cms.InputTag("pfNoPileUp" + postfix)
#rocess.pfMETNoPU.jets = cms.InputTag("pfJets"+postfix)
def miniAOD_customizeCommon(process):
process.patMuons.isoDeposits = cms.PSet()
process.patElectrons.isoDeposits = cms.PSet()
process.patTaus.isoDeposits = cms.PSet()
process.patPhotons.isoDeposits = cms.PSet()
#
process.patMuons.embedTrack = True # used for IDs
process.patMuons.embedCombinedMuon = True # used for IDs
process.patMuons.embedMuonBestTrack = True # used for IDs
process.patMuons.embedStandAloneMuon = True # maybe?
process.patMuons.embedPickyMuon = False # no, use best track
process.patMuons.embedTpfmsMuon = False # no, use best track
process.patMuons.embedDytMuon = False # no, use best track
#
# disable embedding of electron and photon associated objects already stored by the ReducedEGProducer
process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core
process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster
process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters
process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters
process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters
process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters
process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer
process.patElectrons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.patElectrons.electronIDSources = cms.PSet(
# configure many IDs as InputTag <someName> = <someTag> you
# can comment out those you don't want to save some disk space
eidRobustLoose = cms.InputTag("reducedEgamma","eidRobustLoose"),
eidRobustTight = cms.InputTag("reducedEgamma","eidRobustTight"),
eidLoose = cms.InputTag("reducedEgamma","eidLoose"),
eidTight = cms.InputTag("reducedEgamma","eidTight"),
eidRobustHighEnergy = cms.InputTag("reducedEgamma","eidRobustHighEnergy"),
)
process.elPFIsoDepositCharged.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositChargedAll.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositNeutral.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositGamma.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositPU.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
#
process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster
process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster
process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters
process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters
process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer
process.patPhotons.photonSource = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.patPhotons.photonIDSources = cms.PSet(
PhotonCutBasedIDLoose = cms.InputTag('reducedEgamma',
'PhotonCutBasedIDLoose'),
PhotonCutBasedIDTight = cms.InputTag('reducedEgamma',
'PhotonCutBasedIDTight')
)
process.phPFIsoDepositCharged.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositChargedAll.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositNeutral.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositGamma.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositPU.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
#
process.selectedPatJets.cut = cms.string("pt > 10")
process.selectedPatMuons.cut = cms.string("pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))")
process.selectedPatElectrons.cut = cms.string("")
process.selectedPatTaus.cut = cms.string("pt > 20 && tauID('decayModeFinding')> 0.5")
process.selectedPatPhotons.cut = cms.string("")
#
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
#switch to AK4 (though it should soon be unnecessary as ak4 should become the 71X default)
#FIXME: still using AK5PFchs for jet energy corrections, while waiting for a new globalTag
switchJetCollection(process, jetSource = cms.InputTag('ak4PFJetsCHS'),
jetCorrections = ('AK5PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), ''),
btagDiscriminators = ['jetBProbabilityBJetTags', 'jetProbabilityBJetTags', 'trackCountingHighPurBJetTags', 'trackCountingHighEffBJetTags', 'simpleSecondaryVertexHighEffBJetTags',
'simpleSecondaryVertexHighPurBJetTags', 'combinedSecondaryVertexBJetTags' , 'combinedInclusiveSecondaryVertexBJetTags' ],
)
#add CA8
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
#
addJetCollection(process, labelName = 'CA8', jetSource = cms.InputTag('ca8PFJetsCHS'),algo= 'CA', rParam = 0.8)
process.selectedPatJetsCA8.cut = cms.string("pt > 100")
process.patJetGenJetMatchCA8.matched = 'slimmedGenJets'
#
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone
switchOnTriggerStandAlone( process, outputModule = '' )
process.patTrigger.packTriggerPathNames = cms.bool(True)
#
# apply type I/type I + II PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
# FIXME: this and the typeI MET should become AK4 once we have the proper JEC?
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
addJetCollection(process, postfix = "ForMetUnc", labelName = 'AK5PF', jetSource = cms.InputTag('ak5PFJets'), jetCorrections = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute'], ''))
process.patJetsAK5PFForMetUnc.getJetMCFlavour = False
runMEtUncertainties(process,jetCollection="selectedPatJetsAK5PFForMetUnc", outputModule=None)
#keep this after all addJetCollections otherwise it will attempt computing them also for stuf with no taginfos
#Some useful BTAG vars
process.patJets.userData.userFunctions = cms.vstring(
'?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().secondaryVertex(0).p4.M):(0)',
'?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().secondaryVertex(0).nTracks):(0)',
'?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().flightDistance(0).value):(0)',
'?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().flightDistance(0).significance):(0)',
)
process.patJets.userData.userFunctionLabels = cms.vstring('vtxMass','vtxNtracks','vtx3DVal','vtx3DSig')
process.patJets.tagInfoSources = cms.VInputTag(cms.InputTag("secondaryVertexTagInfos"))
process.patJets.addTagInfos = cms.bool(True)
#
## PU JetID
process.load("PhysicsTools.PatAlgos.slimming.pileupJetId_cfi")
process.patJets.userData.userFloats.src = [ cms.InputTag("pileupJetId:fullDiscriminant"), ]
process.maxEvents = cms.untracked.PSet(
input=cms.untracked.int32(options.maxEvents))
#Embed the reference to the original jet in the jets, which is constant during the propagation
process.patJetsWithOwnRef = cms.EDProducer('PatObjectOwnRefProducer<pat::Jet>',
src=cms.InputTag("selectedPatJets"))
#Note: this module causes a large memory increase when crossing the file boundary
#Reason - unknown, solution: limit processing to ~1 file.
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(
process,
electronCollection=cms.InputTag("electronsWithID"),
photonCollection=None,
muonCollection=cms.InputTag("muonsWithID"),
tauCollection="", # "" means emtpy, None means cleanPatTaus
jetCollection=cms.InputTag("patJetsWithOwnRef"),
# jetCollection=cms.InputTag("selectedPatJets"),
addToPatDefaultSequence=False)
process.metUncertaintyPath = cms.Path(process.patJetsWithOwnRef *
process.metUncertaintySequence)
process.out = cms.OutputModule(
"PoolOutputModule",
dropMetaData=cms.untracked.string("DROPPED"),
fileName=cms.untracked.string('out_step1B.root'),
SelectEvents=cms.untracked.PSet(SelectEvents=cms.vstring([])),
outputCommands=cms.untracked.vstring(
#'drop *',
'keep *',
process.selectedPatElectrons.cut = (
"(ecalDrivenSeed==1) &&" +
"pt > 5.0 && abs(eta) < 2.5 &&" +
"(isEE || isEB) && !isEBEEGap"
)
######## MET Correction TODO: fix it!
# type 1 +2 MET corrected
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
#--------------------------------------------------------------------------------
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process, 'selectedPatElectrons', '', 'selectedPatMuons', 'selectedPatTaus' , 'selectedPatJets')
process.HbbAnalyzerNew = cms.EDProducer("HbbAnalyzerNew",
runOnMC = cms.bool(isMC),
hltResultsTag = cms.InputTag("TriggerResults::HLT"),
lep_ptCutForBjets = cms.double(5),
electronNoCutsTag = cms.InputTag("gsfElectrons"),
# electronTag = cms.InputTag("selectedElectronsMatched"),
electronTag = cms.InputTag("selectedPatElectrons"),
tauTag = cms.InputTag("patTaus"),
# MinJetPt = cms.double(30),
# MaxJetEta = cms.double(5)
# )
# ------------------------------------------------------------------------------
# MET Smearing Correction
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuidePATTools#MET_Systematics_Tools
# ------------------------------------------------------------------------------
# NB: The photonCollection parameter is set to None per default, in order to
# avoid overlap with the electron collection.
# NB: The energies of pat::Jets are smeared by the Data/MC difference in PFJet
# resolution per default. The smearing factors are taken from JME-10-014.
# NB: Type-0 MET correction are applied (default).
# NB: MET systematic x/y shift correction is not applied (default).
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process, 'selectedPatElectrons', None, 'selectedPatMuons', 'selectedPatTaus', 'selectedPatJets', jetCorrLabel=("L3Absolute" if RUN_ON_MC else "L2L3Residual"), doSmearJets=True, doApplyType0corr=True, doApplySysShiftCorr=False) # change doSmearJets=True to doSmearJets=RUN_ON_MC ?
################################################################################
# Trigger #
################################################################################
from PhysicsTools.PatAlgos.tools.trigTools import *
# In general, it should always be used after any modification done to paths
# (including the out-path), sequences and the modules they contain, since the
# current configuration is used in these tools to determine e.g. the correct
# order of module executions or the output to be saved in the event.
switchOnTrigger( process )
################################################################################
def miniAOD_customizeCommon(process):
process.patMuons.isoDeposits = cms.PSet()
process.patElectrons.isoDeposits = cms.PSet()
process.patTaus.isoDeposits = cms.PSet()
process.patPhotons.isoDeposits = cms.PSet()
#
process.patMuons.embedTrack = True # used for IDs
process.patMuons.embedCombinedMuon = True # used for IDs
process.patMuons.embedMuonBestTrack = True # used for IDs
process.patMuons.embedStandAloneMuon = True # maybe?
process.patMuons.embedPickyMuon = False # no, use best track
process.patMuons.embedTpfmsMuon = False # no, use best track
process.patMuons.embedDytMuon = False # no, use best track
#
process.patElectrons.embedPflowSuperCluster = False
process.patElectrons.embedPflowBasicClusters = False
process.patElectrons.embedPflowPreshowerClusters = False
#
process.selectedPatJets.cut = cms.string("pt > 10")
process.selectedPatMuons.cut = cms.string(
"pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))"
)
process.selectedPatElectrons.cut = cms.string("")
process.selectedPatTaus.cut = cms.string(
"pt > 20 && tauID('decayModeFinding')> 0.5")
process.selectedPatPhotons.cut = cms.string(
"pt > 15 && hadTowOverEm()<0.15 ")
#
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
#
addJetCollection(process,
labelName='CA8',
jetSource=cms.InputTag('ca8PFJetsCHS'),
algo='CA',
rParam=0.8)
process.selectedPatJetsCA8.cut = cms.string("pt > 100")
process.patJetGenJetMatchCA8.matched = 'slimmedGenJets'
#
## PU JetID
process.load("PhysicsTools.PatAlgos.slimming.pileupJetId_cfi")
process.patJets.userData.userFloats.src = [
cms.InputTag("pileupJetId:fullDiscriminant"),
]
#
#Some useful BTAG vars
process.patJets.userData.userFunctions = cms.vstring(
'?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().secondaryVertex(0).p4.M):(0)',
'?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().secondaryVertex(0).nTracks):(0)',
'?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().flightDistance(0).value):(0)',
'?(tagInfoSecondaryVertex().nVertices()>0)?(tagInfoSecondaryVertex().flightDistance(0).significance):(0)',
)
process.patJets.userData.userFunctionLabels = cms.vstring(
'vtxMass', 'vtxNtracks', 'vtx3DVal', 'vtx3DSig')
process.patJets.tagInfoSources = cms.VInputTag(
cms.InputTag("secondaryVertexTagInfos"))
process.patJets.addTagInfos = cms.bool(True)
#
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone
switchOnTriggerStandAlone(process)
process.patTrigger.packTriggerPathNames = cms.bool(True)
#
# apply type I/type I + II PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
addJetCollection(process,
postfix="ForMetUnc",
labelName='AK5PF',
jetSource=cms.InputTag('ak5PFJets'),
jetCorrections=('AK5PF',
['L1FastJet', 'L2Relative',
'L3Absolute'], ''),
btagDiscriminators=['combinedSecondaryVertexBJetTags'])
runMEtUncertainties(process,
jetCollection="selectedPatJetsAK5PFForMetUnc",
outputModule=None)
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
#from JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi import *
#runMEtUncertainties(process)
#from PhysicsTools.PatUtils.tools.metUncertaintyTools import *
print process.pfMEtSysShiftCorrParameters_2012runABCvsNvtx_mc[0]
if isMC == False:
runMEtUncertainties(process,
electronCollection = cms.InputTag('cleanPatElectrons'),
photonCollection = '',
muonCollection = 'selectedPatMuons',
tauCollection = 'selectedPatTaus',
jetCollection = cms.InputTag('selectedPatJets'),
jetCorrLabel = 'L2L3Residual',
doSmearJets = False,
makeType1corrPFMEt = True,
makeType1p2corrPFMEt = False,
makePFMEtByMVA = False,
makeNoPileUpPFMEt = False,
doApplyType0corr = False,
sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runABCvsNvtx_data[0],
#sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runABCvsNvtx_data,
doApplySysShiftCorr = False,
addToPatDefaultSequence = False,
)
else:
runMEtUncertainties(process,
electronCollection = cms.InputTag('cleanPatElectrons'),
photonCollection = '',
muonCollection = 'selectedPatMuons',
process.patElectrons.electronIDSources = process.electronIDSources
postfix = ""
# Configure PAT to use PF2PAT instead of AOD sources:
from PhysicsTools.PatAlgos.tools.pfTools import *
from PhysicsTools.PatAlgos.tools.trigTools import *
from PhysicsTools.PatUtils.tools.metUncertaintyTools import *
Postfix = ""
runOnMC = (not isData)
jetAlgoName = "AK5"
usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgoName, runOnMC=runOnMC, postfix=Postfix, jetCorrections=('AK5PFchs',['L1FastJet','L2Relative','L3Absolute']), pvCollection=cms.InputTag('goodOfflinePrimaryVertices'), typeIMetCorrections=isData)
if (not(isData)):
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process,electronCollection = "selectedPatElectrons", doSmearJets= False, muonCollection = "selectedPatMuons", tauCollection="selectedPatTaus", jetCollection = "selectedPatJets")
#Note: we run the MET uncertainty tools if it is MC. If it is data, the type 1 corrected METs
#Trigger matching:
switchOnTriggerMatchEmbedding(process,triggerMatchers = ['PatMuonTriggerMatchHLTIsoMu24','PatJetTriggerMatchHLTIsoMuBTagIP'])
#PF no Pileup:
process.pfPileUp.Enable = True
process.load("CMGTools.External.pujetidsequence_cff")
process.pfPileUp.checkClosestZVertex = cms.bool(False)
#Use DR = 0.3 for electrons:
process.pfIsolatedElectrons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId"))
process.pfIsolatedElectrons.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId")
process.pfIsolatedElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId"))
#
# )
process.selectedPatElectrons.cut = ("(ecalDrivenSeed==1) &&" +
"pt > 5.0 && abs(eta) < 2.5 &&" +
"(isEE || isEB) && !isEBEEGap")
######## MET Correction TODO: fix it!
# type 1 +2 MET corrected
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
#--------------------------------------------------------------------------------
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process, 'selectedPatElectrons', '', 'selectedPatMuons',
'selectedPatTaus', 'selectedPatJets')
process.HbbAnalyzerNew = cms.EDProducer(
"HbbAnalyzerNew",
runOnMC=cms.bool(isMC),
hltResultsTag=cms.InputTag("TriggerResults::HLT"),
lep_ptCutForBjets=cms.double(5),
electronNoCutsTag=cms.InputTag("gsfElectrons"),
# electronTag = cms.InputTag("selectedElectronsMatched"),
electronTag=cms.InputTag("selectedPatElectrons"),
tauTag=cms.InputTag("patTaus"),
muonNoCutsTag=cms.InputTag("muons"),
muonTag=cms.InputTag("selectedPatMuons"),
# muonTag = cms.InputTag("selectedMuonsMatched"),
jetTag=cms.InputTag("selectedPatJetsCAVHFatPF"),
subjetTag=cms.InputTag("selectedPatJetsCAVHSubPF"),
cms.InputTag('pfMETcorrType0'),
cms.InputTag('pfJetMETcorr', 'type1')
)
# Get PFMET from runMEtUncertainties
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi")
runMEtUncertainties(process,
electronCollection = cms.InputTag('cleanPatElectrons'),
photonCollection = '',
muonCollection = 'cleanPatMuons',
tauCollection = '',
jetCollection = cms.InputTag('selectedPatJets'),
jetCorrLabel = 'L3Absolute',
doSmearJets = True,
makeType1corrPFMEt = True,
makeType1p2corrPFMEt = False,
makePFMEtByMVA = False,
makeNoPileUpPFMEt = False,
doApplyType0corr = True,
#sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc,
doApplySysShiftCorr = False,
)
process.producePatPFMETCorrections.replace(process.patPFJetMETtype2Corr,process.patPFJetMETtype2Corr + process.type0PFMEtCorrectionPFCandToVertexAssociation + process.patPFMETtype0Corr)
# Fix Type0 correction module
process.patPFMETtype0Corr.correction.par3 = cms.double(0.909209)
process.patPFMETtype0Corr.correction.par2 = cms.double(0.0303531)
process.patPFMETtype0Corr.correction.par1 = cms.double(-0.703151)
process.patPFMETtype0Corr.correction.par0 = cms.double(0.0)
process.slimmedJets.clearDaughters = False
#process.slimmedElectrons.dropRecHits = True
#process.slimmedElectrons.dropBasicClusters = True
#process.slimmedElectrons.dropPFlowClusters = True
#process.slimmedElectrons.dropPreshowerClusters = True
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone
switchOnTriggerStandAlone( process )
process.patTrigger.packTriggerPathNames = cms.bool(True)
# ##
# process.options.wantSummary = False ## (to suppress the long output at the end of the job)
# ##
# apply type I/type I + II PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
addJetCollection(process, postfix = "ForMetUnc", labelName = 'AK5PF', jetSource = cms.InputTag('ak5PFJets'), jetCorrections = ('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute'], ''), btagDiscriminators = ['combinedSecondaryVertexBJetTags' ] )
runMEtUncertainties(process,jetCollection="selectedPatJetsAK5PFForMetUnc", outputModule=None)
# process.out.outputCommands = [ ... ] ## (e.g. taken from PhysicsTools/PatAlgos/python/patEventContent_cff.py)
# ##
process.out.fileName = 'patTuple_micro.root'
process.out.outputCommands = process.MicroEventContentMC.outputCommands
process.out.dropMetaData = cms.untracked.string('ALL')
process.out.fastCloning= cms.untracked.bool(False)
process.out.overrideInputFileSplitLevels = cms.untracked.bool(True)
process.source.fileNames = cms.untracked.vstring(options.inputFiles)
process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(options.maxEvents))
#Embed the reference to the original jet in the jets, which is constant during the propagation
process.patJetsWithOwnRef = cms.EDProducer('PatObjectOwnRefProducer<pat::Jet>',
src=cms.InputTag("selectedPatJets")
)
#Note: this module causes a large memory increase when crossing the file boundary
#Reason - unknown, solution: limit processing to ~1 file.
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process,
electronCollection=cms.InputTag("electronsWithID"),
photonCollection=None,
muonCollection=cms.InputTag("muonsWithID"),
tauCollection="", # "" means emtpy, None means cleanPatTaus
jetCollection=cms.InputTag("patJetsWithOwnRef"),
# jetCollection=cms.InputTag("selectedPatJets"),
addToPatDefaultSequence=False
)
process.metUncertaintyPath = cms.Path(
process.patJetsWithOwnRef *
process.metUncertaintySequence
)
process.out = cms.OutputModule("PoolOutputModule",
dropMetaData=cms.untracked.string("DROPPED"),
fileName=cms.untracked.string('out_step1B.root'),
SelectEvents=cms.untracked.PSet(
SelectEvents=cms.vstring([])
),
print sep_line
print 'postfix : ', postfix
print sep_line
print 'JEC : ', jetCorrections
print sep_line
#########################################
usePF2PAT(process, runPF2PAT=True, jetAlgo=jetAlgoName, runOnMC=runOnMC, postfix=postfix,
jetCorrections=('AK5PFchs',jetCorrections), pvCollection=cms.InputTag('goodOfflinePrimaryVertices'),
# jetCorrections=('AK5PFchs',jetCorrections), pvCollection=cms.InputTag('offlinePrimaryVertices'),
typeIMetCorrections=(not doRunMETUncertainties))
if doRunMETUncertainties:
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
if isData:
runMEtUncertainties(process,electronCollection = "selectedPatElectrons", doSmearJets= False, muonCollection = "selectedPatMuons", tauCollection="selectedPatTaus", jetCollection = "selectedPatJets",jetCorrLabel="L2L3Residual")
process.patPFMet.addGenMET = False
process.patPFMetJetEnUp.addGenMET = False
process.patPFMetJetEnDown.addGenMET = False
process.patPFMetElectronEnUp.addGenMET = False
process.patPFMetElectronEnDown.addGenMET = False
process.patPFMetMuonEnUp.addGenMET = False
process.patPFMetMuonEnDown.addGenMET = False
process.patPFMetTauEnUp.addGenMET = False
process.patPFMetTauEnDown.addGenMET = False
process.patPFMetTauEnUp.addGenMET = False
process.patPFMetTauEnDown.addGenMET = False
else:
runMEtUncertainties(process,electronCollection = "selectedPatElectrons", doSmearJets= False, muonCollection = "selectedPatMuons", tauCollection="selectedPatTaus", jetCollection = "selectedPatJets",)
# CONFIGURE LEPTONS for the analysis
def filterTightWenuCandidates(process, isMC):
process.tightWenuSelectionSequence = cms.Sequence()
# Trigger requirements
process.load("HLTrigger.HLTfilters.hltHighLevel_cfi")
process.wenuHLTFilter = process.hltHighLevel.clone(
TriggerResultsTag=cms.InputTag("TriggerResults", "", "HLT"),
HLTPaths=cms.vstring([
# single electron triggers (2011 Run B)
'HLT_Ele32_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v7',
'HLT_Ele25_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v5',
# single electron triggers (Summer'11 MC)
'HLT_Ele32_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v1',
'HLT_Ele27_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v2',
]),
throw=cms.bool(False))
process.tightWenuSelectionSequence += process.wenuHLTFilter
# Vertex selection
process.goodVertex = cms.EDFilter(
"VertexSelector",
src=cms.InputTag("offlinePrimaryVertices"),
cut=cms.string(
"isValid & ndof >= 4 & abs(z) < 24 & abs(position.Rho) < 2"),
filter=cms.bool(True))
process.tightWenuSelectionSequence += process.goodVertex
process.load("CommonTools.ParticleFlow.pfNoPileUp_cff")
process.pfPileUp.Enable = cms.bool(True)
process.pfPileUp.checkClosestZVertex = cms.bool(True)
process.tightWenuSelectionSequence += process.pfNoPileUpSequence
process.load("CommonTools.ParticleFlow.pfParticleSelection_cff")
process.tightWenuSelectionSequence += process.pfParticleSelectionSequence
process.load("PhysicsTools/PatAlgos/patSequences_cff")
# compute electron IsoDeposits
process.load("TauAnalysis.Skimming.electronPFIsolationDeposits_cff")
process.load("TauAnalysis.Skimming.electronPFIsolationValues_cff")
process.electronPFIsolationSequence = cms.Sequence(
process.electronPFIsolationDepositsSequence *
process.electronPFIsolationValuesSequence)
process.tightWenuSelectionSequence += process.electronPFIsolationSequence
# configure pat::Electron production
process.patElectrons.isoDeposits = cms.PSet(
# CV: strings for IsoDeposits defined in PhysicsTools/PatAlgos/plugins/PATMuonProducer.cc
pfChargedHadrons=cms.InputTag("elecPFIsoDepositCharged"),
pfNeutralHadrons=cms.InputTag("elecPFIsoDepositNeutral"),
pfPhotons=cms.InputTag("elecPFIsoDepositGamma"),
user=cms.VInputTag(cms.InputTag("elecPFIsoDepositChargedAll"),
cms.InputTag("elecPFIsoDepositPU")))
process.patElectrons.userIsolation = cms.PSet(
# CV: strings for Isolation values defined in PhysicsTools/PatAlgos/src/MultiIsolator.cc
pfChargedHadron=cms.PSet(
deltaR=cms.double(0.4),
src=process.patElectrons.isoDeposits.pfChargedHadrons,
vetos=process.elecPFIsoValueCharged04.deposits[0].vetos,
skipDefaultVeto=process.elecPFIsoValueCharged04.deposits[0].
skipDefaultVeto),
pfNeutralHadron=cms.PSet(
deltaR=cms.double(0.4),
src=process.patElectrons.isoDeposits.pfNeutralHadrons,
vetos=process.elecPFIsoValueNeutral04.deposits[0].vetos,
skipDefaultVeto=process.elecPFIsoValueNeutral04.deposits[0].
skipDefaultVeto),
pfGamma=cms.PSet(
deltaR=cms.double(0.4),
src=process.patElectrons.isoDeposits.pfPhotons,
vetos=process.elecEBPFIsoValueGamma04.deposits[0].vetos,
skipDefaultVeto=process.elecEBPFIsoValueGamma04.deposits[0].
skipDefaultVeto),
user=cms.VPSet(
cms.PSet(
deltaR=cms.double(0.4),
src=process.patElectrons.isoDeposits.user[0],
vetos=process.elecEBPFIsoValueChargedAll04.deposits[0].vetos,
skipDefaultVeto=process.elecEBPFIsoValueChargedAll04.
deposits[0].skipDefaultVeto),
cms.PSet(deltaR=cms.double(0.4),
src=process.patElectrons.isoDeposits.user[1],
vetos=process.elecPFIsoValuePU04.deposits[0].vetos,
skipDefaultVeto=process.elecPFIsoValuePU04.deposits[0].
skipDefaultVeto),
cms.PSet(deltaR=cms.double(0.4),
src=process.patElectrons.isoDeposits.pfPhotons,
vetos=process.elecEEPFIsoValueGamma04.deposits[0].vetos,
skipDefaultVeto=process.elecEEPFIsoValueGamma04.
deposits[0].skipDefaultVeto),
cms.PSet(
deltaR=cms.double(0.4),
src=process.patElectrons.isoDeposits.user[0],
vetos=process.elecEEPFIsoValueChargedAll04.deposits[0].vetos,
skipDefaultVeto=process.elecEEPFIsoValueChargedAll04.
deposits[0].skipDefaultVeto)))
process.patElectrons.addGenMatch = cms.bool(False)
process.patElectrons.embedHighLevelSelection = cms.bool(True)
process.patElectrons.usePV = cms.bool(
False
) # compute transverse impact parameter wrt. beamspot (not event vertex)
if not isMC:
# remove MC matching from standard PAT sequences
removeMCMatching(process, ["All"], outputInProcess=False)
process.patDefaultSequence.remove(process.patJetPartonMatch)
# select tight electrons, no isolation cuts applied
process.selectedElectronsWP80 = cms.EDFilter("PATElectronSelector",
src = cms.InputTag("patElectrons"),
cut = cms.string(
'pt > 25 & abs(eta) < 2.1 & ' + \
'(isEB & ' + \
' sigmaIetaIeta < 0.010 & ' + \
' deltaPhiSuperClusterTrackAtVtx < 0.06 & deltaEtaSuperClusterTrackAtVtx < 0.004 & ' + \
' hadronicOverEm < 0.04) | ' + \
'(isEE & ' + \
' sigmaIetaIeta < 0.030 & ' + \
' deltaPhiSuperClusterTrackAtVtx < 0.03 & deltaEtaSuperClusterTrackAtVtx < 0.007 & ' + \
' hadronicOverEm < 0.025)'
),
filter = cms.bool(True)
)
process.selectedElectronsWP80conversionVeto = cms.EDFilter(
"NPATElectronConversionFinder",
src=cms.InputTag("selectedElectronsWP80"),
filter=cms.bool(True))
# select loose electrons, used for di-electron veto
process.selectedElectronsWP95 = cms.EDFilter("PATElectronSelector",
src = cms.InputTag("patElectrons"),
cut = cms.string(
'pt > 20 & abs(eta) < 2.5 & ' + \
'gsfTrack.isNonnull & gsfTrack.trackerExpectedHitsInner.numberOfHits <= 1 &' + \
'(isEB & ' + \
' sigmaIetaIeta < 0.010 & ' + \
' deltaPhiSuperClusterTrackAtVtx < 0.80 & deltaEtaSuperClusterTrackAtVtx < 0.007 & ' + \
' hadronicOverEm < 0.15) | ' + \
'(isEE & ' + \
' sigmaIetaIeta < 0.030 & ' + \
' deltaPhiSuperClusterTrackAtVtx < 0.70 & deltaEtaSuperClusterTrackAtVtx < 0.010 & ' + \
' hadronicOverEm < 0.07)'
),
filter = cms.bool(False)
)
# select tight electrons which are isolated
process.selectedIsoElectronsWP80 = cms.EDFilter("PATElectronSelector",
src = cms.InputTag("selectedElectronsWP80conversionVeto"),
cut = cms.string(
'(isEB & ' + \
'(userIsolation("pat::User1Iso")' + \
' + max(0., userIsolation("pat::PfNeutralHadronIso") + userIsolation("pat::PfGammaIso")' + \
' - 0.5*userIsolation("pat::User2Iso"))) < 0.06*pt) | ' + \
'(isEE & ' + \
'(userIsolation("pat::User4Iso")' + \
' + max(0., userIsolation("pat::PfNeutralHadronIso") + userIsolation("pat::User3Iso")' + \
' - 0.5*userIsolation("pat::User2Iso"))) < 0.06*pt)'
),
filter = cms.bool(False)
)
process.patDefaultSequence.replace(
process.patElectrons,
process.patElectrons * process.selectedElectronsWP80 *
process.selectedElectronsWP80conversionVeto *
process.selectedIsoElectronsWP80 * process.selectedElectronsWP95)
# configure pat::Jet production
# (enable L2L3Residual corrections in case running on Data)
jetCorrections = ['L1FastJet', 'L2Relative', 'L3Absolute']
if not isMC:
jetCorrections.append('L2L3Residual')
switchJetCollection(process,
cms.InputTag('ak5PFJets'),
doJTA=True,
doBTagging=False,
jetCorrLabel=('AK5PF', cms.vstring(jetCorrections)),
doType1MET=False,
doJetID=True,
jetIdLabel="ak5",
outputModule='')
# configure pat::MET production
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
process.tightWenuSelectionSequence += process.kt6PFJets
process.tightWenuSelectionSequence += process.ak5PFJets
process.tightWenuSelectionSequence += process.patDefaultSequence
doSmearJets = None
if isMC:
doSmearJets = True
else:
doSmearJets = False
runMEtUncertainties(
process,
electronCollection=cms.InputTag('selectedIsoElectronsWP80'),
photonCollection='',
muonCollection='',
tauCollection='',
jetCollection=cms.InputTag('patJets'),
doSmearJets=doSmearJets,
addToPatDefaultSequence=False)
if isMC:
process.patPFMet.addGenMET = cms.bool(True)
process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string("L3Absolute")
process.tightWenuSelectionSequence += process.metUncertaintySequence
else:
process.patPFMet.addGenMET = cms.bool(False)
process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string(
"L2L3Residual")
process.tightWenuSelectionSequence += process.patJetsNotOverlappingWithLeptonsForMEtUncertainty
process.tightWenuSelectionSequence += process.producePatPFMETCorrections
# Apply event selection cuts
process.isoElectronWP80Filter = cms.EDFilter(
"CandViewCountFilter",
src=cms.InputTag("selectedIsoElectronsWP80"),
minNumber=cms.uint32(1))
process.tightWenuSelectionSequence += process.isoElectronWP80Filter
process.diElectronVeto = cms.EDFilter(
"PATCandViewMaxFilter",
src=cms.InputTag("selectedElectronsWP95"),
maxNumber=cms.uint32(1))
process.tightWenuSelectionSequence += process.diElectronVeto
process.WenuCandidates = cms.EDProducer(
"PATElecNuPairProducer",
srcVisDecayProducts=cms.InputTag('selectedIsoElectronsWP80'),
srcMET=cms.InputTag('patType1CorrectedPFMet'),
verbosity=cms.untracked.int32(0))
process.tightWenuSelectionSequence += process.WenuCandidates
process.selectedWenuCandidates = cms.EDFilter(
"PATElecNuPairSelector",
src=cms.InputTag("WenuCandidates"),
cut=cms.string('mt > 50.'),
filter=cms.bool(False))
process.tightWenuSelectionSequence += process.selectedWenuCandidates
process.tightWenuFilter = cms.EDFilter(
"CandViewCountFilter",
src=cms.InputTag("selectedWenuCandidates"),
minNumber=cms.uint32(1))
process.tightWenuSelectionSequence += process.tightWenuFilter
#process.load("PhysicsTools.PatUtils.tools.metUncertaintyTools")
process.load('Configuration.StandardSequences.Services_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.GlobalTag.globaltag = 'START53_V23::All'
##-------------------- Import the JEC services -----------------------
process.load('JetMETCorrections.Configuration.DefaultJEC_cff')
runMEtUncertainties(process,
electronCollection = cms.InputTag('selectedPatElectrons'),
muonCollection = cms.InputTag('selectedPatMuons'),
tauCollection = cms.InputTag('selectedPatTaus'),
jetCollection = cms.InputTag('selectedPatJets'),
makePFMEtByMVA = True,
doSmearJets = True,
addToPatDefaultSequence = False
)
##########################
# Nominal Systematics #
##########################
process.TupleMuonsNominal = cms.EDProducer('TupleMuonProducer' ,
muonSrc =cms.InputTag('selectedPatMuons'),
vertexSrc =cms.InputTag('offlinePrimaryVertices'),
NAME=cms.string("TupleMuonsNominal")
)
# #
# EXERCISE 3 #
# #
#################
## The MET Uncertainty tool needs some more things to be there:
process.load("Configuration.StandardSequences.Geometry_cff")
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
from Configuration.AlCa.autoCond import autoCond
process.GlobalTag.globaltag = cms.string( autoCond[ 'startup' ] )
process.load("Configuration.StandardSequences.MagneticField_cff")
process.load("PhysicsTools.PatAlgos.patSequences_cff")
#Applying the MET Uncertainty tools
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process, electronCollection = cms.InputTag("selectedPatElectronsPFlow"), jetCollection="selectedPatJetsPFlow", muonCollection = cms.InputTag("selectedPatMuonsPFlow"), tauCollection = cms.InputTag("selectedPatTausPFlow") )
#process.shiftedPatJetsEnUp=process.shiftedPatJetsPFlowEnUpForCorrMEt.clone(shiftBy=cms.double(2), src="selectedPatJetsPFlow")
#process.jecAnalyzerEnUp=process.jecAnalyzer.clone(Jets = cms.InputTag("shiftedPatJetsEnUp"))
#process.p_jec.__iadd__( process.shiftedPatJetsEnUp * process.jecAnalyzerEnUp)
#################
# #
# EXERCISE 4 #
# #
#################
process.patJPsiCandidates = cms.EDProducer("PatJPsiProducer",
muonSrc = cms.InputTag("selectedPatMuonsPFlow")
)
PF2PATPostfix = "PFlow"
jetAlgo="AK5"
#addPfMET(process, postfixLabel=postfix)
usePF2PAT(process,runPF2PAT=True,jetAlgo=jetAlgo,runOnMC=True,postfix=PF2PATPostfix,jetCorrections=('AK5PF',['L1FastJet','L2Relative','L3Absolute']),typeIMetCorrections=True,outputModules=[])
# to use tau-cleaned jet collection uncomment the following:
#getattr(process,"pfNoTau"+postfix).enable = True
# to switch default tau to HPS tau uncomment the following:
#adaptPFTaus(process,"hpsPFTau",postfix=postfix)
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
from JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi import *
runMEtUncertainties(process, electronCollection='selectedPatElectronsPFlow', muonCollection='selectedPatMuonsPFlow', tauCollection='selectedPatTausPFlow', jetCollection='selectedPatJetsPFlow',doApplyType0corr=False, doSmearJets=False, postfix='NotSmeared')
process.patPFMETtype0CorrNotSmeared=process.patPFMETtype0Corr.clone()
process.PF2PAT = cms.Sequence(
# process.patDefaultSequence +
getattr(process,"patPF2PATSequence"+PF2PATPostfix) +
process.type0PFMEtCorrection +
process.patPFMETtype0CorrNotSmeared +
process.metUncertaintySequenceNotSmeared
)
#output commands
skimEventContent = cms.PSet(
outputCommands = cms.untracked.vstring(
"keep *",
"drop *_*ak7*_*_*",
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuidePATTools#MET_Systematics_Tools
# ------------------------------------------------------------------------------
# NB: The photonCollection parameter is set to None per default, in order to
# avoid overlap with the electron collection.
# NB: The energies of pat::Jets are smeared by the Data/MC difference in PFJet
# resolution per default. The smearing factors are taken from JME-10-014.
# NB: Type-0 MET correction are applied (default).
# NB: MET systematic x/y shift correction is not applied (default).
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(
process,
"selectedPatElectrons",
None,
"selectedPatMuons",
"selectedPatTaus",
"selectedPatJets",
jetCorrLabel=("L3Absolute" if RUN_ON_MC else "L2L3Residual"),
doSmearJets=True,
doApplyType0corr=True,
doApplySysShiftCorr=False,
) # change doSmearJets=True to doSmearJets=RUN_ON_MC ?
################################################################################
# Trigger #
################################################################################
from PhysicsTools.PatAlgos.tools.trigTools import *
# In general, it should always be used after any modification done to paths
# (including the out-path), sequences and the modules they contain, since the
# current configuration is used in these tools to determine e.g. the correct
process.pfMEtSysShiftCorr.parameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data
#----------------------------------------------------------------------------------------------------
# Use the runMetUncertainties tool here
# See https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuidePATTools#MET_Systematics_Tools
#----------------------------------------------------------------------------------------------------
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(
process,
jetCollection = cms.InputTag('analysisPatJetsAK5PF'),
doApplySysShiftCorr = True, # Apply correction for systematic x/y shift in MET
doApplyType0corr = True, # Apply correction for pileup
makeType1corrPFMEt = True, # Apply correction for jet energy scale
makeType1p2corrPFMEt = False, # DO NOT apply correction for unclustered energy (degrades MET resolution)
makePFMEtByMVA = False, # We don't use MVA PFMET
doSmearJets = False, # Very important to NOT smear the pfjets (DATA ONLY)
addToPatDefaultSequence = True, # Add this to the PAT sequence
sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runABCDvsNvtx_data
)
#----------------------------------------------------------------------------------------------------
# Available pat::MET collections for analysis
# - process.patMETsTC : raw TCMET (NO jet smearing)
#
# - process.patMETsRawCalo : raw CaloMET (NO jet smearing)
# - process.patMETs : Type1 CaloMET (NO jet smearing)
#
# - process.patMETsRawPF : raw PFMET (NO jet smearing)
# - process.patType1CorrectedPFMet_Type1Only : Type1 PFMET (NO jet smearing)
switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA = True,
doBTagging = False,
jetCorrLabel = _jetCorrections,
doType1MET = False,
doJetID = True,
jetIdLabel = "ak5"
)
# apply type I/type I + II PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process,doApplyType0corr=False)
process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff")
from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfType1CorrectedMet
process.pfMETType0 = pfType1CorrectedMet.clone()
process.pfMETType0.applyType1Corrections = cms.bool(True)
process.pfMETType0.applyType0Corrections = cms.bool(True)
if tauSwitch:
tausequence = cms.Sequence( process.PFTau)
else:
tausequence = cms.Sequence()
if IsPythiaShowered:
filtersequence = cms.Sequence( process.totalKinematicsFilter )
else:
def addInvHiggsProcess(
process,
iRunOnData=True,
iData="ParkedData",
iHLTFilter="MET",
iMCSignal=False,
iFile='/store/data/Run2012C/VBF1Parked/AOD/22Jan2013-v1/20000/40F56410-D979-E211-9843-002618943849.root',
iMaxEvent=100):
###--------------------------------------------------------------
### Load PAT, because it insists on defining the process for you
#from PhysicsTools.PatAlgos.patTemplate_cfg import *
###--------------------------------------------------------------
###--------------------------------------------------------------
### Input
process.maxEvents.input = iMaxEvent
process.source.fileNames = [iFile]
###--------------------------------------------------------------
###--------------------------------------------------------------
### GlobalTag
if iRunOnData == True:
process.GlobalTag.globaltag = "FT53_V21A_AN6::All"
else:
process.GlobalTag.globaltag = "START53_V27::All"
###--------------------------------------------------------------
###--------------------------------------------------------------
### Logger
process.load("FWCore.MessageService.MessageLogger_cfi")
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport = cms.untracked.PSet(
reportEvery=cms.untracked.int32(2000),
limit=cms.untracked.int32(10000000))
###--------------------------------------------------------------
###--------------------------------------------------------------
### L1 Trigger
process.load('L1Trigger.Skimmer.l1Filter_cfi')
process.l1Filter.algorithms = cms.vstring('L1_ETM40')
###--------------------------------------------------------------
###--------------------------------------------------------------
### HLT Trigger(s)
# If it's MC signal, no trigger will be applied
if iRunOnData == False and iMCSignal == True:
iHLTFilter = "NoTrig"
# Load hltHighLevel
process.load('HLTrigger.HLTfilters.hltHighLevel_cfi')
process.hltHighLevel.TriggerResultsTag = cms.InputTag(
"TriggerResults", "", "HLT")
process.hltHighLevel.throw = cms.bool(
False) # Tolerate if triggers not available
process.hltHighLevel.andOr = cms.bool(True) # True = OR, False = AND
if (iRunOnData == True and iHLTFilter.find("MET") == 0):
process.hltHighLevel.HLTPaths = cms.vstring(
#"HLT_DiPFJet40_PFMETnoMu65_MJJ600VBF_LeadingJets_v*",
#"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v*"
"HLT_DiJet35_MJJ700_AllJets_DEta3p5_VBF_v*",
"HLT_DiJet30_MJJ700_AllJets_DEta3p5_VBF_v*")
elif (iHLTFilter.find("SingleMu") == 0):
process.hltHighLevel.HLTPaths = cms.vstring("HLT_IsoMu24_eta2p1_v*",
"HLT_Mu40_eta2p1_v*")
#elif (iHLTFilter.find("DoubleMu")==0):
# process.hltHighLevel.HLTPaths = cms.vstring("HLT_Mu17_Mu8_v*")
#elif (iHLTFilter.find("SingleElectron")==0):
# process.hltHighLevel.HLTPaths = cms.vstring("HLT_Ele27_WP80_v*")
#elif (iHLTFilter.find("DoubleElectron")==0):
# process.hltHighLevel.HLTPaths = cms.vstring("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v*")
elif (iHLTFilter.find("NoTrig") == 0):
process.hltHighLevel.HLTPaths = cms.vstring("*")
else:
process.hltHighLevel.HLTPaths = cms.vstring(
#"HLT_DiPFJet40_PFMETnoMu65_MJJ600VBF_LeadingJets_v*",
#"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v*"
"HLT_DiJet35_MJJ700_AllJets_DEta3p5_VBF_v*",
"HLT_DiJet30_MJJ700_AllJets_DEta3p5_VBF_v*")
### VBF filter for MC Background
process.vbfFilter = cms.EDFilter("HLTPFJetVBFFilter",
saveTags=cms.bool(True),
triggerType=cms.int32(85),
inputTag=cms.InputTag("ak5PFJets"),
leadingJetOnly=cms.bool(False),
minPtHigh=cms.double(25.0),
minPtLow=cms.double(25.0),
maxEta=cms.double(5.0),
etaOpposite=cms.bool(True),
minDeltaEta=cms.double(3.0),
minInvMass=cms.double(500.0))
###--------------------------------------------------------------
###--------------------------------------------------------------
print "-----------------------------------------------"
print "INVISIBLE HIGGS: Ntuple V12 for Parked Data"
print "-----------------------------------------------"
print "RunOnData = ", iRunOnData
if iRunOnData == True:
print "Dataset = ", iData
else:
if iMCSignal == True:
print "Dataset = MC Signal or DYNoTrig"
else:
print "Dataset = MC Background"
print "GlobalTag = ", process.GlobalTag.globaltag
print "Trigger = ", process.hltHighLevel.HLTPaths
print "Sample input file = ", iFile
print "Max events = ", iMaxEvent
print "-----------------------------------------------"
###--------------------------------------------------------------
###--------------------------------------------------------------
### Basic filters
# Track quality filter
process.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))
# Require a good vertex
process.primaryVertexFilter = cms.EDFilter(
"VertexSelector",
src=cms.InputTag("offlinePrimaryVertices"),
cut=cms.string(
"!isFake && ndof > 4 && abs(z) <= 24 && position.Rho <= 2"),
filter=cms.bool(True))
###--------------------------------------------------------------
###--------------------------------------------------------------
### MET Filters
# The iso-based HBHE noise filter
process.load('CommonTools.RecoAlgos.HBHENoiseFilter_cfi')
# The CSC beam halo tight filter
process.load('RecoMET.METAnalyzers.CSCHaloFilter_cfi')
# The HCAL laser filter
process.load("RecoMET.METFilters.hcalLaserEventFilter_cfi")
#process.load("EventFilter.HcalRawToDigi.hcallasereventfilter2012_cff")
#process.hcallasereventfilter2012.eventFileName = cms.string('HCALLaser2012AllDatasets.txt.gz')
process.load(
"EventFilter.HcalRawToDigi.hcallaserFilterFromTriggerResult_cff")
# The ECAL dead cell trigger primitive filter
process.load('RecoMET.METFilters.EcalDeadCellTriggerPrimitiveFilter_cfi')
# The EE bad SuperCrystal filter
process.load('RecoMET.METFilters.eeBadScFilter_cfi')
# The ECAL laser correction filter
process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi')
# The Good vertices collection needed by the tracking failure filter
process.goodVertices = cms.EDFilter(
"VertexSelector",
filter=cms.bool(False),
src=cms.InputTag("offlinePrimaryVertices"),
cut=cms.string(
"!isFake && ndof > 4 && abs(z) <= 24 && position.rho < 2"))
# The tracking failure filter
process.load('RecoMET.METFilters.trackingFailureFilter_cfi')
# The tracking POG filters
process.load('RecoMET.METFilters.trackingPOGFilters_cff')
###--------------------------------------------------------------
###--------------------------------------------------------------
### customise PAT
process.load('JetMETCorrections.Configuration.DefaultJEC_cff')
from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching, runOnData
if iRunOnData == True:
removeMCMatching(process, ['All'])
runOnData(process)
# Add the PF MET
from PhysicsTools.PatAlgos.tools.metTools import addPfMET
addPfMET(process, 'PF')
# Switch to PF jets
from PhysicsTools.PatAlgos.tools.jetTools import switchJetCollection
if iRunOnData == True:
switchJetCollection(process,
cms.InputTag('ak5PFJets'),
doJTA=True,
doBTagging=False,
jetCorrLabel=('AK5PF', [
'L1FastJet', 'L2Relative', 'L3Absolute',
'L2L3Residual'
]),
doType1MET=True,
genJetCollection=cms.InputTag("ak5GenJets"),
doJetID=False,
jetIdLabel="ak5")
else:
switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA=True,
doBTagging=False,
jetCorrLabel=('AK5PF', ['L1FastJet', 'L2Relative', 'L3Absolute']),
doType1MET=True,
genJetCollection=cms.InputTag("ak5GenJets"),
doJetID=False,
jetIdLabel="ak5")
from PhysicsTools.PatAlgos.tools.pfTools import usePFIso
usePFIso(process)
process.patMuons.isoDeposits = cms.PSet()
process.patMuons.isolationValues = cms.PSet()
process.patElectrons.isolationValues = cms.PSet(
pfChargedHadrons=cms.InputTag("elPFIsoValueCharged03PFIdPFIso"),
pfChargedAll=cms.InputTag("elPFIsoValueChargedAll03PFIdPFIso"),
pfPUChargedHadrons=cms.InputTag("elPFIsoValuePU03PFIdPFIso"),
pfNeutralHadrons=cms.InputTag("elPFIsoValueNeutral03PFIdPFIso"),
pfPhotons=cms.InputTag("elPFIsoValueGamma03PFIdPFIso"))
process.patElectrons.isolationValuesNoPFId = cms.PSet(
pfChargedHadrons=cms.InputTag("elPFIsoValueCharged03NoPFIdPFIso"),
pfChargedAll=cms.InputTag("elPFIsoValueChargedAll03NoPFIdPFIso"),
pfPUChargedHadrons=cms.InputTag("elPFIsoValuePU03NoPFIdPFIso"),
pfNeutralHadrons=cms.InputTag("elPFIsoValueNeutral03NoPFIdPFIso"),
pfPhotons=cms.InputTag("elPFIsoValueGamma03NoPFIdPFIso"))
process.patDefaultSequence.replace(
process.patElectrons, process.eleIsoSequence + process.patElectrons)
process.cleanPatTaus.preselection = cms.string(
'tauID("decayModeFinding") > 0.5 & tauID("byLooseCombinedIsolationDeltaBetaCorr") > 0.5'
)
###--------------------------------------------------------------
###--------------------------------------------------------------
### Object (pre) selection
# Jet selection
process.selectedPatJets.cut = cms.string("pt>10. && abs(eta)<5.")
# Remove overlaps ???
# process.cleanPatJets.finalCut = "!hasOverlaps('electrons') && !hasOverlaps('muons')"
# Apply loose PF jet ID
from PhysicsTools.SelectorUtils.pfJetIDSelector_cfi import pfJetIDSelector
process.goodPatJets = cms.EDFilter("PFJetIDSelectionFunctorFilter",
filterParams=pfJetIDSelector.clone(),
src=cms.InputTag("selectedPatJets"),
filter=cms.bool(True))
process.selectedPatMuons.cut = cms.string(
"isGlobalMuon && pt>10. && abs(eta)<2.5")
process.selectedPatElectrons.cut = cms.string("pt>10. && abs(eta)<2.5")
###--------------------------------------------------------------
###--------------------------------------------------------------
### Load the PU JetID sequence
if iRunOnData == True:
process.load("CMGTools.External.pujetidsequence_cff")
process.puJetMva.jets = cms.InputTag("goodPatJets")
process.puJetId.jets = cms.InputTag("goodPatJets")
else:
process.load("CMGTools.External.pujetidsequence_cff")
process.puJetMva.jets = cms.InputTag("goodPatJets")
process.puJetId.jets = cms.InputTag("goodPatJets")
process.puJetMvaSmeared = process.puJetMva.clone()
process.puJetIdSmeared = process.puJetId.clone()
process.puJetMvaResUp = process.puJetMva.clone()
process.puJetIdResUp = process.puJetId.clone()
process.puJetMvaResDown = process.puJetMva.clone()
process.puJetIdResDown = process.puJetId.clone()
process.puJetMvaEnUp = process.puJetMva.clone()
process.puJetIdEnUp = process.puJetId.clone()
process.puJetMvaEnDown = process.puJetMva.clone()
process.puJetIdEnDown = process.puJetId.clone()
process.puJetIdSmeared.jets = cms.InputTag("smearedGoodPatJets")
process.puJetMvaSmeared.jetids = cms.InputTag("puJetIdSmeared")
process.puJetMvaSmeared.jets = cms.InputTag("smearedGoodPatJets")
process.puJetIdResUp.jets = cms.InputTag("smearedGoodPatJetsResUp")
process.puJetMvaResUp.jetids = cms.InputTag("puJetIdResUp")
process.puJetMvaResUp.jets = cms.InputTag("smearedGoodPatJetsResUp")
process.puJetIdResDown.jets = cms.InputTag("smearedGoodPatJetsResDown")
process.puJetMvaResDown.jetids = cms.InputTag("puJetIdResDown")
process.puJetMvaResDown.jets = cms.InputTag(
"smearedGoodPatJetsResDown")
process.puJetIdEnUp.jets = cms.InputTag(
"shiftedGoodPatJetsEnUpForCorrMEt")
process.puJetMvaEnUp.jetids = cms.InputTag("puJetIdEnUp")
process.puJetMvaEnUp.jets = cms.InputTag(
"shiftedGoodPatJetsEnUpForCorrMEt")
process.puJetIdEnDown.jets = cms.InputTag(
"shiftedGoodPatJetsEnDownForCorrMEt")
process.puJetMvaEnDown.jetids = cms.InputTag("puJetIdEnDown")
process.puJetMvaEnDown.jets = cms.InputTag(
"shiftedGoodPatJetsEnDownForCorrMEt")
###--------------------------------------------------------------
###--------------------------------------------------------------
### MET
# Apply type 0 MET corrections based on PFCandidate
process.load("JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi")
process.pfType1CorrectedMet.applyType0Corrections = cms.bool(False)
process.pfType1CorrectedMet.srcType1Corrections = cms.VInputTag(
cms.InputTag('pfMETcorrType0'), cms.InputTag('pfJetMETcorr', 'type1'))
# Get loose ID/Iso muons and veto ID electrons
process.load("InvisibleHiggs.Ntuple.PhysicsObjectCandidates_cff")
# Get PFMET from runMEtUncertainties
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi")
if iRunOnData == True:
runMEtUncertainties(
process,
electronCollection=cms.InputTag('selectVetoElectrons'),
photonCollection='',
muonCollection='selectLooseMuons',
tauCollection='',
jetCollection=cms.InputTag('goodPatJets'),
jetCorrLabel='L2L3Residual',
doSmearJets=False,
makeType1corrPFMEt=True,
makeType1p2corrPFMEt=False,
makePFMEtByMVA=False,
makeNoPileUpPFMEt=False,
doApplyType0corr=True,
sysShiftCorrParameter=process.
pfMEtSysShiftCorrParameters_2012runAvsNvtx_data,
doApplySysShiftCorr=False,
addToPatDefaultSequence=False,
)
process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string(
'L2L3Residual')
process.patPFJetMETtype2Corr.jetCorrLabel = cms.string('L2L3Residual')
else:
runMEtUncertainties(
process,
electronCollection=cms.InputTag('selectVetoElectrons'),
photonCollection='',
muonCollection='selectLooseMuons',
tauCollection='',
jetCollection=cms.InputTag('goodPatJets'),
jetCorrLabel='L3Absolute',
doSmearJets=True,
makeType1corrPFMEt=True,
makeType1p2corrPFMEt=False,
makePFMEtByMVA=False,
makeNoPileUpPFMEt=False,
doApplyType0corr=True,
sysShiftCorrParameter=process.
pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc,
doApplySysShiftCorr=False,
addToPatDefaultSequence=False,
)
# Fix Type0 correction module
#process.patPFMETtype0Corr.correction.par3 = cms.double(0.909209)
#process.patPFMETtype0Corr.correction.par2 = cms.double(0.0303531)
#process.patPFMETtype0Corr.correction.par1 = cms.double(-0.703151)
#process.patPFMETtype0Corr.correction.par0 = cms.double(0.0)
# Need this line for CMSSW_5_3_11
process.producePatPFMETCorrections.replace(
process.patPFJetMETtype2Corr, process.patPFJetMETtype2Corr +
process.type0PFMEtCorrectionPFCandToVertexAssociation +
process.patPFMETtype0Corr)
#process.producePatPFMETCorrections.replace(process.patPFJetMETtype2Corr,process.patPFJetMETtype2Corr + process.patPFMETtype0Corr)
###--------------------------------------------------------------
# PAT/ntuples one step
# Z and W candidates
process.load('InvisibleHiggs/Ntuple/WCandidates_cff')
process.load('InvisibleHiggs/Ntuple/ZCandidates_cff')
# Ntuple producer
process.load('InvisibleHiggs/Ntuple/invHiggsInfo_cfi')
if iRunOnData == False:
# Jet/MET uncertainty
process.invHiggsInfo.jetTag = cms.untracked.InputTag(
"smearedGoodPatJets")
process.invHiggsInfo.metTag = cms.untracked.InputTag(
"patType1CorrectedPFMet")
process.invHiggsInfo.puJetMvaTag = cms.untracked.InputTag(
"puJetMvaSmeared", "full53xDiscriminant")
process.invHiggsInfo.puJetIdTag = cms.untracked.InputTag(
"puJetMvaSmeared", "full53xId")
# PU re-weighting
process.invHiggsInfo.puMCFile = cms.untracked.string("PUHistS10.root")
process.invHiggsInfo.puDataFile = cms.untracked.string(
"PUHistRun2012All_forParked.root")
process.invHiggsInfo.puMCHist = cms.untracked.string("pileup")
process.invHiggsInfo.puDataHist = cms.untracked.string("pileup")
process.invHiggsInfo.mcPYTHIA = cms.untracked.bool(True)
process.invHiggsInfo.trigCorrFile = cms.untracked.string(
"DataMCWeight_53X_v1.root")
# TTree output file
process.load("CommonTools.UtilAlgos.TFileService_cfi")
process.TFileService.fileName = cms.string('invHiggsInfo.root')
###--------------------------------------------------------------
###--------------------------------------------------------------
### Tau
# removeSpecificPATObjects( process, ['Taus'] )
# process.patDefaultSequence.remove( process.patTaus )
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
###--------------------------------------------------------------
###--------------------------------------------------------------
### Trigger matching
# from PhysicsTools.PatAlgos.tools.trigTools import *
# process.metTriggerMatch = cms.EDProducer(
# "PATTriggerMatcherDRLessByR" # match by DeltaR only, best match by DeltaR
# , src = cms.InputTag( 'patMETs' )
# , matched = cms.InputTag( 'patTrigger' ) # default producer label as defined in PhysicsTools/PatAlgos/python/triggerLayer1/triggerProducer_cfi.py
# , matchedCuts = cms.string( 'path( "HLT_MET100_v*" )' )
# , maxDPtRel = cms.double( 0.5 )
# , maxDeltaR = cms.double( 0.5 )
# , resolveAmbiguities = cms.bool( True ) # only one match per trigger object
# , resolveByMatchQuality = cms.bool( True ) # take best match found per reco object: by DeltaR here (s. above)
# )
# process.jetTriggerMatch = cms.EDProducer(
# "PATTriggerMatcherDRLessByR" # match by DeltaR only, best match by DeltaR
# , src = cms.InputTag( 'patJets' )
# , matched = cms.InputTag( 'patTrigger' ) # default producer label as defined in PhysicsTools/PatAlgos/python/triggerLayer1/triggerProducer_cfi.py
# , matchedCuts = cms.string( 'path( "HLT_Jet30_v*" )' )
# , maxDPtRel = cms.double( 0.5 )
# , maxDeltaR = cms.double( 0.5 )
# , resolveAmbiguities = cms.bool( True ) # only one match per trigger object
# , resolveByMatchQuality = cms.bool( True ) # take best match found per reco object: by DeltaR here (s. above)
# )
# switchOnTriggerMatchEmbedding( process, [ 'metTriggerMatch', 'jetTriggerMatch' ] )
###--------------------------------------------------------------
###--------------------------------------------------------------
### Paths
process.p0 = cms.Path(process.HBHENoiseFilter)
process.p1 = cms.Path(process.CSCTightHaloFilter)
process.p2 = cms.Path(process.hcalLaserEventFilter)
process.p3 = cms.Path(process.EcalDeadCellTriggerPrimitiveFilter)
process.p4 = cms.Path(process.eeBadScFilter)
process.p5 = cms.Path(process.ecalLaserCorrFilter)
process.p6 = cms.Path(process.goodVertices * process.trackingFailureFilter)
process.p7 = cms.Path(process.trkPOGFilters)
if iRunOnData == True:
#process.p8 = cms.Path( process.hcallLaserEvent2012Filter )
process.p8 = cms.Path(process.hcalfilter)
else:
process.p8 = cms.Path(process.primaryVertexFilter)
if iRunOnData == True:
process.p = cms.Path(
# Trigger filter
process.l1Filter * process.hltHighLevel *
# Basic filters
process.noscraping * process.primaryVertexFilter *
# MET filters (Move to be flagged)
# MET Correction
process.type0PFMEtCorrection *
# Tau
process.recoTauClassicHPSSequence *
# Generate PAT
process.pfParticleSelectionSequence * process.patDefaultSequence *
process.goodPatJets * process.PhysicsObjectSequence *
process.metUncertaintySequence * process.puJetIdSqeuence *
process.WSequence * process.ZSequence * process.invHiggsInfo)
elif (iMCSignal == True):
process.p = cms.Path(
# Trigger filter
#process.hltHighLevel *
# Basic filters
process.noscraping * process.primaryVertexFilter *
# MET filters (Move to be flags)
# MET Correction
process.type0PFMEtCorrection *
# Tau
process.recoTauClassicHPSSequence *
# Generate PAT
process.pfParticleSelectionSequence * process.patDefaultSequence *
process.goodPatJets * process.PhysicsObjectSequence *
process.metUncertaintySequence * process.puJetIdSqeuence *
process.puJetIdSmeared * process.puJetMvaSmeared *
process.puJetIdResUp * process.puJetMvaResUp *
process.puJetIdResDown * process.puJetMvaResDown *
process.puJetIdEnUp * process.puJetMvaEnUp *
process.puJetIdEnDown * process.puJetMvaEnDown *
process.WSequence * process.ZSequence * process.invHiggsInfo)
else:
process.p = cms.Path(
# Trigger filter
#process.hltHighLevel *
process.vbfFilter *
# Basic filters
process.noscraping * process.primaryVertexFilter *
# MET filters (Move to be flags)
# MET Correction
process.type0PFMEtCorrection *
# Tau
process.recoTauClassicHPSSequence *
# Generate PAT
process.pfParticleSelectionSequence * process.patDefaultSequence *
process.goodPatJets * process.PhysicsObjectSequence *
process.metUncertaintySequence * process.puJetIdSqeuence *
process.puJetIdSmeared * process.puJetMvaSmeared *
process.puJetIdResUp * process.puJetMvaResUp *
process.puJetIdResDown * process.puJetMvaResDown *
process.puJetIdEnUp * process.puJetMvaEnUp *
process.puJetIdEnDown * process.puJetMvaEnDown *
process.WSequence * process.ZSequence * process.invHiggsInfo)
###--------------------------------------------------------------
###--------------------------------------------------------------
### Output
process.out.outputCommands += [
# trigger results
'keep edmTriggerResults_*_*_*',
'keep *_hltTriggerSummaryAOD_*_*'
# L1
,
'keep *_l1extraParticles_MET_RECO',
'keep *_l1extraParticles_MHT_RECO'
# good jets
,
'keep *_goodPatJets_*_*'
# PU jet ID
,
'keep *_puJetId*_*_*',
'keep *_puJetMva*_*_*'
# vertices
,
'keep *_offlineBeamSpot_*_*',
'keep *_offlinePrimaryVertices*_*_*',
'keep *_goodOfflinePrimaryVertices*_*_*',
'keep double_*_rho_*'
]
if iRunOnData == False:
process.out.outputCommands += [
'keep GenEventInfoProduct_*_*_*', 'keep recoGenParticles_*_*_*',
'keep GenMETs_*_*_*', 'keep *_addPileupInfo_*_*',
'keep LHEEventProduct_*_*_*'
]
process.out.fileName = 'patTuple.root'
del (process.out)
del (process.outpath)
# Get PFMET from runMEtUncertainties
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
process.load("JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi")
if isData:
print "not doing runmetunc for data"
else:
runMEtUncertainties(
process,
electronCollection=cms.InputTag('cleanPatElectrons'),
photonCollection='',
muonCollection='cleanPatMuons',
tauCollection='',
jetCollection=cms.InputTag('selectedPatJets'),
jetCorrLabel='L3Absolute',
doSmearJets=True,
makeType1corrPFMEt=True,
makeType1p2corrPFMEt=False,
makePFMEtByMVA=False,
makeNoPileUpPFMEt=False,
doApplyType0corr=True,
#sysShiftCorrParameter = process.pfMEtSysShiftCorrParameters_2012runAvsNvtx_mc,
doApplySysShiftCorr=False,
)
process.producePatPFMETCorrections.replace(
process.patPFJetMETtype2Corr, process.patPFJetMETtype2Corr +
process.type0PFMEtCorrectionPFCandToVertexAssociation +
process.patPFMETtype0Corr)
process.icJetsmearedcentralJets = cms.EDProducer(
'ICPatJetCandidateProducer',
branchName=cms.untracked.string("jetsmearedcentralJets"),
process.patJetsWithOwnRef = cms.EDProducer("PatObjectOwnRefProducer<pat::Jet>",
src=cms.InputTag("selectedPatJets")
)
# type 1 +2 MET corrected
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
#Note: this module causes a large memory increase when crossing the file boundary
#Reason - unknown, solution: limit processing to ~1 file.
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process,
electronCollection=cms.InputTag("selectedPatElectrons"),
photonCollection=None,
muonCollection=cms.InputTag("selectedPatMuons"),
#FIXME: presently tau variations disabled, results in segfault
tauCollection="", # "" means emtpy, None means cleanPatTaus
jetCollection=cms.InputTag("selectedPatJets"),
jetCorrLabel="L3Absolute" if options.isMC else "L2L3Residual",
doSmearJets=options.isMC, #Note: switch this to False for the sync!
jetCorrPayloadName="AK5PFchs",
addToPatDefaultSequence=False
)
process.patPFMetNoPU = process.patMETs.clone(
metSource = cms.InputTag("pfMETNoPU"),
addMuonCorrections = cms.bool(False),
genMETSource = cms.InputTag("genMetTrue")
)
process.pfMETNoPU = process.pfMET.clone()
process.pfMETNoPU.src=cms.InputTag("pfNoPileUp"+postfix)
#rocess.pfMETNoPU.jets = cms.InputTag("pfJets"+postfix)
def filterTightWenuCandidates(process, isMC):
process.tightWenuSelectionSequence = cms.Sequence()
# Trigger requirements
process.load("HLTrigger.HLTfilters.hltHighLevel_cfi")
process.wenuHLTFilter = process.hltHighLevel.clone(
TriggerResultsTag = cms.InputTag("TriggerResults", "", "HLT"),
HLTPaths = cms.vstring([
# single electron triggers (2011 Run B)
'HLT_Ele32_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v7',
'HLT_Ele25_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v5',
# single electron triggers (Summer'11 MC)
'HLT_Ele32_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v1',
'HLT_Ele27_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v2',
]),
throw = cms.bool(False)
)
process.tightWenuSelectionSequence += process.wenuHLTFilter
# Vertex selection
process.goodVertex = cms.EDFilter("VertexSelector",
src = cms.InputTag("offlinePrimaryVertices"),
cut = cms.string("isValid & ndof >= 4 & abs(z) < 24 & abs(position.Rho) < 2"),
filter = cms.bool(True)
)
process.tightWenuSelectionSequence += process.goodVertex
process.load("CommonTools.ParticleFlow.pfNoPileUp_cff")
process.pfPileUp.Enable = cms.bool(True)
process.pfPileUp.checkClosestZVertex = cms.bool(True)
process.tightWenuSelectionSequence += process.pfNoPileUpSequence
process.load("CommonTools.ParticleFlow.pfParticleSelection_cff")
process.tightWenuSelectionSequence += process.pfParticleSelectionSequence
process.load("PhysicsTools/PatAlgos/patSequences_cff")
# compute electron IsoDeposits
process.load("TauAnalysis.Skimming.electronPFIsolationDeposits_cff")
process.load("TauAnalysis.Skimming.electronPFIsolationValues_cff")
process.electronPFIsolationSequence = cms.Sequence(
process.electronPFIsolationDepositsSequence
* process.electronPFIsolationValuesSequence
)
process.tightWenuSelectionSequence += process.electronPFIsolationSequence
# configure pat::Electron production
process.patElectrons.isoDeposits = cms.PSet(
# CV: strings for IsoDeposits defined in PhysicsTools/PatAlgos/plugins/PATMuonProducer.cc
pfChargedHadrons = cms.InputTag("elecPFIsoDepositCharged"),
pfNeutralHadrons = cms.InputTag("elecPFIsoDepositNeutral"),
pfPhotons = cms.InputTag("elecPFIsoDepositGamma"),
user = cms.VInputTag(
cms.InputTag("elecPFIsoDepositChargedAll"),
cms.InputTag("elecPFIsoDepositPU")
)
)
process.patElectrons.userIsolation = cms.PSet(
# CV: strings for Isolation values defined in PhysicsTools/PatAlgos/src/MultiIsolator.cc
pfChargedHadron = cms.PSet(
deltaR = cms.double(0.4),
src = process.patElectrons.isoDeposits.pfChargedHadrons,
vetos = process.elecPFIsoValueCharged04.deposits[0].vetos,
skipDefaultVeto = process.elecPFIsoValueCharged04.deposits[0].skipDefaultVeto
),
pfNeutralHadron = cms.PSet(
deltaR = cms.double(0.4),
src = process.patElectrons.isoDeposits.pfNeutralHadrons,
vetos = process.elecPFIsoValueNeutral04.deposits[0].vetos,
skipDefaultVeto = process.elecPFIsoValueNeutral04.deposits[0].skipDefaultVeto
),
pfGamma = cms.PSet(
deltaR = cms.double(0.4),
src = process.patElectrons.isoDeposits.pfPhotons,
vetos = process.elecEBPFIsoValueGamma04.deposits[0].vetos,
skipDefaultVeto = process.elecEBPFIsoValueGamma04.deposits[0].skipDefaultVeto
),
user = cms.VPSet(
cms.PSet(
deltaR = cms.double(0.4),
src = process.patElectrons.isoDeposits.user[0],
vetos = process.elecEBPFIsoValueChargedAll04.deposits[0].vetos,
skipDefaultVeto = process.elecEBPFIsoValueChargedAll04.deposits[0].skipDefaultVeto
),
cms.PSet(
deltaR = cms.double(0.4),
src = process.patElectrons.isoDeposits.user[1],
vetos = process.elecPFIsoValuePU04.deposits[0].vetos,
skipDefaultVeto = process.elecPFIsoValuePU04.deposits[0].skipDefaultVeto
),
cms.PSet(
deltaR = cms.double(0.4),
src = process.patElectrons.isoDeposits.pfPhotons,
vetos = process.elecEEPFIsoValueGamma04.deposits[0].vetos,
skipDefaultVeto = process.elecEEPFIsoValueGamma04.deposits[0].skipDefaultVeto
),
cms.PSet(
deltaR = cms.double(0.4),
src = process.patElectrons.isoDeposits.user[0],
vetos = process.elecEEPFIsoValueChargedAll04.deposits[0].vetos,
skipDefaultVeto = process.elecEEPFIsoValueChargedAll04.deposits[0].skipDefaultVeto
)
)
)
process.patElectrons.addGenMatch = cms.bool(False)
process.patElectrons.embedHighLevelSelection = cms.bool(True)
process.patElectrons.usePV = cms.bool(False) # compute transverse impact parameter wrt. beamspot (not event vertex)
if not isMC:
# remove MC matching from standard PAT sequences
removeMCMatching(process, ["All"], outputInProcess = False)
process.patDefaultSequence.remove(process.patJetPartonMatch)
# select tight electrons, no isolation cuts applied
process.selectedElectronsWP80 = cms.EDFilter("PATElectronSelector",
src = cms.InputTag("patElectrons"),
cut = cms.string(
'pt > 25 & abs(eta) < 2.1 & ' + \
'(isEB & ' + \
' sigmaIetaIeta < 0.010 & ' + \
' deltaPhiSuperClusterTrackAtVtx < 0.06 & deltaEtaSuperClusterTrackAtVtx < 0.004 & ' + \
' hadronicOverEm < 0.04) | ' + \
'(isEE & ' + \
' sigmaIetaIeta < 0.030 & ' + \
' deltaPhiSuperClusterTrackAtVtx < 0.03 & deltaEtaSuperClusterTrackAtVtx < 0.007 & ' + \
' hadronicOverEm < 0.025)'
),
filter = cms.bool(True)
)
process.selectedElectronsWP80conversionVeto = cms.EDFilter("NPATElectronConversionFinder",
src = cms.InputTag("selectedElectronsWP80"),
filter = cms.bool(True)
)
# select loose electrons, used for di-electron veto
process.selectedElectronsWP95 = cms.EDFilter("PATElectronSelector",
src = cms.InputTag("patElectrons"),
cut = cms.string(
'pt > 20 & abs(eta) < 2.5 & ' + \
'gsfTrack.isNonnull & gsfTrack.trackerExpectedHitsInner.numberOfHits <= 1 &' + \
'(isEB & ' + \
' sigmaIetaIeta < 0.010 & ' + \
' deltaPhiSuperClusterTrackAtVtx < 0.80 & deltaEtaSuperClusterTrackAtVtx < 0.007 & ' + \
' hadronicOverEm < 0.15) | ' + \
'(isEE & ' + \
' sigmaIetaIeta < 0.030 & ' + \
' deltaPhiSuperClusterTrackAtVtx < 0.70 & deltaEtaSuperClusterTrackAtVtx < 0.010 & ' + \
' hadronicOverEm < 0.07)'
),
filter = cms.bool(False)
)
# select tight electrons which are isolated
process.selectedIsoElectronsWP80 = cms.EDFilter("PATElectronSelector",
src = cms.InputTag("selectedElectronsWP80conversionVeto"),
cut = cms.string(
'(isEB & ' + \
'(userIsolation("pat::User1Iso")' + \
' + max(0., userIsolation("pat::PfNeutralHadronIso") + userIsolation("pat::PfGammaIso")' + \
' - 0.5*userIsolation("pat::User2Iso"))) < 0.06*pt) | ' + \
'(isEE & ' + \
'(userIsolation("pat::User4Iso")' + \
' + max(0., userIsolation("pat::PfNeutralHadronIso") + userIsolation("pat::User3Iso")' + \
' - 0.5*userIsolation("pat::User2Iso"))) < 0.06*pt)'
),
filter = cms.bool(False)
)
process.patDefaultSequence.replace(
process.patElectrons,
process.patElectrons
* process.selectedElectronsWP80 * process.selectedElectronsWP80conversionVeto * process.selectedIsoElectronsWP80
* process.selectedElectronsWP95)
# configure pat::Jet production
# (enable L2L3Residual corrections in case running on Data)
jetCorrections = [ 'L1FastJet', 'L2Relative', 'L3Absolute' ]
if not isMC:
jetCorrections.append('L2L3Residual')
switchJetCollection(
process,
cms.InputTag('ak5PFJets'),
doJTA = True,
doBTagging = False,
jetCorrLabel = ( 'AK5PF', cms.vstring(jetCorrections) ),
doType1MET = False,
doJetID = True,
jetIdLabel = "ak5",
outputModule = ''
)
# configure pat::MET production
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
process.tightWenuSelectionSequence += process.kt6PFJets
process.tightWenuSelectionSequence += process.ak5PFJets
process.tightWenuSelectionSequence += process.patDefaultSequence
doSmearJets = None
if isMC:
doSmearJets = True
else:
doSmearJets = False
runMEtUncertainties(
process,
electronCollection = cms.InputTag('selectedIsoElectronsWP80'),
photonCollection = '',
muonCollection = '',
tauCollection = '',
jetCollection = cms.InputTag('patJets'),
doSmearJets = doSmearJets,
addToPatDefaultSequence = False
)
if isMC:
process.patPFMet.addGenMET = cms.bool(True)
process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string("L3Absolute")
process.tightWenuSelectionSequence += process.metUncertaintySequence
else:
process.patPFMet.addGenMET = cms.bool(False)
process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string("L2L3Residual")
process.tightWenuSelectionSequence += process.patJetsNotOverlappingWithLeptonsForMEtUncertainty
process.tightWenuSelectionSequence += process.producePatPFMETCorrections
# Apply event selection cuts
process.isoElectronWP80Filter = cms.EDFilter("CandViewCountFilter",
src = cms.InputTag("selectedIsoElectronsWP80"),
minNumber = cms.uint32(1)
)
process.tightWenuSelectionSequence += process.isoElectronWP80Filter
process.diElectronVeto = cms.EDFilter("PATCandViewMaxFilter",
src = cms.InputTag("selectedElectronsWP95"),
maxNumber = cms.uint32(1)
)
process.tightWenuSelectionSequence += process.diElectronVeto
process.WenuCandidates = cms.EDProducer("PATElecNuPairProducer",
srcVisDecayProducts = cms.InputTag('selectedIsoElectronsWP80'),
srcMET = cms.InputTag('patType1CorrectedPFMet'),
verbosity = cms.untracked.int32(0)
)
process.tightWenuSelectionSequence += process.WenuCandidates
process.selectedWenuCandidates = cms.EDFilter("PATElecNuPairSelector",
src = cms.InputTag("WenuCandidates"),
cut = cms.string('mt > 50.'),
filter = cms.bool(False)
)
process.tightWenuSelectionSequence += process.selectedWenuCandidates
process.tightWenuFilter = cms.EDFilter("CandViewCountFilter",
src = cms.InputTag("selectedWenuCandidates"),
minNumber = cms.uint32(1)
)
process.tightWenuSelectionSequence += process.tightWenuFilter
#################
## The MET Uncertainty tool needs some more things to be there:
process.load("Configuration.StandardSequences.Geometry_cff")
process.load(
"Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
from Configuration.AlCa.autoCond import autoCond
process.GlobalTag.globaltag = cms.string(autoCond['startup'])
process.load("Configuration.StandardSequences.MagneticField_cff")
process.load("PhysicsTools.PatAlgos.patSequences_cff")
#Applying the MET Uncertainty tools
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(
process,
electronCollection=cms.InputTag("selectedPatElectronsPFlow"),
jetCollection="selectedPatJetsPFlow",
muonCollection=cms.InputTag("selectedPatMuonsPFlow"),
tauCollection=cms.InputTag("selectedPatTausPFlow"))
#process.shiftedPatJetsEnUp=process.shiftedPatJetsPFlowEnUpForCorrMEt.clone(shiftBy=cms.double(2), src="selectedPatJetsPFlow")
#process.jecAnalyzerEnUp=process.jecAnalyzer.clone(Jets = cms.InputTag("shiftedPatJetsEnUp"))
#process.p_jec.__iadd__( process.shiftedPatJetsEnUp * process.jecAnalyzerEnUp)
#################
# #
# EXERCISE 4 #
# #
#################
process.patJPsiCandidates = cms.EDProducer(
"PatJPsiProducer", muonSrc=cms.InputTag("selectedPatMuonsPFlow"))
def SingleTopStep1(
process,
):
options = VarParsing('analysis')
options.register ('isMC', True,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Run on MC"
)
options.register ('doDebug', False,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Run in debugging mode"
)
options.register ('doSkimming', True,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Preselect events"
)
options.register ('doSlimming', True,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Drop unnecessary collections"
)
options.register ('doMuon', True,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Do muon paths"
)
options.register ('doElectron', True,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Do electron paths"
)
#Tag from https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideFrontierConditions?redirectedfrom=CMS.SWGuideFrontierConditions#2012_MC_production
# Latest for "53Y Releases (MC)"
options.register ('globalTag', Config.globalTagMC,
VarParsing.multiplicity.singleton,
VarParsing.varType.string,
"Global tag"
)
options.parseArguments()
process.source.fileNames = cms.untracked.vstring(options.inputFiles)
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(options.maxEvents)
)
process.out.fileName = cms.untracked.string(options.outputFile)
process.options = cms.untracked.PSet(wantSummary=cms.untracked.bool(options.doDebug))
if options.doDebug:
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger = cms.Service("MessageLogger",
destinations=cms.untracked.vstring('cout', 'debug'),
debugModules=cms.untracked.vstring('*'),
cout=cms.untracked.PSet(threshold=cms.untracked.string('INFO')),
debug=cms.untracked.PSet(threshold=cms.untracked.string('DEBUG')),
)
else:
process.load("FWCore.MessageService.MessageLogger_cfi")
postfix = ""
jetCorr = ['L1FastJet', 'L2Relative', 'L3Absolute']
if not options.isMC:
jetCorr += ['L2L3Residual']
usePF2PAT(process, runPF2PAT=True, jetAlgo='AK5', runOnMC=options.isMC, postfix=postfix,
jetCorrections=('AK5PFchs', jetCorr),
pvCollection=cms.InputTag('goodOfflinePrimaryVertices'),
#typeIMetCorrections = True
typeIMetCorrections = False #Type1 MET now applied later using runMETUncertainties
)
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU2012
process.pfPileUp.Enable = True
process.pfPileUp.checkClosestZVertex = False
#-------------------------------------------------
# selection step 2: vertex filter
#-------------------------------------------------
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU2012
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefEventSel#Cleaning_Filters
process.goodOfflinePrimaryVertices = cms.EDFilter(
"PrimaryVertexObjectFilter"
, filterParams = cms.PSet(
minNdof = cms.double(4.0)
, maxZ = cms.double(24.0)
, maxRho = cms.double(2.0)
)
, filter = cms.bool(True)
, src = cms.InputTag('offlinePrimaryVertices')
)
#-------------------------------------------------
# Muons
#-------------------------------------------------
#if not maxLeptonIso is None:
# process.pfIsolatedMuons.isolationCut = maxLeptonIso
#Use both isolated and non-isolated muons as a patMuon source
#process.patMuons.pfMuonSource = cms.InputTag("pfMuons")
#process.muonMatch.src = cms.InputTag("pfMuons")
process.patMuons.pfMuonSource = cms.InputTag("pfIsolatedMuons")
process.muonMatch.src = cms.InputTag("pfIsolatedMuons")
process.selectedPatMuons.cut = "pt>20 && abs(eta)<3.0"
# muon ID production (essentially track count embedding) must be here
# because tracks get dropped from the collection after this step, resulting
# in null ptrs.
process.muonsWithID = cms.EDProducer(
'MuonIDProducer',
muonSrc = cms.InputTag("selectedPatMuons"),
primaryVertexSource = cms.InputTag("goodOfflinePrimaryVertices")
)
#process.muonClones = cms.EDProducer("MuonShallowCloneProducer",
# src = cms.InputTag("selectedPatMuons")
#)
#-------------------------------------------------
# Electrons
# Implemented as in https://indico.cern.ch/getFile.py/access?contribId=1&resId=0&materialId=slides&confId=208765
#-------------------------------------------------
#if not maxLeptonIso is None:
# process.pfIsolatedElectrons.isolationCut = maxLeptonIso
#Use both isolated and un-isolated electrons as patElectrons.
#NB: no need to change process.electronMatch.src to pfElectrons,
# it's already gsfElectrons, which is a superset of the pfElectrons
process.patElectrons.pfElectronSource = cms.InputTag("pfElectrons")
process.load('EGamma.EGammaAnalysisTools.electronIdMVAProducer_cfi')
process.mvaID = cms.Sequence(process.mvaTrigV0 + process.mvaNonTrigV0)
process.patElectrons.electronIDSources.mvaTrigV0 = cms.InputTag("mvaTrigV0")
process.patElectrons.electronIDSources.mvaNonTrigV0 = cms.InputTag("mvaNonTrigV0")
process.patPF2PATSequence.replace(process.patElectrons, process.mvaID * process.patElectrons)
process.selectedPatElectrons.cut = "pt>25 && abs(eta)<3.0"
process.electronsWithID = cms.EDProducer(
'ElectronIDProducer',
electronSrc = cms.InputTag("selectedPatElectrons"),
primaryVertexSource = cms.InputTag("goodOfflinePrimaryVertices")
)
#process.electronClones = cms.EDProducer("ElectronShallowCloneProducer",
# src = cms.InputTag("selectedPatElectrons")
#)
#if not maxLeptonIso is None:
# process.pfIsolatedElectrons.isolationCut = maxLeptonIso
#electron dR=0.3
process.pfElectrons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId"))
process.pfElectrons.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId")
process.pfElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId"))
process.pfElectrons.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId")
process.pfElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId"))
process.patElectrons.isolationValues.pfNeutralHadrons = cms.InputTag("elPFIsoValueNeutral03PFId")
process.patElectrons.isolationValues.pfChargedAll = cms.InputTag("elPFIsoValueChargedAll03PFId")
process.patElectrons.isolationValues.pfPUChargedHadrons = cms.InputTag("elPFIsoValuePU03PFId")
process.patElectrons.isolationValues.pfPhotons = cms.InputTag("elPFIsoValueGamma03PFId")
process.patElectrons.isolationValues.pfChargedHadrons = cms.InputTag("elPFIsoValueCharged03PFId")
process.pfIsolatedElectrons.isolationValueMapsCharged = cms.VInputTag(cms.InputTag("elPFIsoValueCharged03PFId"))
process.pfIsolatedElectrons.deltaBetaIsolationValueMap = cms.InputTag("elPFIsoValuePU03PFId")
process.pfIsolatedElectrons.isolationValueMapsNeutral = cms.VInputTag(cms.InputTag("elPFIsoValueNeutral03PFId"), cms.InputTag("elPFIsoValueGamma03PFId"))
#-------------------------------------------------
# Jets
# MET corrections as https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMetAnalysis#Type_I_0_with_PAT
#-------------------------------------------------
#pfNoTau == True => remove taus from jets
#process.pfNoTau.enable = noTau
process.selectedPatJets.cut = cms.string("pt>30 && abs(eta)<5.0")
process.load("CMGTools.External.pujetidsequence_cff")
process.patPF2PATSequence += process.puJetIdSqeuence
#process.jetClones = cms.EDProducer("CaloJetShallowCloneProducer",
# src = cms.InputTag("seletedPatJets")
#)
#-------------------------------------------------
# MET uncertainty step
#-------------------------------------------------
#Embed the reference to the original jet in the jets, which is constant during the propagation
process.patJetsWithOwnRef = cms.EDProducer('PatObjectOwnRefProducer<pat::Jet>',
src=cms.InputTag("selectedPatJets")
)
#Note: this module causes a large memory increase when crossing the file boundary
#Reason - unknown, solution: limit processing to ~1 file.
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process,
electronCollection=cms.InputTag("electronsWithID"),
photonCollection=None,
muonCollection=cms.InputTag("muonsWithID"),
tauCollection="", # "" means emtpy, None means cleanPatTaus
jetCollection=cms.InputTag("patJetsWithOwnRef"),
jetCorrLabel="L3Absolute" if options.isMC else "L2L3Residual",
doSmearJets=options.isMC,
jetCorrPayloadName="AK5PFchs",
addToPatDefaultSequence=False
)
process.stpolMetUncertaintySequence = cms.Sequence(
process.metUncertaintySequence
)
if not options.doSlimming:
process.out.outputCommands = cms.untracked.vstring('keep *')
else:
process.out.outputCommands = cms.untracked.vstring([
'drop *',
'keep edmMergeableCounter_*_*_*', # Keep the lumi-block counter information
'keep edmTriggerResults_TriggerResults__*', #Keep the trigger results
'keep *_genParticles__*', #keep all the genParticles
#'keep recoVertexs_offlinePrimaryVertices__*', #keep the offline PV-s
'keep recoVertexs_goodOfflinePrimaryVertices__*', #keep the offline PV-s
# Jets
'keep patJets_*__*',
'keep double_*_rho_*', #For rho-corr rel iso
'keep recoGenJets_selectedPatJets_genJets_*', #For Jet MC smearing we need to keep the genJets
"keep *_puJetId_*_*", # input variables
"keep *_puJetMva_*_*", # final MVAs and working point flags
'keep *_jetClones__*',
# Muons
'keep patMuons_*__*',
'keep *_muonClones__*',
# Electrons
'keep patElectrons_*__*',
'keep *_electronClones__*',
# METs
'keep patMETs_*__*',
#ECAL laser corr filter
'keep bool_ecalLaserCorrFilter__*',
#For flavour analyzer
'keep GenEventInfoProduct_generator__*',
#PU info
'keep PileupSummaryInfos_addPileupInfo__*',
##PFCandidates
#'keep recoPFCandidates_*_pfCandidates_PAT',
#'keep recoPFMETs_pfMET__*',
#'keep recoPFMETs_pfMet__*',
#'keep recoGenMETs_genMetTrue__*',
#'keep recoPFCandidates_particleFlow__*',
#'keep recoConversions_allConversions__*',
#'keep recoVertexCompositeCandidates_generalV0Candidates_*_*',
#'keep recoTracks_generalTracks__*',
#'keep recoBeamSpot_offlineBeamSpot__*',
#'keep recoMuons_muons__*',
'keep int_*__PAT',
'keep ints_*__PAT',
'keep double_*__PAT',
'keep doubles_*__PAT',
'keep float_*__PAT',
'keep floats_*__PAT',
])
#FIXME: is this correct?
#Keep events that pass either the muon OR the electron path
process.out.SelectEvents = cms.untracked.PSet(
SelectEvents = cms.vstring(
[]
)
)
#-------------------------------------------------
# Paths
#-------------------------------------------------
process.goodOfflinePVCount = cms.EDProducer(
"CollectionSizeProducer<reco::Vertex>",
src = cms.InputTag("goodOfflinePrimaryVertices")
)
process.preCalcSequences = cms.Sequence(
process.patJetsWithOwnRef *
process.goodOfflinePVCount
)
process.patPF2PATSequence.insert(process.patPF2PATSequence.index(process.selectedPatMuons) + 1, process.muonsWithID)
process.patPF2PATSequence.insert(process.patPF2PATSequence.index(process.selectedPatElectrons) + 1, process.electronsWithID)
#Need separate paths because of skimming
if options.doMuon:
process.singleTopPathStep1Mu = cms.Path(
process.goodOfflinePrimaryVertices
* process.patPF2PATSequence
#* process.muonClones
#* process.electronClones
#* process.jetClones
)
if options.doElectron:
process.singleTopPathStep1Ele = cms.Path(
process.goodOfflinePrimaryVertices
* process.patPF2PATSequence
#* process.muonClones
#* process.electronClones
#* process.jetClones
)
if options.doMuon:
process.out.SelectEvents.SelectEvents.append("singleTopPathStep1Mu")
if options.doElectron:
process.out.SelectEvents.SelectEvents.append("singleTopPathStep1Ele")
process.GlobalTag.globaltag = cms.string(options.globalTag)
process.singleTopPathStep1Mu += process.preCalcSequences
process.singleTopPathStep1Ele += process.preCalcSequences
if options.doMuon:
process.singleTopPathStep1Mu += process.stpolMetUncertaintySequence
if options.doElectron:
process.singleTopPathStep1Ele += process.stpolMetUncertaintySequence
if options.isMC:
#https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration?redirectedfrom=CMS.SWGuideBTagJetProbabilityCalibration#Calibration_in_53x_Data_and_MC
process.GlobalTag.toGet = cms.VPSet(
cms.PSet(record = cms.string("BTagTrackProbability2DRcd"),
tag = cms.string("TrackProbabilityCalibration_2D_MC53X_v2"),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")),
cms.PSet(record = cms.string("BTagTrackProbability3DRcd"),
tag = cms.string("TrackProbabilityCalibration_3D_MC53X_v2"),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU"))
)
else:
#https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration?redirectedfrom=CMS.SWGuideBTagJetProbabilityCalibration#Calibration_in_53x_Data_and_MC
process.GlobalTag.toGet = cms.VPSet(
cms.PSet(record = cms.string("BTagTrackProbability2DRcd"),
tag = cms.string("TrackProbabilityCalibration_2D_Data53X_v2"),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU")),
cms.PSet(record = cms.string("BTagTrackProbability3DRcd"),
tag = cms.string("TrackProbabilityCalibration_3D_Data53X_v2"),
connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU"))
)
process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi')
process.ecalLaserCorrFilter.taggingMode=True
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefEventSel#Cleaning_Filters
process.scrapingFilter = cms.EDFilter("FilterOutScraping"
, applyfilter = cms.untracked.bool(True)
, debugOn = cms.untracked.bool(False)
, numtrack = cms.untracked.uint32(10)
, thresh = cms.untracked.double(0.25)
)
#if doElectron:
# process.singleTopPathStep1Ele.insert(0, process.scrapingFilter)
#if doMuon:
# process.singleTopPathStep1Mu.insert(0, process.scrapingFilter)
process.patPF2PATSequence += process.scrapingFilter
process.patPF2PATSequence += process.ecalLaserCorrFilter
#if not onGrid:
# from SingleTopPolarization.Analysis.cmdlineParsing import enableCommandLineArguments
# enableCommandLineArguments(process)
#else:
# process.out.fileName = "step1.root"
if options.doSkimming:
process.out.fileName.setValue(process.out.fileName.value().replace(".root", "_Skim.root"))
else:
process.out.fileName.setValue(process.out.fileName.value().replace(".root", "_noSkim.root"))
#-----------------------------------------------
# Skimming
#-----------------------------------------------
#Throw away events before particle flow?
if options.doSkimming:
from SingleTopPolarization.Analysis.eventSkimming_cfg import skimFilters
skimFilters(process)
if options.doMuon:
process.singleTopPathStep1Mu.insert(0, process.muonSkim)
if options.doElectron:
process.singleTopPathStep1Ele.insert(0, process.electronSkim)
#-----------------------------------------------
# Skim efficiency counters
#-----------------------------------------------
#count all processed events
countProcessed(process)
#count events passing mu and ele paths
if options.doMuon:
countInSequence(process, process.singleTopPathStep1Mu)
if options.doElectron:
countInSequence(process, process.singleTopPathStep1Ele)
#-------------------------------------------------
#
#-------------------------------------------------
if not options.doSlimming:
process.out.fileName.setValue(process.out.fileName.value().replace(".root", "_noSlim.root"))
return process
def configurePatTupleProduction(process,
patSequenceBuilder=buildGenericTauSequence,
patPFTauCleanerPrototype=None,
patCaloTauCleanerPrototype=None,
addSVfitInfo=False,
hltProcess="HLT",
isMC=False,
applyTauVertexMatch=True):
# check that patSequenceBuilder and patTauCleanerPrototype are defined and non-null
if patSequenceBuilder is None:
raise ValueError("Undefined 'patSequenceBuilder' Parameter !!")
if patPFTauCleanerPrototype is None or patCaloTauCleanerPrototype is None:
raise ValueError("Undefined 'patTauCleanerPrototype' Parameter !!")
#--------------------------------------------------------------------------------
# produce PAT objects
#--------------------------------------------------------------------------------
process.load("PhysicsTools.PatAlgos.patSequences_cff")
process.load("PhysicsTools.PatAlgos.producersLayer1.tauProducer_cff")
process.load("PhysicsTools.PatAlgos.producersLayer1.muonProducer_cff")
process.load("PhysicsTools.PatAlgos.producersLayer1.metProducer_cff")
process.load("TauAnalysis.CandidateTools.muTauPairProduction_cff")
# per default, do **not** run SVfit algorithm
if not addSVfitInfo:
process.allMuTauPairs.doSVreco = cms.bool(False)
process.allMuTauPairs.doPFMEtSign = cms.bool(False)
process.allMuTauPairsLooseMuonIsolation.doSVreco = cms.bool(False)
process.allMuTauPairsLooseMuonIsolation.doPFMEtSign = cms.bool(False)
if not isMC:
removeMCMatching(process, ["All"], outputModules=[])
else:
# match pat::Taus to all genJets
# (including to genJets build from electrons/muons produced in tau --> e/mu decays)
process.tauGenJetMatch.matched = cms.InputTag("tauGenJets")
#--------------------------------------------------------------------------------
# configure PAT trigger matching
switchOnTrigger(process, hltProcess=hltProcess, outputModule='')
# CV: disable L1Algos in MC for now, to prevent error messages
#
# %MSG-e L1GlobalTriggerObjectMapRecord: PATTriggerProducer:patTrigger
#
# ERROR: The requested algorithm name = L1_DoubleEG1
# does not exists in the trigger menu.
# Returning zero pointer for getObjectMap
#
# to be printed for every event (06/05/2011)
#
# for Data the L1Algos flag needs to be enabled,
# in order for the prescale computation/correction for Data
# implemented in TauAnalysis/TauIdEfficiency/bin/FWLiteTauIdEffAnalyzer.cc to work
if isMC:
process.patTrigger.addL1Algos = cms.bool(False)
else:
process.patTrigger.addL1Algos = cms.bool(True)
process.patTauTriggerMatchHLTprotoType = cms.EDProducer(
"PATTriggerMatcherDRLessByR",
src=cms.InputTag("cleanLayer1Taus"),
matched=cms.InputTag("patTrigger"),
matchedCuts=cms.string('path("HLT_Jet30_v*")'),
maxDPtRel=cms.double(1.e+3),
maxDeltaR=cms.double(0.5),
resolveAmbiguities=cms.bool(True),
resolveByMatchQuality=cms.bool(True))
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
# compute Pt sum of charged + neutral hadrons and photons within isolation cones of size dR = 0.4/0.6
process.load("RecoMuon/MuonIsolation/muonPFIsolation_cff")
patutils.massSearchReplaceAnyInputTag(
process.muonPFIsolationDepositsSequence, cms.InputTag('muons1stStep'),
cms.InputTag('muons'))
process.patMuons.isoDeposits = cms.PSet(
# CV: strings for IsoDeposits defined in PhysicsTools/PatAlgos/plugins/PATMuonProducer.cc
pfChargedHadrons=cms.InputTag("muPFIsoDepositCharged"),
pfNeutralHadrons=cms.InputTag("muPFIsoDepositNeutral"),
pfPhotons=cms.InputTag("muPFIsoDepositGamma"),
user=cms.VInputTag(cms.InputTag("muPFIsoDepositChargedAll"),
cms.InputTag("muPFIsoDepositPU")))
process.patMuons.userIsolation = cms.PSet(
# CV: strings for Isolation values defined in PhysicsTools/PatAlgos/src/MultiIsolator.cc
pfChargedHadron=cms.PSet(
deltaR=cms.double(0.4),
src=process.patMuons.isoDeposits.pfChargedHadrons,
vetos=process.muPFIsoValueCharged04.deposits[0].vetos,
skipDefaultVeto=process.muPFIsoValueCharged04.deposits[0].
skipDefaultVeto),
pfNeutralHadron=cms.PSet(
deltaR=cms.double(0.4),
src=process.patMuons.isoDeposits.pfNeutralHadrons,
vetos=process.muPFIsoValueNeutral04.deposits[0].vetos,
skipDefaultVeto=process.muPFIsoValueNeutral04.deposits[0].
skipDefaultVeto),
pfGamma=cms.PSet(deltaR=cms.double(0.4),
src=process.patMuons.isoDeposits.pfPhotons,
vetos=process.muPFIsoValueGamma04.deposits[0].vetos,
skipDefaultVeto=process.muPFIsoValueGamma04.
deposits[0].skipDefaultVeto),
user=cms.VPSet(
cms.PSet(deltaR=cms.double(0.4),
src=process.patMuons.isoDeposits.user[0],
vetos=process.muPFIsoValueChargedAll04.deposits[0].vetos,
skipDefaultVeto=process.muPFIsoValueChargedAll04.
deposits[0].skipDefaultVeto),
cms.PSet(deltaR=cms.double(0.4),
src=process.patMuons.isoDeposits.user[1],
vetos=process.muPFIsoValuePU04.deposits[0].vetos,
skipDefaultVeto=process.muPFIsoValuePU04.deposits[0].
skipDefaultVeto)))
process.patMuonsWithinAcc = cms.EDFilter(
"PATMuonSelector",
src=cms.InputTag('patMuons'),
cut=cms.string("pt > 15. & abs(eta) < 2.1"),
filter=cms.bool(False))
process.selectedPatMuonsVBTFid = cms.EDFilter(
"PATMuonIdSelector",
src=cms.InputTag('patMuonsWithinAcc'),
vertexSource=cms.InputTag('selectedPrimaryVertexPosition'),
beamSpotSource=cms.InputTag('offlineBeamSpot'),
filter=cms.bool(False))
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
#
# produce collections of pat::Jets for CaloJets and PFJets
#
# NOTE: needed for evaluating jetId for Calo/TCTaus and PFTaus
#
jec = ['L1FastJet', 'L2Relative', 'L3Absolute']
if not isMC:
jec.extend(['L2L3Residual'])
addJetCollection(process,
cms.InputTag('ak5PFJets'),
'AK5',
'PF',
doJTA=False,
doBTagging=False,
jetCorrLabel=('AK5PF', cms.vstring(jec)),
doType1MET=False,
genJetCollection=cms.InputTag("ak5GenJets"),
doJetID=True,
jetIdLabel="ak5",
outputModules=[])
addJetCollection(process,
cms.InputTag('ak5CaloJets'),
'AK5',
'Calo',
doJTA=False,
doBTagging=False,
jetCorrLabel=('AK5Calo', cms.vstring(jec)),
doType1MET=False,
genJetCollection=cms.InputTag("ak5GenJets"),
doJetID=True,
jetIdLabel="ak5",
outputModules=[])
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
#
# configure Jet Energy Corrections
#
process.load("TauAnalysis.Configuration.jetCorrectionParameters_cfi")
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
# add pfMET
process.load("PhysicsTools.PatUtils.patPFMETCorrections_cff")
if isMC:
import PhysicsTools.PatAlgos.tools.helpers as configtools
configtools.cloneProcessingSnippet(process,
process.producePatPFMETCorrections,
"NoSmearing")
process.selectedPatJetsForMETtype1p2CorrNoSmearing.src = cms.InputTag(
'patJetsNotOverlappingWithLeptonsForMEtUncertainty')
process.selectedPatJetsForMETtype2CorrNoSmearing.src = process.selectedPatJetsForMETtype1p2CorrNoSmearing.src
process.patMEtProductionSequence = cms.Sequence()
process.patMEtProductionSequence += process.patDefaultSequence
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
doSmearJets = None
if isMC:
doSmearJets = True
else:
doSmearJets = False
runMEtUncertainties(
process,
electronCollection='',
photonCollection='',
muonCollection=cms.InputTag('selectedPatMuonsVBTFid'),
tauCollection='',
jetCollection=cms.InputTag('patJetsAK5PF'),
doSmearJets=doSmearJets,
doApplyType0corr=True,
sysShiftCorrParameter=None,
doApplySysShiftCorr=False,
# CV: shift Jet energy by 3 standard-deviations,
# so that template morphing remains an interpolation and no extrapolation is needed
varyByNsigmas=3.0,
addToPatDefaultSequence=False)
if isMC:
process.patPFMet.addGenMET = cms.bool(True)
process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string("L3Absolute")
process.patMEtProductionSequence += process.metUncertaintySequence
else:
process.patPFMet.addGenMET = cms.bool(False)
process.patPFJetMETtype1p2Corr.jetCorrLabel = cms.string(
"L2L3Residual")
process.patMEtProductionSequence += process.patJetsAK5PFnotOverlappingWithLeptonsForMEtUncertainty
process.patMEtProductionSequence += process.producePatPFMETCorrections
#--------------------------------------------------------------------------------
pfJetCollection = 'patJetsAK5PFnotOverlappingWithLeptonsForMEtUncertainty'
pfMEtCollection = 'patType1CorrectedPFMet'
if isMC:
pfJetCollection = 'smearedPatJetsAK5PF'
#--------------------------------------------------------------------------------
#
# produce combinations of muon + tau-jet pairs
# for collection of pat::Tau objects representing CaloTaus
#
switchToCaloTau(process)
process.patCaloTauProducer = copy.deepcopy(process.patTaus)
retVal_caloTau = patSequenceBuilder(
process,
collectionName=["patCaloTaus", ""],
jetCollectionName="patJetsAK5Calo",
patTauProducerPrototype=process.patCaloTauProducer,
patTauCleanerPrototype=patCaloTauCleanerPrototype,
triggerMatcherProtoType=process.patTauTriggerMatchHLTprotoType,
addGenInfo=isMC,
applyTauJEC=False,
applyTauVertexMatch=applyTauVertexMatch)
process.caloTauSequence = retVal_caloTau["sequence"]
process.patMuonCaloTauPairs = process.allMuTauPairs.clone(
srcLeg1=cms.InputTag('selectedPatMuonsVBTFid'),
srcLeg2=cms.InputTag(retVal_caloTau["collection"]),
srcMET=cms.InputTag('patMETs'),
srcGenParticles=cms.InputTag(''),
doSVreco=cms.bool(False),
doPFMEtSign=cms.bool(False))
if hasattr(process.patMuonCaloTauPairs, "nSVfit"):
delattr(process.patMuonCaloTauPairs, "nSVfit")
if hasattr(process.patMuonCaloTauPairs, "pfMEtSign"):
delattr(process.patMuonCaloTauPairs, "pfMEtSign")
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
#
# produce collection of pat::Tau objects representing PFTaus
# reconstructed by fixed signal cone algorithm
# (plus combinations of muon + tau-jet pairs)
#
#switchToPFTauFixedCone(process)
#process.patPFTauProducerFixedCone = copy.deepcopy(process.patTaus)
#
#retVal_pfTauFixedCone = patSequenceBuilder(
# process,
# collectionName = [ "patPFTaus", "FixedCone" ],
# jetCollectionName = pfJetCollection,
# patTauProducerPrototype = process.patPFTauProducerFixedCone,
# patTauCleanerPrototype = patPFTauCleanerPrototype,
# triggerMatcherProtoType = process.patTauTriggerMatchHLTprotoType,
# addGenInfo = isMC,
# applyTauJEC = False,
# applyTauVertexMatch = applyTauVertexMatch
#)
#process.pfTauSequenceFixedCone = retVal_pfTauFixedCone["sequence"]
#
#process.patMuonPFTauPairsFixedCone = process.allMuTauPairs.clone(
# srcLeg1 = cms.InputTag('selectedPatMuonsVBTFid'),
# srcLeg2 = cms.InputTag(retVal_pfTauFixedCone["collection"]),
# srcMET = cms.InputTag(pfMEtCollection),
# srcGenParticles = cms.InputTag(''),
# doSVreco = cms.bool(False)
#)
#if hasattr(process.patMuonPFTauPairsFixedCone, "nSVfit"):
# delattr(process.patMuonPFTauPairsFixedCone, "nSVfit")
#if hasattr(process.patMuonPFTauPairsFixedCone, "pfMEtSign"):
# delattr(process.patMuonPFTauPairsFixedCone, "pfMEtSign")
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
#
# produce collection of pat::Tau objects representing PFTaus
# reconstructed by shrinking signal cone algorithm
# (plus combinations of muon + tau-jet pairs)
#
#switchToPFTauShrinkingCone(process)
#process.patPFTauProducerShrinkingCone = copy.deepcopy(process.patTaus)
#
#retVal_pfTauShrinkingCone = patSequenceBuilder(
# process,
# collectionName = [ "patPFTaus", "ShrinkingCone" ],
# jetCollectionName = pfJetCollection,
# patTauProducerPrototype = process.patPFTauProducerShrinkingCone,
# patTauCleanerPrototype = patPFTauCleanerPrototype,
# triggerMatcherProtoType = process.patTauTriggerMatchHLTprotoType,
# addGenInfo = isMC,
# applyTauJEC = False,
# applyTauVertexMatch = applyTauVertexMatch
#)
#process.pfTauSequenceShrinkingCone = retVal_pfTauShrinkingCone["sequence"]
#
#process.patMuonPFTauPairsShrinkingCone = process.allMuTauPairs.clone(
# srcLeg1 = cms.InputTag('selectedPatMuonsVBTFid'),
# srcLeg2 = cms.InputTag(retVal_pfTauShrinkingCone["collection"]),
# srcMET = cms.InputTag(pfMEtCollection),
# srcGenParticles = cms.InputTag(''),
# doSVreco = cms.bool(False)
#)
#if hasattr(process.patMuonPFTauPairsShrinkingCone, "nSVfit"):
# delattr(process.patMuonPFTauPairsShrinkingCone, "nSVfit")
#if hasattr(process.patMuonPFTauPairsShrinkingCone, "pfMEtSign"):
# delattr(process.patMuonPFTauPairsShrinkingCone, "pfMEtSign")
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
#
# produce collection of pat::Tau objects representing PFTaus
# reconstructed by hadron + strips (HPS) algorithm
# (plus combinations of muon + tau-jet pairs)
#
# NOTE: switchToPFTauHPS function overwrites process.cleanPatTaus.preselection using HPS specific discriminators;
# undo overwriting, in order to prevent run-time errors in case of subsequence _switchToPFTau call,
# arising from the fact that HPS specific discriminators are not available for all tau types
#
switchToPFTauHPS(process)
process.cleanPatTaus.preselection = cms.string('')
process.patPFTauProducerHPS = copy.deepcopy(process.patTaus)
retVal_pfTauHPS = patSequenceBuilder(
process,
collectionName=["patPFTaus", "HPS"],
jetCollectionName=pfJetCollection,
patTauProducerPrototype=process.patPFTauProducerHPS,
patTauCleanerPrototype=patPFTauCleanerPrototype,
triggerMatcherProtoType=process.patTauTriggerMatchHLTprotoType,
addGenInfo=isMC,
applyTauJEC=True,
applyTauVertexMatch=applyTauVertexMatch)
process.pfTauSequenceHPS = retVal_pfTauHPS["sequence"]
process.patMuonPFTauPairsHPS = process.allMuTauPairs.clone(
srcLeg1=cms.InputTag('selectedPatMuonsVBTFid'),
srcLeg2=cms.InputTag(retVal_pfTauHPS["collection"]),
srcMET=cms.InputTag(pfMEtCollection),
srcGenParticles=cms.InputTag(''),
doSVreco=cms.bool(False))
if hasattr(process.patMuonPFTauPairsHPS, "nSVfit"):
delattr(process.patMuonPFTauPairsHPS, "nSVfit")
if hasattr(process.patMuonPFTauPairsHPS, "pfMEtSign"):
delattr(process.patMuonPFTauPairsHPS, "pfMEtSign")
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
#
# produce collection of pat::Tau objects representing PFTaus
# reconstructed by HPS + TaNC combined tau id. algorithm
# (plus combinations of muon + tau-jet pairs)
#
switchToPFTauHPSpTaNC(process)
process.cleanPatTaus.preselection = cms.string('')
process.patPFTauProducerHPSpTaNC = copy.deepcopy(process.patTaus)
retVal_pfTauHPSpTaNC = patSequenceBuilder(
process,
collectionName=["patPFTaus", "HPSpTaNC"],
jetCollectionName=pfJetCollection,
patTauProducerPrototype=process.patPFTauProducerHPSpTaNC,
patTauCleanerPrototype=patPFTauCleanerPrototype,
triggerMatcherProtoType=process.patTauTriggerMatchHLTprotoType,
addGenInfo=isMC,
applyTauJEC=True,
applyTauVertexMatch=applyTauVertexMatch)
process.pfTauSequenceHPSpTaNC = retVal_pfTauHPSpTaNC["sequence"]
process.patMuonPFTauPairsHPSpTaNC = process.allMuTauPairs.clone(
srcLeg1=cms.InputTag('selectedPatMuonsVBTFid'),
srcLeg2=cms.InputTag(retVal_pfTauHPSpTaNC["collection"]),
srcMET=cms.InputTag(pfMEtCollection),
srcGenParticles=cms.InputTag(''),
doSVreco=cms.bool(False))
if hasattr(process.patMuonPFTauPairsHPSpTaNC, "nSVfit"):
delattr(process.patMuonPFTauPairsHPSpTaNC, "nSVfit")
if hasattr(process.patMuonPFTauPairsHPSpTaNC, "pfMEtSign"):
delattr(process.patMuonPFTauPairsHPSpTaNC, "pfMEtSign")
#--------------------------------------------------------------------------------
process.patTupleProductionSequence = cms.Sequence(
process.muonPFIsolationSequence + process.patDefaultSequence
##+ process.patTrigger + process.patTriggerEvent
+ process.patMuonsWithinAcc + process.selectedPatMuonsVBTFid +
process.patMEtProductionSequence + process.caloTauSequence
# store TaNC inputs as discriminators
#+ process.produceTancMVAInputDiscriminators
#+ process.pfTauSequenceFixedCone
#+ process.pfTauSequenceShrinkingCone
+ process.pfTauSequenceHPS + process.pfTauSequenceHPSpTaNC +
process.patMuonCaloTauPairs
#+ process.patMuonPFTauPairsFixedCone
#+ process.patMuonPFTauPairsShrinkingCone
+ process.patMuonPFTauPairsHPS + process.patMuonPFTauPairsHPSpTaNC)
# return names of "final" collections of CaloTaus/different types of PFTaus
# to be used as InputTag for further processing
retVal = {}
retVal["caloTauCollection"] = retVal_caloTau["collection"]
retVal["muonCaloTauCollection"] = process.patMuonCaloTauPairs.label()
#retVal["pfTauCollectionFixedCone"] = retVal_pfTauFixedCone["collection"]
#retVal["muonPFTauCollectionFixedCone"] = process.patMuonPFTauPairsFixedCone.label()
#retVal["pfTauCollectionShrinkingCone"] = retVal_pfTauShrinkingCone["collection"]
#retVal["muonPFTauCollectionShrinkingCone"] = process.patMuonPFTauPairsShrinkingCone.label()
retVal["pfTauCollectionHPS"] = retVal_pfTauHPS["collection"]
retVal["muonPFTauCollectionHPS"] = process.patMuonPFTauPairsHPS.label()
retVal["pfTauCollectionHPSpTaNC"] = retVal_pfTauHPSpTaNC["collection"]
retVal[
"muonPFTauCollectionHPSpTaNC"] = process.patMuonPFTauPairsHPSpTaNC.label(
)
return retVal
)
# Weights
process.pileupReweighter= cms.EDFilter("RSPileupReweighter",
generatedFile = cms.string("pileup_Wjets.root"),
dataFile = cms.string("Pileup_2011_EPS_8_jul.root"),
genHistName = cms.string("pileup"),
dataHistName = cms.string("pileup"),
useROOThistos = cms.bool(False)
)
# MET systematics
# apply type I/type I + II PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process)
process.cleanPatMuons.src = "selectedPatMuonsPFlow"
process.cleanPatElectrons.src = "selectedPatElectronsPFlow"
process.cleanPatTaus.src = "selectedPatTausPFlow"
process.cleanPatJets.src = "selectedPatJetsPFlow"
process.patseq = cms.Sequence(
process.preselection*
getattr(process,"patPF2PATSequence"+postfix)*
process.patDefaultSequence*
process.goodPatJetsPFlow*
process.goodPatJetsCA8PrunedPF*
process.cutOnJet
)
from PhysicsTools.PatAlgos.tools.metTools import *
postfix = "PFlow"
jetAlgo="AK5"
#addPfMET(process, postfixLabel=postfix)
usePF2PAT(process,runPF2PAT=True,jetAlgo=jetAlgo,runOnMC=True,postfix=postfix,jetCorrections=('AK5PF',['L1FastJet','L2Relative','L3Absolute']),typeIMetCorrections=True,outputModules=[])
# to use tau-cleaned jet collection uncomment the following:
#getattr(process,"pfNoTau"+postfix).enable = True
# to switch default tau to HPS tau uncomment the following:
#adaptPFTaus(process,"hpsPFTau",postfix=postfix)
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(process, electronCollection='selectedPatElectronsPFlow', muonCollection='selectedPatMuonsPFlow', tauCollection='selectedPatTausPFlow', jetCollection='selectedPatJetsPFlow',doApplyType0corr=False)
process.PF2PAT = cms.Sequence(
# process.patDefaultSequence +
getattr(process,"patPF2PATSequence"+postfix) +
process.metUncertaintySequence
)
#output commands
skimEventContent = cms.PSet(
outputCommands = cms.untracked.vstring(
"keep *",
"drop *_*ak7*_*_*",
"drop *_*kt4*_*_*",
"drop *_kt6GenJets_*_*",
"drop *_kt6CaloJets*_*_*",
def SingleTopStep1(process, ):
options = VarParsing('analysis')
options.register('isMC', True, VarParsing.multiplicity.singleton,
VarParsing.varType.bool, "Run on MC")
options.register('doDebug', False, VarParsing.multiplicity.singleton,
VarParsing.varType.bool, "Run in debugging mode")
options.register('doSkimming', True, VarParsing.multiplicity.singleton,
VarParsing.varType.bool, "Preselect events")
options.register('doSlimming', True, VarParsing.multiplicity.singleton,
VarParsing.varType.bool, "Drop unnecessary collections")
options.register('doMuon', True, VarParsing.multiplicity.singleton,
VarParsing.varType.bool, "Do muon paths")
options.register('doElectron', True, VarParsing.multiplicity.singleton,
VarParsing.varType.bool, "Do electron paths")
#Tag from https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideFrontierConditions?redirectedfrom=CMS.SWGuideFrontierConditions#2012_MC_production
# Latest for "53Y Releases (MC)"
options.register('globalTag', Config.globalTagMC,
VarParsing.multiplicity.singleton,
VarParsing.varType.string, "Global tag")
options.parseArguments()
process.source.fileNames = cms.untracked.vstring(options.inputFiles)
process.maxEvents = cms.untracked.PSet(
input=cms.untracked.int32(options.maxEvents))
process.out.fileName = cms.untracked.string(options.outputFile)
process.options = cms.untracked.PSet(
wantSummary=cms.untracked.bool(options.doDebug))
if options.doDebug:
process.load("FWCore.MessageLogger.MessageLogger_cfi")
process.MessageLogger = cms.Service(
"MessageLogger",
destinations=cms.untracked.vstring('cout', 'debug'),
debugModules=cms.untracked.vstring('*'),
cout=cms.untracked.PSet(threshold=cms.untracked.string('INFO')),
debug=cms.untracked.PSet(threshold=cms.untracked.string('DEBUG')),
)
else:
process.load("FWCore.MessageService.MessageLogger_cfi")
postfix = ""
jetCorr = ['L1FastJet', 'L2Relative', 'L3Absolute']
if not options.isMC:
jetCorr += ['L2L3Residual']
usePF2PAT(
process,
runPF2PAT=True,
jetAlgo='AK5',
runOnMC=options.isMC,
postfix=postfix,
jetCorrections=('AK5PFchs', jetCorr),
pvCollection=cms.InputTag('goodOfflinePrimaryVertices'),
#typeIMetCorrections = True
typeIMetCorrections=
False #Type1 MET now applied later using runMETUncertainties
)
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU2012
process.pfPileUp.Enable = True
process.pfPileUp.checkClosestZVertex = False
#-------------------------------------------------
# selection step 2: vertex filter
#-------------------------------------------------
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCorPFnoPU2012
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefEventSel#Cleaning_Filters
process.goodOfflinePrimaryVertices = cms.EDFilter(
"PrimaryVertexObjectFilter",
filterParams=cms.PSet(minNdof=cms.double(4.0),
maxZ=cms.double(24.0),
maxRho=cms.double(2.0)),
filter=cms.bool(True),
src=cms.InputTag('offlinePrimaryVertices'))
#-------------------------------------------------
# Muons
#-------------------------------------------------
#if not maxLeptonIso is None:
# process.pfIsolatedMuons.isolationCut = maxLeptonIso
#Use both isolated and non-isolated muons as a patMuon source
#process.patMuons.pfMuonSource = cms.InputTag("pfMuons")
#process.muonMatch.src = cms.InputTag("pfMuons")
process.patMuons.pfMuonSource = cms.InputTag("pfIsolatedMuons")
process.muonMatch.src = cms.InputTag("pfIsolatedMuons")
process.selectedPatMuons.cut = "pt>20 && abs(eta)<3.0"
# muon ID production (essentially track count embedding) must be here
# because tracks get dropped from the collection after this step, resulting
# in null ptrs.
process.muonsWithID = cms.EDProducer(
'MuonIDProducer',
muonSrc=cms.InputTag("selectedPatMuons"),
primaryVertexSource=cms.InputTag("goodOfflinePrimaryVertices"))
#process.muonClones = cms.EDProducer("MuonShallowCloneProducer",
# src = cms.InputTag("selectedPatMuons")
#)
#-------------------------------------------------
# Electrons
# Implemented as in https://indico.cern.ch/getFile.py/access?contribId=1&resId=0&materialId=slides&confId=208765
#-------------------------------------------------
#if not maxLeptonIso is None:
# process.pfIsolatedElectrons.isolationCut = maxLeptonIso
#Use both isolated and un-isolated electrons as patElectrons.
#NB: no need to change process.electronMatch.src to pfElectrons,
# it's already gsfElectrons, which is a superset of the pfElectrons
process.patElectrons.pfElectronSource = cms.InputTag("pfElectrons")
process.load('EGamma.EGammaAnalysisTools.electronIdMVAProducer_cfi')
process.mvaID = cms.Sequence(process.mvaTrigV0 + process.mvaNonTrigV0)
process.patElectrons.electronIDSources.mvaTrigV0 = cms.InputTag(
"mvaTrigV0")
process.patElectrons.electronIDSources.mvaNonTrigV0 = cms.InputTag(
"mvaNonTrigV0")
process.patPF2PATSequence.replace(process.patElectrons,
process.mvaID * process.patElectrons)
process.selectedPatElectrons.cut = "pt>25 && abs(eta)<3.0"
process.electronsWithID = cms.EDProducer(
'ElectronIDProducer',
electronSrc=cms.InputTag("selectedPatElectrons"),
primaryVertexSource=cms.InputTag("goodOfflinePrimaryVertices"))
#process.electronClones = cms.EDProducer("ElectronShallowCloneProducer",
# src = cms.InputTag("selectedPatElectrons")
#)
#if not maxLeptonIso is None:
# process.pfIsolatedElectrons.isolationCut = maxLeptonIso
#electron dR=0.3
process.pfElectrons.isolationValueMapsCharged = cms.VInputTag(
cms.InputTag("elPFIsoValueCharged03PFId"))
process.pfElectrons.deltaBetaIsolationValueMap = cms.InputTag(
"elPFIsoValuePU03PFId")
process.pfElectrons.isolationValueMapsNeutral = cms.VInputTag(
cms.InputTag("elPFIsoValueNeutral03PFId"),
cms.InputTag("elPFIsoValueGamma03PFId"))
process.pfElectrons.deltaBetaIsolationValueMap = cms.InputTag(
"elPFIsoValuePU03PFId")
process.pfElectrons.isolationValueMapsNeutral = cms.VInputTag(
cms.InputTag("elPFIsoValueNeutral03PFId"),
cms.InputTag("elPFIsoValueGamma03PFId"))
process.patElectrons.isolationValues.pfNeutralHadrons = cms.InputTag(
"elPFIsoValueNeutral03PFId")
process.patElectrons.isolationValues.pfChargedAll = cms.InputTag(
"elPFIsoValueChargedAll03PFId")
process.patElectrons.isolationValues.pfPUChargedHadrons = cms.InputTag(
"elPFIsoValuePU03PFId")
process.patElectrons.isolationValues.pfPhotons = cms.InputTag(
"elPFIsoValueGamma03PFId")
process.patElectrons.isolationValues.pfChargedHadrons = cms.InputTag(
"elPFIsoValueCharged03PFId")
process.pfIsolatedElectrons.isolationValueMapsCharged = cms.VInputTag(
cms.InputTag("elPFIsoValueCharged03PFId"))
process.pfIsolatedElectrons.deltaBetaIsolationValueMap = cms.InputTag(
"elPFIsoValuePU03PFId")
process.pfIsolatedElectrons.isolationValueMapsNeutral = cms.VInputTag(
cms.InputTag("elPFIsoValueNeutral03PFId"),
cms.InputTag("elPFIsoValueGamma03PFId"))
#-------------------------------------------------
# Jets
# MET corrections as https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMetAnalysis#Type_I_0_with_PAT
#-------------------------------------------------
#pfNoTau == True => remove taus from jets
#process.pfNoTau.enable = noTau
process.selectedPatJets.cut = cms.string("pt>30 && abs(eta)<5.0")
process.load("CMGTools.External.pujetidsequence_cff")
process.patPF2PATSequence += process.puJetIdSqeuence
#process.jetClones = cms.EDProducer("CaloJetShallowCloneProducer",
# src = cms.InputTag("seletedPatJets")
#)
#-------------------------------------------------
# MET uncertainty step
#-------------------------------------------------
#Embed the reference to the original jet in the jets, which is constant during the propagation
process.patJetsWithOwnRef = cms.EDProducer(
'PatObjectOwnRefProducer<pat::Jet>',
src=cms.InputTag("selectedPatJets"))
#Note: this module causes a large memory increase when crossing the file boundary
#Reason - unknown, solution: limit processing to ~1 file.
from PhysicsTools.PatUtils.tools.metUncertaintyTools import runMEtUncertainties
runMEtUncertainties(
process,
electronCollection=cms.InputTag("electronsWithID"),
photonCollection=None,
muonCollection=cms.InputTag("muonsWithID"),
tauCollection="", # "" means emtpy, None means cleanPatTaus
jetCollection=cms.InputTag("patJetsWithOwnRef"),
jetCorrLabel="L3Absolute" if options.isMC else "L2L3Residual",
doSmearJets=options.isMC,
jetCorrPayloadName="AK5PFchs",
addToPatDefaultSequence=False)
process.stpolMetUncertaintySequence = cms.Sequence(
process.metUncertaintySequence)
if not options.doSlimming:
process.out.outputCommands = cms.untracked.vstring('keep *')
else:
process.out.outputCommands = cms.untracked.vstring([
'drop *',
'keep edmMergeableCounter_*_*_*', # Keep the lumi-block counter information
'keep edmTriggerResults_TriggerResults__*', #Keep the trigger results
'keep *_genParticles__*', #keep all the genParticles
#'keep recoVertexs_offlinePrimaryVertices__*', #keep the offline PV-s
'keep recoVertexs_goodOfflinePrimaryVertices__*', #keep the offline PV-s
# Jets
'keep patJets_*__*',
'keep double_*_rho_*', #For rho-corr rel iso
'keep recoGenJets_selectedPatJets_genJets_*', #For Jet MC smearing we need to keep the genJets
"keep *_puJetId_*_*", # input variables
"keep *_puJetMva_*_*", # final MVAs and working point flags
'keep *_jetClones__*',
# Muons
'keep patMuons_*__*',
'keep *_muonClones__*',
# Electrons
'keep patElectrons_*__*',
'keep *_electronClones__*',
# METs
'keep patMETs_*__*',
#ECAL laser corr filter
'keep bool_ecalLaserCorrFilter__*',
#For flavour analyzer
'keep GenEventInfoProduct_generator__*',
#PU info
'keep PileupSummaryInfos_addPileupInfo__*',
##PFCandidates
#'keep recoPFCandidates_*_pfCandidates_PAT',
#'keep recoPFMETs_pfMET__*',
#'keep recoPFMETs_pfMet__*',
#'keep recoGenMETs_genMetTrue__*',
#'keep recoPFCandidates_particleFlow__*',
#'keep recoConversions_allConversions__*',
#'keep recoVertexCompositeCandidates_generalV0Candidates_*_*',
#'keep recoTracks_generalTracks__*',
#'keep recoBeamSpot_offlineBeamSpot__*',
#'keep recoMuons_muons__*',
'keep int_*__PAT',
'keep ints_*__PAT',
'keep double_*__PAT',
'keep doubles_*__PAT',
'keep float_*__PAT',
'keep floats_*__PAT',
])
#FIXME: is this correct?
#Keep events that pass either the muon OR the electron path
process.out.SelectEvents = cms.untracked.PSet(SelectEvents=cms.vstring([]))
#-------------------------------------------------
# Paths
#-------------------------------------------------
process.goodOfflinePVCount = cms.EDProducer(
"CollectionSizeProducer<reco::Vertex>",
src=cms.InputTag("goodOfflinePrimaryVertices"))
process.preCalcSequences = cms.Sequence(process.patJetsWithOwnRef *
process.goodOfflinePVCount)
process.patPF2PATSequence.insert(
process.patPF2PATSequence.index(process.selectedPatMuons) + 1,
process.muonsWithID)
process.patPF2PATSequence.insert(
process.patPF2PATSequence.index(process.selectedPatElectrons) + 1,
process.electronsWithID)
#Need separate paths because of skimming
if options.doMuon:
process.singleTopPathStep1Mu = cms.Path(
process.goodOfflinePrimaryVertices * process.patPF2PATSequence
#* process.muonClones
#* process.electronClones
#* process.jetClones
)
if options.doElectron:
process.singleTopPathStep1Ele = cms.Path(
process.goodOfflinePrimaryVertices * process.patPF2PATSequence
#* process.muonClones
#* process.electronClones
#* process.jetClones
)
if options.doMuon:
process.out.SelectEvents.SelectEvents.append("singleTopPathStep1Mu")
if options.doElectron:
process.out.SelectEvents.SelectEvents.append("singleTopPathStep1Ele")
process.GlobalTag.globaltag = cms.string(options.globalTag)
process.singleTopPathStep1Mu += process.preCalcSequences
process.singleTopPathStep1Ele += process.preCalcSequences
if options.doMuon:
process.singleTopPathStep1Mu += process.stpolMetUncertaintySequence
if options.doElectron:
process.singleTopPathStep1Ele += process.stpolMetUncertaintySequence
if options.isMC:
#https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration?redirectedfrom=CMS.SWGuideBTagJetProbabilityCalibration#Calibration_in_53x_Data_and_MC
process.GlobalTag.toGet = cms.VPSet(
cms.PSet(record=cms.string("BTagTrackProbability2DRcd"),
tag=cms.string("TrackProbabilityCalibration_2D_MC53X_v2"),
connect=cms.untracked.string(
"frontier://FrontierPrep/CMS_COND_BTAU")),
cms.PSet(record=cms.string("BTagTrackProbability3DRcd"),
tag=cms.string("TrackProbabilityCalibration_3D_MC53X_v2"),
connect=cms.untracked.string(
"frontier://FrontierPrep/CMS_COND_BTAU")))
else:
#https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration?redirectedfrom=CMS.SWGuideBTagJetProbabilityCalibration#Calibration_in_53x_Data_and_MC
process.GlobalTag.toGet = cms.VPSet(
cms.PSet(
record=cms.string("BTagTrackProbability2DRcd"),
tag=cms.string("TrackProbabilityCalibration_2D_Data53X_v2"),
connect=cms.untracked.string(
"frontier://FrontierPrep/CMS_COND_BTAU")),
cms.PSet(
record=cms.string("BTagTrackProbability3DRcd"),
tag=cms.string("TrackProbabilityCalibration_3D_Data53X_v2"),
connect=cms.untracked.string(
"frontier://FrontierPrep/CMS_COND_BTAU")))
process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi')
process.ecalLaserCorrFilter.taggingMode = True
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/TWikiTopRefEventSel#Cleaning_Filters
process.scrapingFilter = cms.EDFilter(
"FilterOutScraping",
applyfilter=cms.untracked.bool(True),
debugOn=cms.untracked.bool(False),
numtrack=cms.untracked.uint32(10),
thresh=cms.untracked.double(0.25))
#if doElectron:
# process.singleTopPathStep1Ele.insert(0, process.scrapingFilter)
#if doMuon:
# process.singleTopPathStep1Mu.insert(0, process.scrapingFilter)
process.patPF2PATSequence += process.scrapingFilter
process.patPF2PATSequence += process.ecalLaserCorrFilter
#if not onGrid:
# from SingleTopPolarization.Analysis.cmdlineParsing import enableCommandLineArguments
# enableCommandLineArguments(process)
#else:
# process.out.fileName = "step1.root"
if options.doSkimming:
process.out.fileName.setValue(process.out.fileName.value().replace(
".root", "_Skim.root"))
else:
process.out.fileName.setValue(process.out.fileName.value().replace(
".root", "_noSkim.root"))
#-----------------------------------------------
# Skimming
#-----------------------------------------------
#Throw away events before particle flow?
if options.doSkimming:
from SingleTopPolarization.Analysis.eventSkimming_cfg import skimFilters
skimFilters(process)
if options.doMuon:
process.singleTopPathStep1Mu.insert(0, process.muonSkim)
if options.doElectron:
process.singleTopPathStep1Ele.insert(0, process.electronSkim)
#-----------------------------------------------
# Skim efficiency counters
#-----------------------------------------------
#count all processed events
countProcessed(process)
#count events passing mu and ele paths
if options.doMuon:
countInSequence(process, process.singleTopPathStep1Mu)
if options.doElectron:
countInSequence(process, process.singleTopPathStep1Ele)
#-------------------------------------------------
#
#-------------------------------------------------
if not options.doSlimming:
process.out.fileName.setValue(process.out.fileName.value().replace(
".root", "_noSlim.root"))
return process
