def customise_addPuppiNTupleToRECO(process):
process.pfPuppi = _puppi.clone()
process.pfPuppiNoLep = _puppiNoLep.clone()
process.pfPuppiWithPixVtx = _puppi.clone(
candName='particleFlow',
vertexName='pixelVertices',
UseFromPVLooseTight=True,
vtxNdofCut=0,
)
process.pfPuppiNoLepWithPixVtx = _puppiNoLep.clone(
candName='particleFlow',
vertexName='pixelVertices',
UseFromPVLooseTight=True,
vtxNdofCut=0,
)
process.puppiSeq = cms.Sequence(process.pfPuppi + process.pfPuppiNoLep +
process.pfPuppiWithPixVtx +
process.pfPuppiNoLepWithPixVtx)
process.puppiPath = cms.Path(process.reconstruction_pixelTrackingOnly +
process.puppiSeq)
process.puppiNTuple = cms.EDAnalyzer(
'JMETriggerNTuple',
TTreeName=cms.string('Events'),
TriggerResults=cms.InputTag('TriggerResults'),
TriggerResultsFilterOR=cms.vstring(),
TriggerResultsFilterAND=cms.vstring(),
TriggerResultsCollections=cms.vstring(),
outputBranchesToBeDropped=cms.vstring(),
recoVertexCollections=cms.PSet(
pixelVertices=cms.InputTag('pixelVertices'),
offlinePrimaryVertices=cms.InputTag('offlinePrimaryVertices'),
),
recoPFCandidateCollections=cms.PSet(
# particleFlow = cms.InputTag('particleFlow'),
puppi=cms.InputTag('pfPuppi'),
puppiNoLep=cms.InputTag('pfPuppiNoLep'),
puppiWithPixVtx=cms.InputTag('pfPuppiWithPixVtx'),
puppiNoLepWithPixVtx=cms.InputTag('pfPuppiNoLepWithPixVtx'),
))
process.puppiNTupleEndPath = cms.EndPath(process.puppiNTuple)
if process.schedule_() is not None:
process.schedule_().append(process.puppiPath)
process.schedule_().append(process.puppiNTupleEndPath)
return process
def load_pfParticle_sequence(proc, withLeptons):
from CommonTools.PileupAlgos.Puppi_cff import puppi
if withLeptons:
puppiR05 = puppi.clone()
setattr(proc, "puppiR05", puppiR05)
pfAllPhotonsPuppi = cms.EDFilter("CandPtrSelector", src = cms.InputTag("puppiR05"), cut = cms.string("pdgId == 22"))
pfAllNeutralHadronsPuppi = cms.EDFilter("CandPtrSelector", src = cms.InputTag("puppiR05"), cut = cms.string("pdgId == 111 || pdgId == 130 || pdgId == 310 || pdgId == 2112"))
pfAllChargedHadronsPuppi = cms.EDFilter("CandPtrSelector", src = cms.InputTag("puppiR05"), cut = cms.string("pdgId == 211 || pdgId == -211 || pdgId == 321 || pdgId == -321 || pdgId == 999211 || pdgId == 2212 || pdgId == -2212"))
setattr(proc, "pfAllPhotonsPuppi", pfAllPhotonsPuppi)
setattr(proc, "pfAllNeutralHadronsPuppi", pfAllNeutralHadronsPuppi)
setattr(proc, "pfAllChargedHadronsPuppi", pfAllChargedHadronsPuppi)
pfParticlesForPUPPI = cms.Sequence()
pfParticlesForPUPPI += getattr(proc, "puppiR05")
pfParticlesForPUPPI += getattr(proc, "pfAllPhotonsPuppi")
pfParticlesForPUPPI += getattr(proc, "pfAllNeutralHadronsPuppi")
pfParticlesForPUPPI += getattr(proc, "pfAllChargedHadronsPuppi")
return pfParticlesForPUPPI
else :
packedPFCandidatesNoLep = cms.EDFilter("CandPtrSelector", src = cms.InputTag("particleFlow"), cut = cms.string("abs(pdgId) != 13 && abs(pdgId) != 11 "))
setattr(proc, "packedPFCandidatesNoLep", packedPFCandidatesNoLep)
puppiR05NoLep = puppi.clone(
candName = 'packedPFCandidatesNoLep'
)
setattr(proc, "puppiR05NoLep", puppiR05NoLep)
pfAllPhotonsPuppiNoLep = cms.EDFilter("CandPtrSelector", src = cms.InputTag("puppiR05NoLep"), cut = cms.string("pdgId == 22"))
pfAllNeutralHadronsPuppiNoLep = cms.EDFilter("CandPtrSelector", src = cms.InputTag("puppiR05NoLep"), cut = cms.string("pdgId == 111 || pdgId == 130 || pdgId == 310 || pdgId == 2112"))
pfAllChargedHadronsPuppiNoLep = cms.EDFilter("CandPtrSelector", src = cms.InputTag("puppiR05NoLep"), cut = cms.string("pdgId == 211 || pdgId == -211 || pdgId == 321 || pdgId == -321 || pdgId == 999211 || pdgId == 2212 || pdgId == -2212"))
setattr(proc, "pfAllPhotonsPuppiNoLep", pfAllPhotonsPuppiNoLep)
setattr(proc, "pfAllNeutralHadronsPuppiNoLep", pfAllNeutralHadronsPuppiNoLep)
setattr(proc, "pfAllChargedHadronsPuppiNoLep", pfAllChargedHadronsPuppiNoLep)
pfParticlesForPUPPINoLep = cms.Sequence()
pfParticlesForPUPPINoLep += getattr(proc, "packedPFCandidatesNoLep")
pfParticlesForPUPPINoLep += getattr(proc, "puppiR05NoLep")
pfParticlesForPUPPINoLep += getattr(proc, "pfAllPhotonsPuppiNoLep")
pfParticlesForPUPPINoLep += getattr(proc, "pfAllNeutralHadronsPuppiNoLep")
pfParticlesForPUPPINoLep += getattr(proc, "pfAllChargedHadronsPuppiNoLep")
return pfParticlesForPUPPINoLep
def producePF(process) :
from CommonTools.PileupAlgos.Puppi_cff import puppi
puppi.useExistingWeights = True
puppi.candName = "packedPFCandidates"
puppi.vertexName = "offlineSlimmedPrimaryVertices"
_addProcessAndTask(process,"leptonLessPFProducer",leptonLessPFProducer.clone())
_addProcessAndTask(process,"leptonLesspuppi",puppi.clone(candName = cms.InputTag('leptonLessPFProducer')))
def makePuppiAlgo(process):
puppi.candName = cms.InputTag('packedPFCandidates')
puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
process.puppi = puppi.clone()
process.puppi_onMiniAOD = cms.Sequence(process.puppi)
def addRecoJetCollection(self,
proc,
jet,
inputCollection = "",
minPtFastjet = None,
genJetsCollection = "",
bTagDiscriminators = ["None"],
JETCorrLevels = ["L1FastJet", "L2Relative", "L3Absolute", "L2L3Residual"],
):
print("jetCollectionTools::RecoJetAdder::addRecoJetCollection: Adding Reco Jet Collection: {}".format(jet))
currentTasks = []
if inputCollection and inputCollection not in self.patJetsInMiniAOD:
raise RuntimeError("Invalid input collection: %s" % inputCollection)
#=======================================================
#
# Figure out which jet collection we're dealing with
#
#=======================================================
recoJetInfo = RecoJetInfo(jet, inputCollection)
jetLower = recoJetInfo.jetLower
jetUpper = recoJetInfo.jetUpper
tagName = recoJetInfo.jetTagName
if inputCollection == "slimmedJets":
assert(jetLower == "ak4pfchs")
elif inputCollection == "slimmedJetsAK8":
assert(jetLower == "ak8pfpuppi")
elif inputCollection == "slimmedJetsPuppi":
assert(jetLower == "ak4pfpuppi")
elif inputCollection == "slimmedCaloJets":
assert(jetLower == "ak4calo")
#=======================================================
#
# If the patJet collection in MiniAOD is not specified,
# we have to build the patJet collection from scratch.
#
#========================================================
if not inputCollection or recoJetInfo.doCalo:
print("jetCollectionTools::RecoJetAdder::addRecoJetCollection: inputCollection not specified. Building recojet collection now")
#=======================================================
#
# Prepare the inputs to jet clustering
#
#========================================================
#
# Specify PF candidates
#
pfCand = self.pfLabel
#
# Setup PU method for PF candidates
#
if recoJetInfo.jetPUMethod not in [ "", "cs" ]:
pfCand += recoJetInfo.jetPUMethod
#
# Setup modules to perform PU mitigation for
# PF candidates
#
if pfCand not in self.prerequisites:
#
# Skip if no PU Method or CS specified
#
if recoJetInfo.jetPUMethod in [ "", "cs" ]:
pass
#
# CHS
#
elif recoJetInfo.jetPUMethod == "chs":
from CommonTools.ParticleFlow.pfCHS_cff import pfCHS, packedPrimaryVertexAssociationJME
self.addProcessAndTask(proc, "packedPrimaryVertexAssociationJME", packedPrimaryVertexAssociationJME.clone())
self.prerequisites.append("packedPrimaryVertexAssociationJME")
self.addProcessAndTask(proc, pfCand, pfCHS.clone())
self.prerequisites.append(pfCand)
#
# PUPPI
#
elif recoJetInfo.jetPUMethod == "puppi":
self.addProcessAndTask(proc, pfCand, puppi.clone(
candName = self.pfLabel,
vertexName = self.pvLabel,
)
)
self.prerequisites.append(pfCand)
#
# Softkiller
#
elif recoJetInfo.jetPUMethod == "sk":
self.addProcessAndTask(proc, pfCand, softKiller.clone(
PFCandidates = self.pfLabel,
rParam = recoJetInfo.jetSizeNr,
)
)
self.prerequisites.append(pfCand)
else:
raise RuntimeError("Currently unsupported PU method: '%s'" % recoJetInfo.jetPUMethod)
#============================================
#
# Create the recojet collection
#
#============================================
if not recoJetInfo.doCalo:
jetCollection = '{}Collection'.format(jetUpper)
if jetCollection in self.main:
raise ValueError("Step '%s' already implemented" % jetCollection)
#
# Cluster new jet
#
if recoJetInfo.jetPUMethod == "chs":
self.addProcessAndTask(proc, jetCollection, ak4PFJetsCHS.clone(
src = pfCand,
)
)
elif recoJetInfo.jetPUMethod == "puppi":
self.addProcessAndTask(proc, jetCollection, ak4PFJetsPuppi.clone(
src = self.pfLabel,
srcWeights = pfCand
)
)
elif recoJetInfo.jetPUMethod == "sk":
self.addProcessAndTask(proc, pfCand, ak4PFJetsSK.clone(
src = pfCand,
)
)
elif recoJetInfo.jetPUMethod == "cs":
self.addProcessAndTask(proc, jetCollection, ak4PFJetsCS.clone(
src = pfCand,
)
)
else:
self.addProcessAndTask(proc, jetCollection, ak4PFJets.clone(
src = pfCand,
)
)
getattr(proc, jetCollection).jetAlgorithm = supportedJetAlgos[recoJetInfo.jetAlgo]
getattr(proc, jetCollection).rParam = recoJetInfo.jetSizeNr
#
# Set minimum pt threshold of reco jets to be saved after fastjet clustering
#
if minPtFastjet != None:
getattr(proc, jetCollection).jetPtMin = minPtFastjet
currentTasks.append(jetCollection)
else:
jetCollection = inputCollection
#=============================================
#
# Make patJet collection
#
#=============================================
#
# Jet correction
#
if recoJetInfo.jetPUMethod == "puppi":
jetCorrLabel = "Puppi"
elif recoJetInfo.jetPUMethod in [ "cs", "sk" ]:
jetCorrLabel = "chs"
else:
jetCorrLabel = recoJetInfo.jetPUMethod
jetCorrections = (
"{}{}{}{}".format(
recoJetInfo.jetAlgo.upper(),
recoJetInfo.jetSize,
"Calo" if recoJetInfo.doCalo else recoJetInfo.jetReco.upper(),
jetCorrLabel
),
JETCorrLevels,
"None",
)
postfix = "Recluster" if inputCollection == "" else ""
addJetCollection(
proc,
labelName = jetUpper,
postfix = postfix,
jetSource = cms.InputTag(jetCollection),
algo = recoJetInfo.jetAlgo,
rParam = recoJetInfo.jetSizeNr,
pvSource = cms.InputTag(self.pvLabel),
pfCandidates = cms.InputTag(self.pfLabel),
svSource = cms.InputTag(self.svLabel),
muSource = cms.InputTag(self.muLabel),
elSource = cms.InputTag(self.elLabel),
genJetCollection = cms.InputTag(genJetsCollection),
genParticles = cms.InputTag(self.gpLabel),
jetCorrections = jetCorrections,
)
#
# Need to set this explicitly for PUPPI jets
#
if recoJetInfo.jetPUMethod == "puppi":
getattr(proc, "patJetFlavourAssociation{}{}".format(jetUpper,postfix)).weights = cms.InputTag(pfCand)
getJetMCFlavour = not recoJetInfo.doCalo and recoJetInfo.jetPUMethod != "cs"
if not self.runOnMC: #Remove modules for Gen-level object matching
delattr(proc, 'patJetGenJetMatch{}{}'.format(jetUpper,postfix))
delattr(proc, 'patJetPartonMatch{}{}'.format(jetUpper,postfix))
getJetMCFlavour = False
setattr(getattr(proc, "patJets{}{}".format(jetUpper,postfix)), "getJetMCFlavour", cms.bool(getJetMCFlavour))
selectedPatJets = "selectedPatJets{}{}".format(jetUpper,postfix)
#=============================================
#
# Update the patJet collection.
# This is where we setup
# - JEC
# - b-tagging discriminators
#
#=============================================
updateJetCollection(
proc,
labelName = jetUpper,
postfix = "Final",
jetSource = cms.InputTag(selectedPatJets),
jetCorrections = jetCorrections,
btagDiscriminators = bTagDiscriminators,
)
recoJetInfo.patJetFinalCollection = "selectedUpdatedPatJets{}{}".format(jetUpper,"Final")
else:
recoJetInfo.patJetFinalCollection = inputCollection
self.main.extend(currentTasks)
return recoJetInfo
def addRecoJetCollection(
self,
proc,
jet,
inputCollection="",
genJetsCollection="",
minPt=5.,
bTagDiscriminators=None,
JETCorrLevels=None,
):
print(
"jetCollectionTools::RecoJetAdder::addRecoJetCollection: Adding Reco Jet Collection: {}"
.format(jet))
currentTasks = []
if inputCollection and inputCollection not in [
"slimmedJets",
"slimmedJetsAK8",
"slimmedJetsPuppi",
"slimmedCaloJets",
]:
raise RuntimeError("Invalid input collection: %s" %
inputCollection)
if bTagDiscriminators is None:
bTagDiscriminators = self.bTagDiscriminators
if JETCorrLevels is None:
JETCorrLevels = self.JETCorrLevels
#
# Decide which jet collection we're dealing with
#
recoJetInfo = RecoJetInfo(jet, inputCollection)
jetLower = recoJetInfo.jetLower
jetUpper = recoJetInfo.jetUpper
tagName = recoJetInfo.jetTagName
if inputCollection == "slimmedJets":
assert (jetLower == "ak4pfchs")
elif inputCollection == "slimmedJetsAK8":
assert (jetLower == "ak8pfpuppi")
elif inputCollection == "slimmedJetsPuppi":
assert (jetLower == "ak4pfpuppi")
elif inputCollection == "slimmedCaloJets":
assert (jetLower == "ak4calo")
#=======================================================
#
# If jet collection in MiniAOD is not
# specified, build the jet collection.
#
#========================================================
if not inputCollection or recoJetInfo.doCalo:
print(
"jetCollectionTools::RecoJetAdder::addRecoJetCollection: inputCollection not specified. Building recojet collection now"
)
#=======================================================
#
# Prepare the inputs to jet clustering
#
#========================================================
#
# Set up PF candidates
#
pfCand = self.pfLabel
#
# Setup PU method for PF candidates
#
if recoJetInfo.jetPUMethod not in ["", "cs"]:
pfCand += recoJetInfo.jetPUMethod
#
#
#
if pfCand not in self.prerequisites:
#
# Skip if no PU Method or CS specified
#
if recoJetInfo.jetPUMethod in ["", "cs"]:
pass
#
# CHS
#
elif recoJetInfo.jetPUMethod == "chs":
setattr(
proc, pfCand,
cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag(self.pfLabel),
cut=cms.string("fromPV"),
))
self.prerequisites.append(pfCand)
#
# PUPPI
#
elif recoJetInfo.jetPUMethod == "puppi":
setattr(
proc, pfCand,
puppi.clone(
candName=self.pfLabel,
vertexName=self.pvLabel,
))
self.prerequisites.append(pfCand)
#
# Softkiller
#
elif recoJetInfo.jetPUMethod == "sk":
setattr(
proc, pfCand,
softKiller.clone(
PFCandidates=self.pfLabel,
rParam=recoJetInfo.jetSizeNr,
))
self.prerequisites.append(pfCand)
else:
raise RuntimeError(
"Currently unsupported PU method: '%s'" %
recoJetInfo.jetPUMethod)
#============================================
#
# Create the recojet collection
#
#============================================
if not recoJetInfo.doCalo:
jetCollection = '{}Collection'.format(tagName)
if jetCollection in self.main:
raise ValueError("Step '%s' already implemented" %
jetCollection)
setattr(
proc, jetCollection,
ak4PFJetsCS.clone(
src=pfCand,
doAreaFastjet=True,
jetPtMin=minPt,
jetAlgorithm=supportedJetAlgos[recoJetInfo.jetAlgo],
rParam=recoJetInfo.jetSizeNr,
useConstituentSubtraction=recoJetInfo.doCS,
csRParam=0.4 if recoJetInfo.doCS else -1.,
csRho_EtaMax=PFJetParameters.Rho_EtaMax
if recoJetInfo.doCS else -1.,
useExplicitGhosts=recoJetInfo.doCS
or recoJetInfo.jetPUMethod == "sk",
))
currentTasks.append(jetCollection)
else:
jetCollection = inputCollection
#
# PATify
#
if recoJetInfo.jetPUMethod == "puppi":
jetCorrLabel = "Puppi"
elif recoJetInfo.jetPUMethod in ["cs", "sk"]:
jetCorrLabel = "chs"
else:
jetCorrLabel = recoJetInfo.jetPUMethod
#
# Jet correction
#
jetCorrections = (
"{}{}{}{}".format(
recoJetInfo.jetAlgo.upper(), recoJetInfo.jetSize, "Calo"
if recoJetInfo.doCalo else recoJetInfo.jetReco.upper(),
jetCorrLabel),
JETCorrLevels,
"None",
)
addJetCollection(
proc,
labelName=tagName,
jetSource=cms.InputTag(jetCollection),
algo=recoJetInfo.jetAlgo,
rParam=recoJetInfo.jetSizeNr,
pvSource=cms.InputTag(self.pvLabel),
pfCandidates=cms.InputTag(self.pfLabel),
svSource=cms.InputTag(self.svLabel),
muSource=cms.InputTag(self.muLabel),
elSource=cms.InputTag(self.elLabel),
btagDiscriminators=bTagDiscriminators
if not recoJetInfo.doCalo else ["None"],
jetCorrections=jetCorrections,
genJetCollection=cms.InputTag(genJetsCollection),
genParticles=cms.InputTag(self.gpLabel),
)
getJetMCFlavour = not recoJetInfo.doCalo and recoJetInfo.jetPUMethod != "cs"
setattr(getattr(proc, "patJets{}".format(tagName)),
"getJetMCFlavour", cms.bool(getJetMCFlavour))
setattr(getattr(proc, "patJetCorrFactors{}".format(tagName)),
"payload", cms.string(recoJetInfo.jetCorrPayload))
selJet = "selectedPatJets{}".format(tagName)
else:
selJet = inputCollection
if not recoJetInfo.skipUserData:
#
#
#
jercVar = "jercVars{}".format(tagName)
if jercVar in self.main:
raise ValueError("Step '%s' already implemented" % jercVar)
setattr(proc, jercVar, proc.jercVars.clone(srcJet=selJet))
currentTasks.append(jercVar)
#
#
#
looseJetId = "looseJetId{}".format(tagName)
if looseJetId in self.main:
raise ValueError("Step '%s' already implemented" % looseJetId)
setattr(proc, looseJetId, proc.looseJetId.clone(src=selJet))
#
#
#
tightJetId = "tightJetId{}".format(tagName)
if tightJetId in self.main:
raise ValueError("Step '%s' already implemented" % tightJetId)
setattr(proc, tightJetId, proc.tightJetId.clone(src=selJet))
currentTasks.append(tightJetId)
#
#
#
tightJetIdLepVeto = "tightJetIdLepVeto{}".format(tagName)
if tightJetIdLepVeto in self.main:
raise ValueError("Step '%s' already implemented" %
tightJetIdLepVeto)
setattr(proc, tightJetIdLepVeto,
proc.tightJetIdLepVeto.clone(src=selJet))
currentTasks.append(tightJetIdLepVeto)
#
#
#
selectedPatJetsWithUserData = "{}WithUserData".format(selJet)
if selectedPatJetsWithUserData in self.main:
raise ValueError("Step '%s' already implemented" %
selectedPatJetsWithUserData)
setattr(
proc, selectedPatJetsWithUserData,
cms.EDProducer(
"PATJetUserDataEmbedder",
src=cms.InputTag(selJet),
userFloats=cms.PSet(
jercCHPUF=cms.InputTag(
"{}:chargedHadronPUEnergyFraction".format(
jercVar)),
jercCHF=cms.InputTag(
"{}:chargedHadronCHSEnergyFraction".format(
jercVar)),
),
userInts=cms.PSet(
tightId=cms.InputTag(tightJetId),
tightIdLepVeto=cms.InputTag(tightJetIdLepVeto),
),
))
for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016:
selectedPatJetsWithUserDataObj = getattr(
proc, selectedPatJetsWithUserData)
modifier.toModify(
selectedPatJetsWithUserDataObj.userInts,
looseId=looseJetId,
tightIdLepVeto=None,
)
currentTasks.append(selectedPatJetsWithUserData)
else:
selectedPatJetsWithUserData = "selectedPatJets{}".format(tagName)
#
# Not sure why we can't re-use patJetCorrFactors* created by addJetCollection()
# (even cloning doesn't work) Let's just create our own
#
jetCorrFactors = "jetCorrFactors{}".format(tagName)
if jetCorrFactors in self.main:
raise ValueError("Step '%s' already implemented" % jetCorrFactors)
setattr(
proc, jetCorrFactors,
patJetCorrFactors.clone(
src=selectedPatJetsWithUserData,
levels=JETCorrLevels,
primaryVertices=self.pvLabel,
payload=recoJetInfo.jetCorrPayload,
rho="fixedGridRhoFastjetAll{}".format(
"Calo" if recoJetInfo.doCalo else ""),
))
currentTasks.append(jetCorrFactors)
updatedJets = "updatedJets{}".format(tagName)
if updatedJets in self.main:
raise ValueError("Step '%s' already implemented" % updatedJets)
setattr(
proc, updatedJets,
updatedPatJets.clone(
addBTagInfo=False,
jetSource=selectedPatJetsWithUserData,
jetCorrFactorsSource=[jetCorrFactors],
))
currentTasks.append(updatedJets)
self.main.extend(currentTasks)
return recoJetInfo
#################################################
### Softdrop
from RecoJets.Configuration.RecoPFJets_cff import ak8PFJetsCHS
process.ak8CHSJetsSoftDrop = ak8PFJetsCHSSoftDrop.clone(src = cms.InputTag('chs'), jetPtMin = fatjet_ptmin)
process.ca15CHSJetsSoftDrop = ak8PFJetsCHSSoftDrop.clone(src = cms.InputTag('chs'), jetPtMin = fatjet_ptmin, jetAlgorithm = cms.string("CambridgeAachen"), rParam = 1.5, R0 = 1.5, zcut = cms.double(0.2), beta = cms.double(1.0))
from RecoJets.JetProducers.ak4PFJetsPruned_cfi import ak4PFJetsPruned
#Note low pt threshold as jets currently not stored but used just to derived pruned mass
process.ak8CHSJetsPruned = ak4PFJetsPruned.clone(rParam = 0.8, doAreaFastjet = True, src = 'chs', jetPtMin = 70)
process.ca15CHSJetsPruned = ak4PFJetsPruned.clone(rParam = 1.5, jetAlgorithm = "CambridgeAachen", doAreaFastjet = True, src = 'chs', jetPtMin = 70)
###############################################
# PUPPI JETS
from CommonTools.PileupAlgos.Puppi_cff import puppi
process.puppi = puppi.clone(candName = cms.InputTag('packedPFCandidates'), vertexName = cms.InputTag('offlineSlimmedPrimaryVertices'))
# copy all the jet collections above; just use 'puppi' instead of 'chs' as input:
#for name in ['ca8CHSJets', 'ca15CHSJets', 'ca8CHSJetsPruned', 'ca15CHSJetsFiltered', 'cmsTopTagCHS', 'hepTopTagCHS', 'ca8CHSJetsSoftDrop']:
# setattr(process, name.replace('CHS', 'Puppi'), getattr(process, name).clone(src = cms.InputTag('puppi')))
###############################################
# PAT JETS and Gen Jets
#
# 'Patify' the jet collections defined above and also add the corresponding
# genjets.
# captitalize string; needed below to construct pat module names.
def cap(s): return s[0].upper() + s[1:]
from PhysicsTools.PatAlgos.tools.jetTools import *
opts.register('verbosity', 0,
vpo.VarParsing.multiplicity.singleton,
vpo.VarParsing.varType.int,
'verbosity level')
opts.parseArguments()
###
### Puppi Sequence
###
import FWCore.ParameterSet.Config as cms
process = cms.Process('TEST')
from CommonTools.PileupAlgos.Puppi_cff import puppi as _puppi, puppiNoLep as _puppiNoLep
process.pfPuppi = _puppi.clone()
process.pfPuppiNoLep = _puppiNoLep.clone()
#process.pfPuppiPix = _puppi.clone(
# candName = 'particleFlow',
# vertexName = 'pixelVertices',
# UseFromPVLooseTight = True,
# vtxNdofCut = 0,
#)
#
#process.pfPuppiNoLepPix = _puppiNoLep.clone(
# candName = 'particleFlow',
# vertexName = 'pixelVertices',
# UseFromPVLooseTight = True,
# vtxNdofCut = 0,
#)
'''if not(runOnMC) and useJSON:
import FWCore.PythonUtilities.LumiList as LumiList
import FWCore.ParameterSet.Types as CfgTypes
process.source.lumisToProcess = CfgTypes.untracked(CfgTypes.VLuminosityBlockRange())
myLumis = LumiList.LumiList(filename = JSONfile).getCMSSWString().split(',')
process.source.lumisToProcess.extend(myLumis)
'''
####### Redo Jet clustering sequence ##########
from RecoJets.Configuration.RecoPFJets_cff import ak4PFJetsCHS, ak8PFJetsCHS, ak8PFJetsCHSPruned, ak8PFJetsCHSSoftDrop, ak8PFJetsCHSPrunedMass, ak8PFJetsCHSSoftDropMass# , ak8PFJetsCSTrimmed, ak8PFJetsCSFiltered, ak8PFJetsCHSFilteredMass, ak8PFJetsCHSTrimmedMass
from CommonTools.PileupAlgos.Puppi_cff import puppi
process.puppi = puppi.clone()
process.puppi.useExistingWeights = True
process.puppi.candName = cms.InputTag('packedPFCandidates')
process.puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
process.ak8PFJetsCHS = ak8PFJetsCHS.clone( src = 'puppi', jetPtMin = 100.0 )
process.ak8PFJetsCHSPruned = ak8PFJetsCHSPruned.clone( src = 'puppi', jetPtMin = 100.0 )
process.ak8PFJetsCHSPrunedMass = ak8PFJetsCHSPrunedMass.clone()
process.ak8PFJetsCHSSoftDrop = ak8PFJetsCHSSoftDrop.clone( src = 'puppi', jetPtMin = 100.0 )
process.ak8PFJetsCHSSoftDropMass = ak8PFJetsCHSSoftDropMass.clone()
process.NjettinessAK8 = cms.EDProducer("NjettinessAdder",
src = cms.InputTag("ak8PFJetsCHS"),
Njets = cms.vuint32(1, 2, 3, 4),
# variables for measure definition :
def load_pfParticle_sequence(proc, withLeptons):
from CommonTools.PileupAlgos.Puppi_cff import puppi
if withLeptons:
puppiR05 = puppi.clone()
setattr(proc, "puppiR05", puppiR05)
pfAllPhotonsPuppi = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("puppiR05"),
cut=cms.string("pdgId == 22"))
pfAllNeutralHadronsPuppi = cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("puppiR05"),
cut=cms.string(
"pdgId == 111 || pdgId == 130 || pdgId == 310 || pdgId == 2112"
))
pfAllChargedHadronsPuppi = cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("puppiR05"),
cut=cms.string(
"pdgId == 211 || pdgId == -211 || pdgId == 321 || pdgId == -321 || pdgId == 999211 || pdgId == 2212 || pdgId == -2212"
))
setattr(proc, "pfAllPhotonsPuppi", pfAllPhotonsPuppi)
setattr(proc, "pfAllNeutralHadronsPuppi", pfAllNeutralHadronsPuppi)
setattr(proc, "pfAllChargedHadronsPuppi", pfAllChargedHadronsPuppi)
pfParticlesForPUPPI = cms.Sequence()
pfParticlesForPUPPI += getattr(proc, "puppiR05")
pfParticlesForPUPPI += getattr(proc, "pfAllPhotonsPuppi")
pfParticlesForPUPPI += getattr(proc, "pfAllNeutralHadronsPuppi")
pfParticlesForPUPPI += getattr(proc, "pfAllChargedHadronsPuppi")
return pfParticlesForPUPPI
else:
packedPFCandidatesNoLep = cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("particleFlow"),
cut=cms.string("abs(pdgId) != 13 && abs(pdgId) != 11 "))
setattr(proc, "packedPFCandidatesNoLep", packedPFCandidatesNoLep)
puppiR05NoLep = puppi.clone(candName='packedPFCandidatesNoLep')
setattr(proc, "puppiR05NoLep", puppiR05NoLep)
pfAllPhotonsPuppiNoLep = cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("puppiR05NoLep"),
cut=cms.string("pdgId == 22"))
pfAllNeutralHadronsPuppiNoLep = cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("puppiR05NoLep"),
cut=cms.string(
"pdgId == 111 || pdgId == 130 || pdgId == 310 || pdgId == 2112"
))
pfAllChargedHadronsPuppiNoLep = cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("puppiR05NoLep"),
cut=cms.string(
"pdgId == 211 || pdgId == -211 || pdgId == 321 || pdgId == -321 || pdgId == 999211 || pdgId == 2212 || pdgId == -2212"
))
setattr(proc, "pfAllPhotonsPuppiNoLep", pfAllPhotonsPuppiNoLep)
setattr(proc, "pfAllNeutralHadronsPuppiNoLep",
pfAllNeutralHadronsPuppiNoLep)
setattr(proc, "pfAllChargedHadronsPuppiNoLep",
pfAllChargedHadronsPuppiNoLep)
pfParticlesForPUPPINoLep = cms.Sequence()
pfParticlesForPUPPINoLep += getattr(proc, "packedPFCandidatesNoLep")
pfParticlesForPUPPINoLep += getattr(proc, "puppiR05NoLep")
pfParticlesForPUPPINoLep += getattr(proc, "pfAllPhotonsPuppiNoLep")
pfParticlesForPUPPINoLep += getattr(proc,
"pfAllNeutralHadronsPuppiNoLep")
pfParticlesForPUPPINoLep += getattr(proc,
"pfAllChargedHadronsPuppiNoLep")
return pfParticlesForPUPPINoLep
def makeTreeTreeFromMiniAOD(process,
outFileName,
NJetsMin=2,
HTMin=350.,
MHTMin=0.,
reportEveryEvt=10,
testFileName="",
Global_Tag="",
METFiltersProcess="",
MC=False,
debug = False,
QCD=False,
LostLepton=False,
numProcessedEvt=1000,
doAK8Reclustering=False,
doJECCorrection=False,
doPuppi=False,
leptonFilter=True,
genJetsAK8Reclustering=True,
customizeHBHENoiseForEarlyData=False,
customizeHBHENoiseForRun2015D=True,
jsonFileName="",
reDoPruningAndSoftdrop=False,
isCrab=False):
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff")
if (MC):
customizeHBHENoiseForRun2015D=False
process.GlobalTag.globaltag = Global_Tag
## Added Geometry cfi files ###
## Not in current EXO-WW configuration ##
process.load("Geometry.CMSCommonData.cmsIdealGeometryXML_cfi");
process.load("Geometry.CaloEventSetup.CaloGeometry_cfi");
process.load("Geometry.CaloEventSetup.CaloTopology_cfi");
## --- Log output ------------------------------------------------------
process.load("FWCore.MessageService.MessageLogger_cfi")
process.MessageLogger.cerr = cms.untracked.PSet(
placeholder = cms.untracked.bool(True)
)
process.MessageLogger.cout = cms.untracked.PSet(
INFO = cms.untracked.PSet(reportEvery = cms.untracked.int32(reportEveryEvt))
)
process.options = cms.untracked.PSet(
wantSummary = cms.untracked.bool(True)
)
## --- Files to process ------------------------------------------------
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(numProcessedEvt)
)
process.source = cms.Source("PoolSource",
fileNames = cms.untracked.vstring(testFileName)
)
## ----------------------------------------------------------------------------------------------
## 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 SemiLeptonicWVA.Utils.triggerproducer_cfi import triggerProducer
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 = cms.vstring( # list of trigger names
'HLT_Ele22_eta2p1_WPTight_Gsf_v',
'HLT_IsoMu20_v',
'HLT_IsoTkMu20_v',
'HLT_Ele27_WP85_Gsf_v'
)
)
## --- Output file -----------------------------------------------------
process.TFileService = cms.Service(
"TFileService",
fileName = cms.string(outFileName+".root")
)
############### JSON Filter
import FWCore.PythonUtilities.LumiList as LumiList
import sys
if not MC:
if(len(jsonFileName)>0):
import FWCore.PythonUtilities.LumiList as LumiList
process.source.lumisToProcess = LumiList.LumiList(filename = jsonFileName).getVLuminosityBlockRange()
else:
print "ERROR!! running on data with no json file applied!"
sys.exit()
####### some gen infos
from SemiLeptonicWVA.Utils.geneventinfo_cfi import geneventinfo
process.GenEventInfo = geneventinfo.clone()
###Lepton Filter
process.filterSeq = cms.Sequence ()
process.load('SemiLeptonicWVA.Utils.leptonfilter_cfi')
process.leptonFilter.electronsInputTag = cms.InputTag("slimmedElectrons")
process.leptonFilter.muonsInputTag = cms.InputTag("slimmedMuons")
process.leptonFilter.eleFilterPtCut = cms.double(20.0)
process.leptonFilter.muFilterPtCut = cms.double(20.0)
if (leptonFilter):
process.filterSeq = cms.Sequence (process.leptonFilter)
## --- Setup of TreeMaker ----------------------------------------------
FilterNames = cms.VInputTag()
FilterNames.append(cms.InputTag("HBHENoiseFilterRA2","HBHENoiseFilterResult","PAT"))
FilterNames.append(cms.InputTag("beamHaloFilter"))
FilterNames.append(cms.InputTag("eeNoiseFilter"))
FilterNames.append(cms.InputTag("trackingFailureFilter"))
FilterNames.append(cms.InputTag("inconsistentMuons"))
FilterNames.append(cms.InputTag("greedyMuons"))
FilterNames.append(cms.InputTag("ra2EcalTPFilter"))
FilterNames.append(cms.InputTag("ra2EcalBEFilter"))
FilterNames.append(cms.InputTag("hcalLaserEventFilter"))
FilterNames.append(cms.InputTag("ecalLaserCorrFilter"))
FilterNames.append(cms.InputTag("eeBadScFilter"))
FilterNames.append(cms.InputTag("PBNRFilter"))
FilterNames.append(cms.InputTag("HCALLaserEvtFilterList2012"))
FilterNames.append(cms.InputTag("manystripclus53X"))
FilterNames.append(cms.InputTag("toomanystripclus53X"))
FilterNames.append(cms.InputTag("logErrorTooManyClusters"))
FilterNames.append(cms.InputTag("RA2HONoiseFilter"))
## --- Setup WeightProducer -------------------------------------------
from SemiLeptonicWVA.WeightProducer.getWeightProducer_cff import getWeightProducer
process.WeightProducer = getWeightProducer(testFileName)
process.WeightProducer.Lumi = cms.double(5000)
process.WeightProducer.PU = cms.int32(0) # PU S10 3 for S10 2 for S7
process.WeightProducer.FileNamePUDataDistribution = cms.string("NONE")
print process.WeightProducer.PU
from RecoBTag.Configuration.RecoBTag_cff import *
from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import *
process.slimmedJetsPFJetTracksAssociatorAtVertex = cms.EDProducer("JetTracksAssociatorAtVertex",
j2tParametersVX,
jets = cms.InputTag("iterativeCone5PFJets")
)
process.slimmedJetsPFJetTracksAssociatorAtVertex.jets = "slimmedJets"
process.slimmedJetsPFJetTracksAssociatorAtVertex.tracks = "generalTracks"
process.slimmedJetsPFImpactParameterTagInfos = impactParameterTagInfos.clone()
process.slimmedJetsPFImpactParameterTagInfos.jetTracks = "slimmedJetsPFJetTracksAssociatorAtVertex"
process.slimmedJetsPFSecondaryVertexTagInfos = secondaryVertexTagInfos.clone()
process.slimmedJetsPFSecondaryVertexTagInfos.trackIPTagInfos = "slimmedJetsPFImpactParameterTagInfos"
process.slimmedJetsPFJetBtaggingSV = cms.Sequence(
process.slimmedJetsPFImpactParameterTagInfos *
process.slimmedJetsPFSecondaryVertexTagInfos
)
process.slimmedJetsPFJetsBtag = cms.Sequence(
process.slimmedJetsPFJetTracksAssociatorAtVertex *
process.slimmedJetsPFJetBtaggingSV
)
## isotrack producer
from SemiLeptonicWVA.Utils.trackIsolationMaker_cfi import trackIsolationFilter
from SemiLeptonicWVA.Utils.trackIsolationMaker_cfi import trackIsolationCounter
## default
process.IsolatedTracks = trackIsolationFilter.clone(
doTrkIsoVeto= False,
vertexInputTag = cms.InputTag("offlineSlimmedPrimaryVertices"),
pfCandidatesTag = cms.InputTag("packedPFCandidates"),
dR_ConeSize = cms.double(0.3),
dz_CutValue = cms.double(0.05),
minPt_PFCandidate = cms.double(15.0),
isoCut = cms.double(0.1),
)
process.CountIsoTracks = trackIsolationCounter.clone(
src = cms.InputTag("IsolatedTracks"),
minNumber = 1,
)
process.substructureSequence = cms.Sequence()
process.softdrop_onMiniAOD = cms.Sequence()
process.pruning_onMiniAOD = cms.Sequence()
process.redoPatJets = cms.Sequence()
process.puppi_onMiniAOD = cms.Sequence()
process.redoPuppiJets = cms.Sequence()
if (doAK8Reclustering):
from RecoJets.Configuration.RecoPFJets_cff import ak4PFJetsCHS, ak8PFJetsCHS, ak8PFJetsCHSPruned, ak8PFJetsCHSSoftDrop, ak8PFJetsCHSPrunedMass, ak8PFJetsCHSSoftDropMass
process.chs = cms.EDFilter("CandPtrSelector",
src = cms.InputTag('packedPFCandidates'),
cut = cms.string('fromPV')
)
process.NjettinessAK8 = cms.EDProducer("NjettinessAdder",
src=cms.InputTag("ak8PFJetsCHS"),
Njets=cms.vuint32(1,2,3,4), # compute 1-, 2-, 3-, 4- subjettiness
# variables for measure definition :
measureDefinition = cms.uint32( 0 ), # CMS default is normalized measure
beta = cms.double(1.0), # CMS default is 1
R0 = cms.double( 0.8 ), # CMS default is jet cone size
Rcutoff = cms.double( -999.0), # not used by default
# variables for axes definition :
axesDefinition = cms.uint32( 6 ), # CMS default is 1-pass KT axes
nPass = cms.int32(-999), # not used by default
akAxesR0 = cms.double(-999.0) # not used by default
)
process.ak4PFJetsCHS = ak4PFJetsCHS.clone(src = 'chs')
process.ak8PFJetsCHS = ak8PFJetsCHS.clone( src = 'chs', jetPtMin = 100.0 )
process.ak8PFJetsCHSPruned = ak8PFJetsCHSPruned.clone( src = 'chs', jetPtMin = 100.0 )
process.ak8PFJetsCHSPrunedMass = ak8PFJetsCHSPrunedMass.clone()
process.ak8PFJetsCHSSoftDrop = ak8PFJetsCHSSoftDrop.clone( src = 'chs', jetPtMin = 100.0 )
process.ak8PFJetsCHSSoftDropMass = ak8PFJetsCHSSoftDropMass.clone()
process.substructureSequence+=process.chs
process.substructureSequence+=process.ak8PFJetsCHS
process.substructureSequence+=process.NjettinessAK8
process.softdrop_onMiniAOD += process.ak8PFJetsCHSSoftDrop + process.ak8PFJetsCHSSoftDropMass
process.pruning_onMiniAOD += process.ak8PFJetsCHSPruned + process.ak8PFJetsCHSPrunedMass
####### Redo pat jets sequence ##########
from ExoDiBosonResonances.EDBRJets.redoPatJets_cff import patJetCorrFactorsAK8, patJetsAK8, selectedPatJetsAK8
# Redo pat jets from ak8PFJetsCHS
process.patJetCorrFactorsAK8 = patJetCorrFactorsAK8.clone( src = 'ak8PFJetsCHS' )
process.patJetsAK8 = patJetsAK8.clone( jetSource = 'ak8PFJetsCHS' )
process.patJetsAK8.userData.userFloats.src = [ cms.InputTag("ak8PFJetsCHSPrunedMass"), cms.InputTag("ak8PFJetsCHSSoftDropMass"), cms.InputTag("NjettinessAK8:tau1"), cms.InputTag("NjettinessAK8:tau2"), cms.InputTag("NjettinessAK8:tau3")]
process.patJetsAK8.jetCorrFactorsSource = cms.VInputTag( cms.InputTag("patJetCorrFactorsAK8") )
process.selectedPatJetsAK8 = selectedPatJetsAK8.clone( cut = cms.string('pt > 20') )
process.redoPatJets+=process.patJetCorrFactorsAK8
process.redoPatJets+=process.patJetsAK8
process.redoPatJets+=process.selectedPatJetsAK8
if (reDoPruningAndSoftdrop):
process.patJetCorrFactorsAK8Pruned = patJetCorrFactorsAK8.clone( src = 'ak8PFJetsCHSPruned' )
process.patJetsAK8Pruned = patJetsAK8.clone( jetSource = 'ak8PFJetsCHSPruned' )
process.patJetsAK8Pruned.userData.userFloats.src = [ "" ]
process.patJetsAK8Pruned.jetCorrFactorsSource = cms.VInputTag( cms.InputTag("patJetCorrFactorsAK8Pruned") )
process.selectedPatJetsAK8Pruned = selectedPatJetsAK8.clone(
src = cms.InputTag('patJetsAK8Pruned'),
cut = cms.string('pt > 20')
)
process.redoPatJets+=process.patJetCorrFactorsAK8Pruned
process.redoPatJets+=process.patJetsAK8Pruned
process.redoPatJets+=process.selectedPatJetsAK8Pruned
process.patJetCorrFactorsAK8Softdrop = patJetCorrFactorsAK8.clone( src = 'ak8PFJetsCHSSoftDrop' )
process.patJetsAK8Softdrop = patJetsAK8.clone( jetSource = 'ak8PFJetsCHSSoftDrop' )
process.patJetsAK8Softdrop.userData.userFloats.src = [ "" ]
process.patJetsAK8Softdrop.jetCorrFactorsSource = cms.VInputTag( cms.InputTag("patJetCorrFactorsAK8Softdrop") )
process.selectedPatJetsAK8Softdrop = selectedPatJetsAK8.clone(
src = cms.InputTag('patJetsAK8Softdrop'),
cut = cms.string('pt > 20')
)
process.redoPatJets+=process.patJetCorrFactorsAK8Softdrop
process.redoPatJets+=process.patJetsAK8Softdrop
process.redoPatJets+=process.selectedPatJetsAK8Softdrop
if (doPuppi):
from CommonTools.PileupAlgos.Puppi_cff import puppi
from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi
process.ak8PFJetsPuppi = ak4PFJetsPuppi.clone( rParam = 0.8 )
process.puppi = puppi.clone( candName = cms.InputTag('packedPFCandidates'),
vertexName = cms.InputTag('offlineSlimmedPrimaryVertices'))
process.puppi_onMiniAOD = cms.Sequence(process.puppi + process.ak8PFJetsPuppi)
from RecoJets.Configuration.RecoPFJets_cff import ak4PFJetsCHS, ak8PFJetsCHS, ak8PFJetsCHSPruned, ak8PFJetsCHSSoftDrop, ak8PFJetsCHSPrunedMass, ak8PFJetsCHSSoftDropMass
process.NjettinessAK8 = cms.EDProducer("NjettinessAdder",
src=cms.InputTag("ak8PFJetsPuppi"),
Njets=cms.vuint32(1,2,3,4), # compute 1-, 2-, 3-, 4- subjettiness
# variables for measure definition :
measureDefinition = cms.uint32( 0 ), # CMS default is normalized measure
beta = cms.double(1.0), # CMS default is 1
R0 = cms.double( 0.8 ), # CMS default is jet cone size
Rcutoff = cms.double( -999.0), # not used by default
# variables for axes definition :
axesDefinition = cms.uint32( 6 ), # CMS default is 1-pass KT axes
nPass = cms.int32(-999), # not used by default
akAxesR0 = cms.double(-999.0) # not used by default
)
process.ak4PFJetsPuppi = ak4PFJetsPuppi.clone(src = 'puppi')
process.ak8PFJetsPuppi = process.ak8PFJetsPuppi.clone( src = 'puppi', jetPtMin = 100.0 )
process.ak8PFJetsCHSPruned = ak8PFJetsCHSPruned.clone( src = 'puppi', jetPtMin = 100.0 )
process.ak8PFJetsCHSPrunedMass = ak8PFJetsCHSPrunedMass.clone(
matched = cms.InputTag("ak8PFJetsCHSPruned"),
src = cms.InputTag("ak8PFJetsPuppi")
)
process.ak8PFJetsCHSSoftDrop = ak8PFJetsCHSSoftDrop.clone( src = 'puppi', jetPtMin = 100.0 )
process.ak8PFJetsCHSSoftDropMass = ak8PFJetsCHSSoftDropMass.clone(
matched = cms.InputTag("ak8PFJetsCHSSoftDrop"),
src = cms.InputTag("ak8PFJetsPuppi")
)
process.substructureSequence+=process.puppi
process.substructureSequence+=process.ak8PFJetsPuppi
process.substructureSequence+=process.NjettinessAK8
process.softdrop_onMiniAOD += process.ak8PFJetsCHSSoftDrop + process.ak8PFJetsCHSSoftDropMass
process.pruning_onMiniAOD += process.ak8PFJetsCHSPruned + process.ak8PFJetsCHSPrunedMass
####### Redo pat jets sequence ##########
from ExoDiBosonResonances.EDBRJets.redoPatJets_cff import patJetCorrFactorsAK8, patJetsAK8, selectedPatJetsAK8
# Redo pat jets from puppi AK8
process.puppiJetCorrFactorsAK8 = patJetCorrFactorsAK8.clone( src = 'ak8PFJetsPuppi',
levels = cms.vstring('L2Relative',
'L3Absolute')
)
process.puppiJetsAK8 = patJetsAK8.clone( jetSource = 'ak8PFJetsPuppi' )
process.puppiJetsAK8.userData.userFloats.src = [ cms.InputTag("ak8PFJetsCHSPrunedMass"), cms.InputTag("ak8PFJetsCHSSoftDropMass"), cms.InputTag("NjettinessAK8:tau1"), cms.InputTag("NjettinessAK8:tau2"), cms.InputTag("NjettinessAK8:tau3")]
process.puppiJetsAK8.jetCorrFactorsSource = cms.VInputTag( cms.InputTag("puppiJetCorrFactorsAK8") )
process.selectedPuppiJetsAK8 = selectedPatJetsAK8.clone( src = 'puppiJetsAK8', cut = cms.string('pt > 20') )
process.redoPuppiJets+=process.puppiJetCorrFactorsAK8
process.redoPuppiJets+=process.puppiJetsAK8
process.redoPuppiJets+=process.selectedPuppiJetsAK8
#######AK8 GEN JETS################
process.substructureSequenceGen = cms.Sequence()
process.softdropGen_onMiniAOD = cms.Sequence()
process.pruningGen_onMiniAOD = cms.Sequence()
process.redoGenJets = cms.Sequence()
# process.puppi_onMiniAOD = cms.Sequence()
if (genJetsAK8Reclustering and MC):
from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
process.ak8GenJets = ak4GenJets.clone(src = cms.InputTag('packedGenParticles'),
rParam = cms.double(0.8)
)
from RecoJets.Configuration.RecoPFJets_cff import ak4PFJetsCHS, ak8PFJetsCHS, ak8PFJetsCHSPruned, ak8PFJetsCHSSoftDrop, ak8PFJetsCHSPrunedMass, ak8PFJetsCHSSoftDropMass
process.NjettinessGenAK8 = cms.EDProducer("NjettinessAdder",
src=cms.InputTag("ak8GenJets"),
Njets=cms.vuint32(1,2,3,4), # compute 1-, 2-, 3-, 4- subjettiness
# variables for measure definition :
measureDefinition = cms.uint32( 0 ), # CMS default is normalized measure
beta = cms.double(1.0), # CMS default is 1
R0 = cms.double( 0.8 ), # CMS default is jet cone size
Rcutoff = cms.double( -999.0), # not used by default
# variables for axes definition :
axesDefinition = cms.uint32( 6 ), # CMS default is 1-pass KT axes
nPass = cms.int32(-999), # not used by default
akAxesR0 = cms.double(-999.0) # not used by default
)
process.genParticlesForJets = cms.EDProducer("InputGenJetsParticleSelector",
src = cms.InputTag("packedGenParticles"),
ignoreParticleIDs = cms.vuint32(
1000022,
1000012, 1000014, 1000016,
2000012, 2000014, 2000016,
1000039, 5100039,
4000012, 4000014, 4000016,
9900012, 9900014, 9900016,
39),
partonicFinalState = cms.bool(False),
excludeResonances = cms.bool(False),
excludeFromResonancePids = cms.vuint32(12, 13, 14, 16),
tausAsJets = cms.bool(False)
)
from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters
process.ak8GenJetsPruned = ak4GenJets.clone(
SubJetParameters,
rParam = cms.double(0.8),
src = cms.InputTag("genParticlesForJets"),
usePruning = cms.bool(True),
writeCompound = cms.bool(True),
jetCollInstanceName=cms.string("SubJets")
)
# process.ak8GenJetsPruned = ak8PFJetsCHSPruned.clone( src = 'packedGenParticles', jetPtMin = 100.0 )
process.ak8GenJetsPrunedMass = ak8PFJetsCHSPrunedMass.clone(
matched = cms.InputTag("ak8GenJetsPruned"),
src = cms.InputTag("ak8GenJets")
)
process.ak8GenJetsSoftDrop = ak4GenJets.clone(
SubJetParameters,
rParam = cms.double(0.8),
src = cms.InputTag("genParticlesForJets"),
useSoftDrop = cms.bool(True),
R0 = cms.double(0.8),
beta = cms.double(0.0),
writeCompound = cms.bool(True),
jetCollInstanceName=cms.string("SubJets")
)
process.ak8GenJetsSoftDropMass = ak8PFJetsCHSSoftDropMass.clone(
matched = cms.InputTag("ak8GenJetsSoftDrop"),
src = cms.InputTag("ak8GenJets")
)
process.substructureSequenceGen+=process.genParticlesForJets
process.substructureSequenceGen+=process.ak8GenJets
process.substructureSequenceGen+=process.NjettinessGenAK8
process.softdropGen_onMiniAOD += process.ak8GenJetsSoftDrop + process.ak8GenJetsSoftDropMass
process.pruningGen_onMiniAOD += process.ak8GenJetsPruned + process.ak8GenJetsPrunedMass
####### Redo pat jets sequence ##########
from ExoDiBosonResonances.EDBRJets.redoPatJets_cff import patJetCorrFactorsAK8, patJetsAK8, selectedPatJetsAK8
# Redo pat jets from gen AK8
process.genJetsAK8 = patJetsAK8.clone( jetSource = 'ak8GenJets' )
process.genJetsAK8.userData.userFloats.src = [ cms.InputTag("ak8GenJetsPrunedMass"), cms.InputTag("ak8GenJetsSoftDropMass"), cms.InputTag("NjettinessGenAK8:tau1"), cms.InputTag("NjettinessGenAK8:tau2"), cms.InputTag("NjettinessGenAK8:tau3")]
process.genJetsAK8.addJetCorrFactors = cms.bool(False)
process.genJetsAK8.jetCorrFactorsSource = cms.VInputTag( cms.InputTag("") )
process.selectedGenJetsAK8 = selectedPatJetsAK8.clone( src = 'genJetsAK8', cut = cms.string('pt > 20') )
process.redoGenJets+=process.genJetsAK8
process.redoGenJets+=process.selectedGenJetsAK8
######### A4PF-nonCHS jets ###########
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
process.ak4PFJets = ak4PFJets.clone(src = "packedPFCandidates")
from SemiLeptonicWVA.Utils.ak4pfjets_cfi import patJetCorrFactorsAK4, patJetsAK4
process.patJetCorrFactorsAK4 = patJetCorrFactorsAK4.clone( src = 'ak4PFJets' )
process.patJetsAK4 = patJetsAK4.clone( jetSource = 'ak4PFJets' )
#
# Set up electron ID (VID framework)
#
from PhysicsTools.SelectorUtils.tools.vid_id_tools import *
# turn on VID producer, indicate data format to be
# DataFormat.AOD or DataFormat.MiniAOD, as appropriate
dataFormat=DataFormat.MiniAOD
switchOnVIDElectronIdProducer(process,dataFormat)
process.egmGsfElectronIDSequence = cms.Sequence(process.egmGsfElectronIDs)
# define which IDs we want to produce
my_id_modules = ['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff']
#add them to the VID producer
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection)
# Producers
from SemiLeptonicWVA.Utils.electron_cfi import electron
process.Electrons = electron.clone(
VertexTag = cms.InputTag("offlineSlimmedPrimaryVertices"),
EleTag = cms.InputTag("slimmedElectrons"),
MinPt = cms.double(-1),
RhoTag = cms.InputTag("fixedGridRhoFastjetAll"),
eleVetoIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-veto"),
eleLooseIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-loose"),
eleMediumIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-medium"),
eleTightIdMap = cms.InputTag("egmGsfElectronIDs:cutBasedElectronID-Spring15-25ns-V1-standalone-tight"),
eleHEEPIdMap = cms.InputTag("egmGsfElectronIDs:heepElectronID-HEEPV60")
)
# Add in Photons:
switchOnVIDPhotonIdProducer(process, dataFormat)
my_id_modules = ['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_25ns_V1_cff']
for idmod in my_id_modules:
setupAllVIDIdsInModule(process,idmod,setupVIDPhotonSelection)
from SemiLeptonicWVA.Utils.photon_cfi import photon
process.Photons = photon.clone(
PhoTag = cms.InputTag("slimmedPhotons"),
phoLooseIdMap = cms.InputTag("egmPhotonIDs:cutBasedPhotonID-Spring15-25ns-V1-standalone-loose"),
phoMediumIdMap = cms.InputTag("egmPhotonIDs:cutBasedPhotonID-Spring15-25ns-V1-standalone-medium"),
phoTightIdMap = cms.InputTag("egmPhotonIDs:cutBasedPhotonID-Spring15-25ns-V1-standalone-tight"),
phoTightIdFullInfoMap = cms.InputTag("egmPhotonIDs:cutBasedPhotonID-Spring15-25ns-V1-standalone-tight")
)
from SemiLeptonicWVA.Utils.muon_cfi import muon
process.Muons = muon.clone(
VertexTag = cms.InputTag("offlineSlimmedPrimaryVertices"),
MuTag = cms.InputTag("slimmedMuons"),
MinPt = cms.double(-1),
RhoTag = cms.InputTag("fixedGridRhoFastjetAll")
)
from SemiLeptonicWVA.Utils.subJetSelection_cfi import SubJetSelection
process.HTJets = SubJetSelection.clone(
JetTag = cms.InputTag('slimmedJets'),
MinPt = cms.double(50),
MaxEta = cms.double(2.5),
)
from SemiLeptonicWVA.Utils.htdouble_cfi import htdouble
process.HT = htdouble.clone(
JetTag = cms.InputTag('HTJets'),
)
from SemiLeptonicWVA.Utils.njetint_cfi import njetint
process.NJets = njetint.clone(
JetTag = cms.InputTag('HTJets'),
)
from SemiLeptonicWVA.Utils.btagint_cfi import btagint
process.BTags = btagint.clone(
JetTag = cms.InputTag('HTJets'),
BTagInputTag = cms.string('combinedInclusiveSecondaryVertexV2BJetTags'),
BTagCutValue = cms.double(0.679)
)
from SemiLeptonicWVA.Utils.subJetSelection_cfi import SubJetSelection
process.MHTJets = SubJetSelection.clone(
JetTag = cms.InputTag('slimmedJets'),
MinPt = cms.double(30),
MaxEta = cms.double(5.0),
)
process.MHTJetsAK8 = SubJetSelection.clone(
JetTag = cms.InputTag('slimmedJetsAK8'),
MinPt = cms.double(30),
MaxEta = cms.double(5.0),
)
from SemiLeptonicWVA.Utils.jetproperties_cfi import jetproperties
process.MHTJetsProperties = jetproperties.clone(
JetTag = cms.InputTag('MHTJets'),
doJEC = cms.bool(doJECCorrection),
L1File = cms.string("Summer15_25nsV7_DATA_L1FastJet_AK4PFchs.txt"),
L2File = cms.string("Summer15_25nsV7_DATA_L2Relative_AK4PFchs.txt"),
L3File = cms.string("Summer15_25nsV7_DATA_L3Absolute_AK4PFchs.txt"),
L2L3File = cms.string("Summer15_25nsV7_DATA_L2L3Residual_AK4PFchs.txt"),
)
from SemiLeptonicWVA.Utils.jetpropertiesAK8_cfi import jetpropertiesAK8
process.MHTJetsPropertiesAK8 = jetpropertiesAK8.clone(
JetTag = cms.InputTag('MHTJetsAK8'),
puppiJetTag = cms.InputTag('selectedPuppiJetsAK8'),
doJEC = cms.bool(doJECCorrection),
doReclusteringForPrunedAndSoftdrop = cms.bool(reDoPruningAndSoftdrop),
L1File = cms.string("Summer15_25nsV7_DATA_L1FastJet_AK8PFchs.txt"),
L2File = cms.string("Summer15_25nsV7_DATA_L2Relative_AK8PFchs.txt"),
L3File = cms.string("Summer15_25nsV7_DATA_L3Absolute_AK8PFchs.txt"),
L2L3File = cms.string("Summer15_25nsV7_DATA_L2L3Residual_AK8PFchs.txt"),
)
if (reDoPruningAndSoftdrop):
process.MHTJetsPropertiesAK8.prunedJetTag = cms.InputTag('selectedPatJetsAK8Pruned')
process.MHTJetsPropertiesAK8.softdropJetTag = cms.InputTag('selectedPatJetsAK8Softdrop')
else:
process.MHTJetsPropertiesAK8.prunedJetTag = cms.InputTag('slimmedJetsAK8')
process.MHTJetsPropertiesAK8.softdropJetTag = cms.InputTag('slimmedJetsAK8')
if (MC):
process.MHTJetsProperties.L1File = cms.string("Summer15_25nsV7_MC_L1FastJet_AK4PFchs.txt")
process.MHTJetsProperties.L2File = cms.string("Summer15_25nsV7_MC_L2Relative_AK4PFchs.txt")
process.MHTJetsProperties.L3File = cms.string("Summer15_25nsV7_MC_L3Absolute_AK4PFchs.txt")
process.MHTJetsProperties.L2L3File = cms.string("NONE")
process.MHTJetsPropertiesAK8.L1File = cms.string("Summer15_25nsV7_MC_L1FastJet_AK8PFchs.txt")
process.MHTJetsPropertiesAK8.L2File = cms.string("Summer15_25nsV7_MC_L2Relative_AK8PFchs.txt")
process.MHTJetsPropertiesAK8.L3File = cms.string("Summer15_25nsV7_MC_L3Absolute_AK8PFchs.txt")
process.MHTJetsPropertiesAK8.L2L3File = cms.string("NONE")
from SemiLeptonicWVA.Utils.jetproperties_cfi import jetproperties
process.JetsProperties = jetproperties.clone(
JetTag = cms.InputTag('slimmedJets'),
MinPt = cms.double(-1),
doJEC = cms.bool(doJECCorrection),
L1File = cms.string("Summer15_25nsV7_DATA_L1FastJet_AK4PFchs.txt"),
L2File = cms.string("Summer15_25nsV7_DATA_L2Relative_AK4PFchs.txt"),
L3File = cms.string("Summer15_25nsV7_DATA_L3Absolute_AK4PFchs.txt"),
L2L3File = cms.string("Summer15_25nsV7_DATA_L2L3Residual_AK4PFchs.txt"),
)
from SemiLeptonicWVA.Utils.jetpropertiesAK8_cfi import jetpropertiesAK8
process.JetsPropertiesAK8 = jetpropertiesAK8.clone(
JetTag = cms.InputTag('slimmedJetsAK8'),
MinPt = cms.double(-1),
doJEC = cms.bool(doJECCorrection),
doReclusteringForPrunedAndSoftdrop = cms.bool(reDoPruningAndSoftdrop),
L1File = cms.string("Summer15_25nsV7_DATA_L1FastJet_AK8PFchs.txt"),
L2File = cms.string("Summer15_25nsV7_DATA_L2Relative_AK8PFchs.txt"),
L3File = cms.string("Summer15_25nsV7_DATA_L3Absolute_AK8PFchs.txt"),
L2L3File = cms.string("Summer15_25nsV7_DATA_L2L3Residual_AK8PFchs.txt"),
)
if (reDoPruningAndSoftdrop):
process.JetsPropertiesAK8.prunedJetTag = cms.InputTag('selectedPatJetsAK8Pruned')
process.JetsPropertiesAK8.softdropJetTag = cms.InputTag('selectedPatJetsAK8Softdrop')
else:
process.JetsPropertiesAK8.prunedJetTag = cms.InputTag('slimmedJetsAK8')
process.JetsPropertiesAK8.softdropJetTag = cms.InputTag('slimmedJetsAK8')
if (MC):
process.JetsProperties.L1File = cms.string("Summer15_25nsV7_MC_L1FastJet_AK4PFchs.txt")
process.JetsProperties.L2File = cms.string("Summer15_25nsV7_MC_L2Relative_AK4PFchs.txt")
process.JetsProperties.L3File = cms.string("Summer15_25nsV7_MC_L3Absolute_AK4PFchs.txt")
process.JetsProperties.L2L3File = cms.string("NONE")
process.JetsPropertiesAK8.L1File = cms.string("Summer15_25nsV7_MC_L1FastJet_AK8PFchs.txt")
process.JetsPropertiesAK8.L2File = cms.string("Summer15_25nsV7_MC_L2Relative_AK8PFchs.txt")
process.JetsPropertiesAK8.L3File = cms.string("Summer15_25nsV7_MC_L3Absolute_AK8PFchs.txt")
process.JetsPropertiesAK8.L2L3File = cms.string("NONE")
if doAK8Reclustering:
process.JetsPropertiesAK8.JetTag = cms.InputTag('selectedPatJetsAK8')
if doPuppi:
process.JetsPropertiesAK8.JetTag = cms.InputTag('selectedPuppiJetsAK8')
from SemiLeptonicWVA.Utils.mhtdouble_cfi import mhtdouble
process.MHT = mhtdouble.clone(
JetTag = cms.InputTag('MHTJets'),
)
from SemiLeptonicWVA.Utils.deltaphidouble_cfi import deltaphidouble
process.DeltaPhi = deltaphidouble.clone(
DeltaPhiJets = cms.InputTag('HTJets'),
MHTJets = cms.InputTag("MHTJets"),
)
from SemiLeptonicWVA.Utils.metdouble_cfi import metdouble
process.MET = metdouble.clone(
METTag = cms.InputTag("slimmedMETs"),
JetTag = cms.InputTag('slimmedJets'),
doJEC = cms.bool(doJECCorrection),
L1File = cms.string("Summer15_25nsV7_DATA_L1FastJet_AK4PFchs.txt"),
L2File = cms.string("Summer15_25nsV7_DATA_L2Relative_AK4PFchs.txt"),
L3File = cms.string("Summer15_25nsV7_DATA_L3Absolute_AK4PFchs.txt"),
L2L3File = cms.string("Summer15_25nsV7_DATA_L2L3Residual_AK4PFchs.txt"),
MuTag = cms.InputTag("slimmedMuons"),
RhoTag = cms.InputTag("fixedGridRhoFastjetAll"),
corrMet = cms.bool(doJECCorrection),
)
if (MC):
process.MET.L1File = cms.string("Summer15_25nsV7_MC_L1FastJet_AK4PFchs.txt")
process.MET.L2File = cms.string("Summer15_25nsV7_MC_L2Relative_AK4PFchs.txt")
process.MET.L3File = cms.string("Summer15_25nsV7_MC_L3Absolute_AK4PFchs.txt")
process.MET.L2L3File = cms.string("NONE")
from SemiLeptonicWVA.Utils.primaryverticies_cfi import primaryverticies
process.NVtx = primaryverticies.clone(
VertexCollection = cms.InputTag('offlineSlimmedPrimaryVertices'),
)
from SemiLeptonicWVA.Utils.genLeptonRecoCand_cfi import genLeptonRecoCand
process.GenLeptons = genLeptonRecoCand.clone(
PrunedGenParticleTag = cms.InputTag("prunedGenParticles"),
)
from SemiLeptonicWVA.Utils.genJet_cfi import genJet
process.GenJets = genJet.clone(
GenJetCollTag = cms.InputTag("slimmedGenJets"),
)
from SemiLeptonicWVA.Utils.genJetAK8_cfi import genJetAK8
process.GenJetsAK8 = genJetAK8.clone(
GenJetCollTag = cms.InputTag("selectedGenJetsAK8"),
)
if not MC:
process.GenLeptons = cms.Sequence()
process.GenJets = cms.Sequence()
process.GenJetsAK8 = cms.Sequence()
##### MET filters #####
#### -----> MET Filter Flags from MiniAOD/TWiki <----- ####
import HLTrigger.HLTfilters.triggerResultsFilter_cfi as hlt
process.metBits_miniAOD = hlt.triggerResultsFilter.clone()
# default is to use the latest process (but can set different process through Commandline Args)
process.metBits_miniAOD.hltResults = cms.InputTag('TriggerResults::%s'%METFiltersProcess)
process.metBits_miniAOD.l1tResults = cms.InputTag('')
#currently configured for CSCTightHaloFilter + GoodVertices
met_bits = ['(Flag_CSCTightHaloFilter)','(Flag_goodVertices)','(Flag_eeBadScFilter)']
bitsexpr = ' AND '.join(met_bits)
process.metBits_miniAOD.triggerConditions = cms.vstring(bitsexpr)
#### -----> HBHE noise filter <----- ####
process.load('CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi')
process.HBHENoiseFilterResultProducer.minZeros = cms.int32(99999)
process.HBHENoiseFilterResultProducer.IgnoreTS4TS5ifJetInLowBVRegion=cms.bool(False)
process.HBHENoiseFilterResultProducer.defaultDecision = cms.string("HBHENoiseFilterResultRun2Loose")
########## save flags for filters
from SemiLeptonicWVA.Utils.filterproducer_cfi import filterProducer
process.FilterProducer = filterProducer.clone(
noiseFilterTag = cms.InputTag("TriggerResults"),
HBHENoiseFilter_Selector_ = cms.string("Flag_HBHENoiseFilter"),
HBHENoiseIsoFilter_Selector_ = cms.string("Flag_HBHENoiseIsoFilter"),
CSCHaloNoiseFilter_Selector_ = cms.string("Flag_CSCTightHaloFilter"),
GoodVtxNoiseFilter_Selector_ = cms.string("Flag_goodVertices"),
EEBadScNoiseFilter_Selector_ = cms.string("Flag_eeBadScFilter"),
HBHENoiseFilterLoose = cms.InputTag("HBHENoiseFilterResultProducer", "HBHENoiseFilterResultRun2Loose"),
HBHENoiseFilterTight = cms.InputTag("HBHENoiseFilterResultProducer", "HBHENoiseFilterResultRun2Tight"),
HBHENoiseIsoFilter = cms.InputTag("HBHENoiseFilterResultProducer", "HBHEIsoNoiseFilterResult")
)
RecoCandVector = cms.vstring()
RecoCandVector.extend(['IsolatedTracks']) # basic muons electrons and isoalted tracks
RecoCandVector.extend(['GenLeptons:Boson(GenBoson)|GenLeptons:BosonPDGId(I_GenBosonPDGId)','GenLeptons:Muon(GenMu)|GenLeptons:MuonTauDecay(I_GenMuFromTau)' ,'GenLeptons:Electron(GenElec)|GenLeptons:ElectronTauDecay(I_GenElecFromTau)','GenLeptons:Tau(GenTau)|GenLeptons:TauHadronic(I_GenTauHad)','GenLeptons:Neutrino(GenNu)'] ) # gen information on leptons
RecoCandVector.extend(['GenJets:GenJet(GenJets)'] ) # gen information on jets
RecoCandVector.extend(['GenJetsAK8:GenJetAK8(GenJetsAK8)|GenJetsAK8:GenAK8prunedMass(F_prunedMass)|GenJetsAK8:GenAK8softdropMass(F_softdropMass)|GenJetsAK8:GenAK8tau1(F_tau1)|GenJetsAK8:GenAK8tau2(F_tau2)|GenJetsAK8:GenAK8tau3(F_tau3)'] ) # gen information on AK8 jets
RecoCandVector.extend(['JetsProperties(Jets)|JetsProperties:bDiscriminatorCSV(F_bDiscriminatorCSV)|JetsProperties:bDiscriminatorICSV(F_bDiscriminatorICSV)|JetsProperties:chargedEmEnergyFraction(F_chargedEmEnergyFraction)|JetsProperties:chargedHadronEnergyFraction(F_chargedHadronEnergyFraction)|JetsProperties:chargedHadronMultiplicity(I_chargedHadronMultiplicity)|JetsProperties:electronMultiplicity(I_electronMultiplicity)|JetsProperties:jetArea(F_jetArea)|JetsProperties:muonEnergyFraction(F_muonEnergyFraction)|JetsProperties:muonMultiplicity(I_muonMultiplicity)|JetsProperties:neutralEmEnergyFraction(F_neutralEmEnergyFraction)|JetsProperties:neutralHadronMultiplicity(I_neutralHadronMultiplicity)|JetsProperties:photonEnergyFraction(F_photonEnergyFraction)|JetsProperties:photonMultiplicity(I_photonMultiplicity)|JetsProperties:isLooseJetId(b_isLooseJetId)|JetsProperties:isTightJetId(b_isTightJetId)|JetsProperties:isTightLepVetoJetId(b_isTightLepVetoJetId)|JetsProperties:PtCorr(F_PtCorr)|JetsProperties:EtaCorr(F_EtaCorr)|JetsProperties:PhiCorr(F_PhiCorr)|JetsProperties:ECorr(F_ECorr)'] ) # jet information on various variables
RecoCandVector.extend(['JetsPropertiesAK8(AK8Jets)|JetsPropertiesAK8:AK8bDiscriminatorCSV(F_bDiscriminatorCSV)|JetsPropertiesAK8:AK8bDiscriminatorICSV(F_bDiscriminatorICSV)|JetsPropertiesAK8:AK8chargedEmEnergyFraction(F_chargedEmEnergyFraction)|JetsPropertiesAK8:AK8chargedHadronEnergyFraction(F_chargedHadronEnergyFraction)|JetsPropertiesAK8:AK8chargedHadronMultiplicity(I_chargedHadronMultiplicity)|JetsPropertiesAK8:AK8electronMultiplicity(I_electronMultiplicity)|JetsPropertiesAK8:AK8jetArea(F_jetArea)|JetsPropertiesAK8:AK8muonEnergyFraction(F_muonEnergyFraction)|JetsPropertiesAK8:AK8muonMultiplicity(I_muonMultiplicity)|JetsPropertiesAK8:AK8neutralEmEnergyFraction(F_neutralEmEnergyFraction)|JetsPropertiesAK8:AK8neutralHadronMultiplicity(I_neutralHadronMultiplicity)|JetsPropertiesAK8:AK8photonEnergyFraction(F_photonEnergyFraction)|JetsPropertiesAK8:AK8photonMultiplicity(I_photonMultiplicity)|JetsPropertiesAK8:AK8prunedMass(F_prunedMass)|JetsPropertiesAK8:AK8softDropMass(F_softDropMass)|JetsPropertiesAK8:AK8trimmedMass(F_trimmedMass)|JetsPropertiesAK8:AK8filteredMass(F_filteredMass)|JetsPropertiesAK8:AK8tau1(F_tau1)|JetsPropertiesAK8:AK8tau2(F_tau2)|JetsPropertiesAK8:AK8tau3(F_tau3)|JetsPropertiesAK8:AK8isLooseJetId(b_AK8isLooseJetId)|JetsPropertiesAK8:AK8isTightJetId(b_AK8isTightJetId)|JetsPropertiesAK8:AK8isTightLepVetoJetId(b_AK8isTightLepVetoJetId)|JetsPropertiesAK8:PtCorr(F_PtCorr)|JetsPropertiesAK8:EtaCorr(F_EtaCorr)|JetsPropertiesAK8:PhiCorr(F_PhiCorr)|JetsPropertiesAK8:ECorr(F_ECorr)'] ) # AK8 jet information on various variables
#
RecoCandVector.extend(['Electrons(Electrons)|Electrons:charge(I_charge)|Electrons:isHEEP(b_isHEEP)|Electrons:type(I_type)|Electrons:mass(F_mass)|Electrons:pfDeltaCorrRelIso(F_pfDeltaCorrRelIso)|Electrons:pfRhoCorrRelIso04(F_pfRhoCorrRelIso04)|Electrons:pfRhoCorrRelIso03(F_pfRhoCorrRelIso03)|Electrons:pfRelIso(F_pfRelIso)|Electrons:photonIso(F_photonIso)|Electrons:neutralHadIso(F_neutralHadIso)|Electrons:chargedHadIso(F_chargedHadIso)|Electrons:trackIso(F_trackIso)|Electrons:isLoose(b_isLoose)|Electrons:isMedium(b_isMedium)|Electrons:isTight(b_isTight)|Electrons:SCEnergy(F_SCEnergy)|Electrons:deltaEtaSCTracker(F_deltaEtaSCTracker)|Electrons:deltaPhiSCTracker(F_deltaPhiSCTracker)|Electrons:sigmaIetaIeta(F_sigmaIetaIeta)|Electrons:sigmaIphiIphi(F_sigmaIphiIphi)'] ) # electron information on various variables
RecoCandVector.extend(['Muons(Muons)|Muons:charge(I_charge)|Muons:isHighPt(b_isHighPt)|Muons:type(I_type)|Muons:mass(F_mass)|Muons:pfDeltaCorrRelIso(F_pfDeltaCorrRelIso)|Muons:pfRelIso(F_pfRelIso)|Muons:photonIso(F_photonIso)|Muons:neutralHadIso(F_neutralHadIso)|Muons:chargedHadIso(F_chargedHadIso)|Muons:trackIso(F_trackIso)|Muons:isLoose(b_isLoose)|Muons:isMedium(b_isMedium)|Muons:isTight(b_isTight)|Muons:isPFMuon(b_isPFMuon)'] ) # muon information on various variables
RecoCandVector.extend(['Photons(Photons)|Photons:isLoose(b_isLoose)|Photons:isMedium(b_isMedium)|Photons:isTight(b_isTight)|Photons:minPt(F_minPt)|Photons:phoSCEtaMultiRange(F_phoSCEtaMultiRange)|Photons:phoSingleTowerHadOverEm(F_phoSingleTowerHadOverEm)|Photons:phoFull5x5SigmaIEtaIEta(F_phoFull5x5SigmaIEtaIEta)|Photons:phoAnyPFIsoWithEA(F_phoAnyPFIsoWithEA)|Photons:phoAnyPFIsoWithEAAndExpoScaling(F_phoAnyPFIsoWithEAAndExpoScaling)|Photons:phoAnyPFIsoWithEA1(F_phoAnyPFIsoWithEA1)|Photons:hasPixelSeed(b_hasPixelSeed)|Photons:passElectronVeto(b_passElectronVeto)|Photons:photonIso(F_photonIso)|Photons:neutralHadIso(F_neutralHadIso)|Photons:chargedHadIso(F_chargedHadIso)|Photons:puChargedHadIso(F_puChargedHadIso)|Photons:sigmaIetaIeta(F_sigmaIetaIeta)'] ) # photon information on various variables
from SemiLeptonicWVA.TreeMaker.treeMaker import TreeMaker
process.TreeMaker2 = TreeMaker.clone(
TreeName = cms.string("PreSelection"),
VarsRecoCand = RecoCandVector,
VarsDouble = cms.vstring('WeightProducer:weight(Weight)','MHT','MET:Pt(METPt)','MET:Phi(METPhi)','MET:PtRaw(METPtRaw)','MET:PhiRaw(METPhiRaw)','MET:CaloMetPt(CaloMetPt)','MET:CaloMetPhi(CaloMetPhi)','HT','DeltaPhi:DeltaPhi1(DeltaPhi1)','DeltaPhi:DeltaPhi2(DeltaPhi2)','DeltaPhi:DeltaPhi3(DeltaPhi3)','GenEventInfo:genEventWeight(genEventWeight)','GenEventInfo:PUWeight(PUWeight)','GenEventInfo:originalWeight(originalWeight)'),
VarsInt = cms.vstring('NJets','BTags','NVtx','GenEventInfo:npT(npT)','FilterProducer:passFilterHBHE(passFilterHBHE)','FilterProducer:passFilterHBHEIso(passFilterHBHEIso)','FilterProducer:passFilterCSCHalo(passFilterCSCHalo)','FilterProducer:passFilterGoodVtx(passFilterGoodVtx)','FilterProducer:passFilterEEBadSC(passFilterEEBadSC)','FilterProducer:passFilterHBHELooseRerun(passFilterHBHELooseRerun)','FilterProducer:passFilterHBHETightRerun(passFilterHBHETightRerun)','FilterProducer:passFilterHBHEIsoRerun(passFilterHBHEIsoRerun)'),
debug = debug,
)
process.TreeMaker2.VarsDouble.extend(['MET:PtDefault(METPtDefault)','MET:PhiDefault(METPhiDefault)','MET:PtType1(METPtType1)','MET:PhiType1(METPhiType1)','MET:PtType1XYSmear(METPtType1XYSmear)','MET:PhiType1XYSmear(METPhiType1XYSmear)','MET:PtType1Smear(METPtType1Smear)','MET:PhiType1Smear(METPhiType1Smear)','MET:PtType1XY(METPtType1XY)','MET:PhiType1XY(METPhiType1XY)'])
process.TreeMaker2.VectorBool.extend(['TriggerProducer:TriggerPass'])
process.TreeMaker2.VectorInt.extend(['TriggerProducer:TriggerPrescales'])
process.TreeMaker2.VectorDouble.extend(['GenEventInfo:AQGCweights'])
process.TreeMaker2.VectorString.extend(['TriggerProducer:TriggerNames'])
## --- Final paths ----------------------------------------------------
process.out = cms.OutputModule("PoolOutputModule",
fileName = cms.untracked.string("output.root"),
)
process.dump = cms.EDAnalyzer("EventContentAnalyzer")
process.WriteTree = cms.Path(
process.TriggerProducer*
### MET Filter Bits
process.HBHENoiseFilterResultProducer*
process.FilterProducer* #this now contains all the met filters
### rest of ntupling starts after here
process.filterSeq *
process.GenEventInfo *
process.Muons *
process.egmGsfElectronIDSequence*
process.Electrons *
process.egmPhotonIDSequence *
process.Photons *
process.WeightProducer *
process.IsolatedTracks *
process.substructureSequenceGen *
process.softdropGen_onMiniAOD *
process.pruningGen_onMiniAOD *
process.redoGenJets*
process.GenJetsAK8 *
process.puppi_onMiniAOD *
process.substructureSequence *
process.softdrop_onMiniAOD *
process.pruning_onMiniAOD *
process.redoPatJets*
process.redoPuppiJets*
process.HTJets *
process.HT *
process.NJets *
process.BTags *
process.MHTJets *
process.MHTJetsProperties *
process.JetsProperties *
process.MHTJetsAK8 *
process.MHTJetsPropertiesAK8 *
process.JetsPropertiesAK8 *
process.MHT *
process.MET *
process.DeltaPhi *
process.NVtx *
process.GenLeptons *
process.GenJets *
process.TreeMaker2
)
def addStandardPuppiJets(
process,
label='',
useLocalJEC=True,
dbfile='flashgg/MetaData/data/PuppiJEC/PY8_RunIISpring15DR74_bx50_MC.db',
debug=False):
print ':: Running a standard PUPPI : --'
from CommonTools.PileupAlgos.Puppi_cff import puppi
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
# from RecoJets.JetProducers.PileupJetIDParams_cfi import cutbased_new as pu_jetid
from flashgg.MicroAOD.flashggJets_cfi import flashggBTag
setattr(
process, 'flashggStdPuppi' + label,
puppi.clone(
candName=cms.InputTag('packedPFCandidates'),
vertexName=cms.InputTag('offlineSlimmedPrimaryVertices'),
))
setattr(
process, 'ak4PFJetsStdPuppi' + label,
ak4PFJets.clone(src=cms.InputTag('flashggStdPuppi'),
doAreaFastjet=True))
if useLocalJEC:
print ':: using a local JEC dbfile for PUPPI :',
print ' -- ', dbfile
from flashgg.MicroAOD.flashggJetTools_cfi import loadLocalJECDBfile
loadLocalJECDBfile(
process,
dbfile=os.environ['CMSSW_BASE'] + '/src/' + dbfile,
tag=
'JetCorrectorParametersCollection_PY8_RunIISpring15DR74_bx50_MC_AK4PUPPI',
label='AK4PFPuppi')
addJetCollection(
process,
postfix='std' + label,
labelName='AK4PUPPI',
jetSource=cms.InputTag('ak4PFJetsStdPuppi'),
pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'),
pfCandidates=cms.InputTag('packedPFCandidates'),
svSource=cms.InputTag('slimmedSecondaryVertices'),
elSource=cms.InputTag("slimmedElectrons"),
muSource=cms.InputTag("slimmedMuons"),
runIVF=True,
btagDiscriminators=[
flashggBTag,
flashggCMVABTag,
flashggDeepCSVb,
flashggDeepCSVbb,
flashggDeepCSVc,
flashggDeepCSVudsg,
],
jetCorrections=('AK4PFchs', ['L1FastJet', 'L2Relative',
'L3Absolute'], 'None'),
genJetCollection=cms.InputTag('slimmedGenJets'),
genParticles=cms.InputTag('prunedGenParticles'),
# jet param
algo='AK',
rParam=0.4)
getattr(process, 'patJetCorrFactorsAK4PUPPIstd' +
label).primaryVertices = "offlineSlimmedPrimaryVertices"
setattr(
process,
'flashggStdPUPPIJets',
cms.EDProducer(
'FlashggJetProducer',
DiPhotonTag=cms.InputTag('flashggDiPhotons'),
VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'),
JetTag=cms.InputTag('patJetsAK4PUPPIstd' + label),
VertexCandidateMapTag=cms.InputTag("flashggVertexMapForPUPPI"),
UsePuppi=cms.untracked.bool(True),
# PileupJetIdParameters = cms.PSet(pu_jetid))
))
setattr(
process, 'selectedFlashggStdPUPPIJets' + label,
cms.EDFilter("FLASHggJetSelector",
src=cms.InputTag('flashggStdPUPPIJets'),
cut=cms.string("pt > 15.")))
def addLeptonSubtractedPFCands(process, era, useFakeable, puMethod, runOnMC):
assert (era in ["2016", "2017", "2018"])
assert (puMethod in ['chs', 'puppi'])
suffix = "Fakeable" if useFakeable else "Loose"
#----------------------------------------------------------------------------
# produce collections of electrons and muons passing loose or fakeable lepton selection of ttH multilepton+tau analysis (HIG-18-019)
electronCollectionTTH_str = 'electronCollectionTTH%s' % suffix
if not hasattr(process, electronCollectionTTH_str):
setattr(
process, electronCollectionTTH_str,
cms.EDProducer("PATElectronSelector%s" % suffix,
src=cms.InputTag("linkedObjects", "electrons"),
src_mvaTTH=cms.InputTag("electronMVATTH"),
era=cms.string(era),
debug=cms.bool(False)))
muonCollectionTTH_str = 'muonCollectionTTH%s' % suffix
if not hasattr(process, muonCollectionTTH_str):
setattr(
process, muonCollectionTTH_str,
cms.EDProducer("PATMuonSelector%s" % suffix,
src=cms.InputTag("linkedObjects", "muons"),
src_mvaTTH=cms.InputTag("muonMVATTH"),
era=cms.string(era),
debug=cms.bool(False)))
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
# produce collection of packedPFCandidates not associated to loose or fakeable electrons or muons
leptonLessPFProducer_str = 'leptonLessPFProducer%s' % suffix
if not hasattr(process, leptonLessPFProducer_str):
setattr(
process, leptonLessPFProducer_str,
cms.EDProducer(
'LeptonLessPFProducer',
src_pfCands=cms.InputTag("packedPFCandidates"),
src_electrons=cms.InputTag(electronCollectionTTH_str),
src_muons=cms.InputTag(muonCollectionTTH_str),
debug=cms.bool(False)))
leptonLessPU_str = 'leptonLess%s%s' % (puMethod, suffix)
if puMethod == 'puppi':
# run PUPPI algorithm (arXiv:1407.6013) on cleaned packedPFCandidates collection
# cf. https://twiki.cern.ch/twiki/bin/view/CMS/JetToolbox#New_PF_Collection
if not hasattr(process, leptonLessPU_str):
setattr(
process, leptonLessPU_str,
puppi.clone(
candName=cms.InputTag(leptonLessPFProducer_str),
vertexName=cms.InputTag("offlineSlimmedPrimaryVertices"),
useExistingWeights=cms.bool(True)))
elif puMethod == 'chs':
leptonLessCands_tmp1 = '%stmp1' % leptonLessPU_str
leptonLessCands_tmp2 = '%stmp2' % leptonLessPU_str
setattr(
process, leptonLessCands_tmp1,
cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("fromPV"),
))
setattr(
process, leptonLessCands_tmp2,
cms.EDProducer(
"CandPtrProjector",
src=cms.InputTag(leptonLessCands_tmp1),
veto=cms.InputTag(muonCollectionTTH_str),
))
setattr(
process, leptonLessPU_str,
cms.EDProducer(
"CandPtrProjector",
src=cms.InputTag(leptonLessCands_tmp2),
veto=cms.InputTag(electronCollectionTTH_str),
))
else:
raise RuntimeError("Invalid PU method: %s" % puMethod)
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
# produce collection of generator-level particles excluding prompt leptons and leptons from tau decays
# (used to produce lepton-subtracted generator-level jets)
# NB.: Selection taken from the Higgs->tautau twiki
# https://twiki.cern.ch/twiki/bin/viewauth/CMS/HiggsToTauTauWorking2016#MC_Matching
if runOnMC:
if not hasattr(process, GENPARTICLESFORJETSNONU_STR):
setattr(
process, GENPARTICLESFORJETSNONU_STR,
genParticlesForJetsNoNu.clone(
src=cms.InputTag("prunedGenParticles"), ))
if not hasattr(process, LEPTONLESSGENPARTICLEPRODUCER_STR):
setattr(
process, LEPTONLESSGENPARTICLEPRODUCER_STR,
cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag(GENPARTICLESFORJETSNONU_STR),
cut=cms.string(
'!(pt > 8 & (abs(pdgId) = 11 | abs(pdgId) = 13) & (isPromptFinalState | isDirectPromptTauDecayProductFinalState))'
),
stableOnly=cms.bool(True),
filter=cms.bool(False),
))
#----------------------------------------------------------------------------
leptonSubtractedPFCandsSequence_str = 'leptonSubtractedPFCandsSequence%s%s' % (
puMethod, suffix)
if not hasattr(process, leptonSubtractedPFCandsSequence_str):
if puMethod == 'puppi':
setattr(process, leptonSubtractedPFCandsSequence_str,
cms.Sequence(
getattr(process, electronCollectionTTH_str) + getattr(process, muonCollectionTTH_str) + \
getattr(process, leptonLessPFProducer_str) + getattr(process, leptonLessPU_str)
)
)
elif puMethod == 'chs':
setattr(process, leptonSubtractedPFCandsSequence_str,
cms.Sequence(
getattr(process, electronCollectionTTH_str) + getattr(process, muonCollectionTTH_str) + \
getattr(process, leptonLessPFProducer_str) + getattr(process, leptonLessCands_tmp1) + \
getattr(process, leptonLessCands_tmp2) + getattr(process, leptonLessPU_str)
)
)
else:
raise RuntimeError("Invalid PU method: %s" % puMethod)
if runOnMC:
leptonSubtractedPFCandsSequence = getattr(
process, leptonSubtractedPFCandsSequence_str)
leptonSubtractedPFCandsSequence += getattr(process, GENPARTICLESFORJETSNONU_STR) + \
getattr(process, LEPTONLESSGENPARTICLEPRODUCER_STR)
return (getattr(process,
leptonSubtractedPFCandsSequence_str), leptonLessPU_str)
def addStandardPuppiJets(process,
label ='',
useLocalJEC = True,
dbfile = 'flashgg/MetaData/data/PuppiJEC/PY8_RunIISpring15DR74_bx50_MC.db',
debug = False):
print ':: Running a standard PUPPI : --'
from CommonTools.PileupAlgos.Puppi_cff import puppi
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
# from RecoJets.JetProducers.PileupJetIDParams_cfi import cutbased_new as pu_jetid
from flashgg.MicroAOD.flashggJets_cfi import flashggBTag
setattr(process, 'flashggStdPuppi' + label,
puppi.clone( candName = cms.InputTag('packedPFCandidates'),
vertexName = cms.InputTag('offlineSlimmedPrimaryVertices'),
))
setattr(process, 'ak4PFJetsStdPuppi' + label,
ak4PFJets.clone ( src = cms.InputTag('flashggStdPuppi'),
doAreaFastjet = True
))
if useLocalJEC :
print ':: using a local JEC dbfile for PUPPI :',
print ' -- ', dbfile
from flashgg.MicroAOD.flashggJetTools_cfi import loadLocalJECDBfile
loadLocalJECDBfile(process,
dbfile = os.environ['CMSSW_BASE'] + '/src/' + dbfile,
tag = 'JetCorrectorParametersCollection_PY8_RunIISpring15DR74_bx50_MC_AK4PUPPI',
label = 'AK4PFPuppi')
addJetCollection(
process,
postfix = 'std' + label,
labelName = 'AK4PUPPI',
jetSource = cms.InputTag('ak4PFJetsStdPuppi'),
pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'),
pfCandidates = cms.InputTag('packedPFCandidates'),
svSource = cms.InputTag('slimmedSecondaryVertices'),
btagDiscriminators = [ flashggBTag ],
jetCorrections = ('AK4PFchs',['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'),
genJetCollection = cms.InputTag('slimmedGenJets'),
genParticles = cms.InputTag('prunedGenParticles'),
# jet param
algo = 'AK', rParam = 0.4
)
getattr(process, 'patJetCorrFactorsAK4PUPPIstd' + label).primaryVertices = "offlineSlimmedPrimaryVertices"
setattr(process, 'flashggStdPUPPIJets',
cms.EDProducer('FlashggJetProducer',
DiPhotonTag = cms.InputTag('flashggDiPhotons'),
VertexTag = cms.InputTag('offlineSlimmedPrimaryVertices'),
JetTag = cms.InputTag('patJetsAK4PUPPIstd' + label),
VertexCandidateMapTag = cms.InputTag("flashggVertexMapForPUPPI"),
UsePuppi = cms.untracked.bool(True),
# PileupJetIdParameters = cms.PSet(pu_jetid))
)
)
setattr(process, 'selectedFlashggStdPUPPIJets' + label,
cms.EDFilter("FLASHggJetSelector",
src = cms.InputTag( 'flashggStdPUPPIJets'),
cut = cms.string("pt > 15."))
)
# Copied from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD
from CommonTools.PileupAlgos.Puppi_cff import puppi
puppi.candName = 'packedPFCandidates'
puppi.vertexName = 'offlineSlimmedPrimaryVertices'
#puppi.useExistingWeights = False # I still don't trust miniaod...
puppi.useExistingWeights = True
puppi.clonePackedCands = True # if !useExistingWeights, need to set this flag to make PuppiProducer create packed candidates
pfNoLepPUPPI = cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("abs(pdgId) != 13 && abs(pdgId) != 11 && abs(pdgId) != 15"))
puppiNoLep = puppi.clone(candName='pfNoLepPUPPI',
useWeightsNoLep=True,
useExistingWeights=False)
pfLeptonsPUPPET = cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("abs(pdgId) == 13 || abs(pdgId) == 11 || abs(pdgId) == 15"))
puppiMerged = cms.EDProducer("CandViewMerger",
src=cms.VInputTag('puppiNoLep',
'pfLeptonsPUPPET'))
import PandaProd.Producer.utils.egmidconf as egmidconf
from CommonTools.PileupAlgos.PhotonPuppi_cff import puppiPhoton
puppiForMET = puppiPhoton.clone(
'''
# ---------------------------------------------------------
# DeepAK8: set up TransientTrackBuilder
process.load('Configuration.StandardSequences.MagneticField_cff')
process.TransientTrackBuilderESProducer = cms.ESProducer("TransientTrackBuilderESProducer",
ComponentName=cms.string('TransientTrackBuilder')
)
# ---------------------------------------------------------
####### Redo Jet clustering sequence ##########
from RecoJets.Configuration.RecoPFJets_cff import ak4PFJetsCHS, ak8PFJetsCHS, ak8PFJetsCHSPruned, ak8PFJetsCHSSoftDrop, ak8PFJetsCHSPrunedMass, ak8PFJetsCHSSoftDropMass# , ak8PFJetsCSTrimmed, ak8PFJetsCSFiltered, ak8PFJetsCHSFilteredMass, ak8PFJetsCHSTrimmedMass
from CommonTools.PileupAlgos.Puppi_cff import puppi
process.puppi = puppi.clone()
process.puppi.useExistingWeights = True
process.puppi.candName = cms.InputTag('packedPFCandidates')
process.puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
process.ak8PFJetsCHS = ak8PFJetsCHS.clone( src = 'puppi', jetPtMin = 100.0 )
process.ak8PFJetsCHSPruned = ak8PFJetsCHSPruned.clone( src = 'puppi', jetPtMin = 100.0 )
process.ak8PFJetsCHSPrunedMass = ak8PFJetsCHSPrunedMass.clone()
process.ak8PFJetsCHSSoftDrop = ak8PFJetsCHSSoftDrop.clone( src = 'puppi', jetPtMin = 100.0 )
process.ak8PFJetsCHSSoftDropMass = ak8PFJetsCHSSoftDropMass.clone()
process.NjettinessAK8 = cms.EDProducer("NjettinessAdder",
src = cms.InputTag("ak8PFJetsCHS"),
Njets = cms.vuint32(1, 2, 3, 4),
# variables for measure definition :
def addPaths_MC_JMEPFPuppiROI(process):
process.hltPreMCJMEPFPuppiROI = cms.EDFilter(
'HLTPrescaler',
L1GtReadoutRecordTag=cms.InputTag('hltGtStage2Digis'),
offset=cms.uint32(0))
process.hltPixelClustersMultiplicity = _nSiPixelClusters.clone(
src='hltSiPixelClusters', defaultValue=-1.)
process.hltPFPuppiROI = _puppi.clone(
candName='hltParticleFlowForBTag',
vertexName='hltVerticesPFForBTag',
usePUProxyValue=True,
PUProxyValue='hltPixelClustersMultiplicity',
)
process.HLTPFPuppiSequenceROI = cms.Sequence(
process.HLTDoCaloSequencePF + process.HLTL2muonrecoSequence +
process.HLTL3muonrecoSequence + process.HLTTrackReconstructionForBTag +
process.HLTParticleFlowSequenceForBTag + process.hltVerticesPFForBTag +
process.hltPixelClustersMultiplicity + process.hltPFPuppiROI)
## AK4
process.hltAK4PFPuppiJetsROI = _ak4PFJetsPuppi.clone(
src='hltParticleFlowForBTag',
srcWeights='hltPFPuppiROI',
applyWeight=True,
)
process.hltAK4PFPuppiJetCorrectorL1ROI = cms.EDProducer(
'L1FastjetCorrectorProducer',
algorithm=cms.string('AK4PFPuppiHLT'),
level=cms.string('L1FastJet'),
srcRho=cms.InputTag('hltFixedGridRhoFastjetAllForBTag'),
)
process.hltAK4PFPuppiJetCorrectorL2ROI = cms.EDProducer(
'LXXXCorrectorProducer',
algorithm=cms.string('AK4PFPuppiHLT'),
level=cms.string('L2Relative'))
process.hltAK4PFPuppiJetCorrectorL3ROI = cms.EDProducer(
'LXXXCorrectorProducer',
algorithm=cms.string('AK4PFPuppiHLT'),
level=cms.string('L3Absolute'))
process.hltAK4PFPuppiJetCorrectorROI = cms.EDProducer(
'ChainedJetCorrectorProducer',
correctors=cms.VInputTag(
'hltAK4PFPuppiJetCorrectorL1ROI',
'hltAK4PFPuppiJetCorrectorL2ROI',
'hltAK4PFPuppiJetCorrectorL3ROI',
),
)
process.hltAK4PFPuppiJetsCorrectedROI = cms.EDProducer(
'CorrectedPFJetProducer',
src=cms.InputTag('hltAK4PFPuppiJetsROI'),
correctors=cms.VInputTag('hltAK4PFPuppiJetCorrectorROI'),
)
process.HLTAK4PFPuppiJetsSequenceROI = cms.Sequence(
process.hltAK4PFPuppiJetsROI + process.hltAK4PFPuppiJetCorrectorL1ROI +
process.hltAK4PFPuppiJetCorrectorL2ROI +
process.hltAK4PFPuppiJetCorrectorL3ROI +
process.hltAK4PFPuppiJetCorrectorROI +
process.hltAK4PFPuppiJetsCorrectedROI)
## Modifications to PUPPI parameters
for mod_i in [process.hltPFPuppiROI]:
for algo_idx in range(len(mod_i.algos)):
if len(mod_i.algos[algo_idx].MinNeutralPt) != len(
mod_i.algos[algo_idx].MinNeutralPtSlope):
raise RuntimeError(
'instance of PuppiProducer is misconfigured:\n\n' +
str(mod_i) + ' = ' + mod_i.dumpPython())
for algoReg_idx in range(len(mod_i.algos[algo_idx].MinNeutralPt)):
mod_i.algos[algo_idx].MinNeutralPt[
algoReg_idx] += 2.56 * mod_i.algos[
algo_idx].MinNeutralPtSlope[algoReg_idx]
mod_i.algos[algo_idx].MinNeutralPtSlope[algoReg_idx] *= 0.00271
## Path
process.MC_JMEPFPuppiROI_v1 = cms.Path(
process.HLTBeginSequence + process.hltPreMCJMEPFPuppiROI
## AK4 Jets
+ process.HLTAK4PFJetsSequenceForBTag # New
+ process.HLTPFPuppiSequenceROI + process.HLTAK4PFPuppiJetsSequenceROI)
if process.schedule_():
process.schedule_().append(process.MC_JMEPFPuppiROI_v1)
return process
