def applyElectronRegression(self):
"""
Apply electron regression from
https://twiki.cern.ch/twiki/bin/view/CMS/EGMRegression
"""
if self.verbose:
print("")
print("Applying electron regression...")
# Read corrections for database
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
regressionWeights(self.process)
self.process.load(
'EgammaAnalysis.ElectronTools.regressionApplication_cff')
# Rename the collection
self.process.slimmedElectronsWithRegression = self.process.slimmedElectrons.clone(
)
# Look for producers using the default electron input
for producer in self.producers:
p = getattr(self.process.framework.producers, producer)
change_input_tags_and_strings(p,
self.__miniaod_electron_collection,
'slimmedElectronsWithRegression',
'producers.' + producer, ' ')
self.__miniaod_electron_collection = 'slimmedElectronsWithRegression'
if self.verbose:
print("New electrons collection: %r" %
(self.__miniaod_electron_collection))
def customizeEGM(process,runOnData):
process = regressionWeights(process)
process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
process.load('EgammaAnalysis.ElectronTools.calibratedPatElectronsRun2_cfi')
process.calibratedPatElectrons.isMC = cms.bool(False) if runOnData else cms.bool(True)
print 'Using smeared electrons with corrections from',process.calibratedPatElectrons.correctionFile
# Set up electron ID (VID framework)
dataFormat = DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process, dataFormat)
my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronHLTPreselecition_Summer16_V1_cff']
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
process.selectedElectrons = cms.EDFilter("PATElectronSelector",
src = cms.InputTag("calibratedPatElectrons"),
cut = cms.string("pt>5")
)
process.egmGsfElectronIDs.physicsObjectSrc = cms.InputTag('selectedElectrons')
process.electronRegressionValueMapProducer.srcMiniAOD = cms.InputTag('selectedElectrons')
process.electronMVAValueMapProducer.srcMiniAOD = cms.InputTag('selectedElectrons')
process.EGMRegression = cms.Path(process.regressionApplication)
process.EGMSmearerElectrons = cms.Path(process.calibratedPatElectrons)
def makeAnalysisStep(self, stepName, **inputs):
step = super(ElectronCalibration,
self).makeAnalysisStep(stepName, **inputs)
if stepName == 'preliminary':
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
self.process = regressionWeights(self.process)
from EgammaAnalysis.ElectronTools.regressionApplication_cff import slimmedElectrons as eReg
eReg.src = step.getObjTag('e')
step.addModule('electronRegression', eReg, 'e')
cutOnSCEta = cms.EDFilter(
"PATElectronSelector",
src=step.getObjTag('e'),
cut=cms.string('pt >= 5. && abs(superCluster.eta) < 2.5'),
)
step.addModule('selectElectronsBeforeID', cutOnSCEta, 'e')
if not hasattr(self.process, 'RandomNumberGeneratorService'):
self.process.RandomNumberGeneratorService = cms.Service(
'RandomNumberGeneratorService', )
self.process.RandomNumberGeneratorService.calibratedPatElectrons = cms.PSet(
initialSeed=cms.untracked.uint32(987), )
from EgammaAnalysis.ElectronTools.calibratedPatElectronsRun2_cfi import calibratedPatElectrons
calibratedPatElectrons.isMC = cms.bool(self.isMC)
calibratedPatElectrons.electrons = step.getObjTag('e')
calibratedPatElectrons.isSynchronization = cms.bool(self.isSync)
#self.process.calibratedPatElectrons.correctionFile = cms.string(correctionFile),
step.addModule('calibratedPatElectrons', calibratedPatElectrons,
'e')
if self.electronScaleShift or self.electronRhoResShift or self.electronPhiResShift:
self.process.RandomNumberGeneratorService.electronSystematicShift = cms.PSet(
initialSeed=cms.untracked.uint32(345), )
shiftMod = cms.EDProducer(
"PATElectronSystematicShifter",
src=step.getObjTag('e'),
correctionFile=cms.string(correctionFile),
scaleShift=cms.double(self.electronScaleShift),
rhoResShift=cms.double(self.electronRhoResShift),
phiResShift=cms.double(self.electronPhiResShift),
)
step.addModule('electronSystematicShift', shiftMod, 'e')
if stepName == 'selection':
# need to re-sort now that we're calibrated
eSort = cms.EDProducer(
"PATElectronCollectionSorter",
src=step.getObjTag('e'),
function=cms.string('pt'),
)
step.addModule('electronSorting', eSort, 'e')
return step
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 setup_electrons(process, cms, options):
print '=' * 60
print "Setting up Electrons and ID"
print '=' * 60
isMC = not options.isData
##########################################################
### Applying the Electron Regression #####################
##########################################################
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
process = regressionWeights(process)
process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
##########################################################
### Applying the Electron Smearer ########################
##########################################################
process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService",
calibratedPatElectrons = cms.PSet(
initialSeed = cms.untracked.uint32(81),
engineName = cms.untracked.string('TRandom3'),
),
)
process.load('EgammaAnalysis.ElectronTools.calibratedPatElectronsRun2_cfi')
process.calibratedPatElectrons.isMC = cms.bool(isMC)
##########################################################
### Applying the ID ######################################
##########################################################
process.load("RecoEgamma.ElectronIdentification.ElectronIDValueMapProducer_cfi")
from PhysicsTools.SelectorUtils.tools.vid_id_tools import *
dataFormat = DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process, dataFormat)
# define which IDs we want to produce
my_id_modules = [
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronHLTPreselecition_Summer16_V1_cff',
]
#add them to the VID producer
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
process.selectedElectrons = cms.EDFilter("PATElectronSelector",
src = cms.InputTag("calibratedPatElectrons"),
cut = cms.string("pt > 5 && abs(eta)<2.5")
)
process.egmGsfElectronIDs.physicsObjectSrc = cms.InputTag("selectedElectrons")
process.electronIDValueMapProducer.srcMiniAOD = cms.InputTag('selectedElectrons')
process.electronRegressionValueMapProducer.srcMiniAOD = cms.InputTag('selectedElectrons')
process.processedElectrons = cms.Sequence( process.regressionApplication + process.calibratedPatElectrons + process.selectedElectrons + process.egmGsfElectronIDSequence + process.electronIDValueMapProducer)
def customizeDec2016Regression(self,process):
if not (process.GlobalTag.globaltag == "80X_mcRun2_asymptotic_2016_TrancheIV_v7" or process.GlobalTag.globaltag == "80X_dataRun2_2016SeptRepro_v6"):
raise Exception,"Regression application turned on but globalTag has unexpected value %s - see MicroAODCustomize.py" % process.GlobalTag.globaltag
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
process = regressionWeights(process)
process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
process.p.insert(0,process.regressionApplication)
process.electronMVAValueMapProducer.srcMiniAOD = cms.InputTag("slimmedElectrons")
process.photonMVAValueMapProducer.srcMiniAOD = cms.InputTag("slimmedPhotons")
process.photonIDValueMapProducer.srcMiniAOD = cms.InputTag("slimmedPhotons")
def customizeDec2016Regression(self,process):
if not (process.GlobalTag.globaltag == "80X_mcRun2_asymptotic_2016_TrancheIV_v7" or process.GlobalTag.globaltag == "80X_dataRun2_2016SeptRepro_v6"):
raise Exception,"Regression application turned on but globalTag has unexpected value %s - see MicroAODCustomize.py" % process.GlobalTag.globaltag
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
process = regressionWeights(process)
process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
process.p.insert(0,process.regressionApplication)
process.electronMVAValueMapProducer.srcMiniAOD = cms.InputTag("slimmedElectrons")
process.photonMVAValueMapProducer.srcMiniAOD = cms.InputTag("slimmedPhotons")
process.photonIDValueMapProducer.srcMiniAOD = cms.InputTag("slimmedPhotons")
def enableElectronRegression(process):
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
process = regressionWeights(process)
from EgammaAnalysis.ElectronTools.regressionWeights_local_cfi import GBRDWrapperRcd
GBRDWrapperRcd.connect = "sqlite_fip:EgammaAnalysis/ElectronTools/data/ged_regression_20170114.db"
process.regressions = GBRDWrapperRcd
process.es_prefer_regressions = cms.ESPrefer('PoolDBESSource','regressions')
process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
process.catElectrons.unsmaredElectrons = "slimmedElectrons::"+process.process
return process
def calibrateEGM(process, options):
### apply 80X regression
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
process = regressionWeights(process)
process.RandomNumberGeneratorService = cms.Service(
"RandomNumberGeneratorService",
calibratedPatElectrons=cms.PSet(
initialSeed=cms.untracked.uint32(81),
engineName=cms.untracked.string('TRandom3'),
),
calibratedPatPhotons=cms.PSet(
initialSeed=cms.untracked.uint32(81),
engineName=cms.untracked.string('TRandom3'),
),
)
process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
process.load('EgammaAnalysis.ElectronTools.calibratedPatElectronsRun2_cfi')
process.load('EgammaAnalysis.ElectronTools.calibratedPatPhotonsRun2_cfi')
process.calibratedPatElectrons.electrons = cms.InputTag(
options['ELECTRON_COLL'])
process.calibratedPatPhotons.photons = cms.InputTag(options['PHOTON_COLL'])
if options['isMC']:
process.calibratedPatElectrons.isMC = cms.bool(True)
process.calibratedPatPhotons.isMC = cms.bool(True)
else:
process.calibratedPatElectrons.isMC = cms.bool(False)
process.calibratedPatPhotons.isMC = cms.bool(False)
process.selectElectronsBase = cms.EDFilter(
"PATElectronSelector",
src=cms.InputTag('calibratedPatElectrons'),
cut=cms.string(options['ELECTRON_CUTS']),
)
process.selectPhotonsBase = cms.EDFilter(
"PATPhotonSelector",
src=cms.InputTag('calibratedPatPhotons'),
cut=cms.string(options['PHOTON_CUTS']),
)
### change the input collection to be the calibrated energy one for all other modules from now on
options['ELECTRON_COLL'] = 'selectElectronsBase'
options['PHOTON_COLL'] = 'selectPhotonsBase'
# '/store/data/Run2016E/DoubleMuon/MINIAOD/03Feb2017-v1/100000/062FB971-1AED-E611-965F-0CC47A4C8F12.root',
# '/store/data/Run2016E/DoubleMuon/MINIAOD/23Sep2016-v1/100000/0049B6D2-278C-E611-AEB4-0025902D944E.root',
#'/store/data/Run2016H/DoubleMuon/MINIAOD/PromptReco-v3/000/284/036/00000/04DC0281-C89F-E611-81C6-02163E0141E6.root'
# '/store/data/Run2016B/SingleElectron/MINIAOD/23Sep2016-v2/80000/5A4402F5-638C-E611-A471-0025905A60AA.root'
))
#process.load("PhysicsTools.PatAlgos.patSequences_cff")
process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff")
process.load("PhysicsTools.PatAlgos.triggerLayer1.triggerProducer_cff")
process.load("PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff")
### EGM 80X regression
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
process = regressionWeights(process)
process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
### EGM scale and smearing correction
process.load('EgammaAnalysis.ElectronTools.calibratedPatElectronsRun2_cfi')
process.load('EgammaAnalysis.ElectronTools.calibratedPatPhotonsRun2_cfi')
#from PhysicsTools.PatAlgos.tools.cmsswVersionTools import *
from PhysicsTools.PatAlgos.tools.coreTools import *
runOnData(process,
names=['Photons', 'Electrons', 'Muons', 'Taus', 'Jets'],
outputModules=[])
#runOnData( process, outputModules = [] )
#removeMCMatching(process, names=['All'], outputModules=[])
#GLOBALTAG
process.load('Configuration.StandardSequences.Services_cff')#Lisa
process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff')
from Configuration.AlCa.GlobalTag import GlobalTag
GT = ''
if isData: GT = '80X_dataRun2_2016SeptRepro_v7'
elif not(isData): GT = '80X_mcRun2_asymptotic_2016_TrancheIV_v8'
process.GlobalTag = GlobalTag(process.GlobalTag, GT)
print 'GlobalTag', GT
#electron/photon regression modules
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
process = regressionWeights(process)
process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
#electrons upstream modules
from PhysicsTools.SelectorUtils.tools.vid_id_tools import *
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
ele_id_modules = ['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff']
for ele_idmod in ele_id_modules:
setupAllVIDIdsInModule(process,ele_idmod,setupVIDElectronSelection)
#muons upstream modules
process.cleanedMuons = cms.EDProducer('PATMuonCleanerBySegments',
src = cms.InputTag('slimmedMuons'),#('calibratedMuons'),
def makeAnalysisStep(self, stepName, **inputs):
step = super(ElectronCalibration, self).makeAnalysisStep(stepName, **inputs)
if stepName == 'preliminary':
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
self.process = regressionWeights(self.process)
from EgammaAnalysis.ElectronTools.regressionApplication_cff import slimmedElectrons as eReg
eReg.src = step.getObjTag('e')
step.addModule('electronRegression', eReg, 'e')
cutOnSCEta = cms.EDFilter(
"PATElectronSelector",
src = step.getObjTag('e'),
cut = cms.string('pt >= 5. && abs(superCluster.eta) < 2.5'),
)
step.addModule('selectElectronsBeforeID', cutOnSCEta, 'e')
if not hasattr(self.process, 'RandomNumberGeneratorService'):
self.process.RandomNumberGeneratorService = cms.Service(
'RandomNumberGeneratorService',
)
self.process.RandomNumberGeneratorService.calibratedPatElectrons = cms.PSet(
initialSeed = cms.untracked.uint32(987),
)
from EgammaAnalysis.ElectronTools.calibratedPatElectronsRun2_cfi import calibratedPatElectrons
calibratedPatElectrons.isMC = cms.bool(self.isMC)
calibratedPatElectrons.electrons = step.getObjTag('e')
calibratedPatElectrons.isSynchronization = cms.bool(self.isSync)
#self.process.calibratedPatElectrons.correctionFile = cms.string(correctionFile),
step.addModule('calibratedPatElectrons', calibratedPatElectrons, 'e')
if self.electronScaleShift or self.electronRhoResShift or self.electronPhiResShift:
self.process.RandomNumberGeneratorService.electronSystematicShift = cms.PSet(
initialSeed = cms.untracked.uint32(345),
)
shiftMod = cms.EDProducer(
"PATElectronSystematicShifter",
src = step.getObjTag('e'),
correctionFile = cms.string(correctionFile),
scaleShift = cms.double(self.electronScaleShift),
rhoResShift = cms.double(self.electronRhoResShift),
phiResShift = cms.double(self.electronPhiResShift),
)
step.addModule('electronSystematicShift', shiftMod, 'e')
if stepName == 'selection':
# need to re-sort now that we're calibrated
eSort = cms.EDProducer(
"PATElectronCollectionSorter",
src = step.getObjTag('e'),
function = cms.string('pt'),
)
step.addModule('electronSorting', eSort, 'e')
return step
def setup_electrons(process, cms, options):
print '=' * 60
print "Setting up Electrons and ID"
print '=' * 60
isMC = not options.isData
##########################################################
### Applying the Electron Regression #####################
##########################################################
# TODO PROPERLY
# Apply the regression from local sqlite file
# from EgammaAnalysis.ElectronTools.regressionWeights_local_cfi import GBRDWrapperRcd
# process.regressions = GBRDWrapperRcd
# process.es_prefer_regressions = cms.ESPrefer('PoolDBESSource','regressions')
# process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
# Apply the regression from a remote database
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
process = regressionWeights(process)
process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
# Apply from GT
# process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
process.electronRegression = cms.Sequence(process.regressionApplication)
##########################################################
### Applying the Electron Smearer ########################
##########################################################
if isMC:
process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService",
calibratedPatElectrons = cms.PSet(
initialSeed = cms.untracked.uint32(81),
engineName = cms.untracked.string('TRandom3'),
),
)
process.load('EgammaAnalysis.ElectronTools.calibratedElectronsRun2_cfi')
process.selectedSlimmedElectrons = cms.EDFilter("PATElectronSelector",
src = cms.InputTag("slimmedElectrons"),
cut = cms.string("pt > 5 && abs(eta)<2.5")
)
process.calibratedPatElectrons = cms.EDProducer("CalibratedPatElectronProducerRun2",
electrons = cms.InputTag("selectedSlimmedElectrons"),
gbrForestName = cms.string('gedelectron_p4combination_25ns'),
isMC = cms.bool(isMC),
isSynchronization = cms.bool(False),
correctionFile = cms.string("EgammaAnalysis/ElectronTools/data/ScalesSmearings/Winter_2016_reReco_v1_ele"),
)
# process.smearedElectrons = cms.Sequence( process.selectedSlimmedElectrons + process.calibratedPatElectrons)
process.smearedElectrons = cms.Sequence( process.electronRegression + process.selectedSlimmedElectrons + process.calibratedPatElectrons)
##########################################################
### Applying the ID ######################################
##########################################################
from PhysicsTools.SelectorUtils.tools.vid_id_tools import *
# Switch ValueMap Producer to use calibrated Electrons
process.load("RecoEgamma.ElectronIdentification.ElectronIDValueMapProducer_cfi")
process.electronIDValueMapProducer.srcMiniAOD = cms.InputTag('calibratedPatElectrons')
# turn on VID producer, indicate data format to be
# DataFormat.AOD or DataFormat.MiniAOD, as appropriate
dataFormat = DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process, dataFormat)
# Switch egmGsfElectronIDs from switchOnVIDElectronIdProducer to use calibrated Electrons
process.egmGsfElectronIDs.physicsObjectSrc = cms.InputTag("calibratedPatElectrons")
# define which IDs we want to produce
my_id_modules = [
# 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
# 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_Trig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_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)
def makeTreeFromMiniAOD(
process,
outfile,
reportfreq=10,
dataset="",
globaltag="",
numevents=1000,
geninfo=False,
tagname="RECO",
jsonfile="",
jecfile="",
residual=False,
jerfile="",
pufile="",
doPDFs=False,
fastsim=False,
signal=False,
scenario=""
):
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Preamble
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff")
process.GlobalTag.globaltag = globaltag
# log output
process.load("FWCore.MessageService.MessageLogger_cfi")
process.MessageLogger.cerr.FwkReport.reportEvery = reportfreq
process.options = cms.untracked.PSet(
allowUnscheduled = cms.untracked.bool(True),
# wantSummary = cms.untracked.bool(True) # off by default
)
# files to process
import FWCore.PythonUtilities.LumiList as LumiList
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(numevents)
)
process.source = cms.Source("PoolSource",
fileNames = cms.untracked.vstring(dataset)
)
if len(jsonfile)>0: process.source.lumisToProcess = LumiList.LumiList(filename = jsonfile).getVLuminosityBlockRange()
# output file
process.TFileService = cms.Service("TFileService",
fileName = cms.string(outfile+".root")
)
# branches for treemaker
VectorRecoCand = cms.vstring()
VarsDouble = cms.vstring()
VarsInt = cms.vstring()
VarsBool = cms.vstring()
VectorTLorentzVector = cms.vstring()
VectorDouble = cms.vstring()
VectorString = cms.vstring()
VectorInt = cms.vstring()
VectorBool = cms.vstring()
# configure treemaker
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.treeMaker import TreeMaker
process.LQTreeMaker2 = TreeMaker.clone(
TreeName = cms.string("SimpleTree"),
VectorRecoCand = VectorRecoCand,
VarsDouble = VarsDouble,
VarsInt = VarsInt,
VarsBool = VarsBool,
VectorTLorentzVector = VectorTLorentzVector,
VectorDouble = VectorDouble,
VectorInt = VectorInt,
VectorString = VectorString,
VectorBool = VectorBool,
)
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Standard producers
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## SUSY scan info
## ----------------------------------------------------------------------------------------------
## WeightProducer
## ----------------------------------------------------------------------------------------------
if geninfo:
from LeptoQuarkTreeMaker.WeightProducer.getWeightProducer_cff import getWeightProducer
process.WeightProducer = getWeightProducer(process.source.fileNames[0],fastsim and signal)
process.WeightProducer.Lumi = cms.double(1) #default: 1 pb-1 (unit value)
process.WeightProducer.FileNamePUDataDistribution = cms.string(pufile)
VarsDouble.extend(['WeightProducer:weight(Weight)','WeightProducer:xsec(CrossSection)','WeightProducer:nevents(NumEvents)',
'WeightProducer:TrueNumInteractions','WeightProducer:PUweight(puWeight)','WeightProducer:PUSysUp(puSysUp)','WeightProducer:PUSysDown(puSysDown)'])
VarsInt.extend(['WeightProducer:NumInteractions'])
## ----------------------------------------------------------------------------------------------
## PDF weights for PDF systematics
## ----------------------------------------------------------------------------------------------
if geninfo and doPDFs:
process.PDFWeights = cms.EDProducer('PDFWeightProducer')
VectorDouble.extend(['PDFWeights:PDFweights','PDFWeights:ScaleWeights','PDFWeights:genWeight'])
VectorInt.extend(['PDFWeights:PDFids'])
## ----------------------------------------------------------------------------------------------
## GenHT for stitching together MC samples
## ----------------------------------------------------------------------------------------------
if geninfo:
process.MadHT = cms.EDProducer('GenHTProducer')
# called madHT, i.e. MadGraph, to distinguish from GenHT from GenJets
VarsDouble.extend(['MadHT:genHT(madHT)'])
## ----------------------------------------------------------------------------------------------
## PrimaryVertices
## ----------------------------------------------------------------------------------------------
process.goodVertices = cms.EDFilter("VertexSelector",
src = cms.InputTag("offlineSlimmedPrimaryVertices"),
cut = cms.string("!isFake && ndof > 4 && abs(z) < 24 && position.Rho < 2"),
filter = cms.bool(False)
)
from LeptoQuarkTreeMaker.Utils.primaryvertices_cfi import primaryvertices
process.NVtx = primaryvertices.clone(
VertexCollection = cms.InputTag('goodVertices'),
)
VarsInt.extend(['NVtx'])
# also store total number of vertices without quality checks
process.nAllVertices = primaryvertices.clone(
VertexCollection = cms.InputTag('offlineSlimmedPrimaryVertices'),
)
VarsInt.extend(['nAllVertices'])
## ----------------------------------------------------------------------------------------------
## GenParticles
## ----------------------------------------------------------------------------------------------
## JECs
## ----------------------------------------------------------------------------------------------
process.load("CondCore.DBCommon.CondDBCommon_cfi")
from CondCore.DBCommon.CondDBSetup_cfi import CondDBSetup
# default miniAOD tags
JetTag = cms.InputTag('slimmedJets')
JetAK8Tag = cms.InputTag('slimmedJetsAK8')
METTag = cms.InputTag('slimmedMETs')
if scenario=="2016ReMiniAOD03Feb": METTag = cms.InputTag('slimmedMETsMuEGClean')
# get the JECs (disabled by default)
# this requires the user to download the .db file from this twiki
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/JECDataMC
if len(jecfile)>0:
#get name of JECs without any directories
JECera = jecfile.split('/')[-1]
JECPatch = cms.string('sqlite_file:'+jecfile+'.db')
if os.getenv('GC_CONF'):
JECPatch = cms.string('sqlite_file:../src/'+jecfile+'.db')
process.jec = cms.ESSource("PoolDBESSource",CondDBSetup,
connect = JECPatch,
toGet = cms.VPSet(
cms.PSet(
record = cms.string("JetCorrectionsRecord"),
tag = cms.string("JetCorrectorParametersCollection_"+JECera+"_AK4PFchs"),
label = cms.untracked.string("AK4PFchs")
),
cms.PSet(
record = cms.string("JetCorrectionsRecord"),
tag = cms.string("JetCorrectorParametersCollection_"+JECera+"_AK4PF"),
label = cms.untracked.string("AK4PF")
),
cms.PSet(
record = cms.string("JetCorrectionsRecord"),
tag = cms.string("JetCorrectorParametersCollection_"+JECera+"_AK8PFchs"),
label = cms.untracked.string("AK8PFchs")
),
)
)
process.es_prefer_jec = cms.ESPrefer("PoolDBESSource","jec")
levels = ['L1FastJet','L2Relative','L3Absolute']
if residual: levels.append('L2L3Residual')
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
postfix = 'UpdatedJEC',
jetCorrections = ('AK4PFchs', levels, 'None')
)
JetTag = cms.InputTag('updatedPatJetsUpdatedJEC')
# also update the corrections for AK8 jets
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJetsAK8'),
labelName = 'AK8',
postfix = 'UpdatedJEC',
jetCorrections = ('AK8PFchs', levels, 'None')
)
JetAK8Tag = cms.InputTag('updatedPatJetsAK8UpdatedJEC')
# update the MET to account for the new JECs
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD
runMetCorAndUncFromMiniAOD(
process,
isData=not geninfo, # controls gen met
)
process.load('RecoMET.METFilters.badGlobalMuonTaggersMiniAOD_cff')
process.badGlobalMuonTaggerMAOD.taggingMode = cms.bool(True)
process.cloneGlobalMuonTaggerMAOD.taggingMode = cms.bool(True)
from PhysicsTools.PatUtils.tools.muonRecoMitigation import muonRecoMitigation
muonRecoMitigation(
process = process,
pfCandCollection = "packedPFCandidates", #input PF Candidate Collection
runOnMiniAOD = True, #To determine if you are running on AOD or MiniAOD
selection="", #You can use a custom selection for your bad muons. Leave empty if you would like to use the bad muon recipe definition.
muonCollection="", #The muon collection name where your custom selection will be applied to. Leave empty if you would like to use the bad muon recipe definition.
cleanCollName="cleanMuonsPFCandidates", #output pf candidate collection ame
cleaningScheme="computeAllApplyClone", #Options are: "all", "computeAllApplyBad","computeAllApplyClone". Decides which (or both) bad muon collections to be used for MET cleaning coming from the bad muon recipe.
postfix="" #Use if you would like to add a post fix to your muon / pf collections
)
runMetCorAndUncFromMiniAOD(process,
isData=not geninfo,
pfCandColl="cleanMuonsPFCandidates",
recoMetFromPFCs=True,
postfix="MuClean"
)
process.mucorMET = cms.Sequence(
process.badGlobalMuonTaggerMAOD *
process.cloneGlobalMuonTaggerMAOD *
#process.badMuons * # If you are using cleaning mode "all", uncomment this line
process.cleanMuonsPFCandidates *
process.fullPatMetSequenceMuClean
)
from PhysicsTools.PatUtils.tools.corMETFromMuonAndEG import corMETFromMuonAndEG
corMETFromMuonAndEG(process,
pfCandCollection="", #not needed
electronCollection="slimmedElectronsBeforeGSFix",
photonCollection="slimmedPhotonsBeforeGSFix",
corElectronCollection="slimmedElectrons",
corPhotonCollection="slimmedPhotons",
allMETEGCorrected=True,
muCorrection=False,
eGCorrection=True,
runOnMiniAOD=True,
postfix="MuEGClean"
)
process.slimmedMETsMuEGClean = process.slimmedMETs.clone()
process.slimmedMETsMuEGClean.src = cms.InputTag("patPFMetT1MuEGClean")
process.slimmedMETsMuEGClean.rawVariation = cms.InputTag("patPFMetRawMuEGClean")
process.slimmedMETsMuEGClean.t1Uncertainties = cms.InputTag("patPFMetT1%sMuEGClean")
del process.slimmedMETsMuEGClean.caloMET
METTag = cms.InputTag('slimmedMETs','',process.name_())
else:
# pointless run of MET tool because it is barely functional
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD
runMetCorAndUncFromMiniAOD(
process,
isData=not geninfo, # controls gen met
)
# keep jets before any further modifications for hadtau
JetTagBeforeSmearing = JetTag
# JEC uncertainty - after JECs are updated
from LeptoQuarkTreeMaker.Utils.jetuncertainty_cfi import JetUncertaintyProducer
process.jecUnc = JetUncertaintyProducer.clone(
JetTag = JetTag,
jecUncDir = cms.int32(0)
)
_infosToAdd = ['jecUnc']
if geninfo:
# JER factors - central, up, down
from LeptoQuarkTreeMaker.Utils.smearedpatjet_cfi import SmearedPATJetProducer
process.jerFactor = SmearedPATJetProducer.clone(
src = JetTag,
variation = cms.int32(0),
store_factor = cms.bool(True)
)
process.jerFactorUp = SmearedPATJetProducer.clone(
src = JetTag,
variation = cms.int32(1),
store_factor = cms.bool(True)
)
process.jerFactorDown = SmearedPATJetProducer.clone(
src = JetTag,
variation = cms.int32(-1),
store_factor = cms.bool(True)
)
_infosToAdd.extend(['jerFactor','jerFactorUp','jerFactorDown'])
# add userfloat & update tag
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.addJetInfo import addJetInfo
process, JetTag = addJetInfo(process, JetTag, _infosToAdd, [])
## ----------------------------------------------------------------------------------------------
## IsoTracks
## ----------------------------------------------------------------------------------------------
## MET Filters
## ----------------------------------------------------------------------------------------------
# When the miniAOD file is created, the results of several different
# MET filters are save in a TriggerResults object for the PAT process
# Look at /PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py
# for the available filter flags
# The decision was made to include the filter decision flags
# as individual branches in the tree
if not fastsim: # MET filters are not run for fastsim samples
from LeptoQuarkTreeMaker.Utils.filterdecisionproducer_cfi import filterDecisionProducer
process.CSCTightHaloFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_CSCTightHalo2015Filter"),
)
VarsInt.extend(['CSCTightHaloFilter'])
process.globalTightHalo2016Filter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_globalTightHalo2016Filter"),
)
VarsInt.extend(['globalTightHalo2016Filter'])
process.HBHENoiseFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_HBHENoiseFilter"),
)
VarsInt.extend(['HBHENoiseFilter'])
process.HBHEIsoNoiseFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_HBHENoiseIsoFilter"),
)
VarsInt.extend(['HBHEIsoNoiseFilter'])
process.EcalDeadCellTriggerPrimitiveFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_EcalDeadCellTriggerPrimitiveFilter"),
)
VarsInt.extend(['EcalDeadCellTriggerPrimitiveFilter'])
process.eeBadScFilter = filterDecisionProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string(tagname),
filterName = cms.string("Flag_eeBadScFilter"),
)
VarsInt.extend(['eeBadScFilter'])
# some filters need to be rerun
process.load('RecoMET.METFilters.BadChargedCandidateFilter_cfi')
process.BadChargedCandidateFilter.muons = cms.InputTag("slimmedMuons")
process.BadChargedCandidateFilter.PFCandidates = cms.InputTag("packedPFCandidates")
process.BadChargedCandidateFilter.taggingMode = True
VarsBool.extend(['BadChargedCandidateFilter'])
process.load('RecoMET.METFilters.BadPFMuonFilter_cfi')
process.BadPFMuonFilter.muons = cms.InputTag("slimmedMuons")
process.BadPFMuonFilter.PFCandidates = cms.InputTag("packedPFCandidates")
process.BadPFMuonFilter.taggingMode = True
VarsBool.extend(['BadPFMuonFilter'])
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
process = regressionWeights(process)
'''
process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService",
calibratedPatElectrons = cms.PSet( initialSeed = cms.untracked.uint32(8675389),
engineName = cms.untracked.string('TRandom3'),
),
calibratedPatPhotons = cms.PSet( initialSeed = cms.untracked.uint32(8675389),
engineName = cms.untracked.string('TRandom3'),
),
)
'''
process.load('Configuration.StandardSequences.Services_cff')
process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService",
calibratedPatElectrons = cms.PSet(
initialSeed = cms.untracked.uint32(81),
engineName = cms.untracked.string('TRandom3'),
),
calibratedPatPhotons = cms.PSet(
initialSeed = cms.untracked.uint32(81),
engineName = cms.untracked.string('TRandom3'),
),
)
process.load('EgammaAnalysis.ElectronTools.regressionApplication_cff')
process.load('EgammaAnalysis.ElectronTools.calibratedPatElectronsRun2_cfi')
process.calibratedPatElectrons.isMC = cms.bool(False)
process.selectedElectrons = cms.EDFilter(
"PATElectronSelector",
src = cms.InputTag("slimmedElectrons"),
cut = cms.string("pt > 5 && abs(eta)<2.5")
)
process.calibratedPatElectrons.electrons = cms.InputTag('selectedElectrons')
process.calibratedPatElectrons.isMC = cms.bool(False)
#process.EGMRegression =cms.Path(process.regressionApplication)
# process.EGMSmearerElectrons = cms.Path(process.calibratedPatElectrons)
# process.EGMSmearerElectrons.isMC = cms.bool(False)
#process.schedule = cms.Schedule(process.EGMRegression,process.EGMSmearerElectrons,process.analysis)
'''
process.load('Configuration.StandardSequences.Services_cff')
process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService",
calibratedPatElectrons = cms.PSet(
initialSeed = cms.untracked.uint32(81),
engineName = cms.untracked.string('TRandom3'),
),
calibratedPatPhotons = cms.PSet(
initialSeed = cms.untracked.uint32(81),
engineName = cms.untracked.string('TRandom3'),
),
)
process.load('EgammaAnalysis.ElectronTools.calibratedElectronsRun2_cfi')
correctionType = "Moriond2017_JEC "
calibratedPatElectrons = cms.EDProducer("CalibratedPatElectronProducerRun2",
# input collections
electrons = cms.InputTag('slimmedElectrons'),
gbrForestName = cms.string("gedelectron_p4combination_25ns"),
# data or MC corrections
# if isMC is false, data corrections are applied
isMC = cms.bool(True),
# set to True to get special "fake" smearing for synchronization. Use JUST in case of synchronization
isSynchronization = cms.bool(True),
correctionFile = cms.string("Moriond2017_JEC ")
)
'''
#process.Baseline += process.calibratedPatElectrons
from PhysicsTools.SelectorUtils.tools.vid_id_tools import *
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD)
my_id_modules = []
my_id_modules.append('RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff')
my_id_modules.append('RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff')
my_id_modules.append('RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff')
my_id_modules.append('RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff')
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
process.egmGsfElectronIDs.physicsObjectSrc = cms.InputTag('calibratedPatElectrons')
process.electronMVAValueMapProducer.srcMiniAOD = cms.InputTag('calibratedPatElectrons')
process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag('calibratedPatElectrons')
process.electronRegressionValueMapProducer.srcMiniAOD = cms.InputTag('calibratedPatElectrons')
from LeptoQuarkTreeMaker.Utils.HEEPProducer_cfi import HEEPProducer
process.HEEPProducer = HEEPProducer.clone(
eletag = cms.InputTag('calibratedPatElectrons')
)
#process.Baseline += process.HEEPProducer
VectorDouble.extend(['HEEPProducer:trackiso(Electron_trackiso)'])
#VectorDouble.extend(['HEEPProducer:Eta(Electron_Eta)'])
VectorDouble.extend(['HEEPProducer:Et(Electron_Et)'])
VectorDouble.extend(['HEEPProducer:DeltaEtain(Electron_DeltaEtain)'])
VectorDouble.extend(['HEEPProducer:DeltaPhiin(Electron_DeltaPhiin)'])
VectorDouble.extend(['HEEPProducer:HbE(Electron_HOverE)'])
#VectorDouble.extend(['HEEPProducer:SiEtaiEta(Electron_SiEtaiEta)'])
VectorDouble.extend(['HEEPProducer:Ecaliso(Electron_Ecaliso)'])
VectorDouble.extend(['HEEPProducer:HD1iso(Electron_HD1iso)'])
#VectorDouble.extend(['HEEPProducer:HD2iso(Electron_HD2iso)'])
VectorBool.extend(['HEEPProducer:ecalDriven(Electron_ecalDriven)'])
#VectorDouble.extend(['HEEPProducer:e25max(Electron_e25max)'])
#VectorDouble.extend(['HEEPProducer:e55(Electron_e55)'])
VectorDouble.extend(['HEEPProducer:e25bye55(Electron_e25bye55)'])
VectorDouble.extend(['HEEPProducer:Fullsce25bye55(Electron_Fullsce25bye55)'])
VectorDouble.extend(['HEEPProducer:Fulle15bye55(Electron_Fulle15bye55)'])
VectorDouble.extend(['HEEPProducer:scEnergy(Electron_scEnergy)'])
VectorDouble.extend(['HEEPProducer:DeltaEtaSeed(Electron_DeltaEtaSeed)'])
VectorDouble.extend(['HEEPProducer:rho(rho)'])
VectorInt.extend(['HEEPProducer:Charge(Electron_Charge)'])
#VectorDouble.extend(['HEEPProducer:ePt(Electron_Pt)'])
#VectorDouble.extend(['HEEPProducer:e15(Electron_e15)'])
VectorDouble.extend(['HEEPProducer:ecalEnergy(Electron_ecalEnergy)'])
VectorDouble.extend(['HEEPProducer:full55SiEtaiEta(Electron_full55SiEtaiEta)'])
#VectorDouble.extend(['HEEPProducer:sce25max(Electron_sce25max)'])
#VectorDouble.extend(['HEEPProducer:sce55(Electron_sce55)'])
VectorDouble.extend(['HEEPProducer:sce25bye55(Electron_sce25bye55)'])
VectorDouble.extend(['HEEPProducer:e15bye55(Electron_e15bye55)'])
#VectorDouble.extend(['HEEPProducer:DeltaEtaSeedscandTrack(Electron_DeltaEtaSeedscandTrack)'])
VectorDouble.extend(['HEEPProducer:Phi(Electron_Phi)'])
VectorDouble.extend(['HEEPProducer:eEnergy(Electron_Energy)'])
VectorDouble.extend(['HEEPProducer:dxy(dxy)'])
VectorInt.extend(['HEEPProducer:losthits(Electron_losthits)'])
VectorDouble.extend(['HEEPProducer:ePz(Electron_Pz)'])
#VectorDouble.extend(['HEEPProducer:eTheta(Electron_Theta)'])
VectorDouble.extend(['HEEPProducer:ePx(Electron_Px)'])
VectorDouble.extend(['HEEPProducer:ePy(Electron_Py)'])
#VectorDouble.extend(['HEEPProducer:normalizedChi2(Electron_normalizedChi2)'])
VectorInt.extend(['HEEPProducer:PDGID(PDGID)'])
VectorInt.extend(['HEEPProducer:gencharge(gencharge)'])
VectorDouble.extend(['HEEPProducer:genPt(genPt)'])
VectorDouble.extend(['HEEPProducer:genEta(genEta)'])
VectorDouble.extend(['HEEPProducer:genPhi(genPhi)'])
VectorDouble.extend(['HEEPProducer:genEnergy(genEnergy)'])
VectorInt.extend(['HEEPProducer:motherPDGID(motherPDGID)'])
VectorInt.extend(['HEEPProducer:elstatus(elstatus)'])
VectorDouble.extend(['HEEPProducer:PtHEEP(Electron_PtHEEP)'])
#VectorDouble.extend(['HEEPProducer:scEtaa(Electron_scEtaa)'])
VectorDouble.extend(['HEEPProducer:scEta(Electron_scEta)'])
VectorDouble.extend(['HEEPProducer:heep70TrkIso(Electron_heep70TrkIso)'])
VectorBool.extend(['HEEPProducer:passEMHD1iso(Electron_passEMHD1iso)'])
VectorBool.extend(['HEEPProducer:passShowerShape(Electron_passShowerShape)'])
VectorBool.extend(['HEEPProducer:passDeltaEta(Electron_passDeltaEta)'])
VectorBool.extend(['HEEPProducer:passDeltaPhi(Electron_passDeltaPhi)'])
VectorBool.extend(['HEEPProducer:passEMHD1iso(Electron_passEMHD1iso)'])
VectorBool.extend(['HEEPProducer:passHoverE(Electron_passHoverE)'])
VectorBool.extend(['HEEPProducer:passDXY(Electron_passDXY)'])
VectorBool.extend(['HEEPProducer:passMissingHits(Electron_passMissingHits)'])
VectorBool.extend(['HEEPProducer:passEcaldriven(Electron_passEcaldriven)'])
VectorBool.extend(['HEEPProducer:passN1TrkIso(Electron_passN1TrkIso)'])
VectorDouble.extend(['HEEPProducer:worzsystempt(worzsystempt)'])
## Muons
## ----------------------------------------------------------------------------------------------
from LeptoQuarkTreeMaker.Utils.MuonProducer_cfi import MuonProducer
process.MuonProducer = MuonProducer.clone(
muontag = cms.InputTag('slimmedMuons')
)
#process.Baseline += process.MuonProducer
#VectorBool.extend(['MuonProducer:MuonisTightMuon(MuonisTightMuon)'])
#VectorBool.extend(['MuonProducer:MuonisHighPtMuon(MuonisHighPtMuon)'])
VectorDouble.extend(['MuonProducer:MuonEta(MuonEta)'])
VectorDouble.extend(['MuonProducer:MuonPhi(MuonPhi)'])
VectorDouble.extend(['MuonProducer:MuonPt(MuonPt)'])
VectorDouble.extend(['MuonProducer:MuonEnergy(MuonEnergy)'])
#VectorDouble.extend(['MuonProducer:MuonPtError(MuonPtError)'])
#VectorDouble.extend(['MuonProducer:MuonGlobalChi2(MuonGlobalChi2)'])
#VectorDouble.extend(['MuonProducer:MuonTrkPtError(MuonTrkPtError)'])
#VectorInt.extend(['MuonProducer:MuonIsPF(MuonIsPF)'])
VectorInt.extend(['MuonProducer:MuonCharge(MuonCharge)'])
#VectorInt.extend(['MuonProducer:MuonGlobalTrkValidHits(MuonGlobalTrkValidHits)'])
#VectorInt.extend(['MuonProducer:MuonTrkPixelHits(MuonTrkPixelHits)'])
#VectorInt.extend(['MuonProducer:MuonStationMatches(MuonStationMatches)'])
#VectorDouble.extend(['MuonProducer:MuonPFIsoR04Photon(MuonPFIsoR04Photon)'])
#VectorDouble.extend(['MuonProducer:MuonPFIsoR04NeutralHadron(MuonPFIsoR04NeutralHadron)'])
#VectorDouble.extend(['MuonProducer:MuonPFIsoR04PU(MuonPFIsoR04PU)'])
#VectorDouble.extend(['MuonProducer:MuonTrackerIsoSumPT(MuonTrackerIsoSumPT)'])
#VectorDouble.extend(['MuonProducer:MuonPFIsoR04ChargedHadron(MuonPFIsoR04ChargedHadron)'])
VectorInt.extend(['MuonProducer:MuonPassID(MuonPassID)'])
VectorInt.extend(['MuonProducer:MuonIsGlobal(MuonIsGlobal)'])
#VectorInt.extend(['MuonProducer:MuonTrackLayersWithMeasurement(MuonTrackLayersWithMeasurement)'])
#VectorDouble.extend(['MuonProducer:CocktailEta(CocktailPtError)'])
#VectorDouble.extend(['MuonProducer:CocktailPt(CocktailPt)'])
#VectorDouble.extend(['MuonProducer:MuonBestTrackVtxDistXY(MuonBestTrackVtxDistXY)'])
#VectorDouble.extend(['MuonProducer:MuonBestTrackVtxDistZ(MuonBestTrackVtxDistZ)'])
## ----------------------------------------------------------------------------------------------
## Taus
## ----------------------------------------------------------------------------------------------
from LeptoQuarkTreeMaker.Utils.TauProducer_cfi import TauProducer
process.TauProducer = TauProducer.clone(
tautag = cms.InputTag('slimmedTaus')
)
#process.Baseline += process.TauProducer
VectorDouble.extend(['TauProducer:tEta(TauEta)'])
VectorDouble.extend(['TauProducer:tPhi(TauPhi)'])
VectorDouble.extend(['TauProducer:tPt(TauPt)'])
## ----------------------------------------------------------------------------------------------
## Triggers
## ----------------------------------------------------------------------------------------------
# The trigger results are saved to the tree as a vector
# Three vectors are saved:
# 1) names of the triggers
# 2) trigger results
# 3) trigger prescales
# the indexing of these vectors must match
# If the version number of the input trigger name is omitted,
# any matching trigger will be included (default behavior)
from LeptoQuarkTreeMaker.Utils.triggerproducer_cfi import triggerProducer
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.triggerNameList import triggerNameList as _triggerNameList
process.TriggerProducer = triggerProducer.clone(
trigTagArg1 = cms.string('TriggerResults'),
trigTagArg2 = cms.string(''),
trigTagArg3 = cms.string('HLT'),
prescaleTagArg1 = cms.string('patTrigger'),
prescaleTagArg2 = cms.string(''),
prescaleTagArg3 = cms.string(''),
triggerNameList = _triggerNameList
)
VectorInt.extend(['TriggerProducer:TriggerPass','TriggerProducer:TriggerPrescales'])
VectorString.extend(['TriggerProducer:TriggerNames'])
VectorDouble.extend(['TriggerProducer:objectPt'])
VectorDouble.extend(['TriggerProducer:objecteta'])
VectorDouble.extend(['TriggerProducer:objectphi'])
VectorDouble.extend(['TriggerProducer:objectE'])
VectorDouble.extend(['TriggerProducer:ColumnNum'])
## ----------------------------------------------------------------------------------------------
## JER smearing, various uncertainties
## ----------------------------------------------------------------------------------------------
# list of clean tags - ignore jet ID for jets matching these objects
SkipTag = cms.VInputTag(
)
# get the JERs (disabled by default)
# this requires the user to download the .db file from this github
# https://github.com/cms-jet/JRDatabase
if len(jerfile)>0:
#get name of JERs without any directories
JERera = jerfile.split('/')[-1]
JERPatch = cms.string('sqlite_file:'+jerfile+'.db')
if os.getenv('GC_CONF'):
JERPatch = cms.string('sqlite_file:../src/'+jerfile+'.db')
process.jer = cms.ESSource("PoolDBESSource",CondDBSetup,
connect = JERPatch,
toGet = cms.VPSet(
cms.PSet(
record = cms.string('JetResolutionRcd'),
tag = cms.string('JR_'+JERera+'_PtResolution_AK4PFchs'),
label = cms.untracked.string('AK4PFchs_pt')
),
cms.PSet(
record = cms.string('JetResolutionScaleFactorRcd'),
tag = cms.string('JR_'+JERera+'_SF_AK4PFchs'),
label = cms.untracked.string('AK4PFchs')
),
),
)
process.es_prefer_jer = cms.ESPrefer('PoolDBESSource', 'jer')
# skip all jet smearing and uncertainties for data
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.JetDepot import JetDepot #........Uncomment it once you start running on MC datasets
from LeptoQuarkTreeMaker.LeptoQuarkTreeMaker.makeJetVars import makeJetVars
process = makeJetVars(process,
JetTag=JetTag,
suff='',
skipGoodJets=False,
storeProperties=2,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
if geninfo:
# JEC unc up
process, JetTagJECup = JetDepot(process,
JetTag=JetTag,
jecUncDir=1,
doSmear=True,
jerUncDir=0
)
process = makeJetVars(process,
JetTag=JetTagJECup,
suff='JECup',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# JEC unc down
process, JetTagJECdown = JetDepot(process,
JetTag=JetTag,
jecUncDir=-1,
doSmear=True,
jerUncDir=0
)
process = makeJetVars(process,
JetTag=JetTagJECdown,
suff='JECdown',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# JER unc up
process, JetTagJERup = JetDepot(process,
JetTag=JetTag,
jecUncDir=0,
doSmear=True,
jerUncDir=1
)
process = makeJetVars(process,
JetTag=JetTagJERup,
suff='JERup',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# JER unc down
process, JetTagJERdown = JetDepot(process,
JetTag=JetTag,
jecUncDir=0,
doSmear=True,
jerUncDir=-1
)
process = makeJetVars(process,
JetTag=JetTagJERdown,
suff='JERdown',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# finally, do central smearing and replace jet tag
process, JetTag = JetDepot(process,
JetTag=JetTag,
jecUncDir=0,
doSmear=True,
jerUncDir=0
)
## ----------------------------------------------------------------------------------------------
## Jet variables
## ----------------------------------------------------------------------------------------------
'''
# get updated QG training
QGPatch = cms.string('sqlite_file:data/QGL_80X.db')
if os.getenv('GC_CONF'):
QGPatch = cms.string('sqlite_file:../src/data/QGL_80X.db')
process.qgdb = cms.ESSource("PoolDBESSource",CondDBSetup,
connect = QGPatch,
toGet = cms.VPSet(
cms.PSet(
record = cms.string('QGLikelihoodRcd'),
tag = cms.string('QGLikelihoodObject_80X_AK4PFchs'),
label = cms.untracked.string('QGL_AK4PFchs')
),
cms.PSet(
record = cms.string('QGLikelihoodRcd'),
tag = cms.string('QGLikelihoodObject_80X_AK4PFchs_antib'),
label = cms.untracked.string('QGL_AK4PFchs_antib')
),
)
)
process.es_prefer_qg = cms.ESPrefer("PoolDBESSource","qgdb")
# get QG tagging discriminant
process.QGTagger = cms.EDProducer('QGTagger',
srcJets = JetTag,
jetsLabel = cms.string('QGL_AK4PFchs'),
srcRho = cms.InputTag('fixedGridRhoFastjetAll'),
srcVertexCollection = cms.InputTag('offlinePrimaryVerticesWithBS'),
useQualityCuts = cms.bool(False)
)
# add userfloats & update tag
process, JetTag = addJetInfo(process, JetTag, ['QGTagger:qgLikelihood','QGTagger:ptD', 'QGTagger:axis2'], ['QGTagger:mult'])
process = makeJetVars(process,
JetTag=JetTag,
suff='',
skipGoodJets=False,
storeProperties=2,
geninfo=geninfo,
fastsim=fastsim,
SkipTag=SkipTag
)
# get double b-tagger (w/ miniAOD customizations)
process.load("RecoBTag.ImpactParameter.pfImpactParameterAK8TagInfos_cfi")
process.pfImpactParameterAK8TagInfos.primaryVertex = cms.InputTag("offlineSlimmedPrimaryVertices")
process.pfImpactParameterAK8TagInfos.candidates = cms.InputTag("packedPFCandidates")
process.pfImpactParameterAK8TagInfos.jets = JetAK8Tag
process.load("RecoBTag.SecondaryVertex.pfInclusiveSecondaryVertexFinderAK8TagInfos_cfi")
process.pfInclusiveSecondaryVertexFinderAK8TagInfos.extSVCollection = cms.InputTag("slimmedSecondaryVertices")
process.pfInclusiveSecondaryVertexFinderAK8TagInfos.trackIPTagInfos = cms.InputTag("pfImpactParameterAK8TagInfos")
process.load("RecoBTag.SecondaryVertex.pfBoostedDoubleSVAK8TagInfos_cfi")
process.load("RecoBTag.SecondaryVertex.candidateBoostedDoubleSecondaryVertexAK8Computer_cfi")
process.load("RecoBTag.SecondaryVertex.pfBoostedDoubleSecondaryVertexAK8BJetTags_cfi")
# add discriminator and update tag
process, JetAK8Tag = addJetInfo(process, JetAK8Tag, [], [], cms.VInputTag(cms.InputTag("pfBoostedDoubleSecondaryVertexAK8BJetTags")))
# apply jet ID
process = makeJetVars(process,
JetTag=JetAK8Tag,
suff='AK8',
skipGoodJets=False,
storeProperties=1,
geninfo=geninfo,
fastsim=fastsim,
onlyGoodJets=True
)
# AK8 jet variables - separate instance of jet properties producer
from LeptoQuarkTreeMaker.Utils.jetproperties_cfi import jetproperties
process.JetsPropertiesAK8 = jetproperties.clone(
JetTag = JetAK8Tag,
properties = cms.vstring(
"prunedMass" ,
"NsubjettinessTau1" ,
"NsubjettinessTau2" ,
"NsubjettinessTau3" ,
"bDiscriminatorSubjet1",
"bDiscriminatorSubjet2",
"bDiscriminatorCSV" ,
"NumBhadrons" ,
"NumChadrons" ,
)
)
#specify userfloats
process.JetsPropertiesAK8.prunedMass = cms.vstring('ak8PFJetsCHSPrunedMass')
process.JetsPropertiesAK8.NsubjettinessTau1 = cms.vstring('NjettinessAK8:tau1')
process.JetsPropertiesAK8.NsubjettinessTau2 = cms.vstring('NjettinessAK8:tau2')
process.JetsPropertiesAK8.NsubjettinessTau3 = cms.vstring('NjettinessAK8:tau3')
process.JetsPropertiesAK8.bDiscriminatorSubjet1 = cms.vstring('SoftDrop','pfCombinedInclusiveSecondaryVertexV2BJetTags')
process.JetsPropertiesAK8.bDiscriminatorSubjet2 = cms.vstring('SoftDrop','pfCombinedInclusiveSecondaryVertexV2BJetTags')
process.JetsPropertiesAK8.bDiscriminatorCSV = cms.vstring('pfBoostedDoubleSecondaryVertexAK8BJetTags')
#VectorRecoCand.extend([JetAK8Tag.value()+'(JetsAK8)'])
VectorDouble.extend(['JetsPropertiesAK8:prunedMass(JetsAK8_prunedMass)',
'JetsPropertiesAK8:bDiscriminatorSubjet1(JetsAK8_bDiscriminatorSubjet1CSV)',
'JetsPropertiesAK8:bDiscriminatorSubjet2(JetsAK8_bDiscriminatorSubjet2CSV)',
'JetsPropertiesAK8:bDiscriminatorCSV(JetsAK8_doubleBDiscriminator)',
'JetsPropertiesAK8:NsubjettinessTau1(JetsAK8_NsubjettinessTau1)',
'JetsPropertiesAK8:NsubjettinessTau2(JetsAK8_NsubjettinessTau2)',
'JetsPropertiesAK8:NsubjettinessTau3(JetsAK8_NsubjettinessTau3)'])
VectorInt.extend(['JetsPropertiesAK8:NumBhadrons(JetsAK8_NumBhadrons)',
'JetsPropertiesAK8:NumChadrons(JetsAK8_NumChadrons)'])
'''
## ----------------------------------------------------------------------------------------------
## GenJet variables
## ----------------------------------------------------------------------------------------------
if geninfo:
# store all genjets
VectorRecoCand.extend ( [ 'slimmedGenJets(GenJets)' ] )
from LeptoQuarkTreeMaker.Utils.subJetSelection_cfi import SubGenJetSelection
process.GenHTJets = SubGenJetSelection.clone(
JetTag = cms.InputTag('slimmedGenJets'),
MinPt = cms.double(30),
MaxEta = cms.double(2.4),
)
VectorBool.extend(['GenHTJets:SubJetMask(GenJets_HTMask)'])
# make gen HT
from LeptoQuarkTreeMaker.Utils.htdouble_cfi import htdouble
process.GenHT = htdouble.clone(
JetTag = cms.InputTag("GenHTJets"),
)
VarsDouble.extend(['GenHT'])
process.GenMHTJets = SubGenJetSelection.clone(
JetTag = cms.InputTag('slimmedGenJets'),
MinPt = cms.double(30),
MaxEta = cms.double(5.0),
)
VectorBool.extend(['GenMHTJets:SubJetMask(GenJets_MHTMask)'])
# make gen MHT
## ----------------------------------------------------------------------------------------------
## Baseline filters
## ----------------------------------------------------------------------------------------------
# sequence for baseline filters
process.Baseline = cms.Sequence()
#process.Baseline += process.MHTFilter
## ----------------------------------------------------------------------------------------------
## MET
## ----------------------------------------------------------------------------------------------
from LeptoQuarkTreeMaker.Utils.metdouble_cfi import metdouble
process.MET = metdouble.clone(
METTag = METTag,
GenMETTag = cms.InputTag("slimmedMETs","",tagname), #original collection used deliberately here
JetTag = cms.InputTag('HTJets'),
geninfo = cms.untracked.bool(geninfo),
)
VarsDouble.extend(['MET:Pt(MET)','MET:Phi(METPhi)','MET:CaloPt(CaloMET)','MET:CaloPhi(CaloMETPhi)','MET:PFCaloPtRatio(PFCaloMETRatio)'])
if geninfo:
VarsDouble.extend(['MET:GenPt(GenMET)','MET:GenPhi(GenMETPhi)'])
VectorDouble.extend(['MET:PtUp(METUp)', 'MET:PtDown(METDown)', 'MET:PhiUp(METPhiUp)', 'MET:PhiDown(METPhiDown)'])
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Optional producers (background estimations, control regions)
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Hadronic Tau Background
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Lost Lepton Background
## ----------------------------------------------------------------------------------------------
## Zinv Background
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
## Final steps
## ----------------------------------------------------------------------------------------------
## ----------------------------------------------------------------------------------------------
# create the process path
process.dump = cms.EDAnalyzer("EventContentAnalyzer")
process.WriteTree = cms.Path(
process.Baseline *
process.LQTreeMaker2
)
return process
def makeAnalysisStep(self, stepName, **inputs):
step = super(ElectronCalibration, self).makeAnalysisStep(stepName, **inputs)
if stepName == 'preliminary':
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
self.process = regressionWeights(self.process)
from EgammaAnalysis.ElectronTools.regressionApplication_cff import slimmedElectrons as eReg
eReg.src = step.getObjTag('e')
step.addModule('electronRegression', eReg, 'e')
cutOnSCEta = cms.EDFilter(
"PATElectronSelector",
src = step.getObjTag('e'),
cut = cms.string('pt >= 5. && abs(superCluster.eta) < 2.5'),
)
step.addModule('selectElectronsBeforeID', cutOnSCEta, 'e')
if not hasattr(self.process, 'RandomNumberGeneratorService'):
self.process.RandomNumberGeneratorService = cms.Service(
'RandomNumberGeneratorService',
)
self.process.RandomNumberGeneratorService.calibratedPatElectrons = cms.PSet(
initialSeed = cms.untracked.uint32(987),
)
from EgammaAnalysis.ElectronTools.calibratedPatElectronsRun2_cfi import calibratedPatElectrons
from EgammaAnalysis.ElectronTools.calibrationTablesRun2 import files
# from EgammaAnalysis.ElectronTools.calibrationTablesRun2 import correctionType
# This would give you the default value of Legacy2016_v1 which should be used for
# the ReReco, not the ReMiniAOD
correctionType = "Moriond17_23Jan"
calibratedPatElectrons.isMC = cms.bool(self.isMC)
calibratedPatElectrons.electrons = step.getObjTag('e')
calibratedPatElectrons.isSynchronization = cms.bool(self.isSync)
calibratedPatElectrons.correctionFile = cms.string(files[correctionType])
step.addModule('calibratedPatElectrons', calibratedPatElectrons, 'e')
if self.isMC:
makeNewCollection=False
if self.electronScaleShift or self.electronRhoResShift or self.electronPhiResShift:
makeNewCollection=True
self.process.RandomNumberGeneratorService.electronSystematicShift = cms.PSet(
initialSeed = cms.untracked.uint32(345),
)
shiftMod = cms.EDProducer(
"PATElectronSystematicShifter",
src = step.getObjTag('e'),
recHitCollectionEB = cms.InputTag('reducedEgamma:reducedEBRecHits'),
recHitCollectionEE = cms.InputTag('reducedEgamma:reducedEERecHits'),
correctionFile = cms.string(files[correctionType]),
scaleShift = cms.double(self.electronScaleShift),
rhoResShift = cms.double(self.electronRhoResShift),
phiResShift = cms.double(self.electronPhiResShift),
shiftCollection = cms.bool(makeNewCollection),
)
step.addModule('electronSystematicShift', shiftMod, 'e')
if stepName == 'selection':
# need to re-sort now that we're calibrated
eSort = cms.EDProducer(
"PATElectronCollectionSorter",
src = step.getObjTag('e'),
function = cms.string('pt'),
)
step.addModule('electronSorting', eSort, 'e')
return step
def makeAnalysisStep(self, stepName, **inputs):
step = super(ElectronCalibration,
self).makeAnalysisStep(stepName, **inputs)
if stepName == 'preliminary':
from EgammaAnalysis.ElectronTools.regressionWeights_cfi import regressionWeights
self.process = regressionWeights(self.process)
from EgammaAnalysis.ElectronTools.regressionApplication_cff import slimmedElectrons as eReg
eReg.src = step.getObjTag('e')
step.addModule('electronRegression', eReg, 'e')
cutOnSCEta = cms.EDFilter(
"PATElectronSelector",
src=step.getObjTag('e'),
cut=cms.string('pt >= 5. && abs(superCluster.eta) < 2.5'),
)
step.addModule('selectElectronsBeforeID', cutOnSCEta, 'e')
if not hasattr(self.process, 'RandomNumberGeneratorService'):
self.process.RandomNumberGeneratorService = cms.Service(
'RandomNumberGeneratorService', )
self.process.RandomNumberGeneratorService.calibratedPatElectrons = cms.PSet(
initialSeed=cms.untracked.uint32(987), )
from EgammaAnalysis.ElectronTools.calibratedPatElectronsRun2_cfi import calibratedPatElectrons
from EgammaAnalysis.ElectronTools.calibrationTablesRun2 import files
# from EgammaAnalysis.ElectronTools.calibrationTablesRun2 import correctionType
# This would give you the default value of Legacy2016_v1 which should be used for
# the ReReco, not the ReMiniAOD
correctionType = "Moriond17_23Jan"
calibratedPatElectrons.isMC = cms.bool(self.isMC)
calibratedPatElectrons.electrons = step.getObjTag('e')
calibratedPatElectrons.isSynchronization = cms.bool(self.isSync)
calibratedPatElectrons.correctionFile = cms.string(
files[correctionType])
step.addModule('calibratedPatElectrons', calibratedPatElectrons,
'e')
if self.isMC:
makeNewCollection = False
if self.electronScaleShift or self.electronRhoResShift or self.electronPhiResShift:
makeNewCollection = True
self.process.RandomNumberGeneratorService.electronSystematicShift = cms.PSet(
initialSeed=cms.untracked.uint32(345), )
shiftMod = cms.EDProducer(
"PATElectronSystematicShifter",
src=step.getObjTag('e'),
recHitCollectionEB=cms.InputTag(
'reducedEgamma:reducedEBRecHits'),
recHitCollectionEE=cms.InputTag(
'reducedEgamma:reducedEERecHits'),
correctionFile=cms.string(files[correctionType]),
scaleShift=cms.double(self.electronScaleShift),
rhoResShift=cms.double(self.electronRhoResShift),
phiResShift=cms.double(self.electronPhiResShift),
shiftCollection=cms.bool(makeNewCollection),
)
step.addModule('electronSystematicShift', shiftMod, 'e')
if stepName == 'selection':
# need to re-sort now that we're calibrated
eSort = cms.EDProducer(
"PATElectronCollectionSorter",
src=step.getObjTag('e'),
function=cms.string('pt'),
)
step.addModule('electronSorting', eSort, 'e')
return step