def customizeSummer16EleID(self, process):
from PhysicsTools.SelectorUtils.tools.vid_id_tools import DataFormat, switchOnVIDElectronIdProducer, setupAllVIDIdsInModule, setupVIDElectronSelection
dataFormat = DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
my_id_modules = [
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff'
]
for idmod in my_id_modules:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
process.flashggElectrons.effAreasConfigFile = cms.FileInPath(
"RecoEgamma/ElectronIdentification/data/Summer16/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_80X.txt"
)
process.flashggElectrons.eleVetoIdMap = cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-veto")
process.flashggElectrons.eleLooseIdMap = cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-loose")
process.flashggElectrons.eleMediumIdMap = cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-medium")
process.flashggElectrons.eleTightIdMap = cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-tight")
process.flashggElectrons.eleMVAMediumIdMap = cms.InputTag(
"egmGsfElectronIDs:mvaEleID-Spring16-GeneralPurpose-V1-wp90")
process.flashggElectrons.eleMVATightIdMap = cms.InputTag(
"egmGsfElectronIDs:mvaEleID-Spring16-GeneralPurpose-V1-wp80")
process.flashggElectrons.mvaValuesMap = cms.InputTag(
"electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring16GeneralPurposeV1Values"
)
def loadHEEPIDSelector(process):
dataFormat = DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process, dataFormat)
setupAllVIDIdsInModule(
process,
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff',
setupVIDElectronSelection)
def setupElectrons(process):
switchOnVIDElectronIdProducer(process, DataFormat.AOD)
my_id_modules = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff'
]
for idmod in my_id_modules:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
def setupElectrons(process): switchOnVIDElectronIdProducer(process, DataFormat.AOD) my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff'] if tools.is_above_cmssw_version([8]): my_id_modules.extend(['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff']) for idmod in my_id_modules: setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
def setupElectrons(process): switchOnVIDElectronIdProducer(process, DataFormat.AOD) my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff'] if tools.is_above_cmssw_version([8]): my_id_modules.extend(['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff']) for idmod in my_id_modules: setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
def setupElectrons(process):
if (cmssw_version_number.startswith("7_4")):
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_PHYS14_PU20bx25_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_PHYS14_PU20bx25_nonTrig_V1_cff']
else:
my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_PHYS14_PU20bx25_V1_miniAOD_cff']
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
def customizeSpring15EleID(self,process):
from PhysicsTools.SelectorUtils.tools.vid_id_tools import DataFormat,switchOnVIDElectronIdProducer,setupAllVIDIdsInModule,setupVIDElectronSelection
dataFormat = DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff']
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
def customizeSpring15EleID(self,process):
from PhysicsTools.SelectorUtils.tools.vid_id_tools import DataFormat,switchOnVIDElectronIdProducer,setupAllVIDIdsInModule,setupVIDElectronSelection
dataFormat = DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff']
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
def electronPrep(process, isMC, useCalibration):
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
process = regressionWeights(process)
process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
if not hasattr(process, "RandomNumberGeneratorService"):
process.load('Configuration.StandardSequences.Services_cff')
process.RandomNumberGeneratorService = cms.Service(
"RandomNumberGeneratorService")
process.RandomNumberGeneratorService.calibratedPatElectrons = cms.PSet(
initialSeed=cms.untracked.uint32(81),
engineName=cms.untracked.string('TRandom3'),
)
process.load('EgammaAnalysis.ElectronTools.calibratedElectronsRun2_cfi')
process.calibratedPatElectrons.isMC = cms.bool(isMC)
electronInput = cms.InputTag("slimmedElectrons::ANA")
if useCalibration:
electronInput = cms.InputTag("calibratedPatElectrons")
import PhysicsTools.SelectorUtils.tools.vid_id_tools as vid_tools
vid_tools.switchOnVIDElectronIdProducer(process,
vid_tools.DataFormat.MiniAOD)
my_id_modules = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff'
]
for idmod in my_id_modules:
vid_tools.setupAllVIDIdsInModule(process, idmod,
vid_tools.setupVIDElectronSelection)
process.egmGsfElectronIDs.physicsObjectSrc = electronInput
process.electronMVAValueMapProducer.srcMiniAOD = electronInput
process.electronRegressionValueMapProducer.srcMiniAOD = electronInput
process.heepIDVarValueMaps.elesMiniAOD = electronInput
process.preppedElectrons = cms.EDProducer(
"ElectronPrep",
electronSrc=electronInput,
uncalibratedSrc=cms.InputTag("slimmedElectrons::ANA"),
vetoId=cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-veto"),
looseId=cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-loose"),
mediumId=cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-medium"),
tightId=cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-tight"),
heepId=cms.InputTag("egmGsfElectronIDs:heepElectronID-HEEPV70"),
vertexSrc=cms.InputTag("offlineSlimmedPrimaryVertices"),
kinematicCutAnyVariation=cms.string('pt > 10 && abs(eta) < 2.5'),
finalCut=cms.string('userInt("VetoId")'),
)
def MiniAODEleVIDEmbedder(process, eles):
#Turn on versioned cut-based ID
from PhysicsTools.SelectorUtils.tools.vid_id_tools import setupAllVIDIdsInModule, setupVIDElectronSelection, switchOnVIDElectronIdProducer, DataFormat, setupVIDSelection
#from PhysicsTools.SelectorUtils.tools.vid_id_tools import setupAllVIDIdsInModule, setupVIDElectronSelection, switchOnVIDElectronIdProducer, DataFormat
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
process.load("RecoEgamma.ElectronIdentification.egmGsfElectronIDs_cfi")
process.egmGsfElectronIDs.physicsObjectSrc = cms.InputTag(eles)
from PhysicsTools.SelectorUtils.centralIDRegistry import central_id_registry
#egmGsfElectronIDSequence should already be defined in egmGsfElectronIDs_cfi
#process.egmGsfElectronIDSequence = cms.Sequence(process.egmGsfElectronIDs)
process.egmGsfElectronIDSequence = cms.Sequence(
process.electronMVAValueMapProducer + process.egmGsfElectronIDs)
id_modules = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff'
]
for idmod in id_modules:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection, None,
False)
IDLabels = [
"eleMVAIDnonTrig80", "eleMVAIDnonTrig90", "CBIDVeto", "CBIDLoose",
"CBIDMedium", "CBIDTight", "eleHEEPid"
] # keys of based id user floats
IDTags = [
cms.InputTag(
'egmGsfElectronIDs:mvaEleID-Spring15-25ns-nonTrig-V1-wp80'),
cms.InputTag(
'egmGsfElectronIDs:mvaEleID-Spring15-25ns-nonTrig-V1-wp90'),
cms.InputTag(
'egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-veto'
),
cms.InputTag(
'egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-loose'
),
cms.InputTag(
'egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-medium'
),
cms.InputTag(
'egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-tight'
),
cms.InputTag('egmGsfElectronIDs:heepElectronID-HEEPV60')
]
# Embed cut-based VIDs
process.miniAODElectronVID = cms.EDProducer(
"MiniAODElectronVIDEmbedder",
src=cms.InputTag(eles),
idLabels=cms.vstring(*IDLabels),
ids=cms.VInputTag(*IDTags),
eleIsoLabel=cms.string("dBRelIso"))
process.embedEleIDs = cms.Sequence(process.egmGsfElectronIDSequence +
process.miniAODElectronVID)
process.analysisSequence *= process.embedEleIDs
def setupEgammaPostRecoSeq(process,
applyEnergyCorrections=False,
applyVIDOnCorrectedEgamma=False,
isMiniAOD=True,
era="2017-Nov17ReReco",
eleIDModules=_defaultEleIDModules,
phoIDModules=_defaultPhoIDModules,
runVID=True,
runEnergyCorrections=True,
applyEPCombBug=False,
autoAdjustParams=True,
computeHeepTrkPtIso=True):
"""
Note: computeHeepTrkPtIso can't be set to false if you want to run a HEEP ID.
"""
#first check if we are running in a valid release, will throw if not
_validRelease()
from PhysicsTools.SelectorUtils.tools.vid_id_tools import switchOnVIDElectronIdProducer, switchOnVIDPhotonIdProducer, setupAllVIDIdsInModule, DataFormat, setupVIDElectronSelection, setupVIDPhotonSelection
# turn on VID producer, indicate data format to be
# DataFormat.AOD or DataFormat.MiniAOD, as appropriate
if runVID:
if isMiniAOD:
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
switchOnVIDPhotonIdProducer(process, DataFormat.MiniAOD)
else:
switchOnVIDElectronIdProducer(process, DataFormat.AOD)
switchOnVIDPhotonIdProducer(process, DataFormat.AOD)
for idmod in eleIDModules:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
for idmod in phoIDModules:
setupAllVIDIdsInModule(process, idmod, setupVIDPhotonSelection)
if autoAdjustParams:
if ((era == "2016-UL") and runEnergyCorrections):
print "EgammaPostRecoTools:INFO auto adjusting runEnergyCorrections to False as they are not yet availible for 2016-UL, set autoAdjustParams = False to force them to run"
runEnergyCorrections = False
_setupEgammaPostRecoSeq(
process,
applyEnergyCorrections=applyEnergyCorrections,
applyVIDOnCorrectedEgamma=applyVIDOnCorrectedEgamma,
era=era,
runVID=runVID,
runEnergyCorrections=runEnergyCorrections,
applyEPCombBug=applyEPCombBug,
isMiniAOD=isMiniAOD,
computeHeepTrkPtIso=computeHeepTrkPtIso)
return process
def setupEgammaPostRecoSeq(process,
applyEnergyCorrections=False,
applyVIDOnCorrectedEgamma=False,
isMiniAOD=True,
era="2017-Nov17ReReco",
eleIDModules=_defaultEleIDModules,
phoIDModules=_defaultPhoIDModules,
runVID=True,
applyEPCombBug=False):
from PhysicsTools.SelectorUtils.tools.vid_id_tools import switchOnVIDElectronIdProducer, switchOnVIDPhotonIdProducer, setupAllVIDIdsInModule, DataFormat, setupVIDElectronSelection, setupVIDPhotonSelection
# turn on VID producer, indicate data format to be
# DataFormat.AOD or DataFormat.MiniAOD, as appropriate
if runVID:
if isMiniAOD:
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
switchOnVIDPhotonIdProducer(process, DataFormat.MiniAOD)
else:
switchOnVIDElectronIdProducer(process, DataFormat.AOD)
switchOnVIDPhotonIdProducer(process, DataFormat.AOD)
for idmod in eleIDModules:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
for idmod in phoIDModules:
setupAllVIDIdsInModule(process, idmod, setupVIDPhotonSelection)
if isMiniAOD:
_setupEgammaPostRECOSequenceMiniAOD(
process,
applyEnergyCorrections=applyEnergyCorrections,
applyVIDOnCorrectedEgamma=applyVIDOnCorrectedEgamma,
era=era,
runVID=runVID,
applyEPCombBug=applyEPCombBug)
else:
_setupEgammaPostRECOSequence(
process,
applyEnergyCorrections=applyEnergyCorrections,
applyVIDOnCorrectedEgamma=applyVIDOnCorrectedEgamma,
era=era,
runVID=runVID,
applyEPCombBug=applyEPCombBug)
process.egammaScaleSmearSeq = cms.Sequence(process.egammaScaleSmearTask)
process.egammaPostRecoSeq = cms.Sequence(process.egammaScaleSmearSeq)
if runVID:
process.egammaPostRecoSeq = cms.Sequence(
process.egammaScaleSmearSeq * process.egmGsfElectronIDSequence *
process.egmPhotonIDSequence)
return process
def setupEgammaPostRecoSeq(process,
applyEnergyCorrections=False,
applyVIDOnCorrectedEgamma=False,
isMiniAOD=True,
era="2017-Nov17ReReco",
eleIDModules=_defaultEleIDModules,
phoIDModules=_defaultPhoIDModules,
runVID=True,
runEnergyCorrections=True,
applyEPCombBug=False,
autoAdjustParams=True):
from PhysicsTools.SelectorUtils.tools.vid_id_tools import switchOnVIDElectronIdProducer,switchOnVIDPhotonIdProducer,setupAllVIDIdsInModule,DataFormat,setupVIDElectronSelection,setupVIDPhotonSelection
# turn on VID producer, indicate data format to be
# DataFormat.AOD or DataFormat.MiniAOD, as appropriate
if runVID:
if isMiniAOD:
switchOnVIDElectronIdProducer(process,DataFormat.MiniAOD)
switchOnVIDPhotonIdProducer(process,DataFormat.MiniAOD)
else:
switchOnVIDElectronIdProducer(process,DataFormat.AOD)
switchOnVIDPhotonIdProducer(process,DataFormat.AOD)
for idmod in eleIDModules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
for idmod in phoIDModules:
setupAllVIDIdsInModule(process,idmod,setupVIDPhotonSelection)
if autoAdjustParams:
pass #no auto adjustment needed
if isMiniAOD:
_setupEgammaPostRECOSequenceMiniAOD(process,applyEnergyCorrections=applyEnergyCorrections,applyVIDOnCorrectedEgamma=applyVIDOnCorrectedEgamma,era=era,runVID=runVID,runEnergyCorrections=runEnergyCorrections,applyEPCombBug=applyEPCombBug)
else:
_setupEgammaPostRECOSequence(process,applyEnergyCorrections=applyEnergyCorrections,applyVIDOnCorrectedEgamma=applyVIDOnCorrectedEgamma,era=era,runVID=runVID,runEnergyCorrections=runEnergyCorrections,applyEPCombBug=applyEPCombBug)
process.egammaScaleSmearSeq = cms.Sequence(process.egammaScaleSmearTask)
#post reco seq is calibrations -> vid -> pat updator
process.egammaPostRecoSeq = cms.Sequence(process.egammaScaleSmearSeq)
if not runEnergyCorrections and runVID:
process.egammaPostRecoSeq = cms.Sequence(process.egmGsfElectronIDSequence*process.egmPhotonIDSequence)
elif runVID:
process.egammaPostRecoSeq.insert(-1,process.egmGsfElectronIDSequence)
process.egammaPostRecoSeq.insert(-1,process.egmPhotonIDSequence)
if isMiniAOD:
process.egammaPostRecoPatUpdatorSeq = cms.Sequence(process.egammaPostRecoPatUpdatorTask)
process.egammaPostRecoSeq.insert(-1,process.egammaPostRecoPatUpdatorSeq)
return process
def setupElectrons(process, electrons):
egmGsfElectronIDs.physicsObjectSrc = cms.InputTag(electrons)
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
my_id_modules = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff'
]
for idmod in my_id_modules:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
process.elPFIsoDepositCharged.src = cms.InputTag(electrons)
process.elPFIsoDepositChargedAll.src = cms.InputTag(electrons)
process.elPFIsoDepositNeutral.src = cms.InputTag(electrons)
process.elPFIsoDepositGamma.src = cms.InputTag(electrons)
process.elPFIsoDepositPU.src = cms.InputTag(electrons)
def setupVID(process):
#define the default IDs to produce in VID
from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import _defaultEleIDModules, _defaultPhoIDModules
#as we're not running, it doesnt matter if its miniAOD or AOD
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
switchOnVIDPhotonIdProducer(process, DataFormat.MiniAOD)
eleIDModules = _defaultEleIDModules
phoIDModules = _defaultPhoIDModules
for idmod in eleIDModules:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
for idmod in phoIDModules:
setupAllVIDIdsInModule(process, idmod, setupVIDPhotonSelection)
def customizeSummer16EleID(self,process):
from PhysicsTools.SelectorUtils.tools.vid_id_tools import DataFormat,switchOnVIDElectronIdProducer,setupAllVIDIdsInModule,setupVIDElectronSelection
dataFormat = DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff']
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
process.flashggElectrons.effAreasConfigFile = cms.FileInPath("RecoEgamma/ElectronIdentification/data/Summer16/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_80X.txt")
process.flashggElectrons.eleVetoIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-veto")
process.flashggElectrons.eleLooseIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-loose")
process.flashggElectrons.eleMediumIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-medium")
process.flashggElectrons.eleTightIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-tight")
process.flashggElectrons.eleMVAMediumIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Spring16-GeneralPurpose-V1-wp90")
process.flashggElectrons.eleMVATightIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Spring16-GeneralPurpose-V1-wp80")
def addElectronIDEmbedding(self, step):
#if not hasattr(self.process, 'egmGsfElectronIDs'):
switchOnVIDElectronIdProducer(self.process, DataFormat.MiniAOD)
setupAllVIDIdsInModule(
self.process,
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V2_cff',
setupVIDElectronSelection)
#setupAllVIDIdsInModule(self.process,
# 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff',
# setupVIDElectronSelection)
#setupAllVIDIdsInModule(self.process,
# 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronHLTPreselecition_Summer16_V1_cff',
# setupVIDElectronSelection)
self.process.egmGsfElectronIDs.physicsObjectSrc = step.getObjTag('e')
self.process.electronMVAValueMapProducer.srcMiniAOD = step.getObjTag(
'e')
#self.process.electronRegressionValueMapProducer.srcMiniAOD = step.getObjTag('e')
step.addModule('egmGsfElectronIDSequence',
self.process.egmGsfElectronIDSequence)
embedIDs = cms.EDProducer(
"PATElectronValueMapEmbedder",
src=step.getObjTag('e'),
floatLabels=cms.untracked.vstring("MVAIsoID"),
floatVals=cms.untracked.VInputTag(
"electronMVAValueMapProducer:ElectronMVAEstimatorRun2Fall17IsoV2RawValues"
), #2018 Setup
#floatVals = cms.untracked.VInputTag(""),#2018 Setup
#boolLabels = cms.untracked.vstring("IsCBVIDTight", "IsCBVIDMedium", "IsCBVIDLoose", "IsCBVIDVeto", "IsCBVIDHLTSafe"),
#boolLabels = cms.untracked.vstring("IsFall17isoV2wpHZZ"),
#boolVals = cms.untracked.VInputTag(
# cms.InputTag("egmGsfElectronIDs:mvaEleID-Fall17-iso-V2-wpHZZ"),
#boolVals = cms.untracked.VInputTag(
# cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-tight"),
# cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-medium"),
# cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-loose"),
# cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-veto"),
# cms.InputTag("egmGsfElectronIDs:cutBasedElectronHLTPreselection-Summer16-V1"),
# )
)
step.addModule('electronIDEmbedding', embedIDs, 'e')
def customizeRunIIEleID(self, process):
from PhysicsTools.SelectorUtils.tools.vid_id_tools import DataFormat,switchOnVIDElectronIdProducer,setupAllVIDIdsInModule,setupVIDElectronSelection
dataFormat = DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff']
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
process.flashggElectrons.eleVetoIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-veto")
process.flashggElectrons.eleLooseIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-loose")
process.flashggElectrons.eleMediumIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-medium")
process.flashggElectrons.eleTightIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-tight")
process.flashggElectrons.eleMVALooseIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Fall17-iso-V2-wpLoose")
process.flashggElectrons.eleMVAMediumIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Fall17-iso-V2-wp90")
process.flashggElectrons.eleMVATightIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Fall17-iso-V2-wp80")
process.flashggElectrons.mvaValuesMap = cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Fall17IsoV2Values")
process.flashggElectrons.effAreasConfigFile = cms.FileInPath("RecoEgamma/ElectronIdentification/data/Fall17/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_94X.txt")#check what this file is used for
def addElectronIDEmbedding(self, step):
#if not hasattr(self.process, 'egmGsfElectronIDs'):
switchOnVIDElectronIdProducer(self.process, DataFormat.MiniAOD)
setupAllVIDIdsInModule(
self.process,
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_HZZ_V1_cff',
setupVIDElectronSelection)
setupAllVIDIdsInModule(
self.process,
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
setupVIDElectronSelection)
self.process.egmGsfElectronIDs.physicsObjectSrc = step.getObjTag('e')
self.process.electronMVAValueMapProducer.srcMiniAOD = step.getObjTag(
'e')
self.process.electronRegressionValueMapProducer.srcMiniAOD = step.getObjTag(
'e')
step.addModule('egmGsfElectronIDSequence',
self.process.egmGsfElectronIDSequence)
embedIDs = cms.EDProducer(
"PATElectronValueMapEmbedder",
src=step.getObjTag('e'),
floatLabels=cms.untracked.vstring("MVAIDNonTrig"),
floatVals=cms.untracked.VInputTag(
"electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring16HZZV1Values"
),
boolLabels=cms.untracked.vstring("isCBVIDtight", "isCBVIDmedium",
"isCBVIDloose"),
boolVals=cms.untracked.VInputTag(
cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-tight"
),
cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-medium"
),
cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-loose"
)))
step.addModule('electronIDEmbedding', embedIDs, 'e')
def setupElectrons(process, electrons, id_modules=None):
# use `electrons` as source for electron objects
egmGsfElectronIDs.physicsObjectSrc = cms.InputTag(electrons)
# enable the electron VID producer
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
# if no `id_modules` are given, use a sensible default selection:
if id_modules is None:
# always include Spring15 modules (for backward compatibility)
id_modules = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff',
]
# include newer electron VID modules depending on the CMSSW version
if tools.is_above_cmssw_version([8]):
id_modules.extend([
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff',
])
if tools.is_above_cmssw_version([9, 4]):
id_modules.extend([
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff',
])
# set up all VIDs defined in `id_modules`
for id_module in id_modules:
setupAllVIDIdsInModule(process, id_module, setupVIDElectronSelection)
# overwrite input tags to use `electrons` as physics object source
process.elPFIsoDepositCharged.src = cms.InputTag(electrons)
process.elPFIsoDepositChargedAll.src = cms.InputTag(electrons)
process.elPFIsoDepositNeutral.src = cms.InputTag(electrons)
process.elPFIsoDepositGamma.src = cms.InputTag(electrons)
process.elPFIsoDepositPU.src = cms.InputTag(electrons)
def configureElectronId_(self):
with StdStreamSilenter():
from PhysicsTools.SelectorUtils.tools.vid_id_tools import DataFormat, switchOnVIDElectronIdProducer, setupAllVIDIdsInModule, setupVIDElectronSelection
switchOnVIDElectronIdProducer(self.process, DataFormat.MiniAOD)
# Use in input our own electorn collection
self.process.egmGsfElectronIDs.physicsObjectSrc = self.__miniaod_electron_collection
id_modules = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronHLTPreselecition_Summer16_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_HZZ_V1_cff'
]
for mod in id_modules:
setupAllVIDIdsInModule(self.process, mod,
setupVIDElectronSelection)
self.process.electronMVAValueMapProducer.srcMiniAOD = self.__miniaod_electron_collection
def setupVIDForHEEPV70(process, useMiniAOD=True):
#setup the VID with HEEP 7.0
from PhysicsTools.SelectorUtils.tools.vid_id_tools import switchOnVIDElectronIdProducer
from PhysicsTools.SelectorUtils.tools.vid_id_tools import setupVIDElectronSelection
from PhysicsTools.SelectorUtils.tools.vid_id_tools import setupAllVIDIdsInModule
from PhysicsTools.SelectorUtils.tools.vid_id_tools import DataFormat
# turn on VID producer, indicate data format to be
# DataFormat.AOD or DataFormat.MiniAOD, as appropriate
dataFormat = DataFormat.MiniAOD if useMiniAOD else DataFormat.AOD
switchOnVIDElectronIdProducer(process, dataFormat)
# define which IDs we want to produce
my_id_modules = [
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff'
]
my_id_modules.append(
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff'
)
#add them to the VID producer
for idmod in my_id_modules:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
def customizeFall17EleID(self,process):
from PhysicsTools.SelectorUtils.tools.vid_id_tools import DataFormat,switchOnVIDElectronIdProducer,setupAllVIDIdsInModule,setupVIDElectronSelection
dataFormat = DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff']
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
process.flashggElectrons.effAreasConfigFile = cms.FileInPath("RecoEgamma/ElectronIdentification/data/Fall17/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_92X.txt")
process.flashggElectrons.eleVetoIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V1-veto")
process.flashggElectrons.eleLooseIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V1-loose")
process.flashggElectrons.eleMediumIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V1-medium")
process.flashggElectrons.eleTightIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V1-tight")
process.flashggElectrons.eleMVALooseIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Fall17-iso-V1-wpLoose")
process.flashggElectrons.eleMVAMediumIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Fall17-iso-V1-wp90")
process.flashggElectrons.eleMVATightIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Fall17-iso-V1-wp80")
process.flashggElectrons.eleMVALooseNoIsoIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Fall17-noIso-V1-wpLoose")
process.flashggElectrons.eleMVAMediumNoIsoIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Fall17-noIso-V1-wp90")
process.flashggElectrons.eleMVATightNoIsoIdMap = cms.InputTag("egmGsfElectronIDs:mvaEleID-Fall17-noIso-V1-wp80")
process.flashggElectrons.mvaValuesMap = cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Fall17IsoV1Values")
process.flashggElectrons.mvaNoIsoValuesMap = cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Fall17NoIsoV1Values")
def enableElectronVID(process):
from PhysicsTools.SelectorUtils.tools.vid_id_tools import switchOnVIDElectronIdProducer, DataFormat, setupAllVIDIdsInModule, setupVIDElectronSelection
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
electron_ids = [
#'mvaElectronID_Fall17_noIso_V2_cff',
#'mvaElectronID_Fall17_iso_V2_cff',
'cutBasedElectronID_Fall17_94X_V2_cff',
]
for idmod in electron_ids:
idmod = "RecoEgamma.ElectronIdentification.Identification." + idmod
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
electron_idNames = [
#"egmGsfElectronIDs:mvaEleID-Fall17-noIso-V2-wp90",
#"egmGsfElectronIDs:mvaEleID-Fall17-noIso-V2-wp80",
#"egmGsfElectronIDs:mvaEleID-Fall17-noIso-V2-wpLoose",
#"egmGsfElectronIDs:mvaEleID-Fall17-iso-V2-wp90",
#"egmGsfElectronIDs:mvaEleID-Fall17-iso-V2-wp80",
#"egmGsfElectronIDs:mvaEleID-Fall17-iso-V2-wpLoose",
#"egmGsfElectronIDs:mvaEleID-Fall17-iso-V2-wpHZZ",
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-veto",
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-loose",
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-medium",
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-tight",
]
process.catElectrons.electronIDSources = cms.PSet()
for idName in electron_idNames:
setattr(process.catElectrons.electronIDSources,
idName.split(':', 1)[1].replace('-', '_'),
cms.InputTag(idName))
process.catElectrons.electronIDs.append(idName.split(':', 1)[1])
process.egmGsfElectronIDs.physicsObjectSrc = process.catElectrons.unsmaredElectrons
#process.electronMVAValueMapProducer.srcMiniAOD = process.catElectrons.unsmaredElectrons
return process
def addElectronIDEmbedding(self, step):
#if not hasattr(self.process, 'egmGsfElectronIDs'):
switchOnVIDElectronIdProducer(self.process, DataFormat.MiniAOD)
setupAllVIDIdsInModule(self.process,
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_HZZ_V1_cff',
setupVIDElectronSelection)
setupAllVIDIdsInModule(self.process,
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
setupVIDElectronSelection)
setupAllVIDIdsInModule(self.process,
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronHLTPreselecition_Summer16_V1_cff',
setupVIDElectronSelection)
self.process.egmGsfElectronIDs.physicsObjectSrc = step.getObjTag('e')
self.process.electronMVAValueMapProducer.srcMiniAOD = step.getObjTag('e')
self.process.electronRegressionValueMapProducer.srcMiniAOD = step.getObjTag('e')
step.addModule('egmGsfElectronIDSequence',
self.process.egmGsfElectronIDSequence)
embedIDs = cms.EDProducer(
"PATElectronValueMapEmbedder",
src = step.getObjTag('e'),
floatLabels = cms.untracked.vstring("MVAIDNonTrig"),
floatVals = cms.untracked.VInputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring16HZZV1Values"),
boolLabels = cms.untracked.vstring("IsCBVIDTight", "IsCBVIDMedium", "IsCBVIDLoose", "IsCBVIDVeto", "IsCBVIDHLTSafe"),
boolVals = cms.untracked.VInputTag(
cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-tight"),
cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-medium"),
cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-loose"),
cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-veto"),
cms.InputTag("egmGsfElectronIDs:cutBasedElectronHLTPreselection-Summer16-V1"),
)
)
step.addModule('electronIDEmbedding', embedIDs, 'e')
def enableElectronVID(process):
from PhysicsTools.SelectorUtils.tools.vid_id_tools import switchOnVIDElectronIdProducer, DataFormat, setupAllVIDIdsInModule, setupVIDElectronSelection
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
electron_ids = [
'cutBasedElectronHLTPreselecition_Summer16_V1_cff',
'cutBasedElectronID_Summer16_80X_V1_cff',
'heepElectronID_HEEPV70_cff',
'mvaElectronID_Spring16_GeneralPurpose_V1_cff',
'mvaElectronID_Spring16_HZZ_V1_cff',
]
for idmod in electron_ids:
idmod = "RecoEgamma.ElectronIdentification.Identification."+idmod
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
electron_idNames = [
"egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-veto",
"egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-loose",
"egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-medium",
"egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-tight",
"egmGsfElectronIDs:cutBasedElectronHLTPreselection-Summer16-V1",
"egmGsfElectronIDs:heepElectronID-HEEPV70",
"egmGsfElectronIDs:mvaEleID-Spring16-GeneralPurpose-V1-wp90",
"egmGsfElectronIDs:mvaEleID-Spring16-GeneralPurpose-V1-wp80",
"egmGsfElectronIDs:mvaEleID-Spring16-HZZ-V1-wpLoose",
]
process.catElectrons.electronIDSources = cms.PSet()
for idName in electron_idNames:
setattr(process.catElectrons.electronIDSources,
idName.split(':',1)[1].replace('-','_'),
cms.InputTag(idName))
process.catElectrons.electronIDs.append(idName.split(':',1)[1])
process.egmGsfElectronIDs.physicsObjectSrc = process.catElectrons.unsmaredElectrons
process.electronMVAValueMapProducer.srcMiniAOD = process.catElectrons.unsmaredElectrons
return process
def configureElectronId_(self):
with StdStreamSilenter():
from PhysicsTools.SelectorUtils.tools.vid_id_tools import DataFormat, switchOnVIDElectronIdProducer, setupAllVIDIdsInModule, setupVIDElectronSelection
switchOnVIDElectronIdProducer(self.process, DataFormat.MiniAOD)
# Use in input our own electorn collection
self.process.egmGsfElectronIDs.physicsObjectSrc = self.__miniaod_electron_collection
id_modules = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff'
]
for mod in id_modules:
setupAllVIDIdsInModule(self.process, mod,
setupVIDElectronSelection)
self.path.associate(
cms.Task(self.process.electronMVAValueMapProducer))
self.path.associate(cms.Task(self.process.egmGsfElectronIDs))
self.process.electronMVAValueMapProducer.srcMiniAOD = self.__miniaod_electron_collection
def setupElectrons(process): switchOnVIDElectronIdProducer(process, DataFormat.AOD) my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff'] for idmod in my_id_modules: setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
metType='Puppi',
pfCandColl='puppiForMET',
recoMetFromPFCs=True,
jetFlavor='AK4PFPuppi',
postfix='Puppi')
# There is a bug in a function used by runMetCorAndUncFromMiniAOD (PhysicsTools.PatAlgos.tools.removeIfInSequence)
# The following module is supposed to be removed from the sequence but is not
# The bug appears when we don't call the no-postfix version of runMetCor.. first
process.fullPatMetSequencePuppi.remove(
process.selectedPatJetsForMetT1T2CorrPuppi)
### EGAMMA ID
from PhysicsTools.SelectorUtils.tools.vid_id_tools import setupAllVIDIdsInModule, setupVIDElectronSelection, switchOnVIDElectronIdProducer, DataFormat
# Loads egmGsfElectronIDs
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
setupAllVIDIdsInModule(
process,
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
setupVIDElectronSelection)
setupAllVIDIdsInModule(
process,
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronHLTPreselecition_Summer16_V1_cff',
setupVIDElectronSelection)
# original has @skipCurrentProcess
process.photonIDValueMapProducer.srcMiniAOD = 'slimmedPhotons'
process.load('PandaProd.Auxiliary.WorstIsolationProducer_cfi')
egmIdSequence = cms.Sequence(process.photonIDValueMapProducer +
def customizeElectrons(process, coll, **kwargs):
'''Customize electrons'''
isMC = kwargs.pop('isMC', False)
eSrc = coll['electrons']
rhoSrc = coll['rho']
pvSrc = coll['vertices']
# customization path
process.electronCustomization = cms.Path()
###################################
### scale and smear corrections ###
###################################
# embed the uncorrected stuff
process.uncorElec = cms.EDProducer(
"ElectronSelfEmbedder",
src=cms.InputTag(eSrc),
label=cms.string('uncorrected'),
)
eSrc = "uncorElec"
process.electronCustomization *= process.uncorElec
# first need to add a manual protection for the corrections
process.selectedElectrons = cms.EDFilter(
"PATElectronSelector",
src=cms.InputTag(eSrc),
cut=cms.string("pt > 5 && abs(eta)<2.5"))
eSrc = "selectedElectrons"
process.electronCustomization *= process.selectedElectrons
process.load('EgammaAnalysis.ElectronTools.calibratedElectronsRun2_cfi')
process.calibratedPatElectrons.electrons = eSrc
process.calibratedPatElectrons.isMC = isMC
process.electronCustomization *= process.calibratedPatElectrons
eSrc = 'calibratedPatElectrons'
#################
### embed VID ###
#################
from PhysicsTools.SelectorUtils.tools.vid_id_tools import switchOnVIDElectronIdProducer, setupAllVIDIdsInModule, DataFormat, setupVIDElectronSelection
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
# define which IDs we want to produce
my_id_modules = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_Trig_V1_cff',
]
# add them to the VID producer
for idmod in my_id_modules:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
# update the collection
process.egmGsfElectronIDs.physicsObjectSrc = cms.InputTag(eSrc)
process.electronMVAValueMapProducer.srcMiniAOD = cms.InputTag(eSrc)
process.electronRegressionValueMapProducer.srcMiniAOD = cms.InputTag(eSrc)
idDecisionLabels = [
'cutBasedElectronID-Spring15-25ns-V1-standalone-veto',
'cutBasedElectronID-Spring15-25ns-V1-standalone-loose',
'cutBasedElectronID-Spring15-25ns-V1-standalone-medium',
'cutBasedElectronID-Spring15-25ns-V1-standalone-tight',
'heepElectronID-HEEPV60',
'mvaEleID-Spring15-25ns-nonTrig-V1-wp80',
'mvaEleID-Spring15-25ns-nonTrig-V1-wp90',
'mvaEleID-Spring15-25ns-Trig-V1-wp90',
'mvaEleID-Spring15-25ns-Trig-V1-wp80',
]
idDecisionTags = [
cms.InputTag(
'egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-veto'
),
cms.InputTag(
'egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-loose'
),
cms.InputTag(
'egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-medium'
),
cms.InputTag(
'egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-tight'
),
cms.InputTag('egmGsfElectronIDs:heepElectronID-HEEPV60'),
cms.InputTag(
'egmGsfElectronIDs:mvaEleID-Spring15-25ns-nonTrig-V1-wp80'),
cms.InputTag(
'egmGsfElectronIDs:mvaEleID-Spring15-25ns-nonTrig-V1-wp90'),
cms.InputTag('egmGsfElectronIDs:mvaEleID-Spring15-25ns-Trig-V1-wp90'),
cms.InputTag('egmGsfElectronIDs:mvaEleID-Spring15-25ns-Trig-V1-wp80'),
]
mvaValueLabels = [
#"ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Values",
#"ElectronMVAEstimatorRun2Spring15Trig25nsV1Values",
]
mvaValueTags = [
#cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Values"),
#cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15Trig25nsV1Values"),
]
mvaCategoryLabels = [
#"ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Categories",
#"ElectronMVAEstimatorRun2Spring15Trig25nsV1Categories",
]
mvaCategoryTags = [
#cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Categories"),
#cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15Trig25nsV1Categories"),
]
process.eidEmbedder = cms.EDProducer(
"ElectronVIDEmbedder",
src=cms.InputTag(eSrc),
idLabels=cms.vstring(*idDecisionLabels), # labels for bool maps
ids=cms.VInputTag(*idDecisionTags), # bool maps
valueLabels=cms.vstring(*mvaValueLabels), # labels for float maps
values=cms.VInputTag(*mvaValueTags), # float maps
categoryLabels=cms.vstring(*mvaCategoryLabels), # labels for int maps
categories=cms.VInputTag(*mvaCategoryTags), # int maps
)
eSrc = 'eidEmbedder'
process.electronCustomization *= process.egmGsfElectronIDSequence
process.electronCustomization *= process.eidEmbedder
##########################
### embed missing hits ###
##########################
process.eMissingHits = cms.EDProducer(
"ElectronMissingHitsEmbedder",
src=cms.InputTag(eSrc),
)
eSrc = 'eMissingHits'
process.electronCustomization *= process.eMissingHits
###################
### embed ww id ###
###################
process.eWW = cms.EDProducer(
"ElectronWWIdEmbedder",
src=cms.InputTag(eSrc),
vertexSrc=cms.InputTag(pvSrc),
)
eSrc = 'eWW'
process.electronCustomization *= process.eWW
#############################
### embed effective areas ###
#############################
eaFile = 'RecoEgamma/ElectronIdentification/data/Spring15/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_25ns.txt'
process.eEffArea = cms.EDProducer(
"ElectronEffectiveAreaEmbedder",
src=cms.InputTag(eSrc),
label=cms.string(
"EffectiveArea"), # embeds a user float with this name
configFile=cms.FileInPath(eaFile), # the effective areas file
)
eSrc = 'eEffArea'
process.electronCustomization *= process.eEffArea
#################
### embed rho ###
#################
process.eRho = cms.EDProducer(
"ElectronRhoEmbedder",
src=cms.InputTag(eSrc),
rhoSrc=cms.InputTag(rhoSrc),
label=cms.string("rho"),
)
eSrc = 'eRho'
process.electronCustomization *= process.eRho
################
### embed pv ###
################
process.ePV = cms.EDProducer(
"ElectronIpEmbedder",
src=cms.InputTag(eSrc),
vertexSrc=cms.InputTag(pvSrc),
)
eSrc = 'ePV'
process.electronCustomization *= process.ePV
##############################
### embed trigger matching ###
##############################
process.eTrig = cms.EDProducer(
"ElectronHLTMatchEmbedder",
src=cms.InputTag(eSrc),
triggerResults=cms.InputTag('TriggerResults', '', 'HLT'),
triggerObjects=cms.InputTag("selectedPatTrigger"),
deltaR=cms.double(0.5),
labels=cms.vstring(
# single electron
'matches_Ele12_CaloIdL_TrackIdL_IsoVL',
'matches_Ele17_CaloIdL_TrackIdL_IsoVL',
'matches_Ele23_CaloIdL_TrackIdL_IsoVL',
'matches_Ele22_eta2p1_WPLoose_Gsf',
'matches_Ele23_WPLoose_Gsf',
'matches_Ele27_WPLoose_Gsf',
# double electron
'matches_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ',
# muon electron
'matches_Mu8_TrkIsoVVL_Ele17_CaloIdL_TrackIdL_IsoVL',
'matches_Mu17_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL',
# electron tau
'matches_Ele22_eta2p1_WPLoose_Gsf_LooseIsoPFTau20',
'matches_Ele27_eta2p1_WPLoose_Gsf_LooseIsoPFTau20',
# multi lepton
'matches_Ele16_Ele12_Ele8_CaloIdL_TrackIdL',
'matches_Mu8_DiEle12_CaloIdL_TrackIdL',
'matches_DiMu9_Ele9_CaloIdL_TrackIdL',
),
paths=cms.vstring(
# single electron
'HLT_Ele12_CaloIdL_TrackIdL_IsoVL_v\\[0-9]+',
'HLT_Ele17_CaloIdL_TrackIdL_IsoVL_v\\[0-9]+',
'HLT_Ele23_CaloIdL_TrackIdL_IsoVL_v\\[0-9]+',
'HLT_Ele22_eta2p1_WPLoose_Gsf_v\\[0-9]+',
'HLT_Ele23_WPLoose_Gsf_v\\[0-9]+',
'HLT_Ele27_WPLoose_Gsf_v\\[0-9]+',
# double electron
'HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v\\[0-9]+',
# muon electron
'HLT_Mu8_TrkIsoVVL_Ele17_CaloIdL_TrackIdL_IsoVL_v\\[0-9]+',
'HLT_Mu17_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v\\[0-9]+',
# electron tau
'HLT_Ele22_eta2p1_WPLoose_Gsf_LooseIsoPFTau20_v\\[0-9]+',
'HLT_Ele27_eta2p1_WPLoose_Gsf_LooseIsoPFTau20_v\\[0-9]+',
# multi lepton
'HLT_Ele16_Ele12_Ele8_CaloIdL_TrackIdL_v\\[0-9]+',
'HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v\\[0-9]+',
'HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v\\[0-9]+',
),
)
eSrc = 'eTrig'
process.electronCustomization *= process.eTrig
# add to schedule
process.schedule.append(process.electronCustomization)
coll['electrons'] = eSrc
return coll
def customizeElectrons(process,coll,**kwargs):
'''Customize electrons'''
isMC = kwargs.pop('isMC',False)
eSrc = coll['electrons']
rhoSrc = coll['rho']
pvSrc = coll['vertices']
# customization path
process.electronCustomization = cms.Path()
###################################
### scale and smear corrections ###
###################################
# embed the uncorrected stuff
process.uncorElec = cms.EDProducer(
"ElectronSelfEmbedder",
src=cms.InputTag(eSrc),
label=cms.string('uncorrected'),
)
eSrc = "uncorElec"
process.electronCustomization *= process.uncorElec
# first need to add a manual protection for the corrections
process.selectedElectrons = cms.EDFilter(
"PATElectronSelector",
src = cms.InputTag(eSrc),
cut = cms.string("pt > 5 && abs(eta)<2.5")
)
eSrc = "selectedElectrons"
process.electronCustomization *= process.selectedElectrons
process.load('EgammaAnalysis.ElectronTools.calibratedElectronsRun2_cfi')
process.calibratedPatElectrons.electrons = eSrc
process.calibratedPatElectrons.isMC = isMC
process.electronCustomization *= process.calibratedPatElectrons
eSrc = 'calibratedPatElectrons'
#################
### embed VID ###
#################
from PhysicsTools.SelectorUtils.tools.vid_id_tools import switchOnVIDElectronIdProducer, setupAllVIDIdsInModule, DataFormat, setupVIDElectronSelection
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
# define which IDs we want to produce
my_id_modules = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_Trig_V1_cff',
]
# add them to the VID producer
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
# update the collection
process.egmGsfElectronIDs.physicsObjectSrc = cms.InputTag(eSrc)
process.electronMVAValueMapProducer.srcMiniAOD = cms.InputTag(eSrc)
process.electronRegressionValueMapProducer.srcMiniAOD = cms.InputTag(eSrc)
idDecisionLabels = [
'cutBasedElectronID-Spring15-25ns-V1-standalone-veto',
'cutBasedElectronID-Spring15-25ns-V1-standalone-loose',
'cutBasedElectronID-Spring15-25ns-V1-standalone-medium',
'cutBasedElectronID-Spring15-25ns-V1-standalone-tight',
'heepElectronID-HEEPV60',
'mvaEleID-Spring15-25ns-nonTrig-V1-wp80',
'mvaEleID-Spring15-25ns-nonTrig-V1-wp90',
'mvaEleID-Spring15-25ns-Trig-V1-wp90',
'mvaEleID-Spring15-25ns-Trig-V1-wp80',
]
idDecisionTags = [
cms.InputTag('egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-veto'),
cms.InputTag('egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-loose'),
cms.InputTag('egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-medium'),
cms.InputTag('egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-tight'),
cms.InputTag('egmGsfElectronIDs:heepElectronID-HEEPV60'),
cms.InputTag('egmGsfElectronIDs:mvaEleID-Spring15-25ns-nonTrig-V1-wp80'),
cms.InputTag('egmGsfElectronIDs:mvaEleID-Spring15-25ns-nonTrig-V1-wp90'),
cms.InputTag('egmGsfElectronIDs:mvaEleID-Spring15-25ns-Trig-V1-wp90'),
cms.InputTag('egmGsfElectronIDs:mvaEleID-Spring15-25ns-Trig-V1-wp80'),
]
mvaValueLabels = [
#"ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Values",
#"ElectronMVAEstimatorRun2Spring15Trig25nsV1Values",
]
mvaValueTags = [
#cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Values"),
#cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15Trig25nsV1Values"),
]
mvaCategoryLabels = [
#"ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Categories",
#"ElectronMVAEstimatorRun2Spring15Trig25nsV1Categories",
]
mvaCategoryTags = [
#cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Categories"),
#cms.InputTag("electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15Trig25nsV1Categories"),
]
process.eidEmbedder = cms.EDProducer(
"ElectronVIDEmbedder",
src=cms.InputTag(eSrc),
idLabels = cms.vstring(*idDecisionLabels), # labels for bool maps
ids = cms.VInputTag(*idDecisionTags), # bool maps
valueLabels = cms.vstring(*mvaValueLabels), # labels for float maps
values = cms.VInputTag(*mvaValueTags), # float maps
categoryLabels = cms.vstring(*mvaCategoryLabels), # labels for int maps
categories = cms.VInputTag(*mvaCategoryTags), # int maps
)
eSrc = 'eidEmbedder'
process.electronCustomization *= process.egmGsfElectronIDSequence
process.electronCustomization *= process.eidEmbedder
##########################
### embed missing hits ###
##########################
process.eMissingHits = cms.EDProducer(
"ElectronMissingHitsEmbedder",
src = cms.InputTag(eSrc),
)
eSrc = 'eMissingHits'
process.electronCustomization *= process.eMissingHits
###################
### embed ww id ###
###################
process.eWW = cms.EDProducer(
"ElectronWWIdEmbedder",
src = cms.InputTag(eSrc),
vertexSrc = cms.InputTag(pvSrc),
)
eSrc = 'eWW'
process.electronCustomization *= process.eWW
#############################
### embed effective areas ###
#############################
eaFile = 'RecoEgamma/ElectronIdentification/data/Spring15/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_25ns.txt'
process.eEffArea = cms.EDProducer(
"ElectronEffectiveAreaEmbedder",
src = cms.InputTag(eSrc),
label = cms.string("EffectiveArea"), # embeds a user float with this name
configFile = cms.FileInPath(eaFile), # the effective areas file
)
eSrc = 'eEffArea'
process.electronCustomization *= process.eEffArea
#################
### embed rho ###
#################
process.eRho = cms.EDProducer(
"ElectronRhoEmbedder",
src = cms.InputTag(eSrc),
rhoSrc = cms.InputTag(rhoSrc),
label = cms.string("rho"),
)
eSrc = 'eRho'
process.electronCustomization *= process.eRho
################
### embed pv ###
################
process.ePV = cms.EDProducer(
"ElectronIpEmbedder",
src = cms.InputTag(eSrc),
vertexSrc = cms.InputTag(pvSrc),
)
eSrc = 'ePV'
process.electronCustomization *= process.ePV
##############################
### embed trigger matching ###
##############################
process.eTrig = cms.EDProducer(
"ElectronHLTMatchEmbedder",
src = cms.InputTag(eSrc),
triggerResults = cms.InputTag('TriggerResults', '', 'HLT'),
triggerObjects = cms.InputTag("selectedPatTrigger"),
deltaR = cms.double(0.5),
labels = cms.vstring(
# single electron
'matches_Ele12_CaloIdL_TrackIdL_IsoVL',
'matches_Ele17_CaloIdL_TrackIdL_IsoVL',
'matches_Ele23_CaloIdL_TrackIdL_IsoVL',
'matches_Ele22_eta2p1_WPLoose_Gsf',
'matches_Ele23_WPLoose_Gsf',
'matches_Ele27_WPLoose_Gsf',
# double electron
'matches_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ',
# muon electron
'matches_Mu8_TrkIsoVVL_Ele17_CaloIdL_TrackIdL_IsoVL',
'matches_Mu17_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL',
# electron tau
'matches_Ele22_eta2p1_WPLoose_Gsf_LooseIsoPFTau20',
'matches_Ele27_eta2p1_WPLoose_Gsf_LooseIsoPFTau20',
# multi lepton
'matches_Ele16_Ele12_Ele8_CaloIdL_TrackIdL',
'matches_Mu8_DiEle12_CaloIdL_TrackIdL',
'matches_DiMu9_Ele9_CaloIdL_TrackIdL',
),
paths = cms.vstring(
# single electron
'HLT_Ele12_CaloIdL_TrackIdL_IsoVL_v\\[0-9]+',
'HLT_Ele17_CaloIdL_TrackIdL_IsoVL_v\\[0-9]+',
'HLT_Ele23_CaloIdL_TrackIdL_IsoVL_v\\[0-9]+',
'HLT_Ele22_eta2p1_WPLoose_Gsf_v\\[0-9]+',
'HLT_Ele23_WPLoose_Gsf_v\\[0-9]+',
'HLT_Ele27_WPLoose_Gsf_v\\[0-9]+',
# double electron
'HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v\\[0-9]+',
# muon electron
'HLT_Mu8_TrkIsoVVL_Ele17_CaloIdL_TrackIdL_IsoVL_v\\[0-9]+',
'HLT_Mu17_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v\\[0-9]+',
# electron tau
'HLT_Ele22_eta2p1_WPLoose_Gsf_LooseIsoPFTau20_v\\[0-9]+',
'HLT_Ele27_eta2p1_WPLoose_Gsf_LooseIsoPFTau20_v\\[0-9]+',
# multi lepton
'HLT_Ele16_Ele12_Ele8_CaloIdL_TrackIdL_v\\[0-9]+',
'HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v\\[0-9]+',
'HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v\\[0-9]+',
),
)
eSrc = 'eTrig'
process.electronCustomization *= process.eTrig
# add to schedule
process.schedule.append(process.electronCustomization)
coll['electrons'] = eSrc
return coll
),
)
process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
process.load('EgammaAnalysis.ElectronTools.calibratedPatElectronsRun2_cfi')
process.EGMSmearerElectrons = cms.Path(process.calibratedPatElectrons)
process.calibratedPatElectrons.isMC = cms.bool(True) #varOptions.isMC
print "HEEPV70"
from PhysicsTools.SelectorUtils.tools.vid_id_tools import switchOnVIDElectronIdProducer
from PhysicsTools.SelectorUtils.tools.vid_id_tools import setupVIDElectronSelection
from PhysicsTools.SelectorUtils.tools.vid_id_tools import setupAllVIDIdsInModule
from PhysicsTools.SelectorUtils.tools.vid_id_tools import DataFormat
dataFormat = DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process, dataFormat)
my_id_modules = [
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff',
]
for idmod in my_id_modules:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag("slimmedElectrons")
print "MET Filter"
process.load("RecoMET.METFilters.BadPFMuonFilter_cfi")
process.BadPFMuonFilter.muons = cms.InputTag("slimmedMuons")
process.BadPFMuonFilter.PFCandidates = cms.InputTag("packedPFCandidates")
process.load("RecoMET.METFilters.BadChargedCandidateFilter_cfi")
process.BadChargedCandidateFilter.muons = cms.InputTag("slimmedMuons")
process.BadChargedCandidateFilter.PFCandidates = cms.InputTag(
# Step 2
from TopQuarkAnalysis.Configuration.patRefSel_refMuJets_cfi import standAloneLooseMuonVetoFilter
process.standAloneLooseMuonVetoFilter = standAloneLooseMuonVetoFilter.clone()
process.sStandAloneLooseMuonVeto = cms.Sequence( process.standAloneLooseMuonVetoFilter )
process.pStandAloneLooseMuonVeto = cms.Path( process.sStandAloneLooseMuonVeto )
# Step 3
if not runOnMiniAOD:
from PhysicsTools.SelectorUtils.tools.vid_id_tools import switchOnVIDElectronIdProducer, setupAllVIDIdsInModule, setupVIDElectronSelection
electron_ids = [ 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_CSA14_50ns_V1_cff'
, 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_CSA14_PU20bx25_V0_cff'
]
switchOnVIDElectronIdProducer( process )
process.electronIDValueMapProducer.ebReducedRecHitCollection = cms.InputTag( 'reducedEcalRecHitsEB' )
process.electronIDValueMapProducer.eeReducedRecHitCollection = cms.InputTag( 'reducedEcalRecHitsEE' )
process.electronIDValueMapProducer.esReducedRecHitCollection = cms.InputTag( 'reducedEcalRecHitsES' )
for idmod in electron_ids:
setupAllVIDIdsInModule( process, idmod, setupVIDElectronSelection )
if useElecEAIsoCorr:
from EgammaAnalysis.ElectronTools.electronIsolatorFromEffectiveArea_cfi import elPFIsoValueEA03
if runOnMiniAOD:
process.patElPFIsoValueEA03 = elPFIsoValueEA03.clone( gsfElectrons = ''
, pfElectrons = ''
, patElectrons = cms.InputTag( 'slimmedElectrons' )
, rhoIso = cms.InputTag( 'fixedGridRhoFastjetAll' )
)
from EgammaAnalysis.ElectronTools.patElectronEAIsoCorrectionProducer_cfi import patElectronEAIso03CorrectionProducer
def create(isData, era, globalTag=None, analyzers=cms.PSet(), redoJEC=False):
"""Create the CMSSW python configuration for the Framework
Args:
isData (bool): Set to True if you run over data, or False for simulated samples
era (Configuration.StandardSequences.Eras.eras): The era of the sample. Used to distringuish between 50ns and 25ns
globalTag (str): The global tag to use for this workflow. If set to ``None``, a command-line argument named ``globalTag`` must be specified
analyzers (cms.PSet()): A list of analyzers to run. By default, it's empty, and you can still add one to the list afterwards.
redoJEC (bool): If True, a new jet collection will be created, starting from MiniAOD jets but with latest JEC, pulled from the global tag.
Returns:
The ``process`` object for the CMSSW framework
You can use the returned object to add / remove producers, analyzers from the default framework configuration.
Examples:
import FWCore.ParameterSet.Config as cms
from Configuration.StandardSequences.Eras import eras
from cp3_llbb.Framework import Framework
# Run on 50ns data sample
process = Framework.create(True, eras.Run2_50ns, '74X_dataRun2_Prompt_v1')
# Run on 25ns data sample
process = Framework.create(True, eras.Run2_25ns, '74X_dataRun2_Prompt_v2')
# For MC 50ns
process = Framework.create(False, eras.Run2_50ns, 'MCRUN2_74_V9', cms.PSet(
test = cms.PSet(
type = cms.string('test_analyzer'),
prefix = cms.string('test_'),
enable = cms.bool(True)
)
)
)
"""
parseCommandLine = False
import sys
for argv in sys.argv:
if 'globalTag' in argv or 'era' in argv or 'process' in argv:
parseCommandLine = True
break
miniaod_process_name = None
if parseCommandLine:
from FWCore.ParameterSet.VarParsing import VarParsing
options = VarParsing()
options.register('globalTag',
'',
VarParsing.multiplicity.singleton,
VarParsing.varType.string,
'The globaltag to use')
options.register('era',
'',
VarParsing.multiplicity.singleton,
VarParsing.varType.string,
'Era of the dataset')
options.register('process',
'',
VarParsing.multiplicity.singleton,
VarParsing.varType.string,
'Process name of the MiniAOD production.')
options.parseArguments()
if options.globalTag:
globalTag = options.globalTag
if options.era:
assert options.era == '25ns' or options.era == '50ns'
if options.era == '25ns':
era = eras.Run2_25ns
else:
era = eras.Run2_50ns
if options.process:
miniaod_process_name = options.process
if globalTag is None:
raise Exception("No global tag specified. Use the 'globalTag' command line argument to set one.\n\tcmsRun <configuration> globalTag=<global_tag>")
if era is None:
raise Exception("No era specified. Use the 'era' command line argument to set one.\n\tcmsRun <configuration> era=[25ns|50ns]")
print("")
print("CP3 llbb framework:")
print("\t - Running over %s" % ("data" if isData else "simulation"))
print("\t - global tag: %s" % globalTag)
print("\t - era: %s" % ("25ns" if era == eras.Run2_25ns else "50ns"))
print("")
process = cms.Process("ETM", era)
process.options = cms.untracked.PSet(
wantSummary = cms.untracked.bool(False),
allowUnscheduled = cms.untracked.bool(True)
)
# Flags
createNoHFMet = True
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff")
process.load("Configuration.EventContent.EventContent_cff")
process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
process.load('Configuration.StandardSequences.MagneticField_38T_cff')
process.GlobalTag.globaltag = globalTag
process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(20))
process.source = cms.Source("PoolSource")
# Electron ID recipe
from PhysicsTools.SelectorUtils.tools.vid_id_tools import DataFormat, switchOnVIDElectronIdProducer, setupAllVIDIdsInModule, setupVIDElectronSelection
dataFormat = DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
id_modules = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_50ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff'
]
for idmod in id_modules:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
# Services
process.load('FWCore.MessageLogger.MessageLogger_cfi')
process.MessageLogger.cerr.FwkReport.reportEvery = 100
bTagDiscriminators = [
'pfCombinedInclusiveSecondaryVertexV2BJetTags', 'pfJetProbabilityBJetTags', 'pfCombinedMVABJetTags',
'pfSimpleSecondaryVertexHighEffBJetTags', 'pfSimpleSecondaryVertexHighPurBJetTags'
]
if redoJEC:
setup_jets_(process, isData, bTagDiscriminators)
setup_met_(process, isData)
if createNoHFMet:
setup_nohf_met_(process, isData)
# Producers
from cp3_llbb.Framework import EventProducer
from cp3_llbb.Framework import GenParticlesProducer
from cp3_llbb.Framework import HLTProducer
from cp3_llbb.Framework import JetsProducer
from cp3_llbb.Framework import FatJetsProducer
from cp3_llbb.Framework import METProducer
from cp3_llbb.Framework import MuonsProducer
from cp3_llbb.Framework import ElectronsProducer
from cp3_llbb.Framework import VerticesProducer
output = 'output_mc.root' if not isData else 'output_data.root'
process.framework = cms.EDProducer("ExTreeMaker",
output = cms.string(output),
filters = cms.PSet(
),
producers = cms.PSet(
event = EventProducer.default_configuration,
hlt = HLTProducer.default_configuration,
jets = JetsProducer.default_configuration,
fat_jets = FatJetsProducer.default_configuration,
met = METProducer.default_configuration,
muons = MuonsProducer.default_configuration,
electrons = ElectronsProducer.default_configuration,
vertices = VerticesProducer.default_configuration,
),
analyzers = analyzers
)
process.framework.producers.jets.parameters.cut = cms.untracked.string("pt > 10")
process.framework.producers.jets.parameters.btags = cms.untracked.vstring(bTagDiscriminators)
process.framework.producers.fat_jets.parameters.cut = cms.untracked.string("pt > 200")
if era == eras.Run2_25ns:
process.framework.producers.electrons.parameters.ea_R03 = cms.untracked.FileInPath('RecoEgamma/ElectronIdentification/data/Spring15/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_25ns.txt')
else:
process.framework.producers.electrons.parameters.ea_R03 = cms.untracked.FileInPath('RecoEgamma/ElectronIdentification/data/Spring15/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_50ns.txt')
if createNoHFMet:
process.framework.producers.nohf_met = cms.PSet(METProducer.default_configuration.clone())
process.framework.producers.nohf_met.prefix = 'nohf_met_'
process.framework.producers.nohf_met.parameters.met = cms.untracked.InputTag('slimmedMETsNoHF')
path = cms.Path()
if not isData:
process.framework.producers.gen_particles = GenParticlesProducer.default_configuration
else:
# MET Filters
from cp3_llbb.Framework import METFilter
process.framework.filters.met = METFilter.default_configuration
process.load('CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi')
process.filterOnHBHENoiseFilter = cms.EDFilter('BooleanFlagFilter',
inputLabel = cms.InputTag('HBHENoiseFilterResultProducer', 'HBHENoiseFilterResult'),
reverseDecision = cms.bool(False)
)
path += cms.Sequence(process.filterOnHBHENoiseFilter)
if redoJEC:
process.framework.producers.jets.parameters.jets = cms.untracked.InputTag('selectedPatJetsAK4PFCHS')
path += cms.Sequence(
process.egmGsfElectronIDSequence *
process.framework
)
process.p = path
if miniaod_process_name:
print("")
print("Changing process name from %r to %r..." % ('PAT', miniaod_process_name))
change_process_name_(process.framework, 'PAT', miniaod_process_name)
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#! Output and Log
#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
print("")
return process
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff')
process.GlobalTag.globaltag = '80X_dataRun2_Prompt_v11'
process.load("Configuration.Geometry.GeometryIdeal_cff")
process.load('Configuration.StandardSequences.Services_cff')
process.load("Configuration.StandardSequences.MagneticField_cff")
#process.out = cms.OutputModule('PoolOutputModule',
# fileName = cms.untracked.string('test.root')
#)
from PhysicsTools.SelectorUtils.tools.vid_id_tools import setupAllVIDIdsInModule, setupVIDElectronSelection, setupVIDPhotonSelection, switchOnVIDPhotonIdProducer, switchOnVIDElectronIdProducer, DataFormat
switchOnVIDPhotonIdProducer(process, DataFormat.MiniAOD)
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
setupAllVIDIdsInModule(process, 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_25ns_V1_cff', setupVIDPhotonSelection)
setupAllVIDIdsInModule(process, 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff', setupVIDElectronSelection)
photonId = 'egmPhotonIDs:cutBasedPhotonID-Spring15-25ns-V1-standalone-'
photonEA = 'RecoEgamma/PhotonIdentification/data/Spring15/effAreaPhotons_cone03_'
electronId = 'egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-'
electronEA = 'RecoEgamma/ElectronIdentification/data/Spring15/effAreaElectrons_cone03_'
process.ntuples = cms.EDAnalyzer('SimpleTreeProducer',
fillers = cms.untracked.vstring('Electrons', 'HLT', 'Jets', 'MetFilters', 'Muons', 'Photons', 'Rho', 'SuperClusters', 'T1Met', 'Taus', 'Vertices'),
useTrigger = cms.untracked.bool(True),
photons = cms.untracked.string('slimmedPhotons'),
electrons = cms.untracked.string('slimmedElectrons'),
muons = cms.untracked.string('slimmedMuons'),
taus = cms.untracked.string('slimmedTaus'),
def addElectrons(process, coll, **kwargs):
isMC = kwargs.pop('isMC', False)
eSrc = coll['electrons']
pvSrc = coll['vertices']
# customization path
process.electronCustomization = cms.Path()
###################################
### scale and smear corrections ###
###################################
#process.load('EgammaAnalysis.ElectronTools.calibratedElectronsRun2_cfi')
#process.calibratedPatElectrons.electrons = eSrc
#process.calibratedPatElectrons.isMC = isMC
#process.electronCustomization *= process.calibratedPatElectrons
#eSrc = 'calibratedPatElectrons'
######################
### embed gap info ###
######################
process.eGI = cms.EDProducer(
'ElectronGapInfoEmbedder',
src=cms.InputTag(eSrc),
)
eSrc = 'eGI'
process.electronCustomization *= process.eGI
#################
### embed VID ###
#################
from PhysicsTools.SelectorUtils.tools.vid_id_tools import switchOnVIDElectronIdProducer, setupAllVIDIdsInModule, DataFormat, setupVIDElectronSelection
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
# define which IDs we want to produce
my_id_modules = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
]
# add them to the VID producer
for idmod in my_id_modules:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
# update the collection
process.egmGsfElectronIDs.physicsObjectSrc = cms.InputTag(eSrc)
process.electronMVAValueMapProducer.srcMiniAOD = cms.InputTag(eSrc)
process.electronRegressionValueMapProducer.srcMiniAOD = cms.InputTag(eSrc)
idDecisionLabels = [
'cutBasedElectronID-Summer16-80X-V1-veto',
'cutBasedElectronID-Summer16-80X-V1-loose',
'cutBasedElectronID-Summer16-80X-V1-medium',
'cutBasedElectronID-Summer16-80X-V1-tight',
]
idDecisionTags = [
cms.InputTag(
'egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-veto'),
cms.InputTag(
'egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-loose'),
cms.InputTag(
'egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-medium'),
cms.InputTag(
'egmGsfElectronIDs:cutBasedElectronID-Summer16-80X-V1-tight'),
]
mvaValueLabels = [
#'ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Values',
#'ElectronMVAEstimatorRun2Spring15Trig25nsV1Values',
]
mvaValueTags = [
#cms.InputTag('electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Values'),
#cms.InputTag('electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15Trig25nsV1Values'),
]
mvaCategoryLabels = [
#'ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Categories',
#'ElectronMVAEstimatorRun2Spring15Trig25nsV1Categories',
]
mvaCategoryTags = [
#cms.InputTag('electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15NonTrig25nsV1Categories'),
#cms.InputTag('electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring15Trig25nsV1Categories'),
]
process.eidEmbedder = cms.EDProducer(
'ElectronVIDEmbedder',
src=cms.InputTag(eSrc),
idLabels=cms.vstring(*idDecisionLabels), # labels for bool maps
ids=cms.VInputTag(*idDecisionTags), # bool maps
valueLabels=cms.vstring(*mvaValueLabels), # labels for float maps
values=cms.VInputTag(*mvaValueTags), # float maps
categoryLabels=cms.vstring(*mvaCategoryLabels), # labels for int maps
categories=cms.VInputTag(*mvaCategoryTags), # int maps
)
eSrc = 'eidEmbedder'
process.electronCustomization *= process.egmGsfElectronIDSequence
process.electronCustomization *= process.eidEmbedder
##########################
### embed missing hits ###
##########################
process.eMH = cms.EDProducer(
'ElectronMissingHitsEmbedder',
src=cms.InputTag(eSrc),
)
eSrc = 'eMH'
process.electronCustomization *= process.eMH
#############################
### embed effective areas ###
#############################
eaFile = 'RecoEgamma/ElectronIdentification/data/Summer16/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_80X.txt'
#eaFile = 'RecoEgamma/ElectronIdentification/data/Spring15/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_25ns.txt'
process.eEffArea = cms.EDProducer(
'ElectronEffectiveAreaEmbedder',
src=cms.InputTag(eSrc),
label=cms.string(
'EffectiveArea'), # embeds a user float with this name
configFile=cms.FileInPath(eaFile), # the effective areas file
)
eSrc = 'eEffArea'
process.electronCustomization *= process.eEffArea
################
### embed pv ###
################
process.ePV = cms.EDProducer(
'ElectronPVEmbedder',
src=cms.InputTag(eSrc),
vertexSrc=cms.InputTag(pvSrc),
)
eSrc = 'ePV'
process.electronCustomization *= process.ePV
# add to schedule
process.schedule.append(process.electronCustomization)
coll['electrons'] = eSrc
return coll
def define_electrons(process):
"""Define reconstructed electrons.
Configure reconstructed electrons to be used in an analysis,
together with the relevant identification requirements.
Arguments:
process: The process to which relevant electron producers are
added.
Return value:
Return a tuple with the following elements:
eleQualityCuts: List of string-based quality selections whose
decisions are to be saved.
eleEmbeddedCutBasedIDLabels: Labels of boolean electron IDs
embedded in pat::Electron whose decisions are to be saved.
eleCutBasedIDMaps: Tags to access maps with boolean electron IDs
whose decisions are to be saved.
eleMVAIDMaps: Tags to access maps with continuous electron IDs
whose decisions are to be saved.
In addition to constructing the return values, add producers that
create the following collections of electrons:
analysisPatElectrons: Collection of loosely identified
non-isolated electrons to be saved.
patElectronsForEventSelection: Collection of loosely identified
non-isolated electrons that pass a realistically tight
kinematic selection. Exploited in the loose event selection
applied in the main configuration.
"""
# Collection of electrons that will be stored in tuples
process.analysisPatElectrons = cms.EDFilter('PATElectronSelector',
src = cms.InputTag('slimmedElectrons'),
cut = cms.string('pt > 20. & (abs(eta) < 2.5 | abs(superCluster.eta) < 2.5)')
)
# Labels to access embedded cut-based ID. They are not used at the
# moment, and all IDs are evaluated on the fly.
eleEmbeddedCutBasedIDLabels = []
# Setup VID for cut-based ID and trigger-emulating preselection [1]
# and MVA-based ID [2]
# [1] https://twiki.cern.ch/twiki/bin/viewauth/CMS/CutBasedElectronIdentificationRun2?rev=41
# [2] https://twiki.cern.ch/twiki/bin/view/CMS/MultivariateElectronIdentificationRun2?rev=30#VID_based_recipe_provides_pass_f
from PhysicsTools.SelectorUtils.tools.vid_id_tools import (
switchOnVIDElectronIdProducer, setupAllVIDIdsInModule, setupVIDElectronSelection,
DataFormat
)
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
for idModule in [
'cutBasedElectronID_Summer16_80X_V1_cff',
'cutBasedElectronHLTPreselecition_Summer16_V1_cff',
'mvaElectronID_Spring16_GeneralPurpose_V1_cff'
]:
setupAllVIDIdsInModule(
process,
'RecoEgamma.ElectronIdentification.Identification.' +
idModule, setupVIDElectronSelection
)
process.egmGsfElectronIDs.physicsObjectSrc = 'analysisPatElectrons'
process.electronMVAValueMapProducer.srcMiniAOD = 'analysisPatElectrons'
# Add also customized cut-based ID without requirements on isolation
setupAllVIDIdsInModule(
process,
'Analysis.PECTuples.cutBasedElectronID_nonIso_cff',
setupVIDElectronSelection
)
# Labels of maps with electron ID
eleIDProducer = 'egmGsfElectronIDs'
eleCutBasedIDMaps = [eleIDProducer + ':cutBasedElectronID-Summer16-80X-V1-' + p
for p in ['veto', 'loose', 'medium', 'tight']] + \
[eleIDProducer + ':cutBasedElectronHLTPreselection-Summer16-V1'] + \
[eleIDProducer + ':cutBasedElectronID-nonIso-tight']
eleMVAIDMaps = ['electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring16GeneralPurposeV1Values']
# Additional selections to be evaluated (nothing at the moment)
eleQualityCuts = cms.vstring()
# Define electrons to be used for the loose event selection in the
# main configuration. Tighter kinematical cuts are applied to them.
process.patElectronsForEventSelection = cms.EDFilter('PATElectronSelector',
src = cms.InputTag('analysisPatElectrons'),
cut = cms.string('pt > 23. & (abs(eta) < 2.5 | abs(superCluster.eta) < 2.5)')
)
# Return values
return eleQualityCuts, eleEmbeddedCutBasedIDLabels, eleCutBasedIDMaps, eleMVAIDMaps
def define_electrons(process):
"""Define reconstructed electrons.
Configure reconstructed electrons to be used in an analysis,
together with the relevant identification requirements.
Arguments:
process: The process to which relevant electron producers are
added.
Return value:
Return a tuple with the following elements:
eleQualityCuts: List of string-based quality selections whose
decisions are to be saved.
eleEmbeddedCutBasedIDLabels: Labels of boolean electron IDs
embedded in pat::Electron whose decisions are to be saved.
eleCutBasedIDMaps: Tags to access maps with boolean electron IDs
whose decisions are to be saved.
eleMVAIDMaps: Tags to access maps with continuous electron IDs
whose decisions are to be saved.
In addition to constructing the return values, add producers that
create the following collections of electrons:
analysisPatElectrons: Collection of loosely identified
non-isolated electrons to be saved.
patElectronsForEventSelection: Collection of loosely identified
non-isolated electrons that pass a realistically tight
kinematical selection. Exploited in the loose event
selection applied in the main configuration.
"""
# Collection of electrons that will be stored in tuples
process.analysisPatElectrons = cms.EDFilter('PATElectronSelector',
src = cms.InputTag('slimmedElectrons'),
cut = cms.string('pt > 20. & (abs(eta) < 2.5 | abs(superCluster.eta) < 2.5)')
)
# Labels to access embedded cut-based ID. They are not used at the
# moment, and all IDs are evaluated on the fly.
eleEmbeddedCutBasedIDLabels = []
# Setup VID for cut-based ID and trigger-emulating preselection [1]
# and MVA-based ID [2]
# [1] https://twiki.cern.ch/twiki/bin/viewauth/CMS/CutBasedElectronIdentificationRun2?rev=41
# [2] https://twiki.cern.ch/twiki/bin/view/CMS/MultivariateElectronIdentificationRun2?rev=30#VID_based_recipe_provides_pass_f
from PhysicsTools.SelectorUtils.tools.vid_id_tools import (switchOnVIDElectronIdProducer,
setupAllVIDIdsInModule, setupVIDElectronSelection, DataFormat)
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
for idModule in [
'cutBasedElectronID_Summer16_80X_V1_cff',
'cutBasedElectronHLTPreselecition_Summer16_V1_cff',
'mvaElectronID_Spring16_GeneralPurpose_V1_cff'
]:
setupAllVIDIdsInModule(
process,
'RecoEgamma.ElectronIdentification.Identification.' +
idModule, setupVIDElectronSelection
)
process.egmGsfElectronIDs.physicsObjectSrc = 'analysisPatElectrons'
process.electronMVAValueMapProducer.srcMiniAOD = 'analysisPatElectrons'
# Add also customized cut-based ID without requirements on isolation
setupAllVIDIdsInModule(
process,
'Analysis.PECTuples.cutBasedElectronID_nonIso_cff',
setupVIDElectronSelection
)
# Labels of maps with electron ID
eleIDProducer = 'egmGsfElectronIDs'
eleCutBasedIDMaps = [eleIDProducer + ':cutBasedElectronID-Summer16-80X-V1-' + p
for p in ['veto', 'loose', 'medium', 'tight']] + \
[eleIDProducer + ':cutBasedElectronHLTPreselection-Summer16-V1'] + \
[eleIDProducer + ':cutBasedElectronID-nonIso-tight']
eleMVAIDMaps = ['electronMVAValueMapProducer:ElectronMVAEstimatorRun2Spring16GeneralPurposeV1Values']
# Additional selections to be evaluated (nothing at the moment)
eleQualityCuts = cms.vstring()
# Define electrons to be used for the loose event selection in the
# main configuration. Tighter kinematical cuts are applied to them.
process.patElectronsForEventSelection = cms.EDFilter('PATElectronSelector',
src = cms.InputTag('analysisPatElectrons'),
cut = cms.string('pt > 23. & (abs(eta) < 2.5 | abs(superCluster.eta) < 2.5)')
)
# Return values
return eleQualityCuts, eleEmbeddedCutBasedIDLabels, eleCutBasedIDMaps, eleMVAIDMaps
from TopQuarkAnalysis.Configuration.patRefSel_refMuJets_cfi import standAloneLooseMuonVetoFilter
process.standAloneLooseMuonVetoFilter = standAloneLooseMuonVetoFilter.clone()
process.sStandAloneLooseMuonVeto = cms.Sequence(
process.standAloneLooseMuonVetoFilter)
process.pStandAloneLooseMuonVeto = cms.Path(process.sStandAloneLooseMuonVeto)
# Step 3
if not runOnMiniAOD:
from PhysicsTools.SelectorUtils.tools.vid_id_tools import switchOnVIDElectronIdProducer, setupAllVIDIdsInModule, setupVIDElectronSelection
electron_ids = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_CSA14_50ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_CSA14_PU20bx25_V0_cff'
]
switchOnVIDElectronIdProducer(process)
process.electronIDValueMapProducer.ebReducedRecHitCollection = cms.InputTag(
'reducedEcalRecHitsEB')
process.electronIDValueMapProducer.eeReducedRecHitCollection = cms.InputTag(
'reducedEcalRecHitsEE')
process.electronIDValueMapProducer.esReducedRecHitCollection = cms.InputTag(
'reducedEcalRecHitsES')
for idmod in electron_ids:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
if useElecEAIsoCorr:
from EgammaAnalysis.ElectronTools.electronIsolatorFromEffectiveArea_cfi import elPFIsoValueEA03
if runOnMiniAOD:
process.patElPFIsoValueEA03 = elPFIsoValueEA03.clone(
gsfElectrons='',
pfElectrons='',
def catTool(process, runOnMC=True, doSecVertex=True, useMiniAOD=True):
catJetsSource = "slimmedJets"
catJetsPuppiSource = "slimmedJetsPuppi"
catGenJetsSource = "slimmedGenJets"
catMETsSource = "slimmedMETs"
catMETsPuppiSource = "slimmedMETsPuppi"
catMuonsSource = "slimmedMuons"
catElectronsSource = "slimmedElectrons"
catPhotonsSource = "slimmedPhotons"
catTausSource = "slimmedTaus"
catVertexSource = "offlineSlimmedPrimaryVertices"
catMCsource = "prunedGenParticles"
catBeamSpot = "offlineBeamSpot"
catRho = "fixedGridRhoAll"
btagNames = cms.vstring("pfCombinedInclusiveSecondaryVertexV2BJetTags")
ePidNames = cms.vstring()
process.load("CATTools.CatProducer.catCandidates_cff")
process.load("CATTools.CatProducer.recoEventInfo_cfi")
#######################################################################
# getting jec from file for jec on the fly from db file
# currently only for mc
if runOnMC:
from CondCore.DBCommon.CondDBSetup_cfi import CondDBSetup
process.jec = cms.ESSource(
"PoolDBESSource",
CondDBSetup,
connect=cms.string(
'sqlite_fip:CATTools/CatProducer/data/PHYS14_V4_MC.db'),
toGet=cms.VPSet(
cms.PSet(
record=cms.string("JetCorrectionsRecord"),
tag=cms.string(
"JetCorrectorParametersCollection_PHYS14_V4_MC_AK4PFchs"
),
label=cms.untracked.string("AK4PFchs"))))
process.es_prefer_jec = cms.ESPrefer("PoolDBESSource", "jec")
## applying new jec on the fly
if useMiniAOD:
process.load(
"PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cff")
catJetsSource = "patJetsUpdated"
#######################################################################
#######################################################################
## for egamma pid temp
## https://twiki.cern.ch/twiki/bin/viewauth/CMS/CutBasedElectronIdentificationRun2#Recipe_for_regular_users_for_74X
from PhysicsTools.SelectorUtils.tools.vid_id_tools import DataFormat, switchOnVIDElectronIdProducer, setupAllVIDIdsInModule, setupVIDElectronSelection
if not useMiniAOD:
dataFormat = DataFormat.AOD
else:
dataFormat = DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process, dataFormat)
my_id_modules = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_PHYS14_PU20bx25_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV51_cff'
]
for idmod in my_id_modules:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection)
if useMiniAOD:
process.catElectrons.electronIDSources = cms.PSet(
eleVetoIdMap=cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-PHYS14-PU20bx25-V2-standalone-veto"
),
eleLooseIdMap=cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-PHYS14-PU20bx25-V2-standalone-loose"
),
eleMediumIdMap=cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-PHYS14-PU20bx25-V2-standalone-medium"
),
eleTightIdMap=cms.InputTag(
"egmGsfElectronIDs:cutBasedElectronID-PHYS14-PU20bx25-V2-standalone-tight"
),
eleHEEPIdMap=cms.InputTag(
"egmGsfElectronIDs:heepElectronID-HEEPV51"),
)
#######################################################################
if runOnMC: ## Load MC dependent producers
## FIX ME - pile up and pdf weight
process.load("CATTools.CatProducer.pdfWeight_cff")
process.load("CATTools.CatProducer.pileupWeight_cff")
if not useMiniAOD:
process.load("CATTools.CatProducer.genTopProducer_cfi")
## FIX ME very out of date!
## using MEtUncertainties to get lepton shifts
## Need to update - Jet calculation was old, would most likely be the same for leptons
from PhysicsTools.PatUtils.tools.runType1PFMEtUncertainties import runType1PFMEtUncertainties
runType1PFMEtUncertainties(
process,
addToPatDefaultSequence=False,
jetCollection=catJetsSource,
electronCollection=catElectronsSource,
photonCollection=catPhotonsSource,
muonCollection=catMuonsSource,
tauCollection=catTausSource,
makeType1p2corrPFMEt=True,
outputModule=None,
jecUncertaintyFile=None,
)
process.catMuons.shiftedEnDownSrc = cms.InputTag(
"shiftedSlimmedMuonsEnDown")
process.catMuons.shiftedEnUpSrc = cms.InputTag(
"shiftedSlimmedMuonsEnUp")
process.catElectrons.shiftedEnDownSrc = cms.InputTag(
"shiftedSlimmedElectronsEnDown")
process.catElectrons.shiftedEnUpSrc = cms.InputTag(
"shiftedSlimmedElectronsEnUp")
if doSecVertex:
from TrackingTools.TransientTrack.TransientTrackBuilder_cfi import TransientTrackBuilderESProducer
setattr(process, "TransientTrackBuilderESProducer",
TransientTrackBuilderESProducer)
#process.makeCatCandidates += process.catSecVertexs
process.catJets.src = cms.InputTag(catJetsSource)
process.catJets.genJetMatch = cms.InputTag("patJetGenJetMatch")
process.catJets.btagNames = btagNames
process.catTaus.src = cms.InputTag(catTausSource)
process.catTaus.genJetMatch = cms.InputTag("tauGenJetMatch")
process.catMuons.src = cms.InputTag(catMuonsSource)
process.catMuons.mcLabel = cms.InputTag(catMCsource)
process.catMuons.vertexLabel = cms.InputTag(catVertexSource)
process.catMuons.beamLineSrc = cms.InputTag(catBeamSpot)
process.catElectrons.src = cms.InputTag(catElectronsSource)
process.catElectrons.ePidNames = ePidNames
process.catElectrons.vertexLabel = cms.InputTag(catVertexSource)
process.catElectrons.mcLabel = cms.InputTag(catMCsource)
process.catElectrons.beamLineSrc = cms.InputTag(catBeamSpot)
process.catElectrons.rhoLabel = cms.InputTag(catRho)
process.catPhotons.src = cms.InputTag(catPhotonsSource)
process.catMETs.src = cms.InputTag(catMETsSource)
process.catSecVertexs.muonSrc = cms.InputTag(catMuonsSource)
process.catSecVertexs.elecSrc = cms.InputTag(catElectronsSource)
process.catSecVertexs.vertexLabel = cms.InputTag(catVertexSource)
process.catJetsPuppi.src = cms.InputTag(catJetsPuppiSource)
process.catJetsPuppi.genJetMatch = cms.InputTag("patJetGenJetMatch")
process.catJetsPuppi.btagNames = btagNames
process.catMETsPuppi.src = cms.InputTag(catMETsPuppiSource)
