def addFlashggPF(process, doQGTagging=True, label='', debug=False):
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
# process.ak4PFJets = ak4PFJets.clone (src = 'packedPFCandidates', doAreaFastjet = True)
setattr(process, 'ak4PFJets' + label,
ak4PFJets.clone(src='packedPFCandidates', doAreaFastjet=True))
# cluster the jets
addJetCollection(process,
postfix=label,
labelName='AK4PF',
jetSource=cms.InputTag('ak4PFJets' + label),
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'),
algo='AK',
rParam=0.4)
# adjust PV used for Jet Corrections
# getattr(process, 'patJetCorrFactors'+_labelName+label)
getattr(process, 'patJetCorrFactorsAK4PF' +
label).primaryVertices = "offlineSlimmedPrimaryVertices"
#process.patJetCorrFactorsAK4PF.primaryVertices = "offlineSlimmedPrimaryVertices"
print ' --> patJetCorrFactorsAK4PF == ', getattr(
process, 'patJetCorrFactorsAK4PF' + label)
print ' --> patJetsAK4PF == ', getattr(process,
'patJetsAK4PF' + label)
flashggJetsPF = cms.EDProducer(
'FlashggJetProducer',
DiPhotonTag=cms.InputTag('flashggDiPhotons'),
VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'),
JetTag=cms.InputTag('patJetsAK4PF' + label),
VertexCandidateMapTag=cms.InputTag("flashggVertexMapForCHS"),
# PileupJetIdParameters=cms.PSet(pu_jetid),
)
setattr(process, 'flashggJetsPF' + label, flashggJetsPF)
if doQGTagging:
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
setattr(
process, 'QGTaggerPF' + label,
QGTagger.clone(srcJets='flashggJetsPF' + label,
jetsLabel='QGL_AK4PF'))
return getattr(process, 'flashggJetsPF' + label)
def addFlashggPF(process, doQGTagging = True, label ='', debug = False):
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
# process.ak4PFJets = ak4PFJets.clone (src = 'packedPFCandidates', doAreaFastjet = True)
setattr(process, 'ak4PFJets' + label, ak4PFJets.clone (src = 'packedPFCandidates', doAreaFastjet = True))
# cluster the jets
addJetCollection(
process,
postfix = label,
labelName = 'AK4PF' ,
jetSource = cms.InputTag('ak4PFJets'+label),
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'),
algo = 'AK', rParam = 0.4
)
# adjust PV used for Jet Corrections
# getattr(process, 'patJetCorrFactors'+_labelName+label)
getattr(process, 'patJetCorrFactorsAK4PF' + label).primaryVertices = "offlineSlimmedPrimaryVertices"
#process.patJetCorrFactorsAK4PF.primaryVertices = "offlineSlimmedPrimaryVertices"
print ' --> patJetCorrFactorsAK4PF == ', getattr(process, 'patJetCorrFactorsAK4PF' + label)
print ' --> patJetsAK4PF == ', getattr(process, 'patJetsAK4PF' + label)
flashggJetsPF = cms.EDProducer('FlashggJetProducer',
DiPhotonTag=cms.InputTag('flashggDiPhotons'),
VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'),
JetTag=cms.InputTag('patJetsAK4PF' + label ),
VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"),
# PileupJetIdParameters=cms.PSet(pu_jetid),
)
setattr(process, 'flashggJetsPF' + label, flashggJetsPF)
if doQGTagging:
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
setattr(process, 'QGTaggerPF' + label, QGTagger.clone( srcJets = 'flashggJetsPF' + label ,jetsLabel = 'QGL_AK4PF'))
return getattr(process, 'flashggJetsPF' + label)
def addQGLikelihood(process,jetCollection,postfix):
## run evaluator
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
if not hasattr(process,'QGTagger'+postfix):
setattr(process,'QGTagger'+postfix, QGTagger.clone(
srcJets = cms.InputTag(jetCollection),
jetsLabel = cms.string('QGL_AK4PFchs'),
srcVertexCollection = cms.InputTag('offlineSlimmedPrimaryVertices')))
## modify jets
setattr(process,jetCollection+"QG",
updatedPatJets.clone(jetSource = cms.InputTag(jetCollection),
addJetCorrFactors = cms.bool(False),
jetCorrFactorsSource = cms.VInputTag()))
getattr(process,jetCollection+"QG").userData.userFloats = cms.PSet(
src = cms.VInputTag('QGTagger'+postfix+':qgLikelihood'))
return jetCollection+"QG";
def makeFatJets(process, isData, label, candidates, ptMin=100.):
"""
@param label: AK8PFchs, CA15PFPuppi, etc.
"""
matches = re.match('(AK|CA)([0-9]+)PF(.+)', label)
if not matches:
raise RuntimeError('Unknown algo label ' + label)
algo = matches.group(1) + matches.group(2)
# set up radius and algoName from the input label
radius = float(matches.group(2)) * 0.1
if matches.group(1) == 'CA':
algoName = 'CambridgeAachen'
elif matches.group(1) == 'AK':
algoName = 'AntiKt'
pu = matches.group(3)
if pu == 'chs':
jecLabel = 'AK8PFchs' # regardless of jet algo
elif pu == 'Puppi':
jecLabel = 'AK8PFPuppi' # regardless of jet algo
else:
raise RuntimeError('Unknown PU mitigation ' + pu)
sdZcut, sdBeta = sdParams(radius)
sequence = cms.Sequence()
# Callable object that adds the second argument to process and sequence with label attached as suffix
addattr = AddAttr(process, sequence, label)
########################################
## REMAKE JETS ##
########################################
pfJets = addattr(
'pfJets',
ak4PFJets.clone(
doAreaFastjet=cms.bool(
False
), # This flag is turned on by default in CMSSW and makes things much slower, do not turn this on
jetAlgorithm=cms.string(algoName),
rParam=cms.double(radius),
src=cms.InputTag(candidates),
jetPtMin=cms.double(ptMin)))
pfJetsSoftDrop = addattr(
'pfJetsSoftDrop',
ak4PFJets.clone(
doAreaFastjet=cms.bool(
False
), # This flag is turned on by default in CMSSW and makes things much slower, do not turn this on
jetAlgorithm=cms.string(algoName),
rParam=cms.double(radius),
src=cms.InputTag(candidates),
jetPtMin=cms.double(ptMin),
useSoftDrop=cms.bool(True),
R0=cms.double(radius),
zcut=cms.double(sdZcut),
beta=cms.double(sdBeta),
writeCompound=cms.bool(True),
useExplicitGhosts=cms.bool(True),
jetCollInstanceName=cms.string("SubJets")))
subjets = cms.InputTag(pfJetsSoftDrop.getModuleLabel(), 'SubJets')
pfJetsPruned = addattr(
'pfJetsPruned',
ak4PFJets.clone(
doAreaFastjet=cms.bool(
False
), # This flag is turned on by default in CMSSW and makes things much slower, do not turn this on
jetAlgorithm=cms.string(algoName),
rParam=cms.double(radius),
src=cms.InputTag(candidates),
jetPtMin=cms.double(ptMin),
usePruning=cms.bool(True),
useExplicitGhosts=cms.bool(True),
writeCompound=cms.bool(True),
zcut=cms.double(0.1), # no idea if these parameters are correct
rcut_factor=cms.double(0.5),
nFilt=cms.int32(2),
jetCollInstanceName=cms.string("SubJets")))
########################################
## SUBSTRUCTURE ##
#######################################
Njettiness = addattr(
'Njettiness',
nJettinessAdder_cfi.Njettiness.clone(src=pfJets,
R0=cms.double(radius),
Njets=cms.vuint32(1, 2, 3, 4)))
sdKinematics = addattr(
'sdKinematics',
cms.EDProducer('RecoJetDeltaRValueMapProducer',
src=pfJets,
matched=pfJetsSoftDrop,
distMax=cms.double(radius),
values=cms.vstring('mass'),
valueLabels=cms.vstring('Mass')))
prunedKinematics = addattr(
'prunedKinematics',
cms.EDProducer('RecoJetDeltaRValueMapProducer',
src=pfJets,
matched=pfJetsPruned,
distMax=cms.double(radius),
values=cms.vstring('mass'),
valueLabels=cms.vstring('Mass')))
### subjet qg-tagging ###
subQGTag = addattr(
'subQGTag',
QGTagger.clone(srcJets=subjets, jetsLabel=cms.string('QGL_AK4PFchs')))
########################################
## MAKE PAT JETS ##
########################################
## MAIN JET ##
jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute']
if isData:
jecLevels.append('L2L3Residual')
jetCorrFactors = addattr(
'jetCorrFactors',
jetUpdater_cff.patJetCorrFactors.clone(src=pfJets,
payload=jecLabel,
levels=jecLevels,
primaryVertices=pvSource))
if not isData:
genJetMatch = addattr(
'genJetMatch',
patJetGenJetMatch.clone(src=pfJets,
maxDeltaR=radius,
matched='genJetsNoNu' + algo))
patJets = addattr(
'patJets',
_patJets.clone(jetSource=pfJets,
addJetCorrFactors=True,
addBTagInfo=True,
addAssociatedTracks=False,
addJetCharge=False,
addGenPartonMatch=False,
addGenJetMatch=(not isData),
getJetMCFlavour=False,
addJetFlavourInfo=False))
patJetsMod = addattr.last
patJetsMod.jetCorrFactorsSource = [jetCorrFactors]
patJetsMod.discriminatorSources = []
if not isData:
patJetsMod.genJetMatch = genJetMatch
for tau in ['tau1', 'tau2', 'tau3', 'tau4']:
patJetsMod.userData.userFloats.src.append(Njettiness.getModuleLabel() +
':' + tau)
patJetsMod.userData.userFloats.src.append(sdKinematics.getModuleLabel() +
':Mass')
patJetsMod.userData.userFloats.src.append(
prunedKinematics.getModuleLabel() + ':Mass')
patJetsMod.userData.userFloats.labelPostfixesToStrip = cms.vstring(label)
selectedPatJets = addattr(
'selectedPatJets',
jetSelector_cfi.selectedPatJets.clone(src=patJets,
cut='abs(eta) < 2.5'))
## SOFT DROP ##
patJetsSoftDrop = addattr(
'patJetsSoftDrop',
_patJets.clone(jetSource=pfJetsSoftDrop,
addJetCorrFactors=False,
addBTagInfo=False,
addAssociatedTracks=False,
addJetCharge=False,
addGenPartonMatch=False,
addGenJetMatch=False,
getJetMCFlavour=False,
addJetFlavourInfo=False))
selectedPatJetsSoftDrop = addattr(
'selectedPatJetsSoftDrop',
jetSelector_cfi.selectedPatJets.clone(src=patJetsSoftDrop,
cut='abs(eta) < 2.5'))
## GEN MATCH ##
if not isData:
genSubjetsMatch = addattr(
'genSubjetMatch',
patJetGenJetMatch.clone(src=subjets,
maxDeltaR=0.4,
matched='genJetsNoNuSoftDrop' + algo +
':SubJets'))
### SUBJETS ###
patSubjets = addattr(
'patSubjets',
_patJets.clone(jetSource=subjets,
addJetCorrFactors=False,
addBTagInfo=False,
addAssociatedTracks=False,
addJetCharge=False,
addGenPartonMatch=False,
addGenJetMatch=(not isData),
getJetMCFlavour=False,
addJetFlavourInfo=False))
patSubjetsMod = addattr.last
patSubjetsMod.userData.userFloats.src.append(
cms.InputTag(subQGTag.getModuleLabel(), 'qgLikelihood'))
patSubjetsMod.userData.userFloats.labelPostfixesToStrip = cms.vstring(
label)
if not isData:
patSubjetsMod.genJetMatch = genSubjetsMatch
## MERGE SUBJETS BACK ##
jetMerger = addattr(
'jetMerger',
cms.EDProducer("BoostedJetMerger",
jetSrc=selectedPatJetsSoftDrop,
subjetSrc=patSubjets))
## PACK ##
addattr(
'packedPatJets',
cms.EDProducer("JetSubstructurePacker",
jetSrc=selectedPatJets,
distMax=cms.double(radius),
algoTags=cms.VInputTag(jetMerger),
algoLabels=cms.vstring('SoftDrop'),
fixDaughters=cms.bool(False)))
return sequence
def addFlashggPFCHSJets(process, vertexIndex = 0, doQGTagging = True, label ='', debug = False):
setattr(process, 'selectedMuons' + label, cms.EDFilter("CandPtrSelector",
src = cms.InputTag("slimmedMuons"),
cut = cms.string('''abs(eta)<2.5 && pt>10. &&
(pfIsolationR04().sumChargedHadronPt+
max(0.,pfIsolationR04().sumNeutralHadronEt+
pfIsolationR04().sumPhotonEt-
0.50*pfIsolationR04().sumPUPt))/pt < 0.20 &&
(isPFMuon && (isGlobalMuon || isTrackerMuon) )''')))
setattr(process, 'selectedElectrons' + label, cms.EDFilter("CandPtrSelector",
src = cms.InputTag("slimmedElectrons"),
cut = cms.string('''abs(eta)<2.5 && pt>20. &&
gsfTrack.isAvailable() &&
gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2 &&
(pfIsolationVariables().sumChargedHadronPt+
max(0.,pfIsolationVariables().sumNeutralHadronEt+
pfIsolationVariables().sumPhotonEt-
0.5*pfIsolationVariables().sumPUPt))/pt < 0.15''')))
# Simple producer which just removes the Candidates which
# don't come from the legacy vertex according to the Flashgg Vertex Map
setattr(process,'flashggCHSLegacyVertexCandidates' + label,
cms.EDProducer('FlashggMultiCHSLegacyVertexCandProducer',
PFCandidatesTag = cms.InputTag('packedPFCandidates'),
DiPhotonTag = cms.InputTag('flashggDiPhotons'),
VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"),
VertexTag = cms.InputTag('offlineSlimmedPrimaryVertices'),
vertexIndex = cms.untracked.uint32(vertexIndex),
debug = cms.untracked.bool(debug)
)
)
setattr(process, 'pfCHSLeg' + label, cms.EDFilter("CandPtrSelector",
src = cms.InputTag('flashggCHSLegacyVertexCandidates' + label),
cut = cms.string('')))
# then remove the previously selected muons
setattr(process, 'pfNoMuonCHSLeg' + label, cms.EDProducer("CandPtrProjector",
src = cms.InputTag("pfCHSLeg" + label),
veto = cms.InputTag("selectedMuons" + label)))
# then remove the previously selected electrons
setattr(process, 'pfNoElectronsCHSLeg' + label, cms.EDProducer("CandPtrProjector",
src = cms.InputTag("pfNoMuonCHSLeg" + label),
veto = cms.InputTag("selectedElectrons" + label)))
#Import RECO jet producer for ak4 PF and GEN jet
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
#from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
setattr(process, 'ak4PFJetsCHSLeg' + label, ak4PFJets.clone ( src = 'pfNoElectronsCHSLeg' + label, doAreaFastjet = True))
#process.ak4GenJetsLeg = ak4GenJets.clone( src = 'packedGenParticles')
# NOTE: this is the 74X recipe for the jet clustering
addJetCollection(
process,
postfix = label,
labelName = 'AK4PFCHSLeg',
jetSource = cms.InputTag('ak4PFJetsCHSLeg' + label),
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
)
#adjust PV used for Jet Corrections
#process.patJetCorrFactorsAK4PFCHSLeg.primaryVertices = "offlineSlimmedPrimaryVertices"
getattr(process, 'patJetCorrFactorsAK4PFCHSLeg' + label).primaryVertices = "offlineSlimmedPrimaryVertices"
# Flashgg Jet producer using the collection created with function above.
flashggJets = cms.EDProducer('FlashggJetProducer',
DiPhotonTag = cms.InputTag('flashggDiPhotons'),
VertexTag = cms.InputTag('offlineSlimmedPrimaryVertices'),
JetTag = cms.InputTag('patJetsAK4PFCHSLeg' + label),
VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"),
# PileupJetIdParameters = cms.PSet(pu_jetid)
)
setattr( process, 'flashggPFCHSJets'+ label, flashggJets)
if doQGTagging:
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
setattr( process, 'QGTaggerPFCHS' + label, QGTagger.clone( srcJets = 'flashggPFCHSJets' + label ,jetsLabel = 'ak4PFJetsCHS'))
flashggSelectedJets = cms.EDFilter("FLASHggJetSelector",
src = cms.InputTag( 'flashggPFCHSJets'+ label ),
cut = cms.string("pt > 15.")
)
setattr( process, 'flashggSelectedPFCHSJets'+label, flashggSelectedJets )
src=cms.InputTag('slimmedJets', '', cms.InputTag.skipCurrentProcess()),
levels=cms.vstring(*jecLevels),
)
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
process.slimmedJets = updatedPatJets.clone(
jetSource=cms.InputTag('slimmedJets', '',
cms.InputTag.skipCurrentProcess()),
addJetCorrFactors=cms.bool(True),
jetCorrFactorsSource=cms.VInputTag(
cms.InputTag("updatedPatJetCorrFactors")),
addBTagInfo=cms.bool(False),
addDiscriminators=cms.bool(False))
process.QGTagger = QGTagger.clone(srcJets='slimmedJets',
jetsLabel=cms.string('QGL_AK4PFchs'))
jetRecorrectionSequence = cms.Sequence(process.updatedPatJetCorrFactors +
process.slimmedJets + process.QGTagger)
### MET
from PandaProd.Producer.utils.makeMET_cff import initMET, makeMET
initMetSequence = initMET(process, False)
# extracts the raw pfMET from input MINIAOD and repack new corrections
pfMetSequence = makeMET(process, False, 'packedPFCandidates', 'slimmedJets',
'AK4PFchs')
# compute a brand-new pfMET from puppi candidates and pack with corrections
puppiMetSequence = makeMET(process, False, 'puppiForMET', 'selectedJetsPuppi',
'AK4PFPuppi', 'Puppi')
def jetToolbox( proc, jetType, jetSequence,PUMethod='', bTagDiscriminators = None):
JETCorrPayload='None'
JETCorrLevels = [ 'None' ]
bTagDiscriminators = [#'trackCountingHighEffBJetTags',
#'trackCountingHighPurBJetTags',
#'pfTrackCountingHighEffBJetTags',
#'pfTrackCountingHighPurBJetTags',
#'softPFMuonByIP3dBJetTags',
#'softPFElectronByIP3dBJetTags',
#'softPFMuonBJetTags',
#'softPFElectronBJetTags',
#'simpleSecondaryVertexHighEffBJetTags',
#'simpleSecondaryVertexHighPurBJetTags',
#'pfSimpleSecondaryVertexHighEffBJetTags',
#'pfSimpleSecondaryVertexHighPurBJetTags',
#'combinedSecondaryVertexV2BJetTags',
'deepFlavourJetTags:probb',
'deepFlavourJetTags:probc',
'deepFlavourJetTags:probudsg',
'deepFlavourJetTags:probbb',
'deepFlavourJetTags:probcc',
'negativeDeepFlavourJetTags:probb',
'negativeDeepFlavourJetTags:probc',
'negativeDeepFlavourJetTags:probudsg',
'negativeDeepFlavourJetTags:probbb',
'negativeDeepFlavourJetTags:probcc',
'positiveDeepFlavourJetTags:probb',
'positiveDeepFlavourJetTags:probc',
'positiveDeepFlavourJetTags:probudsg',
'positiveDeepFlavourJetTags:probbb',
'positiveDeepFlavourJetTags:probcc',
'pfCombinedCvsLJetTags',
'pfCombinedCvsBJetTags',
'pfBoostedDoubleSecondaryVertexAK8BJetTags',
'pfCombinedSecondaryVertexV2BJetTags',
'pfPositiveCombinedSecondaryVertexV2BJetTags', #implemented
'pfNegativeCombinedSecondaryVertexV2BJetTags', #implemented
'pfCombinedInclusiveSecondaryVertexV2BJetTags', #implemented
'pfCombinedMVAV2BJetTags', #implemented
'pfJetProbabilityBJetTags'] #implemented
GetJetMCFlavour = ['True']
#JECLevels = [ 'L1Offset', 'L1FastJet', 'L1JPTOffset', 'L2Relative', 'L3Absolute', 'L5Falvour', 'L7Parton' ]
algorithm='AntiKt' # CambridgeAachen' , 'Kt'
size = jetType[-1:] #[-1:] takes the last char from string 'akX'
jetSize = float('0.'+jetType[-1:])
jetALGO = jetType.upper()
jetalgo = jetType.lower()
elemToKeep = []
print 'Running processes with: '+str(jetALGO)+' PF '+PUMethod+' jet algorithm with radius parameter '+str(jetSize)
JETCorrPayload = 'AK'+size+'PF'+PUMethod.lower()
JETCorrLevels = ['L1FastJet', 'L2Relative', 'L3Absolute']
#JETCorrLevels = [] #No JEC corrections
JEC = ( JETCorrPayload, JETCorrLevels , 'None')
#################################################################################
####### Toolbox start
#################################################################################
elemToKeep = []
jetSeq = cms.Sequence()
genParticlesLabel = ''
pvLabel = ''
tvLabel = ''
toolsUsed = []
proc.load('RecoJets.Configuration.GenJetParticles_cff')
setattr( proc, jetalgo+'GenJetsNoNu', ak4GenJets.clone( src = 'genParticlesForJetsNoNu', rParam = jetSize, jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, jetalgo+'GenJetsNoNu' )
proc.load('CommonTools.ParticleFlow.pfNoPileUpJME_cff')
#### Creating PATjets
if( PUMethod=='CHS') :
setattr( proc, jetalgo+'PFJetsCHS', ak4PFJets.clone( rParam = jetSize, jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, jetalgo+'PFJetsCHS' )
setattr( proc, jetalgo+'PFJetsCHS',
ak4PFJetsCHS.clone(
doAreaFastjet = True,
rParam = jetSize,
jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, jetalgo+'PFJetsCHS' )
else :
setattr( proc, jetalgo+'PFJets', ak4PFJets.clone( rParam = jetSize, jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, jetalgo+'PFJets' )
setattr( proc, jetalgo+'PFJets',
ak4PFJets.clone(
doAreaFastjet = True,
rParam = jetSize,
jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, jetalgo+'PFJets' )
PUMethod=''
addJetCollection(
proc,
labelName = jetALGO+'PF'+PUMethod,
jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod),
algo = jetalgo,
btagDiscriminators = bTagDiscriminators,
rParam = jetSize,
jetCorrections = JEC, #( 'AK'+size+'PFchs', cms.vstring( ['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
pfCandidates = cms.InputTag( 'particleFlow' ), #'packedPFCandidates'),
svSource = cms.InputTag('inclusiveCandidateSecondaryVertices'),
genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
pvSource = cms.InputTag( 'offlinePrimaryVertices' ), #'offlineSlimmedPrimaryVertices'),
jetTrackAssociation = True,
)
#setattr( proc, jetALGO+'PF'+PUMethod+'pileupJetIdCalculator',
# pileupJetIdCalculator.clone(
# jets = cms.InputTag(jetalgo+'PFJets'+PUMethod),
# rho = cms.InputTag("fixedGridRhoFastjetAll"),
# vertexes = cms.InputTag('offlinePrimaryVertices'),
# applyJec = cms.bool(True),
# inputIsCorrected = cms.bool(False)
# ))
# setattr( proc, jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator',
# pileupJetIdEvaluator.clone(
# jetids = cms.InputTag(jetALGO+'PF'+PUMethod+'pileupJetIdCalculator'),
# jets = cms.InputTag(jetalgo+'PFJets'+PUMethod),
# rho = cms.InputTag("fixedGridRhoFastjetAll"),
# vertexes = cms.InputTag('offlinePrimaryVertices'),
# applyJec = cms.bool(True),
# inputIsCorrected = cms.bool(False)
#
# )
# )
#getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator:fullDiscriminant']
#getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userInts.src += [jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator:cutbasedId',jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator:fullId']
QGjetsLabel='chs'
setattr( proc, 'QGTagger'+jetALGO+'PF'+PUMethod,
QGTagger.clone(
srcJets = cms.InputTag(jetalgo+'PFJets'+PUMethod), # Could be reco::PFJetCollection or pat::JetCollection (both AOD and miniAOD)
jetsLabel = cms.string('QGL_AK4PF'+QGjetsLabel) # Other options (might need to add an ESSource for it): see https://twiki.cern.ch/twiki/bi
)
)
elemToKeep += [ 'keep *_QGTagger'+jetALGO+'PF'+PUMethod+'_*_*' ]
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += ['QGTagger'+jetALGO+'PF'+PUMethod+':qgLikelihood']
jetSeq += getattr(proc, 'QGTagger'+jetALGO+'PF'+PUMethod )
toolsUsed.append( 'QGTagger'+jetALGO+'PF'+PUMethod )
getattr(proc,'patJetPartons').particles = cms.InputTag( 'genParticles' ) #'prunedGenParticles')
setattr(proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod, selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod ) )
setattr(proc, jetSequence, jetSeq)
def nanoAOD_customizeData(process):
process = nanoAOD_customizeCommon(process)
process.calibratedPatElectrons.isMC = cms.bool(False)
process.calibratedPatPhotons.isMC = cms.bool(False)
return process
def nanoAOD_customizeMC(process):
process = nanoAOD_customizeCommon(process)
process.calibratedPatElectrons.isMC = cms.bool(True)
process.calibratedPatPhotons.isMC = cms.bool(True)
return process
### Era dependent customization
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
qgtagger80x=QGTagger.clone(srcJets="slimmedJets",srcVertexCollection="offlineSlimmedPrimaryVertices")
_80x_sequence = nanoSequence.copy()
#remove stuff
_80x_sequence.remove(isoTrackTable)
_80x_sequence.remove(isoTrackSequence)
#add qgl
_80x_sequence.insert(1,qgtagger80x)
_80x_sequenceMC = nanoSequenceMC.copy()
_80x_sequenceMC.remove(genSubJetAK8Table)
_80x_sequenceMC.remove(genJetFlavourTable)
_80x_sequenceMC.insert(-1,genJetFlavourAssociation)
_80x_sequenceMC.insert(-1,genJetFlavourTable)
run2_miniAOD_80XLegacy.toReplaceWith( nanoSequence, _80x_sequence)
run2_miniAOD_80XLegacy.toReplaceWith( nanoSequenceMC, _80x_sequenceMC)
def addFlashggPFCHSJets(
process,
isData,
vertexIndex=0,
#doQGTagging = True,
label='',
debug=False):
setattr(
process, 'selectedMuons' + label,
cms.EDFilter("CandPtrSelector",
src=cms.InputTag("slimmedMuons"),
cut=cms.string('''abs(eta)<2.5 && pt>10. &&
(pfIsolationR04().sumChargedHadronPt+
max(0.,pfIsolationR04().sumNeutralHadronEt+
pfIsolationR04().sumPhotonEt-
0.50*pfIsolationR04().sumPUPt))/pt < 0.20 &&
(isPFMuon && (isGlobalMuon || isTrackerMuon) )'''
)))
setattr(
process, 'selectedElectrons' + label,
cms.EDFilter("CandPtrSelector",
src=cms.InputTag("slimmedElectrons"),
cut=cms.string('''abs(eta)<2.5 && pt>20. &&
gsfTrack.isAvailable() &&
gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2 &&
(pfIsolationVariables().sumChargedHadronPt+
max(0.,pfIsolationVariables().sumNeutralHadronEt+
pfIsolationVariables().sumPhotonEt-
0.5*pfIsolationVariables().sumPUPt))/pt < 0.15'''
)))
# Simple producer which just removes the Candidates which
# don't come from the legacy vertex according to the Flashgg Vertex Map
setattr(
process, 'flashggCHSLegacyVertexCandidates' + label,
cms.EDProducer(
'FlashggMultiCHSLegacyVertexCandProducer',
PFCandidatesTag=cms.InputTag('packedPFCandidates'),
DiPhotonTag=cms.InputTag('flashggDiPhotons'),
VertexCandidateMapTag=cms.InputTag("flashggVertexMapForCHS"),
VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'),
vertexIndex=cms.uint32(vertexIndex),
debug=cms.untracked.bool(debug)))
setattr(
process, 'pfCHSLeg' + label,
cms.EDFilter("CandPtrSelector",
src=cms.InputTag('flashggCHSLegacyVertexCandidates' +
label),
cut=cms.string('')))
# then remove the previously selected muons
setattr(
process, 'pfNoMuonCHSLeg' + label,
cms.EDProducer("CandPtrProjector",
src=cms.InputTag("pfCHSLeg" + label),
veto=cms.InputTag("selectedMuons" + label)))
# then remove the previously selected electrons
setattr(
process, 'pfNoElectronsCHSLeg' + label,
cms.EDProducer("CandPtrProjector",
src=cms.InputTag("pfNoMuonCHSLeg" + label),
veto=cms.InputTag("selectedElectrons" + label)))
#Import RECO jet producer for ak4 PF and GEN jet
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
setattr(
process, 'ak4PFJetsCHSLeg' + label,
ak4PFJets.clone(src='pfNoElectronsCHSLeg' + label, doAreaFastjet=True))
if isData:
JECs = ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']
else:
JECs = ['L1FastJet', 'L2Relative', 'L3Absolute']
# NOTE: this is the 74X recipe for the jet clustering
addJetCollection(
process,
postfix=label,
labelName='AK4PFCHSLeg',
jetSource=cms.InputTag('ak4PFJetsCHSLeg' + label),
pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'),
pfCandidates=cms.InputTag('packedPFCandidates'),
svSource=cms.InputTag('slimmedSecondaryVertices'),
btagDiscriminators=[flashggBTag],
jetCorrections=('AK4PFchs', JECs, 'None'),
genJetCollection=cms.InputTag('slimmedGenJets'),
genParticles=cms.InputTag('prunedGenParticles'),
# jet param
algo='AK',
rParam=0.4,
btagInfos=['pfImpactParameterTagInfos',
'pfSecondaryVertexTagInfos'] #Extra btagging info
)
#Recalculate btagging info
getattr(process, 'patJetsAK4PFCHSLeg' + label).addTagInfos = True
#adjust PV used for Jet Corrections
#process.patJetCorrFactorsAK4PFCHSLeg.primaryVertices = "offlineSlimmedPrimaryVertices"
getattr(process, 'patJetCorrFactorsAK4PFCHSLeg' +
label).primaryVertices = "offlineSlimmedPrimaryVertices"
if not hasattr(process, "QGPoolDBESSource"):
process.QGPoolDBESSource = cms.ESSource(
"PoolDBESSource",
CondDBSetup,
toGet=cms.VPSet(),
connect=cms.string('sqlite:QGL_' + qgDatabaseVersion + '.db'))
process.es_prefer_qg = cms.ESPrefer('PoolDBESSource',
'QGPoolDBESSource')
for type in ['AK4PFchs']: #,'AK4PFchs_antib']:
process.QGPoolDBESSource.toGet.extend(
cms.VPSet(
cms.PSet(record=cms.string('QGLikelihoodRcd'),
tag=cms.string('QGLikelihoodObject_' +
qgDatabaseVersion + '_' + type),
label=cms.untracked.string('QGL_' + type))))
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
setattr(
process, 'QGTaggerPFCHS' + label,
QGTagger.clone(srcJets='patJetsAK4PFCHSLeg' + label,
jetsLabel='QGL_AK4PFchs',
vertexIndex=cms.uint32(vertexIndex),
srcVertexCollection='offlineSlimmedPrimaryVertices'))
from RecoJets.JetProducers.PileupJetIDParams_cfi import full_80x_chs
flashggJets = cms.EDProducer(
'FlashggJetProducer',
DiPhotonTag=cms.InputTag('flashggDiPhotons'),
VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'),
JetTag=cms.InputTag('patJetsAK4PFCHSLeg' + label),
VertexCandidateMapTag=cms.InputTag("flashggVertexMapForCHS"),
qgVariablesInputTag=cms.InputTag('QGTaggerPFCHS' + label,
'qgLikelihood'),
ComputeSimpleRMS=cms.bool(True),
ComputeRegVars=cms.bool(True),
PileupJetIdParameters=full_80x_chs,
rho=cms.InputTag("fixedGridRhoFastjetAll"),
JetCollectionIndex=cms.uint32(vertexIndex),
Debug=cms.untracked.bool(False))
setattr(process, 'flashggPFCHSJets' + label, flashggJets)
# randomize Jets
from flashgg.MicroAOD.flashggRandomizedJetProducer_cfi import flashggRandomizedJets
flashggRandomizedPFCHSJets = flashggRandomizedJets.clone()
flashggRandomizedPFCHSJets.src = "flashggPFCHSJets" + label
setattr(process.RandomNumberGeneratorService,
'flashggRandomizedPFCHSJets' + label,
cms.PSet(initialSeed=cms.untracked.uint32(36423784 + int(label))))
setattr(process, 'flashggRandomizedPFCHSJets' + label,
flashggRandomizedPFCHSJets)
flashggSelectedJets = cms.EDFilter(
"FLASHggJetSelector",
src=cms.InputTag('flashggRandomizedPFCHSJets' + label),
cut=cms.string("pt > 15."))
setattr(process, 'flashggSelectedPFCHSJets' + label, flashggSelectedJets)
def addFlashggPFCHSJets(
process,
DeepJet,
isData,
vertexIndex=0,
#doQGTagging = True,
label='',
debug=False):
setattr(
process, 'pfCHSLeg' + label,
cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("fromPV(%i)" % vertexIndex)))
#Import RECO jet producer for ak4 PF and GEN jet
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
setattr(process, 'ak4PFJetsCHSLeg' + label,
ak4PFJets.clone(src='pfCHSLeg' + label, doAreaFastjet=True))
if isData:
JECs = ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']
else:
JECs = ['L1FastJet', 'L2Relative', 'L3Absolute']
# NOTE: this is the 74X recipe for the jet clustering - has been confirmed to give reasonable results in 10X
addJetCollection(
process,
postfix=label,
labelName='AK4PFCHSLeg',
jetSource=cms.InputTag('ak4PFJetsCHSLeg' + label),
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', JECs, 'None'),
genJetCollection=cms.InputTag('slimmedGenJets'),
genParticles=cms.InputTag('prunedGenParticles'),
# jet param
algo='AK',
rParam=0.4
#btagInfos = ['pfImpactParameterTagInfos', 'pfSecondaryVertexTagInfos', 'pfInclusiveSecondaryVertexFinderTagInfos', 'softPFMuonsTagInfos', 'softPFElectronsTagInfos'] #Extra Btagging Info
)
#Recalculate btagging info
getattr(process, 'patJetsAK4PFCHSLeg' + label).addTagInfos = True
#adjust PV used for Jet Corrections
#process.patJetCorrFactorsAK4PFCHSLeg.primaryVertices = "offlineSlimmedPrimaryVertices"
getattr(process, 'patJetCorrFactorsAK4PFCHSLeg' +
label).primaryVertices = "offlineSlimmedPrimaryVertices"
if DeepJet == "rerun":
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
jetSource=cms.InputTag("slimmedJets"),
pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'),
svSource=cms.InputTag('slimmedSecondaryVertices'),
btagDiscriminators=[
flashggDeepFlavourb,
flashggDeepFlavourbb,
flashggDeepFlavourc,
flashggDeepFlavouruds,
flashggDeepFlavourlepb,
flashggDeepFlavourg,
],
jetCorrections=('AK4PFchs', JECs, 'None'),
)
miniaodJets = "selectedUpdatedPatJets"
else:
miniaodJets = "slimmedJets"
if not hasattr(process, "QGPoolDBESSource"):
process.QGPoolDBESSource = cms.ESSource(
"PoolDBESSource",
#CondDB,
toGet=cms.VPSet(),
connect=cms.string('sqlite:QGL_' + qgDatabaseVersion + '.db'))
process.es_prefer_qg = cms.ESPrefer('PoolDBESSource',
'QGPoolDBESSource')
for type in ['AK4PFchs']: #,'AK4PFchs_antib']:
process.QGPoolDBESSource.toGet.extend(
cms.VPSet(
cms.PSet(record=cms.string('QGLikelihoodRcd'),
tag=cms.string('QGLikelihoodObject_v1_AK4'),
label=cms.untracked.string('QGL_' + type))))
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
setattr(
process, 'QGTaggerPFCHS' + label,
QGTagger.clone(srcJets='patJetsAK4PFCHSLeg' + label,
jetsLabel='QGL_AK4PFchs',
vertexIndex=cms.uint32(vertexIndex),
srcVertexCollection='offlineSlimmedPrimaryVertices'))
from RecoJets.JetProducers.PileupJetIDParams_cfi import full_81x_chs
pujidparam = full_81x_chs
flashggJets = cms.EDProducer(
'FlashggJetProducer',
DiPhotonTag=cms.InputTag('flashggDiPhotons'),
VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'),
JetTag=cms.InputTag('patJetsAK4PFCHSLeg' + label),
VertexCandidateMapTag=cms.InputTag("flashggVertexMapForCHS"),
qgVariablesInputTag=cms.InputTag('QGTaggerPFCHS' + label,
'qgLikelihood'),
ComputeSimpleRMS=cms.bool(True),
PileupJetIdParameters=pujidparam,
rho=cms.InputTag("fixedGridRhoFastjetAll"),
JetCollectionIndex=cms.uint32(vertexIndex),
Debug=cms.untracked.bool(debug),
DoPuJetID=cms.bool(True),
ComputeRegVars=cms.bool(True),
MinPtForEneSum=cms.double(0.),
MaxEtaForEneSum=cms.double(2.5),
NJetsForEneSum=cms.uint32(0),
MiniAodJetTag=cms.InputTag(miniaodJets))
setattr(process, 'flashggPFCHSJets' + label, flashggJets)
# randomize Jets
from flashgg.MicroAOD.flashggRandomizedJetProducer_cfi import flashggRandomizedJets
flashggRandomizedPFCHSJets = flashggRandomizedJets.clone()
flashggRandomizedPFCHSJets.src = "flashggPFCHSJets" + label
setattr(process.RandomNumberGeneratorService,
'flashggRandomizedPFCHSJets' + label,
cms.PSet(initialSeed=cms.untracked.uint32(36423784 + int(label))))
setattr(process, 'flashggRandomizedPFCHSJets' + label,
flashggRandomizedPFCHSJets)
flashggSelectedJets = cms.EDFilter(
"FLASHggJetSelector",
src=cms.InputTag('flashggRandomizedPFCHSJets' + label),
cut=cms.string("pt > 15."))
setattr(process, 'flashggSelectedPFCHSJets' + label, flashggSelectedJets)
def JetSubstructure(process,
isMC,
coneSize=0.8,
algo="AK",
pileupMethod="chs",
selection="pt > 175 && abs(eta) < 2.5",
addPruning=True,
addPrunedSubjets=True,
addSoftDrop=True,
addSoftDropSubjets=True,
addTrimming=False,
addTrimmedSubjets=False,
addFiltering=False,
addFilteredSubjets=False,
addNsubjettiness=True,
addEnergyCorrelation=True,
addQJets=False,
addQGLikelihood=True):
print "############################"
print "add substructure information"
print "isMC = ", isMC
print "coneSize = ", coneSize
print "algo = ", algo
print "pileupMethod = ", pileupMethod
print "selection = ", selection
print "addPruning = ", addPruning
print "addPrunedSubjets = ", addPrunedSubjets
print "addSoftDrop = ", addSoftDrop
print "addSoftDropSubjets = ", addSoftDropSubjets
print "addTrimming = ", addTrimming
print "addTrimmedSubjets = ", addTrimmedSubjets
print "addFiltering = ", addFiltering
print "addFilteredSubjets = ", addFilteredSubjets
print "addNsubjettiness = ", addNsubjettiness
print "addEnergyCorrelation = ", addEnergyCorrelation
print "addQJets = ", addQJets
print "addQGLikelihood = ", addQGLikelihood
print "############################"
## build jet algo name for jet clustering
coneSizeStr = str(coneSize).replace("0", "").replace(".", "")
jetAlgo = algo + coneSizeStr
if algo == "AK":
ALGO = "AntiKt"
elif algo == "CA":
ALGO = "CambridgeAachen"
if isMC:
## run gen jet clustering from genParticles
if not hasattr(process, "genParticlesForJetsNoNu"):
setattr(
process, 'genParticlesForJetsNoNu',
cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("packedGenParticles"),
cut=cms.string(
"abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16 && abs(pdgId) != 1000022 && abs(pdgId) != 1000012 &&"
+
"abs(pdgId) != 1000014 && abs(pdgId) != 1000016 && abs(pdgId) != 2000012 && abs(pdgId) != 2000014 &&"
+
"abs(pdgId) != 2000016 && abs(pdgId) != 1000039 && abs(pdgId) != 5100039 && abs(pdgId) != 4000012 &&"
+
"abs(pdgId) != 4000014 && abs(pdgId) != 4000016 && abs(pdgId) != 9900012 && abs(pdgId) != 9900014 &&"
+
"abs(pdgId) != 9900016 && abs(pdgId) != 39 && abs(pdgId) != 9100012"
))) ## skip all the possible invisible particles
if not hasattr(process, "genJets" + jetAlgo):
setattr(
process, "genJets" + jetAlgo,
ak4GenJets.clone(src='genParticlesForJetsNoNu',
rParam=coneSize,
jetAlgorithm=ALGO,
jetPtMin=cms.double(50.))
) ## fix a lower reasonable threshold give the jet response
## filter only hadronically decaying W/Z and Higgs at generator level
if not hasattr(process, "genBosons"):
setattr(
process, "genBosons",
cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("prunedGenParticles"),
cut=cms.string(
"(abs(pdgId) == 23 || abs(pdgId) == 24 || abs(pdgId) == 25) &&"
+
"numberOfDaughters > 1 && abs(daughter(0).pdgId) <= 5 && abs(daughter(1).pdgId) <= 5"
)))
## b-tag discriminators to be considered
bTagDiscriminators = [
#'pfCombinedInclusiveSecondaryVertexV2BJetTags', ## don't run b-tagging on the whole large cone jet
'pfBoostedDoubleSecondaryVertexAK8BJetTags' ## new tag for Boosted double b-tagging
]
## jet energy corrections already loaded in JECLevels
if pileupMethod != "chs" and pileupMethod != "Puppi" and pileupMethod != "":
sys.exit(
"Invalid pileupMethod setup --> only recognized options are 'chs' and 'Puppi'"
)
## JEC
JECLevel = copy.deepcopy(process.JECLevels.labels)
payloadName = ""
payloadNameSubJet = ""
jetCollection = ""
pfCand = ""
## in case of CHS select particles and re-cluster jets
if pileupMethod == "chs":
## obtain chs candidates
if not hasattr(process, "chs"):
setattr(
process, 'chs',
cms.EDFilter('CandPtrSelector',
src=cms.InputTag("packedPFCandidates"),
cut=cms.string('fromPV')))
## cluster basic jets given rParameter and algorithm
if not hasattr(process, jetAlgo + 'PFJets' + pileupMethod.upper()):
setattr(
process, jetAlgo + 'PFJets' + pileupMethod.upper(),
ak4PFJetsCHS.clone(src=cms.InputTag('chs'),
doAreaFastjet=True,
rParam=coneSize,
jetAlgorithm=ALGO))
payloadName = jetAlgo + 'PF' + pileupMethod
payloadNameSubjet = 'AK4PF' + pileupMethod
jetCollection = jetAlgo + 'PFJets' + pileupMethod.upper()
pfCand = "chs"
## for puppi jets
elif pileupMethod == "Puppi":
### re-run optimal puppi weights
if not hasattr(process, "puppi"):
from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD
makePuppiesFromMiniAOD(process, False)
process.puppi.useExistingWeights = cms.bool(False)
process.puppiNoLep.useExistingWeights = cms.bool(False)
## cluster puppi jets given rParameter and algorithm
if not hasattr(process, jetAlgo + 'PFJets' + pileupMethod):
setattr(
process, jetAlgo + 'PFJets' + pileupMethod,
ak4PFJetsPuppi.clone(src=cms.InputTag('puppi'),
doAreaFastjet=True,
rParam=coneSize,
jetAlgorithm=ALGO))
payloadName = jetAlgo + 'PF' + pileupMethod
payloadNameSubjet = 'AK4PF' + pileupMethod
jetCollection = jetAlgo + 'PFJets' + pileupMethod
pfCand = "puppi"
## standard PF jets
elif pileupMethod == "":
## no pileup mitigation
if not hasattr(process, jetAlgo + 'PFJets'):
setattr(
process, jetAlgo + 'PFJets',
ak4PFJetsPuppi.clone(src=cms.InputTag('packedPFCandidates'),
doAreaFastjet=True,
rParam=coneSize,
jetAlgorithm=ALGO))
payloadName = jetAlgo + 'PF'
payloadNameSubjet = 'AK4PF'
jetCollection = jetAlgo + 'PFJets'
pfCand = "packedPFCandidates"
## apply selection and produce a restricted set of consituents only for jets passig the selection
if not hasattr(process, jetCollection + "Reduced"):
setattr(
process, jetCollection + "Reduced",
cms.EDFilter("MiniAODJetConstituentSelector",
src=cms.InputTag(jetCollection),
cut=cms.string("pt > 100 && abs(eta) < 2.5")))
## build pat-jets from this skimmed collection: example
if not hasattr(process, "patJets" + jetCollection):
addJetCollection(
process,
labelName=jetCollection,
jetSource=cms.InputTag(jetCollection + "Reduced"),
algo=algo,
rParam=coneSize,
pfCandidates=cms.InputTag(pfCand),
jetCorrections=(payloadName, JECLevel, 'None'),
svSource=cms.InputTag('slimmedSecondaryVertices'),
genJetCollection=cms.InputTag("genJets" + jetAlgo),
pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'),
btagDiscriminators=bTagDiscriminators,
getJetMCFlavour=isMC,
genParticles=cms.InputTag("prunedGenParticles"),
)
### special jec set for pruned/sof-drop mass correction --> to be taken from the EDAnalyzer
if hasattr(process, "patJetCorrFactors" + jetCollection):
if isMC:
setattr(
process, "patJetCorrFactors" + jetCollection + "v2",
getattr(
process, "patJetCorrFactors" + jetCollection).clone(
levels=cms.vstring('L2Relative', 'L3Absolute')))
else:
setattr(
process, "patJetCorrFactors" + jetCollection + "v2",
getattr(process, "patJetCorrFactors" +
jetCollection).clone(levels=cms.vstring(
'L2Relative', 'L3Absolute', 'L2L3Residual')))
getattr(process, "patJets" +
jetCollection).jetCorrFactorsSource = cms.VInputTag(
cms.InputTag("patJetCorrFactors" + jetCollection),
cms.InputTag("patJetCorrFactors" + jetCollection +
"v2"))
if hasattr(process, "selectedPatJets" + jetCollection):
getattr(process, "selectedPatJets" +
jetCollection).cut = cms.string(selection)
## match reco-jets with hadronically decaying genBosons (W,Z,H)
if isMC:
if not hasattr(process, jetCollection + 'GenBosonMatched'):
setattr(
process,
jetCollection + 'GenBosonMatched',
cms.EDProducer(
"RecoJetCandDeltaRValueMapProducer",
## basic reco::jet ungroomed
src=cms.InputTag(jetCollection + "Reduced"),
## mathched groomed pat jet
matched=cms.InputTag('genBosons'),
distMax=cms.double(coneSize),
values=cms.vstring("pt", "eta", "phi", "mass"),
valueLabels=cms.vstring("pt", "eta", "phi", "mass")))
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + 'GenBosonMatched:pt'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + 'GenBosonMatched:eta'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + 'GenBosonMatched:phi'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + 'GenBosonMatched:mass'
]
## add QGLikelihood on fat jet
if addQGLikelihood:
if not hasattr(process, jetCollection + "QGL"):
setattr(
process, jetCollection + "QGL",
QGTagger.clone(srcJets=cms.InputTag(jetCollection + "Reduced"),
jetsLabel=cms.string('QGL_AK4PFchs'),
srcVertexCollection=cms.InputTag(
'offlineSlimmedPrimaryVertices')))
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + 'QGL:qgLikelihood'
]
## addNsubjettiness
if addNsubjettiness:
if not hasattr(process, 'Njettiness' + jetCollection):
setattr(
process, 'Njettiness' + jetCollection,
Njettiness.clone(src=cms.InputTag(jetCollection + "Reduced"),
cone=cms.double(coneSize)))
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
'Njettiness' + jetCollection + ':tau1',
'Njettiness' + jetCollection + ':tau2',
'Njettiness' + jetCollection + ':tau3',
'Njettiness' + jetCollection + ':tau4'
]
## on gen jets
if isMC:
if not hasattr(process, "NjettinessGenJets" + jetAlgo):
setattr(
process, "NjettinessGenJets" + jetAlgo,
Njettiness.clone(src=cms.InputTag("genJets" + jetAlgo),
cone=cms.double(coneSize)))
## pattify gen jets --> temp
if not hasattr(process, 'patGenJets' + jetAlgo):
setattr(
process, 'patGenJets' + jetAlgo,
patJets.clone(
jetSource=cms.InputTag("genJets" + jetAlgo),
addJetCorrFactors=cms.bool(False),
addBTagInfo=cms.bool(False),
addDiscriminators=cms.bool(False),
discriminatorSources=cms.VInputTag('None'),
addAssociatedTracks=cms.bool(False),
addJetCharge=cms.bool(False),
addGenPartonMatch=cms.bool(False),
embedGenPartonMatch=cms.bool(False),
addGenJetMatch=cms.bool(False),
embedGenJetMatch=cms.bool(False),
getJetMCFlavour=cms.bool(False),
addJetFlavourInfo=cms.bool(False)))
getattr(process, 'patGenJets' +
jetAlgo).userData.userFloats.src += [
"NjettinessGenJets" + jetAlgo + ':tau1'
]
getattr(process, 'patGenJets' +
jetAlgo).userData.userFloats.src += [
"NjettinessGenJets" + jetAlgo + ':tau2'
]
getattr(process, 'patGenJets' +
jetAlgo).userData.userFloats.src += [
"NjettinessGenJets" + jetAlgo + ':tau3'
]
getattr(process, 'patGenJets' +
jetAlgo).userData.userFloats.src += [
"NjettinessGenJets" + jetAlgo + ':tau4'
]
if not hasattr(process, jetCollection + 'GenNjettinessMatched'):
setattr(
process,
jetCollection + 'GenNjettinessMatched',
cms.EDProducer(
"RecoPATJetDeltaRValueMapProducer",
## basic reco::jet ungroomed
src=cms.InputTag(jetCollection + "Reduced"),
## mathched groomed pat jet
matched=cms.InputTag('patGenJets' + jetAlgo),
distMax=cms.double(coneSize),
values=cms.vstring(
"userFloat('NjettinessGenJets" + jetAlgo +
":tau1')", "userFloat('NjettinessGenJets" +
jetAlgo + ":tau2')",
"userFloat('NjettinessGenJets" + jetAlgo +
":tau3')", "userFloat('NjettinessGenJets" +
jetAlgo + ":tau4')"),
valueLabels=cms.vstring("tau1", "tau2", "tau3",
"tau4")))
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + 'GenNjettinessMatched:tau1',
jetCollection + 'GenNjettinessMatched:tau2',
jetCollection + 'GenNjettinessMatched:tau3',
jetCollection + 'GenNjettinessMatched:tau4'
]
## add ECF
if addEnergyCorrelation:
if not hasattr(process, 'ecf' + jetCollection):
setattr(
process, 'ecf' + jetCollection,
ECF.clone(src=cms.InputTag(jetCollection + "Reduced"),
Njets=cms.vuint32(1, 2, 3)))
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
'ecf' + jetCollection + ':ecf1'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
'ecf' + jetCollection + ':ecf2'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
'ecf' + jetCollection + ':ecf3'
]
## add QJets
if addQJets:
if not hasattr(process, "qjets" + jetCollection):
setattr(
process, "qjets" + jetCollection,
QJetsAdder.clone(src=cms.InputTag(jetCollection + "Reduced"),
jeRad=cms.double(coneSize),
jetAlgo=cms.string(algo)))
setattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
"qjets" + jetCollection + ":QjetsVolatility"
]
### start with substructure: Pruning (run it on both reco and gen jets):
Tags = []
Labels = []
JECLevelTemp = copy.deepcopy(JECLevel)
if 'L1FastJet' in JECLevelTemp:
JECLevelTemp.remove(
'L1FastJet') ## in any case groomers are removing already pileup
if addPruning:
runGroomedMethod(process,
isMC=isMC,
jetCollection=jetCollection,
coneSize=coneSize,
algo=algo,
payloadName=payloadName,
payloadNameSubjet=payloadNameSubjet,
JECLevel=JECLevelTemp,
pfCand=pfCand,
btagDiscriminators=bTagDiscriminators,
addSubJets=addPrunedSubjets,
addQGLikelihood=addQGLikelihood,
isPruning=True,
isSoftDrop=False,
isTrimming=False,
isFiltering=False)
if addPrunedSubjets:
Tags += ['patJets' + jetCollection + 'PrunedPacked']
Labels += ['Pruned']
if addSoftDrop:
runGroomedMethod(process,
isMC=isMC,
jetCollection=jetCollection,
coneSize=coneSize,
algo=algo,
payloadName=payloadName,
payloadNameSubjet=payloadNameSubjet,
JECLevel=JECLevelTemp,
pfCand=pfCand,
btagDiscriminators=bTagDiscriminators,
addSubJets=addSoftDropSubjets,
addQGLikelihood=addQGLikelihood,
isPruning=False,
isSoftDrop=True,
isTrimming=False,
isFiltering=False)
if addSoftDropSubjets:
Tags += ['patJets' + jetCollection + 'SoftDropPacked']
Labels += ['SoftDrop']
if addTrimming:
runGroomedMethod(process,
isMC=isMC,
jetCollection=jetCollection,
coneSize=coneSize,
algo=algo,
payloadName=payloadName,
payloadNameSubjet=payloadNameSubjet,
JECLevel=JECLevelTemp,
pfCand=pfCand,
btagDiscriminators=bTagDiscriminators,
addSubJets=addTrimmedSubjets,
addQGLikelihood=addQGLikelihood,
isPruning=False,
isSoftDrop=False,
isTrimming=True,
isFiltering=False)
if addTrimmedSubjets:
Tags += ['patJets' + jetCollection + 'TrimmedPacked']
Labels += ['Trimmed']
if addFiltering:
runGroomedMethod(process,
isMC=isMC,
jetCollection=jetCollection,
coneSize=coneSize,
algo=algo,
payloadName=payloadName,
payloadNameSubjet=payloadNameSubjet,
JECLevel=JECLevelTemp,
pfCand=pfCand,
btagDiscriminators=bTagDiscriminators,
addSubJets=addFilteredSubjets,
addQGLikelihood=addQGLikelihood,
isPruning=False,
isSoftDrop=False,
isTrimming=False,
isFiltering=True)
if addFilteredSubjets:
Tags += ['patJets' + jetCollection + 'FilteredPacked']
Labels += ['Filtered']
## finally fix the pat fat jet collection
if not hasattr(process, "packedPatJets" + jetCollection):
setattr(
process, "packedPatJets" + jetCollection,
cms.EDProducer("JetSubstructurePacker",
jetSrc=cms.InputTag("selectedPatJets" +
jetCollection),
distMax=cms.double(coneSize),
fixDaughters=cms.bool(False),
algoTags=cms.VInputTag(),
algoLabels=cms.vstring()))
getattr(process, "packedPatJets" + jetCollection).algoTags = Tags
getattr(process, "packedPatJets" + jetCollection).algoLabels = Labels
return "packedPatJets" + jetCollection
def runGroomedMethod(process,
isMC,
jetCollection,
coneSize,
algo,
payloadName,
payloadNameSubjet,
JECLevel,
pfCand,
btagDiscriminators,
addSubJets=True,
addQGLikelihood=True,
isPruning=True,
isSoftDrop=True,
isTrimming=True,
isFiltering=True):
### name for cone size and algo
coneSizeStr = str(coneSize).replace("0", "").replace(".", "")
jetAlgo = algo + coneSizeStr
if algo == "AK":
ALGO = "AntiKt"
elif algo == "CA":
ALGO = "CambridgeAachen"
btagSubjets = ['pfCombinedInclusiveSecondaryVertexV2BJetTags']
### form the right postfix
if not isPruning and not isSoftDrop and not isTrimming and not isFiltering:
sys.exit("runGroomedMethod: all bools are false --> please check")
if isPruning and not isSoftDrop and not isTrimming and not isFiltering:
postfix = "Pruned"
elif not isPruning and isSoftDrop and not isTrimming and not isFiltering:
postfix = "SoftDrop"
elif not isPruning and not isSoftDrop and isTrimming and not isFiltering:
postfix = "Trimmed"
elif not isPruning and not isSoftDrop and not isTrimming and isFiltering:
postfix = "Filtered"
else:
sys.exit(
"wrong setup, only one groomer is allowed each time --> please check"
)
## build default reco groomed jets
if not hasattr(process, jetCollection + postfix):
if isPruning:
setattr(process, jetCollection + postfix,
ak8PFJetsCHSPruned.clone())
elif isSoftDrop:
setattr(process, jetCollection + postfix,
ak8PFJetsCHSSoftDrop.clone())
elif isTrimming:
setattr(process, jetCollection + postfix,
ak8PFJetsCHSTrimmed.clone())
elif isFiltering:
setattr(process, jetCollection + postfix,
ak8PFJetsCHSFiltered.clone())
getattr(process, jetCollection + postfix).src = cms.InputTag(
jetCollection + "Reduced", 'constituents')
getattr(process, jetCollection + postfix).rParam = coneSize
getattr(process, jetCollection + postfix).jetAlgorithm = ALGO
## write compounds means that subjets are stored as reco::Jet while the groomed jet is stored as base::Jet
getattr(process,
jetCollection + postfix).writeCompound = cms.bool(True)
getattr(process,
jetCollection + postfix).doAreaFastjet = cms.bool(True)
## gen groomed jets
if isMC:
if not hasattr(process, "genJets" + jetAlgo + postfix):
## store AK8 gen::Jet
setattr(
process, "genJets" + jetAlgo + postfix,
getattr(process, jetCollection + postfix).clone(
src=cms.InputTag('genParticlesForJetsNoNu'),
writeCompound=cms.bool(False),
useExplicitGhosts=cms.bool(True),
jetPtMin=cms.double(50.),
jetType=cms.string('GenJet'),
jetCollInstanceName=cms.string("")))
## pruned pat jets with embeded gen-jet info
if not hasattr(process, "patJets" + jetCollection + postfix):
addJetCollection(
process,
labelName=jetCollection + postfix,
jetSource=cms.InputTag(jetCollection + postfix),
algo=algo,
pfCandidates=cms.InputTag(pfCand),
rParam=coneSize,
jetCorrections=(payloadName, JECLevel, 'None'),
svSource=cms.InputTag('slimmedSecondaryVertices'),
genJetCollection=cms.InputTag("genJets" + jetAlgo + postfix),
pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'),
btagDiscriminators=
btagDiscriminators, ## no b-tag info for pruned jets
getJetMCFlavour=
isMC, ## no flavor info
genParticles=cms.InputTag("prunedGenParticles"))
## matched fat jet with groomed one adding info as user float
if not hasattr(process, jetCollection + postfix + 'Matched'):
setattr(
process,
jetCollection + postfix + 'Matched',
cms.EDProducer(
"RecoPATJetDeltaRValueMapProducer",
## basic reco::jet ungroomed
src=cms.InputTag(jetCollection + "Reduced"),
## mathched groomed pat jet
matched=cms.InputTag('patJets' + jetCollection + postfix),
distMax=cms.double(coneSize),
values=cms.vstring(
"mass", "pt", "eta", "phi",
"bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",
"bDiscriminator('pfBoostedDoubleSecondaryVertexAK8BJetTags')",
"correctedP4(0).mass()", "correctedP4(0).pt()",
"correctedP4(0).eta()", "correctedP4(0).phi()"),
valueLabels=cms.vstring(
"mass", "pt", "eta", "phi",
"pfCombinedInclusiveSecondaryVertexV2BJetTags",
"pfBoostedDoubleSecondaryVertexAK8BJetTags", "rawmass",
"rawpt", "raweta", "rawphi")))
if isMC:
getattr(process,
jetCollection + postfix + 'Matched').valueLabels += [
"hadronFlavour", "partonFlavour", "genMass", "genPt",
"genEta", "genPhi"
]
getattr(process, jetCollection + postfix + 'Matched').values += [
"hadronFlavour", "partonFlavour", "genJet().mass",
"genJet().pt", "genJet().eta", "genJet().phi"
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:mass'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:pt'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix +
'Matched:pfCombinedInclusiveSecondaryVertexV2BJetTags'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix +
'Matched:pfBoostedDoubleSecondaryVertexAK8BJetTags'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:eta'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:phi'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:rawmass'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:rawpt'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:raweta'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:rawphi'
]
if isMC:
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:hadronFlavour'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:partonFlavour'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:genMass'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:genPt'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:genEta'
]
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'Matched:genPhi'
]
## add QGL --> some tricks are needed
if addQGLikelihood:
## redo groomed jet with a special postfix (ForQGL)
if not hasattr(process, jetCollection + postfix + "ForQGL"):
setattr(
process, jetCollection + postfix + "ForQGL",
getattr(process, jetCollection + postfix).clone(
writeCompound=cms.bool(False),
jetCollInstanceName=cms.string("")))
## run QGL evaluator
if not hasattr(process, jetCollection + postfix + "QGL"):
setattr(
process, jetCollection + postfix + "QGL",
QGTagger.clone(srcJets=cms.InputTag(jetCollection + postfix +
"ForQGL"),
jetsLabel=cms.string('QGL_AK4PFchs'),
srcVertexCollection=cms.InputTag(
'offlineSlimmedPrimaryVertices')))
## pattify jets on the fly
if not hasattr(process, 'patJets' + jetCollection + postfix + "QGL"):
setattr(
process, 'patJets' + jetCollection + postfix + "QGL",
patJets.clone(jetSource=cms.InputTag(jetCollection + postfix +
"ForQGL"),
addJetCorrFactors=cms.bool(False),
addBTagInfo=cms.bool(False),
addDiscriminators=cms.bool(False),
discriminatorSources=cms.VInputTag('None'),
addAssociatedTracks=cms.bool(False),
addJetCharge=cms.bool(False),
addGenPartonMatch=cms.bool(False),
embedGenPartonMatch=cms.bool(False),
addGenJetMatch=cms.bool(False),
embedGenJetMatch=cms.bool(False),
getJetMCFlavour=cms.bool(False),
addJetFlavourInfo=cms.bool(False)))
getattr(process, 'patJets' + jetCollection + postfix +
"QGL").userData.userFloats.src += [
jetCollection + postfix + "QGL:qgLikelihood"
]
## match QGL value with the original jet
if not hasattr(process, jetCollection + postfix + "QGLMatched"):
setattr(
process, jetCollection + postfix + 'QGLMatched',
cms.EDProducer(
"RecoPATJetDeltaRValueMapProducer",
src=cms.InputTag(jetCollection + "Reduced"),
matched=cms.InputTag('patJets' + jetCollection + postfix +
"QGL"),
distMax=cms.double(coneSize),
values=cms.vstring("userFloat('" + jetCollection +
postfix + "QGL:qgLikelihood')"),
valueLabels=cms.vstring("qgLikelihood")))
getattr(process,
'patJets' + jetCollection).userData.userFloats.src += [
jetCollection + postfix + 'QGLMatched:qgLikelihood'
]
## add subjet information
if addSubJets:
## gen groomed sub-jets --> star with default clustering
if isMC and not hasattr(process,
"genJets" + jetAlgo + postfix + "SubJets"):
setattr(
process, "genJets" + jetAlgo + postfix + "SubJets",
getattr(process, "genJets" + jetAlgo + postfix).clone(
writeCompound=cms.bool(True),
jetCollInstanceName=cms.string('SubJets')))
if not hasattr(process,
"patJets" + jetCollection + postfix + "SubJets"):
addJetCollection(
process,
labelName=jetCollection + postfix + 'SubJets',
jetSource=cms.InputTag(jetCollection + postfix, 'SubJets'),
algo=algo, # needed for subjet b tagging
rParam=coneSize, # needed for subjet b tagging
pfCandidates=cms.InputTag(pfCand),
jetCorrections=(payloadNameSubjet, JECLevel, 'None'),
pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'),
svSource=cms.InputTag('slimmedSecondaryVertices'),
getJetMCFlavour=isMC,
genParticles=cms.InputTag("prunedGenParticles"),
btagDiscriminators=btagSubjets,
genJetCollection=cms.InputTag(
"genJets" + jetAlgo + postfix + "SubJets", "SubJets"),
explicitJTA=True, # needed for subjet b tagging
svClustering=True, # needed for subjet b tagging
fatJets=cms.InputTag(
jetCollection +
"Reduced"), # needed for subjet flavor clustering
groomedFatJets=cms.InputTag(
jetCollection +
postfix), # needed for subjet flavor clustering
)
## adding sub-jet QGL
if addQGLikelihood:
if not hasattr(process, jetCollection + postfix + "SubJetsQGL"):
setattr(
process, jetCollection + postfix + "SubJetsQGL",
QGTagger.clone(srcJets=cms.InputTag(
jetCollection + postfix, "SubJets"),
jetsLabel=cms.string('QGL_AK4PFchs'),
srcVertexCollection=cms.InputTag(
'offlineSlimmedPrimaryVertices')))
getattr(process, 'patJets' + jetCollection + postfix +
"SubJets").userData.userFloats.src += [
jetCollection + postfix + 'SubJetsQGL:qgLikelihood'
]
## Establish references between PATified fat jets and subjets using the BoostedJetMerger
if not hasattr(process,
'patJets' + jetCollection + postfix + 'Packed'):
setattr(
process, 'patJets' + jetCollection + postfix + 'Packed',
cms.EDProducer(
"BoostedJetMerger",
jetSrc=cms.InputTag('selectedPatJets' + jetCollection +
postfix),
subjetSrc=cms.InputTag("selectedPatJets" + jetCollection +
postfix + "SubJets")))
def makeJets(process, isData, label, candidates, suffix):
"""
Light-weight version of pat addJetCollection.
@labels: e.g. 'AK4PFPuppi'
"""
sequence = cms.Sequence()
addattr = AddAttr(process, sequence, suffix)
jets = addattr('ak4PFJets',
ak4PFJets.clone(src=candidates, doAreaFastjet=True))
jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute']
if isData:
jecLevels.append('L2L3Residual')
jetCorrFactors = addattr(
'jetCorrFactors',
patJetCorrFactors.clone(src=jets,
payload=label,
levels=jecLevels,
primaryVertices=pvSource))
# btag should always use standard PF collection
sequence += initBTag(process, '', pfSource, pvSource)
sequence += setupBTag(process,
jetCollection=jets,
suffix=suffix,
vsuffix='',
muons=muons,
electrons=electrons,
tags=[
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfCombinedMVAV2BJetTags', 'pfDeepCSVJetTags',
'pfDeepCMVAJetTags'
])
qgTagger = addattr('QGTagger', QGTagger.clone(srcJets=jets))
if not isData:
genJetMatch = addattr(
'genJetMatch',
patJetGenJetMatch.clone(src=jets, maxDeltaR=0.4, matched=genJets))
allPatJets = addattr('patJets',
patJets.clone(
jetSource = jets,
addJetCorrFactors = True,
jetCorrFactorsSource = [jetCorrFactors],
addBTagInfo = True,
discriminatorSources = [
cms.InputTag('pfCombinedInclusiveSecondaryVertexV2BJetTags' + suffix),
cms.InputTag('pfCombinedMVAV2BJetTags' + suffix),
] + \
sum([[cms.InputTag('pfDeepCSVJetTags' + suffix, 'prob' + prob),
cms.InputTag('pfDeepCMVAJetTags' + suffix, 'prob' + prob)]
# for prob in ['udsg', 'b', 'c', 'bb', 'cc']],
for prob in ['udsg', 'b', 'c', 'bb']],
[]),
addAssociatedTracks = False,
addJetCharge = False,
addGenPartonMatch = False,
addGenJetMatch = (not isData),
getJetMCFlavour = False,
addJetFlavourInfo = False
)
)
addattr.last.userData.userFloats.src = [
qgTagger.getModuleLabel() + ':qgLikelihood'
]
addattr.last.userData.userFloats.labelPostfixesToStrip = cms.vstring(
suffix)
if not isData:
addattr.last.genJetMatch = genJetMatch
selectedJets = addattr(
'selectedJets', selectedPatJets.clone(src=allPatJets, cut='pt > 15'))
addattr('slimmedJets',
slimmedJets.clone(src=selectedJets, rekeyDaughters='0'))
return sequence
def jetToolbox(proc,
jetType,
jetSequence,
PUMethod='',
bTagDiscriminators=None):
JETCorrPayload = 'None'
JETCorrLevels = ['None']
# See PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py for further options
bTagDiscriminators = [
'pfDeepCSVJetTags:probb',
'pfDeepCSVJetTags:probc',
'pfDeepCSVJetTags:probudsg',
'pfDeepCSVJetTags:probbb',
#'pfDeepFlavourJetTags:probb',
#'pfDeepFlavourJetTags:probc',
#'pfDeepFlavourJetTags:probg',
#'pfDeepFlavourJetTags:probuds',
#'pfDeepFlavourJetTags:probbb',
#'pfTrackCountingHighEffBJetTags',
'pfJetProbabilityBJetTags',
#'pfSimpleSecondaryVertexHighEffBJetTags',
'pfCombinedCvsLJetTags',
'pfCombinedCvsBJetTags',
'pfBoostedDoubleSecondaryVertexAK8BJetTags',
#'pfCombinedSecondaryVertexV2BJetTags',
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfCombinedMVAV2BJetTags',
'pfJetProbabilityBJetTags'
]
GetJetMCFlavour = ['True']
algorithm = 'AntiKt' # CambridgeAachen' , 'Kt'
size = jetType[-1:] #[-1:] takes the last char from string 'akX'
jetSize = float('0.' + jetType[-1:])
jetALGO = jetType.upper()
jetalgo = jetType.lower()
elemToKeep = []
print 'Running processes with: ' + str(
jetALGO
) + ' PF ' + PUMethod + ' jet algorithm with radius parameter ' + str(
jetSize)
JETCorrPayload = 'AK' + size + 'PF' + PUMethod.lower()
JETCorrLevels = ['L1FastJet', 'L2Relative', 'L3Absolute']
JEC = (JETCorrPayload, JETCorrLevels, 'None')
#################################################################################
####### Toolbox start
#################################################################################
elemToKeep = []
jetSeq = cms.Sequence()
genParticlesLabel = ''
pvLabel = ''
tvLabel = ''
toolsUsed = []
proc.load('RecoJets.Configuration.GenJetParticles_cff')
setattr(
proc, jetalgo + 'GenJetsNoNu',
ak4GenJets.clone(src='genParticlesForJetsNoNu',
rParam=jetSize,
jetAlgorithm=algorithm))
jetSeq += getattr(proc, jetalgo + 'GenJetsNoNu')
proc.load('CommonTools.ParticleFlow.pfNoPileUpJME_cff')
if (PUMethod == 'CHS'):
setattr(proc, jetalgo + 'PFJetsCHS',
ak4PFJets.clone(rParam=jetSize, jetAlgorithm=algorithm))
jetSeq += getattr(proc, jetalgo + 'PFJetsCHS')
setattr(
proc, jetalgo + 'PFJetsCHS',
ak4PFJetsCHS.clone(doAreaFastjet=True,
rParam=jetSize,
jetAlgorithm=algorithm))
jetSeq += getattr(proc, jetalgo + 'PFJetsCHS')
else:
setattr(proc, jetalgo + 'PFJets',
ak4PFJets.clone(rParam=jetSize, jetAlgorithm=algorithm))
jetSeq += getattr(proc, jetalgo + 'PFJets')
setattr(
proc, jetalgo + 'PFJets',
ak4PFJets.clone(doAreaFastjet=True,
rParam=jetSize,
jetAlgorithm=algorithm))
jetSeq += getattr(proc, jetalgo + 'PFJets')
PUMethod = ''
#### Creating PATjets
addJetCollection(
proc,
labelName=jetALGO + 'PF' + PUMethod,
jetSource=cms.InputTag(jetalgo + 'PFJets' + PUMethod),
algo=jetalgo,
btagDiscriminators=bTagDiscriminators,
rParam=jetSize,
jetCorrections=JEC,
pfCandidates=cms.InputTag('particleFlow'),
svSource=cms.InputTag('inclusiveCandidateSecondaryVertices'),
genJetCollection=cms.InputTag(jetalgo + 'GenJetsNoNu'),
pvSource=cms.InputTag(
'offlinePrimaryVertices'), #'offlineSlimmedPrimaryVertices'),
jetTrackAssociation=True)
# srcJets Could be reco::PFJetCollection or pat::JetCollection (both AOD and miniAOD)
# Other options for jetsLabel (might need to add an ESSource for it): see https://twiki.cern.ch/twiki/bin/viewauth/CMS/QGDataBaseVersion
setattr(
proc, 'QGTagger' + jetALGO + 'PF' + PUMethod,
QGTagger.clone(srcJets=cms.InputTag(jetalgo + 'PFJets' + PUMethod),
jetsLabel=cms.string('QGL_AK4PFchs')))
elemToKeep += ['keep *_QGTagger' + jetALGO + 'PF' + PUMethod + '_*_*']
getattr(proc,
'patJets' + jetALGO + 'PF' + PUMethod).userData.userFloats.src += [
'QGTagger' + jetALGO + 'PF' + PUMethod + ':qgLikelihood'
]
jetSeq += getattr(proc, 'QGTagger' + jetALGO + 'PF' + PUMethod)
toolsUsed.append('QGTagger' + jetALGO + 'PF' + PUMethod)
getattr(proc, 'patJetPartons').particles = cms.InputTag(
'genParticles') #'prunedGenParticles')
setattr(proc, 'selectedPatJets' + jetALGO + 'PF' + PUMethod,
selectedPatJets.clone(src='patJets' + jetALGO + 'PF' + PUMethod))
setattr(proc, jetSequence, jetSeq)
def jetToolbox(proc, jetType, jetSequence):
# See PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py for further options
bTagDiscriminators = [
'pfDeepCSVJetTags:probb',
'pfDeepCSVJetTags:probc',
'pfDeepCSVJetTags:probudsg',
'pfDeepCSVJetTags:probbb',
#'pfDeepFlavourJetTags:probb',
#'pfDeepFlavourJetTags:probc',
#'pfDeepFlavourJetTags:probg',
#'pfDeepFlavourJetTags:probuds',
#'pfDeepFlavourJetTags:probbb',
#'pfTrackCountingHighEffBJetTags',
'pfJetProbabilityBJetTags',
#'pfSimpleSecondaryVertexHighEffBJetTags',
'pfCombinedCvsLJetTags',
'pfCombinedCvsBJetTags',
'pfBoostedDoubleSecondaryVertexAK8BJetTags',
#'pfCombinedSecondaryVertexV2BJetTags',
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfCombinedMVAV2BJetTags',
'pfJetProbabilityBJetTags'
]
print '|---- jetToolbox: Initialyzing collection...'
algorithm = 'AntiKt' # CambridgeAachen' , 'Kt'
size = jetType[-1:] #[-1:] takes the last char from string 'akX'
jetSize = float('0.' + jetType[-1:])
jetALGO = jetType.upper()
jetalgo = jetType.lower()
PUMethod = 'CHS'
jetNAME = jetALGO + 'PF' + PUMethod
jetname = jetalgo + 'PFJets' + PUMethod
gjetname = jetalgo + 'GenJetsNoNu'
print 'Running processes with: ' + jetNAME + ' jet algorithm with radius parameter ' + str(
jetSize)
JEC = ('AK' + size + 'PF' + PUMethod.lower(),
['L1FastJet', 'L2Relative', 'L3Absolute'], 'None')
print '|---- jetToolBox: Applying these corrections: ' + str(JEC)
#################################################################################
####### Toolbox start
#################################################################################
jetSeq = cms.Sequence()
# Creating GenJets
proc.load('RecoJets.Configuration.GenJetParticles_cff')
setattr(
proc, gjetname,
ak4GenJets.clone(src='genParticlesForJetsNoNu',
rParam=jetSize,
jetAlgorithm=algorithm))
jetSeq += getattr(proc, gjetname)
# Creating AK4PFJetsCHS
proc.load('CommonTools.ParticleFlow.pfNoPileUpJME_cff')
setattr(
proc, jetname,
ak4PFJetsCHS.clone(src=cms.InputTag('pfNoPileUpJME'),
doAreaFastjet=True,
rParam=jetSize,
jetAlgorithm=algorithm))
jetSeq += getattr(proc, jetname)
#### Creating PATjets
addJetCollection(
proc,
labelName=jetNAME,
jetSource=cms.InputTag(jetname),
algo=jetalgo,
rParam=jetSize,
btagDiscriminators=bTagDiscriminators,
jetCorrections=JEC,
pfCandidates=cms.InputTag('particleFlow'), #redundant (default)
svSource=cms.InputTag(
'inclusiveCandidateSecondaryVertices'), # redundant (default)
pvSource=cms.InputTag(
'offlinePrimaryVertices'), # redundant (default)
getJetMCFlavour=True, # redundant (default)
genJetCollection=cms.InputTag(gjetname),
jetTrackAssociation=True)
getattr(proc, 'patJets' + jetNAME).addTagInfos = cms.bool(True)
getattr(proc, 'patJets' + jetNAME).addAssociatedTracks = cms.bool(True)
setattr(
proc, 'QGTagger' + jetNAME,
QGTagger.clone(srcJets=cms.InputTag(jetname),
jetsLabel=cms.string('QGL_AK4PFchs')))
getattr(proc, 'patJets' + jetNAME).userData.userFloats.src += [
'QGTagger' + jetNAME + ':qgLikelihood'
]
jetSeq += getattr(proc, 'QGTagger' + jetNAME)
getattr(proc, 'patJetPartons').particles = cms.InputTag('genParticles')
# This is already done in addJetCollection, but I worry that the changes done to patJets do not get updated to selectedPatJets
setattr(proc, 'selectedPatJets' + jetNAME,
selectedPatJets.clone(src='patJets' + jetNAME))
# return
setattr(proc, jetSequence, jetSeq)
def jetToolbox( proc, jetType, jetSequence, outputFile,
newPFCollection=False, nameNewPFCollection = '',
PUMethod='CHS', #### Options: Puppi, CS, SK, Plain
miniAOD=True,
runOnMC=True,
JETCorrPayload='', JETCorrLevels = [ 'None' ], GetJetMCFlavour=True,
Cut = '',
bTagDiscriminators = None,
subJETCorrPayload='', subJETCorrLevels = [ 'None' ], GetSubjetMCFlavour=False,
CutSubjet = '',
addPruning=False, zCut=0.1, rCut=0.5, addPrunedSubjets=False,
addSoftDrop=False, betaCut=0.0, zCutSD=0.1, addSoftDropSubjets=False,
addTrimming=False, rFiltTrim=0.2, ptFrac=0.03,
addFiltering=False, rfilt=0.3, nfilt=3,
addCMSTopTagger=False,
addMassDrop=False,
addHEPTopTagger=False,
addNsub=False, maxTau=4,
addPUJetID=False,
addQJets=False,
addQGTagger=False, QGjetsLabel='chs',
addEnergyCorrFunc=False, ecfBeta = 1.0, maxECF=3,
):
runOnData = not runOnMC
if runOnData:
GetJetMCFlavour = False
GetSubjetMCFlavour = False
###############################################################################
####### Verifying some inputs and defining variables
###############################################################################
print '|---- jetToolbox: Initialyzing collection...'
if newPFCollection: print '|---- jetToolBox: Using '+ nameNewPFCollection +' as PFCandidates collection'
supportedJetAlgos = { 'ak': 'AntiKt', 'ca' : 'CambridgeAachen', 'kt' : 'Kt' }
recommendedJetAlgos = [ 'ak4', 'ak8', 'ca4', 'ca8', 'ca10' ]
payloadList = [ 'None',
'AK1PFchs', 'AK2PFchs', 'AK3PFchs', 'AK4PFchs', 'AK5PFchs', 'AK6PFchs', 'AK7PFchs', 'AK8PFchs', 'AK9PFchs', 'AK10PFchs',
'AK1PFPUPPI', 'AK2PFPUPPI', 'AK3PFPUPPI', 'AK4PFPUPPI', 'AK5PFPUPPI', 'AK6PFPUPPI', 'AK7PFPUPPI', 'AK8PFPUPPI', 'AK9PFPUPPI', 'AK10PFPUPPI',
'AK1PFSK', 'AK2PFSK', 'AK3PFSK', 'AK4PFSK', 'AK5PFSK', 'AK6PFSK', 'AK7PFSK', 'AK8PFSK', 'AK9PFSK', 'AK10PFSK',
'AK1PF', 'AK2PF', 'AK3PF', 'AK4PF', 'AK5PF', 'AK6PF', 'AK7PF', 'AK8PF', 'AK9PF', 'AK10PF' ]
JECLevels = [ 'L1Offset', 'L1FastJet', 'L1JPTOffset', 'L2Relative', 'L3Absolute', 'L5Falvour', 'L7Parton' ]
if runOnData:
JECLevels += ['L2L3Residual']
jetAlgo = ''
algorithm = ''
size = ''
for type, tmpAlgo in supportedJetAlgos.iteritems():
if type in jetType.lower():
jetAlgo = type
algorithm = tmpAlgo
size = jetType.replace( type, '' )
jetSize = 0.
if int(size) in range(0, 20): jetSize = int(size)/10.
else: print '|---- jetToolBox: jetSize has not a valid value. Insert a number between 1 and 20 after algorithm, like: AK8'
### Trick for uppercase/lowercase algo name
jetALGO = jetAlgo.upper()+size
jetalgo = jetAlgo.lower()+size
if jetalgo not in recommendedJetAlgos: print '|---- jetToolBox: CMS recommends the following jet algoritms: '+' '.join(recommendedJetAlgos)+'. You are using', jetalgo,'.'
#################################################################################
####### Toolbox start
#################################################################################
elemToKeep = []
jetSeq = cms.Sequence()
genParticlesLabel = ''
pvLabel = ''
tvLabel = ''
toolsUsed = []
#### For MiniAOD
if miniAOD:
print '|---- jetToolBox: JETTOOLBOX RUNNING ON MiniAOD FOR '+jetALGO+' JETS USING '+PUMethod
genParticlesLabel = 'prunedGenParticles'
pvLabel = 'offlineSlimmedPrimaryVertices'
svLabel = 'slimmedSecondaryVertices'
tvLabel = 'unpackedTracksAndVertices'
pfCand = nameNewPFCollection if newPFCollection else 'packedPFCandidates'
if runOnMC:
## Filter out neutrinos from packed GenParticles
setattr( proc, 'packedGenParticlesForJetsNoNu',
cms.EDFilter("CandPtrSelector",
src = cms.InputTag("packedGenParticles"),
cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16")
))
jetSeq += getattr(proc, 'packedGenParticlesForJetsNoNu' )
setattr( proc, jetalgo+'GenJetsNoNu',
ak4GenJets.clone( src = 'packedGenParticlesForJetsNoNu',
rParam = jetSize,
jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, jetalgo+'GenJetsNoNu' )
#for Inclusive Vertex Finder
proc.load('PhysicsTools.PatAlgos.slimming.unpackedTracksAndVertices_cfi')
#### For AOD
else:
print '|---- jetToolBox: JETTOOLBOX RUNNING ON AOD FOR '+jetALGO+' JETS USING '+PUMethod
genParticlesLabel = 'genParticles'
pvLabel = 'offlinePrimaryVertices'
tvLabel = 'generalTracks'
pfCand = nameNewPFCollection if newPFCollection else 'particleFlow'
svLabel = 'inclusiveCandidateSecondaryVertices'
if runOnMC:
proc.load('RecoJets.Configuration.GenJetParticles_cff')
setattr( proc, jetalgo+'GenJetsNoNu', ak4GenJets.clone( src = 'genParticlesForJetsNoNu', rParam = jetSize, jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, jetalgo+'GenJetsNoNu' )
## b-tag discriminators
if bTagDiscriminators is None:
bTagDiscriminators = [
'pfTrackCountingHighEffBJetTags',
'pfTrackCountingHighPurBJetTags',
'pfJetProbabilityBJetTags',
'pfJetBProbabilityBJetTags',
'pfSimpleSecondaryVertexHighEffBJetTags',
'pfSimpleSecondaryVertexHighPurBJetTags',
'pfCombinedSecondaryVertexV2BJetTags',
'pfCombinedInclusiveSecondaryVertexV2BJetTags'
]
### Jet Corrections
if not set(JETCorrLevels).issubset(set(JECLevels)):
if ( 'CHS' in PUMethod ) or ( 'Plain' in PUMethod ): JETCorrLevels = ['L1FastJet','L2Relative', 'L3Absolute']
else: JETCorrLevels = [ 'L2Relative', 'L3Absolute']
if runOnData: JETCorrLevels.append('L2L3Residual')
if not set(subJETCorrLevels).issubset(set(JECLevels)):
if ( 'CHS' in PUMethod ) or ( 'Plain' in PUMethod ): subJETCorrLevels = ['L1FastJet','L2Relative', 'L3Absolute']
else: subJETCorrLevels = [ 'L2Relative', 'L3Absolute']
if runOnData: subJETCorrLevels.append('L2L3Residual')
#### Creating PATjets
tmpPfCandName = pfCand.lower()
if 'Puppi' in PUMethod:
if ('puppi' in tmpPfCandName):
srcForPFJets = pfCand
print '|---- jetToolBox: Not running puppi algorithm because keyword puppi was specified in nameNewPFCollection, but applying puppi corrections.'
else:
proc.load('CommonTools.PileupAlgos.Puppi_cff')
puppi.candName = cms.InputTag( pfCand )
if miniAOD: puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
jetSeq += getattr(proc, 'puppi' )
srcForPFJets = 'puppi'
from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi
setattr( proc, jetalgo+'PFJetsPuppi',
ak4PFJetsPuppi.clone( src = cms.InputTag( srcForPFJets ),
doAreaFastjet = True,
rParam = jetSize,
jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, jetalgo+'PFJetsPuppi' )
if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PFPuppi'
if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PFPuppi'
elif 'CS' in PUMethod:
from RecoJets.JetProducers.ak4PFJetsCS_cfi import ak4PFJetsCS
setattr( proc, jetalgo+'PFJetsCS',
ak4PFJetsCS.clone( doAreaFastjet = True,
csRParam = cms.double(jetSize),
jetAlgorithm = algorithm ) )
if miniAOD: getattr( proc, jetalgo+'PFJetsCS').src = pfCand
#setattr( proc, jetalgo+'PFJetsCSConstituents', ak8PFJetsCSConstituents.clone( src = cms.InputTag(jetalgo+'PFJetsCS') ) )
jetSeq += getattr(proc, jetalgo+'PFJetsCS' )
#setattr( proc, jetalgo+'PFJetsCSConstituents', ak8PFJetsCSConstituents.clone( src = cms.InputTag(jetalgo+'PFJetsCS') ) )
jetSeq += getattr(proc, jetalgo+'PFJetsCS' )
if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PFCS'
if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PFCS'
elif 'SK' in PUMethod:
if ('sk' in tmpPfCandName):
srcForPFJets = pfCand
print '|---- jetToolBox: Not running softkiller algorithm because keyword SK was specified in nameNewPFCollection, but applying SK corrections.'
else:
proc.load('CommonTools.PileupAlgos.softKiller_cfi')
getattr( proc, 'softKiller' ).PFCandidates = cms.InputTag( pfCand )
jetSeq += getattr(proc, 'softKiller' )
srcForPFJets = 'softKiller'
from RecoJets.JetProducers.ak4PFJetsSK_cfi import ak4PFJetsSK
setattr( proc, jetalgo+'PFJetsSK',
ak4PFJetsSK.clone( src = cms.InputTag( srcForPFJets ),
rParam = jetSize,
jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, jetalgo+'PFJetsSK' )
if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PFSK'
if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PFSK'
elif 'CHS' in PUMethod:
if miniAOD:
if ('chs' in tmpPfCandName):
srcForPFJets = pfCand
print '|---- jetToolBox: Not running CHS algorithm because keyword CHS was specified in nameNewPFCollection, but applying CHS corrections.'
else:
setattr( proc, 'chs', cms.EDFilter('CandPtrSelector', src = cms.InputTag( pfCand ), cut = cms.string('fromPV')) )
jetSeq += getattr(proc, 'chs')
srcForPFJets = 'chs'
else:
if ( pfCand == 'particleFlow' ):
from RecoParticleFlow.PFProducer.particleFlowTmpPtrs_cfi import particleFlowTmpPtrs
setattr( proc, 'newParticleFlowTmpPtrs', particleFlowTmpPtrs.clone( src = pfCand ) )
jetSeq += getattr(proc, 'newParticleFlowTmpPtrs')
from CommonTools.ParticleFlow.pfNoPileUpJME_cff import pfPileUpJME, pfNoPileUpJME
proc.load('CommonTools.ParticleFlow.goodOfflinePrimaryVertices_cfi')
setattr( proc, 'newPfPileUpJME', pfPileUpJME.clone( PFCandidates= 'newParticleFlowTmpPtrs' ) )
jetSeq += getattr(proc, 'newPfPileUpJME')
setattr( proc, 'newPfNoPileUpJME', pfNoPileUpJME.clone( topCollection='newPfPileUpJME', bottomCollection= 'newParticleFlowTmpPtrs' ) )
jetSeq += getattr(proc, 'newPfNoPileUpJME')
srcForPFJets = 'newPfNoPileUpJME'
else:
proc.load('CommonTools.ParticleFlow.pfNoPileUpJME_cff')
srcForPFJets = 'pfNoPileUpJME'
setattr( proc, jetalgo+'PFJetsCHS',
ak4PFJetsCHS.clone( src = cms.InputTag( srcForPFJets ),
doAreaFastjet = True,
rParam = jetSize,
jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, jetalgo+'PFJetsCHS' )
if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PFchs'
if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PFchs'
else:
PUMethod = ''
setattr( proc, jetalgo+'PFJets',
ak4PFJets.clone(
doAreaFastjet = True,
rParam = jetSize,
jetAlgorithm = algorithm ) )
if miniAOD: getattr( proc, jetalgo+'PFJets').src = pfCand
jetSeq += getattr(proc, jetalgo+'PFJets' )
if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PF'
if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PF'
if 'None' in JETCorrPayload: JEC = None
else: JEC = ( JETCorrPayload.replace('CS','chs').replace('SK','chs') , JETCorrLevels, 'None' ) ### temporary
#else: JEC = ( JETCorrPayload., JETCorrLevels, 'None' )
print '|---- jetToolBox: Applying this corrections: '+str(JEC)
if addPrunedSubjets or addSoftDropSubjets or addCMSTopTagger:
if 'None' in subJETCorrPayload: subJEC = None
else: subJEC = ( subJETCorrPayload.replace('CS','chs').replace('SK','chs') , subJETCorrLevels, 'None' ) ### temporary
if ( 'CHS' in PUMethod ) and miniAOD: setattr( proc, jetalgo+'PFJets'+PUMethod+'Constituents', cms.EDFilter("MiniAODJetConstituentSelector", src = cms.InputTag( jetalgo+'PFJets'+PUMethod ), cut = cms.string( Cut ) ))
else: setattr( proc, jetalgo+'PFJets'+PUMethod+'Constituents', cms.EDFilter("PFJetConstituentSelector", src = cms.InputTag( jetalgo+'PFJets'+PUMethod ), cut = cms.string( Cut ) ))
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Constituents' )
addJetCollection(
proc,
labelName = jetALGO+'PF'+PUMethod,
jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod),
algo = jetalgo,
rParam = jetSize,
jetCorrections = JEC if JEC is not None else None,
pfCandidates = cms.InputTag( pfCand ),
svSource = cms.InputTag( svLabel ),
genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
pvSource = cms.InputTag( pvLabel ),
btagDiscriminators = bTagDiscriminators,
getJetMCFlavour = GetJetMCFlavour,
genParticles = cms.InputTag(genParticlesLabel),
outputModules = ['outputFile']
)
if 'CS' in PUMethod: getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod ).getJetMCFlavour = False # CS jets cannot be re-clustered from their constituents
#### Groomers
if addSoftDrop or addSoftDropSubjets:
setattr( proc, jetalgo+'PFJets'+PUMethod+'SoftDrop',
ak8PFJetsCHSSoftDrop.clone(
src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ),
rParam = jetSize,
jetAlgorithm = algorithm,
useExplicitGhosts=True,
R0= cms.double(jetSize),
#zcut=zCutSD,
beta=betaCut,
writeCompound = cms.bool(True),
jetCollInstanceName=cms.string('SubJets') ) )
setattr( proc, jetalgo+'PFJets'+PUMethod+'SoftDropMass',
ak8PFJetsCHSSoftDropMass.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod),
matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'SoftDrop'),
distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'SoftDropMass_*_*']
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'SoftDrop' )
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'SoftDropMass' )
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'SoftDropMass']
toolsUsed.append( jetalgo+'PFJets'+PUMethod+'SoftDropMass' )
if addSoftDropSubjets:
if runOnMC:
setattr( proc, jetalgo+'GenJetsNoNuSoftDrop',
ak4GenJets.clone(
SubJetParameters,
useSoftDrop = cms.bool(True),
rParam = jetSize,
jetAlgorithm = algorithm,
useExplicitGhosts=cms.bool(True),
#zcut=cms.double(zCutSD),
R0= cms.double(jetSize),
beta=cms.double(betaCut),
writeCompound = cms.bool(True),
jetCollInstanceName=cms.string('SubJets')
))
if miniAOD: getattr( proc, jetalgo+'GenJetsNoNuSoftDrop' ).src = 'packedGenParticlesForJetsNoNu'
jetSeq += getattr(proc, jetalgo+'GenJetsNoNuSoftDrop' )
addJetCollection(
proc,
labelName = jetALGO+'PF'+PUMethod+'SoftDrop',
jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod+'SoftDrop'),
algo = jetalgo,
rParam = jetSize,
jetCorrections = JEC if JEC is not None else None,
pvSource = cms.InputTag( pvLabel ),
btagDiscriminators = ['None'],
genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
getJetMCFlavour = False, # jet flavor should always be disabled for groomed jets
genParticles = cms.InputTag(genParticlesLabel),
outputModules = ['outputFile']
)
setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDrop', selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod+'SoftDrop', cut = Cut ) )
addJetCollection(
proc,
labelName = jetALGO+'PF'+PUMethod+'SoftDropSubjets',
jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod+'SoftDrop', 'SubJets'),
algo = jetalgo, # needed for subjet b tagging
rParam = jetSize, # needed for subjet b tagging
jetCorrections = subJEC if subJEC is not None else None,
pfCandidates = cms.InputTag( pfCand ),
pvSource = cms.InputTag( pvLabel),
svSource = cms.InputTag( svLabel ),
btagDiscriminators = bTagDiscriminators,
genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNuSoftDrop','SubJets'),
getJetMCFlavour = GetSubjetMCFlavour,
genParticles = cms.InputTag(genParticlesLabel),
explicitJTA = True, # needed for subjet b tagging
svClustering = True, # needed for subjet b tagging
fatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod), # needed for subjet flavor clustering
groomedFatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod+'SoftDrop'), # needed for subjet flavor clustering
outputModules = ['outputFile']
)
setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets', selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets', cut = Cut ))
## Establish references between PATified fat jets and subjets using the BoostedJetMerger
setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropPacked',
cms.EDProducer("BoostedJetMerger",
jetSrc=cms.InputTag('selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDrop'),
subjetSrc=cms.InputTag('selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets')
))
jetSeq += getattr(proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropPacked' )
elemToKeep += [ 'keep *_selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropPacked_*_*' ]
toolsUsed.append( 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropPacked' )
toolsUsed.append( 'selectedPatJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets' )
if addPruning or addPrunedSubjets:
setattr( proc, jetalgo+'PFJets'+PUMethod+'Pruned',
ak8PFJetsCHSPruned.clone(
src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ),
rParam = jetSize,
jetAlgorithm = algorithm,
zcut=zCut,
rcut_factor=rCut,
writeCompound = cms.bool(True),
doAreaFastjet = cms.bool(True),
jetCollInstanceName=cms.string('SubJets') ) )
setattr( proc, jetalgo+'PFJets'+PUMethod+'PrunedMass',
ak8PFJetsCHSPrunedMass.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod),
matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Pruned'),
distMax = cms.double( jetSize ) ) )
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Pruned' )
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'PrunedMass' )
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'PrunedMass']
elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'PrunedMass_*_*']
toolsUsed.append( jetalgo+'PFJets'+PUMethod+'PrunedMass' )
if addPrunedSubjets:
if runOnMC:
setattr( proc, jetalgo+'GenJetsNoNuPruned',
ak4GenJets.clone(
SubJetParameters,
rParam = jetSize,
usePruning = cms.bool(True),
writeCompound = cms.bool(True),
jetCollInstanceName=cms.string('SubJets')
))
if miniAOD: getattr( proc, jetalgo+'GenJetsNoNuPruned' ).src = 'packedGenParticlesForJetsNoNu'
jetSeq += getattr(proc, jetalgo+'GenJetsNoNuPruned' )
addJetCollection(
proc,
labelName = jetALGO+'PF'+PUMethod+'Pruned',
jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Pruned'),
algo = jetalgo,
rParam = jetSize,
jetCorrections = JEC if JEC is not None else None,
pvSource = cms.InputTag( pvLabel ),
btagDiscriminators = ['None'],
genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
getJetMCFlavour = False, # jet flavor should always be disabled for groomed jets
genParticles = cms.InputTag(genParticlesLabel),
outputModules = ['outputFile']
)
setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'Pruned', selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod+'Pruned', cut = Cut ) )
addJetCollection(
proc,
labelName = jetALGO+'PF'+PUMethod+'PrunedSubjets',
jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Pruned', 'SubJets'),
algo = jetalgo, # needed for subjet b tagging
rParam = jetSize, # needed for subjet b tagging
jetCorrections = subJEC if subJEC is not None else None,
pfCandidates = cms.InputTag( pfCand ),
pvSource = cms.InputTag( pvLabel),
svSource = cms.InputTag( svLabel ),
getJetMCFlavour = GetSubjetMCFlavour,
genParticles = cms.InputTag(genParticlesLabel),
btagDiscriminators = bTagDiscriminators,
genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNuPruned','SubJets'),
explicitJTA = True, # needed for subjet b tagging
svClustering = True, # needed for subjet b tagging
fatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod), # needed for subjet flavor clustering
groomedFatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod+'Pruned'), # needed for subjet flavor clustering
outputModules = ['outputFile']
)
setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets', selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets', cut = Cut ) )
## Establish references between PATified fat jets and subjets using the BoostedJetMerger
setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedPacked',
cms.EDProducer("BoostedJetMerger",
jetSrc=cms.InputTag('selectedPatJets'+jetALGO+'PF'+PUMethod+'Pruned'),
subjetSrc=cms.InputTag('selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets')
))
jetSeq += getattr(proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedPacked' )
elemToKeep += [ 'keep *_selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedPacked_*_*' ]
toolsUsed.append( 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedPacked' )
toolsUsed.append( 'selectedPatJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets' )
if addTrimming:
setattr( proc, jetalgo+'PFJets'+PUMethod+'Trimmed',
ak8PFJetsCHSTrimmed.clone(
rParam = jetSize,
src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents'),
jetAlgorithm = algorithm,
rFilt= rFiltTrim,
trimPtFracMin= ptFrac) )
setattr( proc, jetalgo+'PFJets'+PUMethod+'TrimmedMass',
ak8PFJetsCHSTrimmedMass.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod),
matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Trimmed'),
distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'TrimmedMass_*_*']
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Trimmed' )
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'TrimmedMass' )
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'TrimmedMass']
toolsUsed.append( jetalgo+'PFJets'+PUMethod+'TrimmedMass' )
if addFiltering:
setattr( proc, jetalgo+'PFJets'+PUMethod+'Filtered',
ak8PFJetsCHSFiltered.clone(
src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ),
rParam = jetSize,
jetAlgorithm = algorithm,
rFilt= rfilt,
nFilt= nfilt ) )
setattr( proc, jetalgo+'PFJets'+PUMethod+'FilteredMass',
ak8PFJetsCHSFilteredMass.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod),
matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Filtered'),
distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'FilteredMass_*_*']
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Filtered' )
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'FilteredMass' )
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'FilteredMass']
toolsUsed.append( jetalgo+'PFJets'+PUMethod+'FilteredMass' )
if addCMSTopTagger :
if 'CA' in jetALGO :
setattr( proc, 'cmsTopTagPFJets'+PUMethod,
cms.EDProducer("CATopJetProducer",
PFJetParameters.clone(
src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(False),
jetPtMin = cms.double(100.0)
),
AnomalousCellParameters,
CATopJetParameters.clone( jetCollInstanceName = cms.string("SubJets"),
verbose = cms.bool(False),
algorithm = cms.int32(1), # 0 = KT, 1 = CA, 2 = anti-KT
tagAlgo = cms.int32(0), #0=legacy top
useAdjacency = cms.int32(2), # modified adjacency
centralEtaCut = cms.double(2.5), # eta for defining "central" jets
sumEtBins = cms.vdouble(0,1600,2600), # sumEt bins over which cuts vary. vector={bin 0 lower bound, bin 1 lower bound, ...}
rBins = cms.vdouble(0.8,0.8,0.8), # Jet distance paramter R. R values depend on sumEt bins.
ptFracBins = cms.vdouble(0.05,0.05,0.05), # minimum fraction of central jet pt for subjets (deltap)
deltarBins = cms.vdouble(0.19,0.19,0.19), # Applicable only if useAdjacency=1. deltar adjacency values for each sumEtBin
nCellBins = cms.vdouble(1.9,1.9,1.9),
),
jetAlgorithm = cms.string("CambridgeAachen"),
rParam = cms.double(jetSize),
writeCompound = cms.bool(True)
)
)
setattr( proc, "CATopTagInfos",
cms.EDProducer("CATopJetTagger",
src = cms.InputTag('cmsTopTagPFJets'+PUMethod),
TopMass = cms.double(171),
TopMassMin = cms.double(0.),
TopMassMax = cms.double(250.),
WMass = cms.double(80.4),
WMassMin = cms.double(0.0),
WMassMax = cms.double(200.0),
MinMassMin = cms.double(0.0),
MinMassMax = cms.double(200.0),
verbose = cms.bool(False)
)
)
addJetCollection(
proc,
labelName = 'CMSTopTag'+PUMethod,
jetSource = cms.InputTag('cmsTopTagPFJets'+PUMethod),
jetCorrections = JEC if JEC is not None else None,
pfCandidates = cms.InputTag( pfCand ),
pvSource = cms.InputTag( pvLabel),
svSource = cms.InputTag( svLabel ),
btagDiscriminators = bTagDiscriminators,
genJetCollection = cms.InputTag(jetalgo+'GenJetsNoNu'),
getJetMCFlavour = False, # jet flavor should always be disabled for groomed jets
genParticles = cms.InputTag(genParticlesLabel)
)
getattr(proc,'patJetsCMSTopTag'+PUMethod).addTagInfos = True
getattr(proc,'patJetsCMSTopTag'+PUMethod).tagInfoSources = cms.VInputTag( cms.InputTag('CATopTagInfos'))
setattr( proc, 'selectedPatJetsCMSTopTag'+PUMethod, selectedPatJets.clone( src = 'patJetsCMSTopTag'+PUMethod, cut = Cut ) )
addJetCollection(
proc,
labelName = 'CMSTopTag'+PUMethod+'Subjets',
jetSource = cms.InputTag('cmsTopTagPFJets'+PUMethod, 'SubJets'),
algo = jetalgo, # needed for subjet b tagging
rParam = jetSize, # needed for subjet b tagging
jetCorrections = subJEC if subJEC is not None else None,
pfCandidates = cms.InputTag( pfCand ),
pvSource = cms.InputTag( pvLabel),
svSource = cms.InputTag( svLabel ),
btagDiscriminators = bTagDiscriminators,
genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
getJetMCFlavour = GetSubjetMCFlavour,
explicitJTA = True, # needed for subjet b tagging
svClustering = True, # needed for subjet b tagging
fatJets=cms.InputTag(jetalgo+'PFJets'+PUMethod), # needed for subjet flavor clustering
groomedFatJets=cms.InputTag('patJetsCMSTopTag'+PUMethod), # needed for subjet flavor clustering
genParticles = cms.InputTag(genParticlesLabel)
)
setattr( proc, 'selectedPatJetsCMSTopTag'+PUMethod+'Subjets', selectedPatJets.clone( src = 'patJetsCMSTopTag'+PUMethod+'Subjets', cut = Cut ) )
setattr( proc, 'patJetsCMSTopTag'+PUMethod+'Packed',
cms.EDProducer("BoostedJetMerger",
jetSrc=cms.InputTag('patJetsCMSTopTag'+PUMethod ),
subjetSrc=cms.InputTag('patJetsCMSTopTag'+PUMethod+'Subjets')
))
jetSeq += getattr(proc, 'patJetsCMSTopTag'+PUMethod+'Packed' )
elemToKeep += [ 'keep *_patJetsCMSTopTag'+PUMethod+'Packed_*_*' ]
toolsUsed.append( 'patJetsCMSTopTag'+PUMethod+'Packed' )
else: print '|---- jetToolBox: CMS recommends CambridgeAachen for CMS Top Tagger, you are using '+algorithm+'. JetToolbox will not run CMS Top Tagger.'
if addMassDrop :
if 'CA' in jetALGO :
setattr( proc, jetalgo+'PFJets'+PUMethod+'MassDropFiltered',
ca15PFJetsCHSMassDropFiltered.clone(
rParam = jetSize,
src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ),
) )
setattr( proc, jetalgo+'PFJets'+PUMethod+'MassDropFilteredMass', ak8PFJetsCHSPrunedMass.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod),
matched = cms.InputTag(jetalgo+'PFJets'+PUMethod+'MassDropFiltered'), distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'MassDropFilteredMass_*_*' ]
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'MassDropFilteredMass' ]
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'MassDropFiltered' )
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'MassDropFilteredMass' )
else: print '|---- jetToolBox: CMS recommends CambridgeAachen for Mass Drop, you are using '+algorithm+'. JetToolbox will not run Mass Drop.'
toolsUsed.append( jetalgo+'PFJets'+PUMethod+'MassDropFilteredMass' )
if addHEPTopTagger:
if ( jetSize >= 1. ) and ( 'CA' in jetALGO ):
setattr( proc, 'hepTopTagPFJets'+PUMethod, hepTopTagPFJetsCHS.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ) ) )
setattr( proc, 'hepTopTagPFJets'+PUMethod+'Mass'+jetALGO, ak8PFJetsCHSPrunedMass.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod),
matched = cms.InputTag("hepTopTagPFJets"+PUMethod), distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_hepTopTagPFJets'+PUMethod+'Mass'+jetALGO+'_*_*' ]
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ 'hepTopTagPFJets'+PUMethod+'Mass'+jetALGO ]
jetSeq += getattr(proc, 'hepTopTagPFJets'+PUMethod )
jetSeq += getattr(proc, 'hepTopTagPFJets'+PUMethod+'Mass'+jetALGO )
toolsUsed.append( 'hepTopTagPFJets'+PUMethod+'Mass'+jetALGO )
else: print '|---- jetToolBox: CMS recommends CambridgeAachen for HEPTopTagger, you are using '+algorithm+', and a jet cone size bigger than 1. JetToolbox will not run HEP TopTagger.'
####### Nsubjettiness
if addNsub:
from RecoJets.JetProducers.nJettinessAdder_cfi import Njettiness
rangeTau = range(1,maxTau+1)
setattr( proc, 'Njettiness'+jetALGO+PUMethod,
Njettiness.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod),
Njets=cms.vuint32(rangeTau), # 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( jetSize ), # 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
elemToKeep += [ 'keep *_Njettiness'+jetALGO+PUMethod+'_*_*' ]
for tau in rangeTau: getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += ['Njettiness'+jetALGO+PUMethod+':tau'+str(tau) ]
jetSeq += getattr(proc, 'Njettiness'+jetALGO+PUMethod )
toolsUsed.append( 'Njettiness'+jetALGO+PUMethod )
###### QJetsAdder
'''
if addQJets:
### there must be a better way to do this random number introduction
setattr( proc, 'RandomNumberGeneratorService', cms.Service("RandomNumberGeneratorService",
QJetsAdderCA8 = cms.PSet(initialSeed = cms.untracked.uint32(7)),
QJetsAdderAK8 = cms.PSet(initialSeed = cms.untracked.uint32(31)),
QJetsAdderCA15 = cms.PSet(initialSeed = cms.untracked.uint32(76)), ) )
from RecoJets.JetProducers.qjetsadder_cfi import QJetsAdder
setattr( proc, 'QJetsAdder'+jetALGO,
QJetsAdder.clone( src = cms.InputTag(jetalgo+'PFJets'+PUMethod),
jetRad = cms.double( jetSize ),
jetAlgo = cms.string( jetALGO[0:2] )))
elemToKeep += [ 'keep *_QJetsAdder'+jetALGO+'_*_*' ]
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += ['QJetsAdder'+jetALGO+':QjetsVolatility']
jetSeq += getattr(proc, 'QJetsAdder'+jetALGO )
toolsUsed.append( 'QJetsAdder'+jetALGO )
'''
###### QGTagger
if addQGTagger:
if ( 'ak4' in jetalgo ) and ( PUMethod not in ['Puppi','CS','SK'] ) :
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
proc.load('RecoJets.JetProducers.QGTagger_cfi') ## In 74X you need to run some stuff before.
setattr( proc, 'QGTagger'+jetALGO+'PF'+PUMethod,
QGTagger.clone(
srcJets = cms.InputTag(jetalgo+'PFJets'+PUMethod), # Could be reco::PFJetCollection or pat::JetCollection (both AOD and miniAOD)
jetsLabel = cms.string('QGL_AK4PF'+QGjetsLabel) # Other options (might need to add an ESSource for it): see https://twiki.cern.ch/twiki/bin/viewauth/CMS/QGDataBaseVersion
)
)
elemToKeep += [ 'keep *_QGTagger'+jetALGO+'PF'+PUMethod+'_*_*' ]
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += ['QGTagger'+jetALGO+'PF'+PUMethod+':qgLikelihood']
jetSeq += getattr(proc, 'QGTagger'+jetALGO+'PF'+PUMethod )
toolsUsed.append( 'QGTagger'+jetALGO+'PF'+PUMethod )
else:
print '|---- jetToolBox: QGTagger is optimized for ak4 jets with CHS. NOT running QGTagger'
####### Pileup JetID
if addPUJetID:
if ( 'ak4' in jetalgo ) and ( 'CHS' in PUMethod ):
from RecoJets.JetProducers.pileupjetidproducer_cfi import pileupJetIdCalculator,pileupJetIdEvaluator
setattr( proc, jetALGO+'PF'+PUMethod+'pileupJetIdCalculator',
pileupJetIdCalculator.clone(
jets = cms.InputTag(jetalgo+'PFJets'+PUMethod),
rho = cms.InputTag("fixedGridRhoFastjetAll"),
vertexes = cms.InputTag(pvLabel),
applyJec = cms.bool(True),
inputIsCorrected = cms.bool(False)
))
setattr( proc, jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator',
pileupJetIdEvaluator.clone(
jetids = cms.InputTag(jetALGO+'PF'+PUMethod+'pileupJetIdCalculator'),
jets = cms.InputTag(jetalgo+'PFJets'+PUMethod),
rho = cms.InputTag("fixedGridRhoFastjetAll"),
vertexes = cms.InputTag(pvLabel)
)
)
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator:fullDiscriminant']
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userInts.src += [jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator:cutbasedId',jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator:fullId']
elemToKeep += ['keep *_'+jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator_*_*']
toolsUsed.append( jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator' )
else:
print '|---- jetToolBox: PUJetID is optimized for ak4 PFjets with CHS. NOT running PUJetID.'
###### Energy Correlation Functions
if addEnergyCorrFunc:
from RecoJets.JetProducers.ECF_cfi import ECF
rangeECF = range(1,maxECF+1)
setattr( proc, jetalgo+'PFJets'+PUMethod+'ECF', ECF.clone(
src = cms.InputTag(jetalgo+'PFJets'+PUMethod),
Njets = cms.vuint32( rangeECF ),
beta = cms.double( ecfBeta )
))
elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'ECF_*_*']
for ecf in rangeECF: getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'ECF:ecf'+str(ecf) ]
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'ECF' )
toolsUsed.append( jetalgo+'PFJets'+PUMethod+'ECF' )
if hasattr(proc, 'patJetPartons'): proc.patJetPartons.particles = genParticlesLabel
setattr( proc, 'selectedPatJets'+jetALGO+'PF'+PUMethod, selectedPatJets.clone( src = 'patJets'+jetALGO+'PF'+PUMethod, cut = Cut ) )
elemToKeep += [ 'keep *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_*_*' ]
elemToKeep += [ 'drop *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_calo*_*' ]
elemToKeep += [ 'drop *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_tagInfos_*' ]
if len(toolsUsed) > 0 : print '|---- jetToolBox: Running '+', '.join(toolsUsed)+'.'
print '|---- jetToolBox: Creating selectedPatJets'+jetALGO+'PF'+PUMethod+' collection.'
### "return"
setattr(proc, jetSequence, jetSeq)
if hasattr(proc, outputFile): getattr(proc, outputFile).outputCommands += elemToKeep
else: setattr( proc, outputFile,
cms.OutputModule('PoolOutputModule',
fileName = cms.untracked.string('jettoolbox.root'),
outputCommands = cms.untracked.vstring( elemToKeep ) ) )
if runOnData:
from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching
removeMCMatching(proc, names=['Jets'], outputModules=[outputFile])
def jetToolbox(proc,
jetType,
jetSequence,
PUMethod='',
bTagDiscriminators=None):
JETCorrPayload = 'None'
JETCorrLevels = ['None']
bTagDiscriminators = [ #'trackCountingHighEffBJetTags',
#'trackCountingHighPurBJetTags',
#'pfTrackCountingHighEffBJetTags',
#'pfTrackCountingHighPurBJetTags',
#'softPFMuonByIP3dBJetTags',
#'softPFElectronByIP3dBJetTags',
#'softPFMuonBJetTags',
#'softPFElectronBJetTags',
#'simpleSecondaryVertexHighEffBJetTags',
#'simpleSecondaryVertexHighPurBJetTags',
#'pfSimpleSecondaryVertexHighEffBJetTags',
#'pfSimpleSecondaryVertexHighPurBJetTags',
#'combinedSecondaryVertexV2BJetTags',
#'deepFlavourJetTags:probb',
#'deepFlavourJetTags:probc',
#'deepFlavourJetTags:probudsg',
#'deepFlavourJetTags:probbb',
#'deepFlavourJetTags:probcc',
#'negativeDeepFlavourJetTags:probb',
#'negativeDeepFlavourJetTags:probc',
#'negativeDeepFlavourJetTags:probudsg',
#'negativeDeepFlavourJetTags:probbb',
#'negativeDeepFlavourJetTags:probcc',
#'positiveDeepFlavourJetTags:probb',
#'positiveDeepFlavourJetTags:probc',
#'positiveDeepFlavourJetTags:probudsg',
#'positiveDeepFlavourJetTags:probbb',
#'positiveDeepFlavourJetTags:probcc',
#'pfCombinedCvsLJetTags',
#'pfCombinedCvsBJetTags',
'pfBoostedDoubleSecondaryVertexAK8BJetTags',
'pfCombinedSecondaryVertexV2BJetTags',
'pfPositiveCombinedSecondaryVertexV2BJetTags', #implemented
'pfNegativeCombinedSecondaryVertexV2BJetTags', #implemented
'pfCombinedInclusiveSecondaryVertexV2BJetTags', #implemented
'pfCombinedMVAV2BJetTags', #implemented
'pfJetProbabilityBJetTags'
] #implemented
GetJetMCFlavour = ['True']
#JECLevels = [ 'L1Offset', 'L1FastJet', 'L1JPTOffset', 'L2Relative', 'L3Absolute', 'L5Falvour', 'L7Parton' ]
algorithm = 'AntiKt' # CambridgeAachen' , 'Kt'
size = jetType[-1:] #[-1:] takes the last char from string 'akX'
jetSize = float('0.' + jetType[-1:])
jetALGO = jetType.upper()
jetalgo = jetType.lower()
elemToKeep = []
print 'Running processes with: ' + str(
jetALGO
) + ' PF ' + PUMethod + ' jet algorithm with radius parameter ' + str(
jetSize)
JETCorrPayload = 'AK' + size + 'PF' + PUMethod.lower()
JETCorrLevels = ['L1FastJet', 'L2Relative', 'L3Absolute']
#JETCorrLevels = [] #No JEC corrections
JEC = (JETCorrPayload, JETCorrLevels, 'None')
#################################################################################
####### Toolbox start
#################################################################################
elemToKeep = []
jetSeq = cms.Sequence()
genParticlesLabel = ''
pvLabel = ''
tvLabel = ''
toolsUsed = []
proc.load('RecoJets.Configuration.GenJetParticles_cff')
setattr(
proc, jetalgo + 'GenJetsNoNu',
ak4GenJets.clone(src='genParticlesForJetsNoNu',
rParam=jetSize,
jetAlgorithm=algorithm))
jetSeq += getattr(proc, jetalgo + 'GenJetsNoNu')
proc.load('CommonTools.ParticleFlow.pfNoPileUpJME_cff')
#### Creating PATjets
if (PUMethod == 'CHS'):
setattr(proc, jetalgo + 'PFJetsCHS',
ak4PFJets.clone(rParam=jetSize, jetAlgorithm=algorithm))
jetSeq += getattr(proc, jetalgo + 'PFJetsCHS')
setattr(
proc, jetalgo + 'PFJetsCHS',
ak4PFJetsCHS.clone(doAreaFastjet=True,
rParam=jetSize,
jetAlgorithm=algorithm))
jetSeq += getattr(proc, jetalgo + 'PFJetsCHS')
else:
setattr(proc, jetalgo + 'PFJets',
ak4PFJets.clone(rParam=jetSize, jetAlgorithm=algorithm))
jetSeq += getattr(proc, jetalgo + 'PFJets')
setattr(
proc, jetalgo + 'PFJets',
ak4PFJets.clone(doAreaFastjet=True,
rParam=jetSize,
jetAlgorithm=algorithm))
jetSeq += getattr(proc, jetalgo + 'PFJets')
PUMethod = ''
addJetCollection(
proc,
labelName=jetALGO + 'PF' + PUMethod,
jetSource=cms.InputTag(jetalgo + 'PFJets' + PUMethod),
algo=jetalgo,
btagDiscriminators=bTagDiscriminators,
rParam=jetSize,
jetCorrections=
JEC, #( 'AK'+size+'PFchs', cms.vstring( ['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
pfCandidates=cms.InputTag('particleFlow'), #'packedPFCandidates'),
svSource=cms.InputTag('inclusiveCandidateSecondaryVertices'),
genJetCollection=cms.InputTag(jetalgo + 'GenJetsNoNu'),
pvSource=cms.InputTag(
'offlinePrimaryVertices'), #'offlineSlimmedPrimaryVertices'),
jetTrackAssociation=True,
)
#setattr( proc, jetALGO+'PF'+PUMethod+'pileupJetIdCalculator',
# pileupJetIdCalculator.clone(
# jets = cms.InputTag(jetalgo+'PFJets'+PUMethod),
# rho = cms.InputTag("fixedGridRhoFastjetAll"),
# vertexes = cms.InputTag('offlinePrimaryVertices'),
# applyJec = cms.bool(True),
# inputIsCorrected = cms.bool(False)
# ))
# setattr( proc, jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator',
# pileupJetIdEvaluator.clone(
# jetids = cms.InputTag(jetALGO+'PF'+PUMethod+'pileupJetIdCalculator'),
# jets = cms.InputTag(jetalgo+'PFJets'+PUMethod),
# rho = cms.InputTag("fixedGridRhoFastjetAll"),
# vertexes = cms.InputTag('offlinePrimaryVertices'),
# applyJec = cms.bool(True),
# inputIsCorrected = cms.bool(False)
#
# )
# )
#getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator:fullDiscriminant']
#getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userInts.src += [jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator:cutbasedId',jetALGO+'PF'+PUMethod+'pileupJetIdEvaluator:fullId']
QGjetsLabel = 'chs'
setattr(
proc,
'QGTagger' + jetALGO + 'PF' + PUMethod,
QGTagger.clone(
srcJets=cms.InputTag(
jetalgo + 'PFJets' + PUMethod
), # Could be reco::PFJetCollection or pat::JetCollection (both AOD and miniAOD)
jetsLabel=cms.string(
'QGL_AK4PF' + QGjetsLabel
) # Other options (might need to add an ESSource for it): see https://twiki.cern.ch/twiki/bi
))
elemToKeep += ['keep *_QGTagger' + jetALGO + 'PF' + PUMethod + '_*_*']
getattr(proc,
'patJets' + jetALGO + 'PF' + PUMethod).userData.userFloats.src += [
'QGTagger' + jetALGO + 'PF' + PUMethod + ':qgLikelihood'
]
jetSeq += getattr(proc, 'QGTagger' + jetALGO + 'PF' + PUMethod)
toolsUsed.append('QGTagger' + jetALGO + 'PF' + PUMethod)
getattr(proc, 'patJetPartons').particles = cms.InputTag(
'genParticles') #'prunedGenParticles')
setattr(proc, 'selectedPatJets' + jetALGO + 'PF' + PUMethod,
selectedPatJets.clone(src='patJets' + jetALGO + 'PF' + PUMethod))
setattr(proc, jetSequence, jetSeq)
def addFlashggPFCHSJets(process,
isData,
vertexIndex=0,
useZeroVertex=False,
label='',
debug=False):
#if useZeroVertex:
setattr(
process, 'pfCHSLeg' + label,
cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("fromPV(%i)" % vertexIndex)))
#else:
# setattr(process, 'selectedMuons' + label, cms.EDFilter("CandPtrSelector",
# src = cms.InputTag("slimmedMuons"),
# cut = cms.string('''abs(eta)<2.5 && pt>10. &&
# (pfIsolationR04().sumChargedHadronPt+
# max(0.,pfIsolationR04().sumNeutralHadronEt+
# pfIsolationR04().sumPhotonEt-
# 0.50*pfIsolationR04().sumPUPt))/pt < 0.20 &&
# (isPFMuon && (isGlobalMuon || isTrackerMuon) )''')))
# setattr(process, 'selectedElectrons' + label, cms.EDFilter("CandPtrSelector",
# src = cms.InputTag("slimmedElectrons"),
# cut = cms.string('''abs(eta)<2.5 && pt>20. &&
# gsfTrack.isAvailable() &&
# gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2 &&
# (pfIsolationVariables().sumChargedHadronPt+
# max(0.,pfIsolationVariables().sumNeutralHadronEt+
# pfIsolationVariables().sumPhotonEt-
# 0.5*pfIsolationVariables().sumPUPt))/pt < 0.15''')))
# # Simple producer which just removes the Candidates which
# # don't come from the legacy vertex according to the Flashgg Vertex Map
# setattr(process,'flashggCHSLegacyVertexCandidates' + label,
# cms.EDProducer('FlashggMultiCHSLegacyVertexCandProducer',
# PFCandidatesTag = cms.InputTag('packedPFCandidates'),
# DiPhotonTag = cms.InputTag('flashggDiPhotons'),
# VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"),
# VertexTag = cms.InputTag('offlineSlimmedPrimaryVertices'),
# vertexIndex = cms.uint32(vertexIndex),
# debug = cms.untracked.bool(debug)
# )
# )
# setattr(process, 'pfCHSLeg' + label, cms.EDFilter("CandPtrSelector",
# src = cms.InputTag('flashggCHSLegacyVertexCandidates' + label),
# cut = cms.string('')))
# # then remove the previously selected muons
# setattr(process, 'pfNoMuonCHSLeg' + label, cms.EDProducer("CandPtrProjector",
# src = cms.InputTag("pfCHSLeg" + label),
# veto = cms.InputTag("selectedMuons" + label)))
# # then remove the previously selected electrons
# setattr(process, 'pfNoElectronsCHSLeg' + label, cms.EDProducer("CandPtrProjector",
# src = cms.InputTag("pfNoMuonCHSLeg" + label),
# veto = cms.InputTag("selectedElectrons" + label)))
#Import RECO jet producer for ak4 PF and GEN jet
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
#if useZeroVertex:
setattr(process, 'ak4PFJetsCHSLeg' + label,
ak4PFJets.clone(src='pfCHSLeg' + label, doAreaFastjet=True))
#else:
# setattr(process, 'ak4PFJetsCHSLeg' + label, ak4PFJets.clone ( src = 'pfNoElectronsCHSLeg' + label, doAreaFastjet = True))
if isData:
JECs = ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']
else:
JECs = ['L1FastJet', 'L2Relative', 'L3Absolute']
# NOTE: this is the 74X recipe for the jet clustering
addJetCollection(
process,
postfix=label,
labelName='AK4PFCHSLeg',
jetSource=cms.InputTag('ak4PFJetsCHSLeg' + label),
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', JECs, 'None'),
genJetCollection=cms.InputTag('slimmedGenJets'),
genParticles=cms.InputTag('prunedGenParticles'),
# jet param
algo='AK',
rParam=0.4)
#Recalculate btagging info
getattr(process, 'patJetsAK4PFCHSLeg' + label).addTagInfos = True
#adjust PV used for Jet Corrections
getattr(process, 'patJetCorrFactorsAK4PFCHSLeg' +
label).primaryVertices = "offlineSlimmedPrimaryVertices"
# Add MiniAOD jet with Deep flavour for matching with flashgg jets based on 0th vertex
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
jetSource=cms.InputTag("slimmedJets"),
pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'),
svSource=cms.InputTag('slimmedSecondaryVertices'),
btagDiscriminators=[
flashggDeepFlavourb,
flashggDeepFlavourbb,
flashggDeepFlavourc,
flashggDeepFlavouruds,
flashggDeepFlavourlepb,
flashggDeepFlavourg,
],
jetCorrections=('AK4PFchs', JECs, 'None'),
)
miniaodJets = "selectedUpdatedPatJets"
# Add new gq tagger database
process.QGPoolDBESSource = cms.ESSource(
"PoolDBESSource",
CondDBSetup,
toGet=cms.VPSet(),
connect=cms.string(
'sqlite_fip:flashggPlugins/flashggAnalysisNtuplizer/data/QGL_' +
qgDatabaseVersion + '.db'))
process.es_prefer_qg = cms.ESPrefer('PoolDBESSource', 'QGPoolDBESSource')
process.QGPoolDBESSource.toGet.extend(
cms.VPSet(
cms.PSet(record=cms.string('QGLikelihoodRcd'),
tag=cms.string('QGLikelihoodObject_v1_AK4'),
label=cms.untracked.string('QGL_AK4PFchs'))))
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
setattr(
process, 'QGTaggerPFCHS' + label,
QGTagger.clone(srcJets='patJetsAK4PFCHSLeg' + label,
jetsLabel='QGL_AK4PFchs',
vertexIndex=cms.uint32(vertexIndex),
srcVertexCollection='offlineSlimmedPrimaryVertices'))
from RecoJets.JetProducers.PileupJetIDParams_cfi import full_81x_chs
flashggJets = cms.EDProducer(
'FlashggJetProducer',
DiPhotonTag=cms.InputTag('flashggDiPhotons'),
VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'),
JetTag=cms.InputTag('patJetsAK4PFCHSLeg' + label),
VertexCandidateMapTag=cms.InputTag("flashggVertexMapForCHS"),
qgVariablesInputTag=cms.InputTag('QGTaggerPFCHS' + label,
'qgLikelihood'),
ComputeSimpleRMS=cms.bool(True),
PileupJetIdParameters=full_81x_chs,
rho=cms.InputTag("fixedGridRhoFastjetAll"),
JetCollectionIndex=cms.uint32(vertexIndex),
Debug=cms.untracked.bool(debug),
DoPuJetID=cms.bool(True),
ComputeRegVars=cms.bool(True),
MinPtForEneSum=cms.double(0.),
MaxEtaForEneSum=cms.double(2.5),
NJetsForEneSum=cms.uint32(0),
MiniAodJetTag=cms.InputTag(miniaodJets))
setattr(process, 'flashggPFCHSJets' + label, flashggJets)
# randomize Jets
from flashgg.MicroAOD.flashggRandomizedJetProducer_cfi import flashggRandomizedJets
flashggRandomizedPFCHSJets = flashggRandomizedJets.clone()
flashggRandomizedPFCHSJets.src = "flashggPFCHSJets" + label
setattr(process.RandomNumberGeneratorService,
'flashggRandomizedPFCHSJets' + label,
cms.PSet(initialSeed=cms.untracked.uint32(36423784 + int(label))))
setattr(process, 'flashggRandomizedPFCHSJets' + label,
flashggRandomizedPFCHSJets)
flashggSelectedJets = cms.EDFilter(
"FLASHggJetSelector",
src=cms.InputTag('flashggRandomizedPFCHSJets' + label),
cut=cms.string("pt > 15."))
setattr(process, 'flashggSelectedPFCHSJets' + label, flashggSelectedJets)
run2_nanoAOD_92X.toModify(
genJetFlavourTable,
jetFlavourInfos=cms.InputTag("genJetFlavourAssociation"),
)
#before cross linking
jetSequence = cms.Sequence(tightJetId + tightJetIdLepVeto + bJetVars +
slimmedJetsWithUserData + jetCorrFactorsNano +
updatedJets + tightJetIdAK8 + tightJetIdLepVetoAK8 +
slimmedJetsAK8WithUserData + jetCorrFactorsAK8 +
updatedJetsAK8 + chsForSATkJets + softActivityJets +
softActivityJets2 + softActivityJets5 +
softActivityJets10 + finalJets + finalJetsAK8)
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
qgtagger80x = QGTagger.clone(
srcJets="slimmedJets", srcVertexCollection="offlineSlimmedPrimaryVertices")
_jetSequence_80X = jetSequence.copy()
_jetSequence_80X.replace(tightJetIdLepVeto, looseJetId)
_jetSequence_80X.replace(tightJetIdLepVetoAK8, looseJetIdAK8)
_jetSequence_80X.insert(1, qgtagger80x)
run2_miniAOD_80XLegacy.toReplaceWith(jetSequence, _jetSequence_80X)
#after cross linkining
jetTables = cms.Sequence(bjetMVA + bjetNN + jetTable + fatJetTable +
subJetTable + saJetTable + saTable)
#MC only producers and tables
jetMC = cms.Sequence(jetMCTable + genJetTable + patJetPartons +
genJetFlavourTable + genJetAK8Table +
genJetAK8FlavourAssociation + genJetAK8FlavourTable +
def jetToolbox( proc, jetType, jetSequence, outputFile,
updateCollection='', updateCollectionSubjets='',
newPFCollection=False, nameNewPFCollection = '',
PUMethod='CHS',
miniAOD=True,
runOnMC=True,
JETCorrPayload='', JETCorrLevels = [ 'None' ], GetJetMCFlavour=True,
Cut = '',
postFix='',
# blank means default list of discriminators, None means none
bTagDiscriminators = '',
bTagInfos = None,
subjetBTagDiscriminators = '',
subjetBTagInfos = None,
subJETCorrPayload='', subJETCorrLevels = [ 'None' ], GetSubjetMCFlavour=True,
CutSubjet = '',
addPruning=False, zCut=0.1, rCut=0.5, addPrunedSubjets=False,
addSoftDrop=False, betaCut=0.0, zCutSD=0.1, addSoftDropSubjets=False,
addTrimming=False, rFiltTrim=0.2, ptFrac=0.03,
addFiltering=False, rfilt=0.3, nfilt=3,
addCMSTopTagger=False,
addMassDrop=False,
addHEPTopTagger=False,
addNsub=False, maxTau=4,
addNsubSubjets=False, subjetMaxTau=4,
addPUJetID=False,
addQGTagger=False, QGjetsLabel='chs',
addEnergyCorrFunc=False,
addEnergyCorrFuncSubjets=False,
# set this to false to disable creation of jettoolbox.root
# then you need to associate the jetTask to a Path or EndPath manually in your config
associateTask=True,
# 0 = no printouts, 1 = warnings only, 2 = warnings & info, 3 = warnings, info, debug
verbosity=2,
):
runOnData = not runOnMC
if runOnData:
GetJetMCFlavour = False
GetSubjetMCFlavour = False
###############################################################################
####### Verifying some inputs and defining variables
###############################################################################
if verbosity>=1: print('|---- jetToolbox: Initializing collection... (with postfix '+postFix+')')
if newPFCollection and verbosity>=2: print('|---- jetToolBox: Using '+ nameNewPFCollection +' as PFCandidates collection')
supportedJetAlgos = { 'ak': 'AntiKt', 'ca' : 'CambridgeAachen', 'kt' : 'Kt' }
recommendedJetAlgos = [ 'ak4', 'ak8', 'ca4', 'ca8', 'ca10', 'ca15' ]
payloadList = [ 'None',
'AK1PFchs', 'AK2PFchs', 'AK3PFchs', 'AK4PFchs', 'AK5PFchs', 'AK6PFchs', 'AK7PFchs', 'AK8PFchs', 'AK9PFchs', 'AK10PFchs',
'AK1PFPuppi', 'AK2PFPuppi', 'AK3PFPuppi', 'AK4PFPuppi', 'AK5PFPuppi', 'AK6PFPuppi', 'AK7PFPuppi', 'AK8PFPuppi', 'AK9PFPuppi', 'AK10PFPuppi',
'AK1PFSK', 'AK2PFSK', 'AK3PFSK', 'AK4PFSK', 'AK5PFSK', 'AK6PFSK', 'AK7PFSK', 'AK8PFSK', 'AK9PFSK', 'AK10PFSK',
'AK1PF', 'AK2PF', 'AK3PF', 'AK4PF', 'AK5PF', 'AK6PF', 'AK7PF', 'AK8PF', 'AK9PF', 'AK10PF' ]
JECLevels = [ 'L1Offset', 'L1FastJet', 'L1JPTOffset', 'L2Relative', 'L3Absolute', 'L5Falvour', 'L7Parton' ]
if runOnData:
JECLevels += ['L2L3Residual']
jetAlgo = ''
algorithm = ''
size = ''
for TYPE, tmpAlgo in supportedJetAlgos.iteritems():
if TYPE in jetType.lower():
jetAlgo = TYPE
algorithm = tmpAlgo
size = jetType.replace( TYPE, '' )
jetSize = 0.
if int(size) in range(0, 20): jetSize = int(size)/10.
else: raise ValueError('|---- jetToolBox: jetSize has not a valid value. Insert a number between 1 and 20 after algorithm, like: AK8')
### Trick for uppercase/lowercase algo name
jetALGO = jetAlgo.upper()+size
jetalgo = jetAlgo.lower()+size
if jetalgo not in recommendedJetAlgos and verbosity>=1: print('|---- jetToolBox: CMS recommends the following jet algorithms: '+' '.join(recommendedJetAlgos)+'. You are using '+jetalgo+' .')
#################################################################################
####### Toolbox start
#################################################################################
elemToKeep = []
jetSeq = cms.Sequence()
genParticlesLabel = ''
pvLabel = ''
tvLabel = ''
toolsUsed = []
mod = OrderedDict()
### List of Jet Corrections
if not set(JETCorrLevels).issubset(set(JECLevels)):
if ( 'CHS' in PUMethod ) or ( 'Plain' in PUMethod ): JETCorrLevels = ['L1FastJet','L2Relative', 'L3Absolute']
else: JETCorrLevels = [ 'L2Relative', 'L3Absolute']
if runOnData: JETCorrLevels.append('L2L3Residual')
if not set(subJETCorrLevels).issubset(set(JECLevels)):
if ( 'CHS' in PUMethod ) or ( 'Plain' in PUMethod ): subJETCorrLevels = ['L1FastJet','L2Relative', 'L3Absolute']
else: subJETCorrLevels = [ 'L2Relative', 'L3Absolute']
if runOnData: subJETCorrLevels.append('L2L3Residual')
## b-tag discriminators
defaultBTagDiscriminators = [
'pfTrackCountingHighEffBJetTags',
'pfTrackCountingHighPurBJetTags',
'pfJetProbabilityBJetTags',
'pfJetBProbabilityBJetTags',
'pfSimpleSecondaryVertexHighEffBJetTags',
'pfSimpleSecondaryVertexHighPurBJetTags',
'pfCombinedSecondaryVertexV2BJetTags',
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfCombinedMVAV2BJetTags'
]
if bTagDiscriminators is '': bTagDiscriminators = defaultBTagDiscriminators
if subjetBTagDiscriminators is '': subjetBTagDiscriminators = defaultBTagDiscriminators
if updateCollection and 'Puppi' in updateCollection: PUMethod='Puppi'
mod["PATJetsLabel"] = jetALGO+'PF'+PUMethod
mod["PATJetsLabelPost"] = mod["PATJetsLabel"]+postFix
# some substructure quantities don't include the 'PF' in the name
mod["SubstructureLabel"] = jetALGO+PUMethod+postFix
if not updateCollection:
mod["GenJetsNoNu"] = jetalgo+'GenJetsNoNu'
#### For MiniAOD
if miniAOD:
if verbosity>=2: print('|---- jetToolBox: JETTOOLBOX RUNNING ON MiniAOD FOR '+jetALGO+' JETS USING '+PUMethod)
genParticlesLabel = 'prunedGenParticles'
pvLabel = 'offlineSlimmedPrimaryVertices'
svLabel = 'slimmedSecondaryVertices'
tvLabel = 'unpackedTracksAndVertices'
muLabel = 'slimmedMuons'
elLabel = 'slimmedElectrons'
pfCand = nameNewPFCollection if newPFCollection else 'packedPFCandidates'
if runOnMC:
## Filter out neutrinos from packed GenParticles
mod["GenParticlesNoNu"] = 'packedGenParticlesForJetsNoNu'
_addProcessAndTask(proc, mod["GenParticlesNoNu"],
cms.EDFilter("CandPtrSelector",
src = cms.InputTag("packedGenParticles"),
cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16")
))
jetSeq += getattr(proc, mod["GenParticlesNoNu"])
_addProcessAndTask(proc, mod["GenJetsNoNu"],
ak4GenJets.clone( src = mod["GenParticlesNoNu"],
rParam = jetSize,
jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, mod["GenJetsNoNu"])
#for Inclusive Vertex Finder
proc.load('PhysicsTools.PatAlgos.slimming.unpackedTracksAndVertices_cfi')
#### For AOD
else:
if verbosity>=2: print('|---- jetToolBox: JETTOOLBOX RUNNING ON AOD FOR '+jetALGO+' JETS USING '+PUMethod)
genParticlesLabel = 'genParticles'
pvLabel = 'offlinePrimaryVertices'
tvLabel = 'generalTracks'
muLabel = 'muons'
elLabel = 'gedGsfElectrons'
pfCand = nameNewPFCollection if newPFCollection else 'particleFlow'
svLabel = 'inclusiveCandidateSecondaryVertices'
if runOnMC:
proc.load('RecoJets.Configuration.GenJetParticles_cff')
_addProcessAndTask(proc, mod["GenJetsNoNu"], ak4GenJets.clone(src='genParticlesForJetsNoNu', rParam=jetSize, jetAlgorithm=algorithm))
jetSeq += getattr(proc, mod["GenJetsNoNu"])
#### Creating PATjets
tmpPfCandName = pfCand.lower()
mod["PFJets"] = ""
if 'Puppi' in PUMethod:
if ('puppi' in tmpPfCandName):
srcForPFJets = pfCand
if verbosity>=1: print('|---- jetToolBox: Not running puppi algorithm because keyword puppi was specified in nameNewPFCollection, but applying puppi corrections.')
else:
proc.load('CommonTools.PileupAlgos.Puppi_cff')
puppi.candName = cms.InputTag( pfCand )
if miniAOD:
puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
puppi.clonePackedCands = cms.bool(True)
puppi.useExistingWeights = cms.bool(True)
_addProcessAndTask(proc, 'puppi', getattr(proc, 'puppi'))
jetSeq += getattr(proc, 'puppi' )
srcForPFJets = 'puppi'
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJetsPuppi
mod["PFJets"] = jetalgo+'PFJetsPuppi'+postFix
_addProcessAndTask(proc, mod["PFJets"],
ak4PFJetsPuppi.clone( src = cms.InputTag( srcForPFJets ),
doAreaFastjet = True,
rParam = jetSize,
jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, mod["PFJets"])
if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PFPuppi'
if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PFPuppi'
elif 'SK' in PUMethod:
if ('sk' in tmpPfCandName):
srcForPFJets = pfCand
if verbosity>=1: print('|---- jetToolBox: Not running softkiller algorithm because keyword SK was specified in nameNewPFCollection, but applying SK corrections.')
else:
proc.load('CommonTools.PileupAlgos.softKiller_cfi')
getattr( proc, 'softKiller' ).PFCandidates = cms.InputTag( pfCand )
_addProcessAndTask(proc, 'softKiller', getattr(proc, 'softKiller'))
jetSeq += getattr(proc, 'softKiller' )
srcForPFJets = 'softKiller'
from RecoJets.JetProducers.ak4PFJetsSK_cfi import ak4PFJetsSK
mod["PFJets"] = jetalgo+'PFJetsSK'+postFix
_addProcessAndTask(proc, mod["PFJets"],
ak4PFJetsSK.clone( src = cms.InputTag( srcForPFJets ),
rParam = jetSize,
jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, mod["PFJets"])
if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PFSK'
if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PFSK'
elif 'CS' in PUMethod:
from RecoJets.JetProducers.ak4PFJetsCHSCS_cfi import ak4PFJetsCHSCS
mod["PFJets"] = jetalgo+'PFJetsCS'+postFix
_addProcessAndTask(proc, mod["PFJets"],
ak4PFJetsCHSCS.clone( doAreaFastjet = True,
src = cms.InputTag( pfCand ), #srcForPFJets ),
csRParam = cms.double(jetSize),
jetAlgorithm = algorithm ) )
if miniAOD: getattr( proc, mod["PFJets"]).src = pfCand
jetSeq += getattr(proc, mod["PFJets"])
if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PFCS'
if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PFCS'
elif 'CHS' in PUMethod:
if miniAOD:
if ('chs' in tmpPfCandName):
srcForPFJets = pfCand
if verbosity>=1: print('|---- jetToolBox: Not running CHS algorithm because keyword CHS was specified in nameNewPFCollection, but applying CHS corrections.')
else:
_addProcessAndTask(proc, 'chs', cms.EDFilter('CandPtrSelector', src=cms.InputTag(pfCand), cut=cms.string('fromPV')))
jetSeq += getattr(proc, 'chs')
srcForPFJets = 'chs'
else:
if ( pfCand == 'particleFlow' ):
from RecoParticleFlow.PFProducer.particleFlowTmpPtrs_cfi import particleFlowTmpPtrs
_addProcessAndTask(proc, 'newParticleFlowTmpPtrs', particleFlowTmpPtrs.clone(src=pfCand))
jetSeq += getattr(proc, 'newParticleFlowTmpPtrs')
from CommonTools.ParticleFlow.pfNoPileUpJME_cff import pfPileUpJME, pfNoPileUpJME
proc.load('CommonTools.ParticleFlow.goodOfflinePrimaryVertices_cfi')
_addProcessAndTask(proc, 'newPfPileUpJME', pfPileUpJME.clone(PFCandidates='newParticleFlowTmpPtrs'))
jetSeq += getattr(proc, 'newPfPileUpJME')
_addProcessAndTask(proc, 'newPfNoPileUpJME', pfNoPileUpJME.clone(topCollection='newPfPileUpJME', bottomCollection='newParticleFlowTmpPtrs'))
jetSeq += getattr(proc, 'newPfNoPileUpJME')
srcForPFJets = 'newPfNoPileUpJME'
else:
proc.load('CommonTools.ParticleFlow.pfNoPileUpJME_cff')
srcForPFJets = 'pfNoPileUpJME'
mod["PFJets"] = jetalgo+'PFJetsCHS'+postFix
_addProcessAndTask(proc, mod["PFJets"],
ak4PFJetsCHS.clone( src = cms.InputTag( srcForPFJets ),
doAreaFastjet = True,
rParam = jetSize,
jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, mod["PFJets"])
if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PFchs'
if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PFchs'
else:
PUMethod = ''
mod["PFJets"] = jetalgo+'PFJets'+postFix
_addProcessAndTask(proc, mod["PFJets"],
ak4PFJets.clone(
doAreaFastjet = True,
rParam = jetSize,
jetAlgorithm = algorithm ) )
if miniAOD: getattr( proc, mod["PFJets"]).src = pfCand
jetSeq += getattr(proc, mod["PFJets"])
if JETCorrPayload not in payloadList: JETCorrPayload = 'AK'+size+'PF'
if subJETCorrPayload not in payloadList: subJETCorrPayload = 'AK4PF'
if 'None' in JETCorrPayload: JEC = None
else: JEC = ( JETCorrPayload.replace('CS','chs').replace('SK','chs') , JETCorrLevels, 'None' ) ### temporary
#else: JEC = ( JETCorrPayload., JETCorrLevels, 'None' )
if verbosity>=2: print('|---- jetToolBox: Applying these corrections: '+str(JEC))
if addPrunedSubjets or addSoftDropSubjets or addCMSTopTagger:
if 'None' in subJETCorrPayload: subJEC = None
else: subJEC = ( subJETCorrPayload.replace('CS','chs').replace('SK','chs') , subJETCorrLevels, 'None' ) ### temporary
mod["PFJetsConstituents"] = mod["PFJets"]+'Constituents'
mod["PFJetsConstituentsColon"] = mod["PFJets"]+'Constituents:constituents'
mod["PFJetsConstituentsColonOrUpdate"] = mod["PFJetsConstituentsColon"] if not updateCollection else updateCollection
if (PUMethod in [ 'CHS', 'CS', 'Puppi' ]) and miniAOD: _addProcessAndTask(proc, mod["PFJetsConstituents"], cms.EDProducer("MiniAODJetConstituentSelector", src=cms.InputTag(mod["PFJets"]), cut=cms.string(Cut)))
else: _addProcessAndTask(proc, mod["PFJetsConstituents"], cms.EDProducer("PFJetConstituentSelector", src=cms.InputTag(mod["PFJets"]), cut=cms.string(Cut)))
jetSeq += getattr(proc, mod["PFJetsConstituents"])
addJetCollection(
proc,
labelName = mod["PATJetsLabel"],
jetSource = cms.InputTag(mod["PFJets"]),
postfix = postFix,
algo = jetalgo,
rParam = jetSize,
jetCorrections = JEC if JEC is not None else None,
pfCandidates = cms.InputTag( pfCand ),
svSource = cms.InputTag( svLabel ),
genJetCollection = cms.InputTag(mod["GenJetsNoNu"]),
pvSource = cms.InputTag( pvLabel ),
muSource = cms.InputTag( muLabel ),
elSource = cms.InputTag( elLabel ),
btagDiscriminators = bTagDiscriminators,
btagInfos = bTagInfos,
getJetMCFlavour = GetJetMCFlavour,
genParticles = cms.InputTag(genParticlesLabel),
outputModules = ['outputFile']
)
patJets = 'patJets'
patSubJets = ''
selPatJets = 'selectedPatJets'
mod["PATJets"] = patJets+mod["PATJetsLabelPost"]
mod["selPATJets"] = selPatJets+mod["PATJetsLabelPost"]
getattr(proc, mod["PATJets"]).addTagInfos = cms.bool(True)
if 'CS' in PUMethod: getattr( proc, mod["PATJets"] ).getJetMCFlavour = False # CS jets cannot be re-clustered from their constituents
else:
if verbosity>=2: print('|---- jetToolBox: JETTOOLBOX IS UPDATING '+updateCollection+' collection')
genParticlesLabel = 'prunedGenParticles'
pvLabel = 'offlineSlimmedPrimaryVertices'
svLabel = 'slimmedSecondaryVertices'
tvLabel = 'unpackedTracksAndVertices'
muLabel = 'slimmedMuons'
elLabel = 'slimmedElectrons'
if not JETCorrPayload:
raise ValueError('|---- jetToolBox: updateCollection option requires to add JETCorrPayload.')
JEC = ( JETCorrPayload, JETCorrLevels, 'None' ) ### temporary
if verbosity>=2: print('|---- jetToolBox: Applying these corrections: '+str(JEC))
updateJetCollection(
proc,
postfix = postFix,
jetSource = cms.InputTag( updateCollection ),
labelName = mod["PATJetsLabel"],
jetCorrections = JEC,
btagDiscriminators = bTagDiscriminators,
)
mod["PATJetsCorrFactors"] = 'patJetCorrFactors'+mod["PATJetsLabelPost"]
getattr( proc, mod["PATJetsCorrFactors"] ).payload = JETCorrPayload
getattr( proc, mod["PATJetsCorrFactors"] ).levels = JETCorrLevels
patJets = 'updatedPatJets'
patSubJets = ''
selPatJets = 'selectedPatJets'
mod["PATJets"] = patJets+mod["PATJetsLabelPost"]
mod["selPATJets"] = selPatJets+mod["PATJetsLabelPost"]
if updateCollectionSubjets:
if verbosity>=2: print('|---- jetToolBox: JETTOOLBOX IS UPDATING '+updateCollectionSubjets+' collection for subjets/groomers.')
if 'SoftDrop' in updateCollectionSubjets: updateSubjetLabel = 'SoftDrop'
else: updateSubjetLabel = 'Pruned'
mod["PATSubjetsLabel"] = jetALGO+'PF'+PUMethod+postFix+updateSubjetLabel+'Packed'
updateJetCollection(
proc,
jetSource = cms.InputTag( updateCollectionSubjets ),
labelName = mod["PATSubjetsLabel"],
jetCorrections = JEC,
explicitJTA = True,
fatJets = cms.InputTag( updateCollection ),
rParam = jetSize,
algo = jetALGO,
btagDiscriminators = subjetBTagDiscriminators,
)
mod["PATSubjetsCorrFactors"] = 'patJetCorrFactors'+mod["PATSubjetsLabel"]
getattr( proc, mod["PATSubjetsCorrFactors"] ).payload = subJETCorrPayload
getattr( proc, mod["PATSubjetsCorrFactors"] ).levels = subJETCorrLevels
patSubJets = 'updatedPatJets'+mod["PATSubjetsLabel"]
if addPrunedSubjets or addSoftDropSubjets or addCMSTopTagger or addMassDrop or addHEPTopTagger or addPruning or addSoftDrop:
if verbosity>=1: print('|---- jetToolBox: You are trying to add a groomer variable into a clustered jet collection. THIS IS NOT RECOMMENDED, it is recommended to recluster jets instead using a plain jetToolbox configuration. Please use this feature at your own risk.')
mod["PFJetsOrUpdate"] = mod["PFJets"] if not updateCollection else updateCollection
if bTagDiscriminators and verbosity>=2: print('|---- jetToolBox: Adding these btag discriminators: '+str(bTagDiscriminators)+' in the jet collection.')
if ( (addPrunedSubjets or addSoftDropSubjets) or (updateCollection and updateCollectionSubjets) ) and subjetBTagDiscriminators and verbosity>=2:
print('|---- jetToolBox: Adding these btag discriminators: '+str(subjetBTagDiscriminators)+' in the subjet collection.')
#### Groomers
if addSoftDrop or addSoftDropSubjets:
mod["PFJetsSoftDrop"] = mod["PFJets"]+'SoftDrop'
mod["SoftDropMass"] = mod["PFJets"]+'SoftDropMass'
_addProcessAndTask(proc, mod["PFJetsSoftDrop"],
ak8PFJetsCHSSoftDrop.clone(
src = cms.InputTag( mod["PFJetsConstituentsColonOrUpdate"] ),
rParam = jetSize,
jetAlgorithm = algorithm,
useExplicitGhosts=True,
R0= cms.double(jetSize),
zcut=zCutSD,
beta=betaCut,
doAreaFastjet = cms.bool(True),
writeCompound = cms.bool(True),
jetCollInstanceName=cms.string('SubJets') ) )
_addProcessAndTask(proc, mod["SoftDropMass"],
ak8PFJetsCHSSoftDropMass.clone( src = cms.InputTag( mod["PFJetsOrUpdate"] ),
matched = cms.InputTag( mod["PFJetsSoftDrop"] ),
distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_'+mod["SoftDropMass"]+'_*_*']
jetSeq += getattr(proc, mod["PFJetsSoftDrop"] )
jetSeq += getattr(proc, mod["SoftDropMass"] )
getattr( proc, mod["PATJets"]).userData.userFloats.src += [ mod["SoftDropMass"] ]
toolsUsed.append( mod["SoftDropMass"] )
if addSoftDropSubjets:
mod["GenJetsNoNuSoftDrop"] = mod["GenJetsNoNu"]+'SoftDrop'
if runOnMC:
_addProcessAndTask(proc, mod["GenJetsNoNuSoftDrop"],
ak4GenJets.clone(
SubJetParameters,
useSoftDrop = cms.bool(True),
rParam = jetSize,
jetAlgorithm = algorithm,
useExplicitGhosts=cms.bool(True),
#zcut=cms.double(zCutSD),
R0= cms.double(jetSize),
beta=cms.double(betaCut),
writeCompound = cms.bool(True),
jetCollInstanceName=cms.string('SubJets')
))
if miniAOD: getattr( proc, mod["GenJetsNoNuSoftDrop"] ).src = mod["GenParticlesNoNu"]
jetSeq += getattr(proc, mod["GenJetsNoNuSoftDrop"] )
mod["PATJetsSoftDropLabel"] = mod["PATJetsLabelPost"]+'SoftDrop'
addJetCollection(
proc,
labelName = mod["PATJetsSoftDropLabel"],
jetSource = cms.InputTag( mod["PFJetsSoftDrop"]),
algo = jetalgo,
rParam = jetSize,
jetCorrections = JEC if JEC is not None else None,
pvSource = cms.InputTag( pvLabel ),
btagDiscriminators = ['None'],
genJetCollection = cms.InputTag( mod["GenJetsNoNu"]),
getJetMCFlavour = False, # jet flavor should always be disabled for groomed jets
genParticles = cms.InputTag(genParticlesLabel),
outputModules = ['outputFile']
)
mod["PATJetsSoftDrop"] = patJets+mod["PATJetsSoftDropLabel"]
mod["selPATJetsSoftDrop"] = selPatJets+mod["PATJetsSoftDropLabel"]
_addProcessAndTask(proc, mod["selPATJetsSoftDrop"], selectedPatJets.clone(src=mod["PATJetsSoftDrop"], cut=Cut))
mod["PATSubjetsSoftDropLabel"] = mod["PATJetsSoftDropLabel"]+'Subjets'
addJetCollection(
proc,
labelName = mod["PATSubjetsSoftDropLabel"],
jetSource = cms.InputTag( mod["PFJetsSoftDrop"], 'SubJets'),
algo = jetalgo, # needed for subjet b tagging
rParam = jetSize, # needed for subjet b tagging
jetCorrections = subJEC if subJEC is not None else None,
pfCandidates = cms.InputTag( pfCand ),
pvSource = cms.InputTag( pvLabel),
svSource = cms.InputTag( svLabel ),
muSource = cms.InputTag( muLabel ),
elSource = cms.InputTag( elLabel ),
btagDiscriminators = subjetBTagDiscriminators,
btagInfos = bTagInfos,
genJetCollection = cms.InputTag( mod["GenJetsNoNuSoftDrop"],'SubJets'),
getJetMCFlavour = GetSubjetMCFlavour,
genParticles = cms.InputTag(genParticlesLabel),
explicitJTA = True, # needed for subjet b tagging
svClustering = True, # needed for subjet b tagging
fatJets=cms.InputTag(mod["PFJets"]), # needed for subjet flavor clustering
groomedFatJets=cms.InputTag(mod["PFJetsSoftDrop"]), # needed for subjet flavor clustering
outputModules = ['outputFile']
)
mod["PATSubjetsSoftDrop"] = patJets+mod["PATSubjetsSoftDropLabel"]
mod["selPATSubjetsSoftDrop"] = selPatJets+mod["PATSubjetsSoftDropLabel"]
_addProcessAndTask(proc, mod["selPATSubjetsSoftDrop"], selectedPatJets.clone(src=mod["PATSubjetsSoftDrop"], cut=CutSubjet))
# Establish references between PATified fat jets and subjets using the BoostedJetMerger
mod["selPATJetsSoftDropPacked"] = mod["selPATJetsSoftDrop"]+'Packed'
_addProcessAndTask(proc, mod["selPATJetsSoftDropPacked"],
cms.EDProducer("BoostedJetMerger",
jetSrc=cms.InputTag(mod["selPATJetsSoftDrop"]),
subjetSrc=cms.InputTag(mod["selPATSubjetsSoftDrop"])
))
jetSeq += getattr(proc, mod["selPATJetsSoftDropPacked"] )
elemToKeep += [ 'keep *_'+mod["selPATJetsSoftDropPacked"]+'_SubJets_*' ]
toolsUsed.append( mod["selPATJetsSoftDropPacked"]+':SubJets' )
## Pack fat jets with subjets
mod["packedPATJetsSoftDrop"] = 'packedPatJets'+mod["PATJetsSoftDropLabel"]
_addProcessAndTask(proc, mod["packedPATJetsSoftDrop"],
cms.EDProducer("JetSubstructurePacker",
jetSrc=cms.InputTag(mod["selPATJets"]),
distMax = cms.double( jetSize ),
fixDaughters = cms.bool(False),
algoTags = cms.VInputTag(
cms.InputTag(mod["selPATJetsSoftDropPacked"])
),
algoLabels =cms.vstring('SoftDrop')
)
)
jetSeq += getattr(proc, mod["packedPATJetsSoftDrop"])
elemToKeep += [ 'keep *_'+mod["packedPATJetsSoftDrop"]+'_*_*' ]
if verbosity>=2: print('|---- jetToolBox: Creating '+mod["packedPATJetsSoftDrop"]+' collection with SoftDrop subjets.')
if addPruning or addPrunedSubjets:
mod["PFJetsPruned"] = mod["PFJets"]+'Pruned'
mod["PrunedMass"] = mod["PFJets"]+'PrunedMass'
_addProcessAndTask(proc, mod["PFJetsPruned"],
ak8PFJetsCHSPruned.clone(
src = cms.InputTag( mod["PFJetsConstituentsColonOrUpdate"] ),
rParam = jetSize,
jetAlgorithm = algorithm,
zcut=zCut,
rcut_factor=rCut,
writeCompound = cms.bool(True),
doAreaFastjet = cms.bool(True),
jetCollInstanceName=cms.string('SubJets') ) )
_addProcessAndTask(proc, mod["PrunedMass"],
ak8PFJetsCHSPrunedMass.clone(
src = cms.InputTag( mod["PFJetsOrUpdate"] ),
matched = cms.InputTag( mod["PFJetsPruned"]),
distMax = cms.double( jetSize ) ) )
jetSeq += getattr(proc, mod["PFJetsPruned"])
jetSeq += getattr(proc, mod["PrunedMass"])
getattr( proc, mod["PATJets"]).userData.userFloats.src += [ mod["PrunedMass"] ]
elemToKeep += [ 'keep *_'+mod["PrunedMass"]+'_*_*']
toolsUsed.append( mod["PrunedMass"] )
if addPrunedSubjets:
if runOnMC:
mod["GenJetsNoNuPruned"] = mod["GenJetsNoNu"]+'Pruned'
_addProcessAndTask(proc, mod["GenJetsNoNuPruned"],
ak4GenJets.clone(
SubJetParameters,
rParam = jetSize,
usePruning = cms.bool(True),
writeCompound = cms.bool(True),
jetCollInstanceName=cms.string('SubJets')
))
if miniAOD: getattr( proc, mod["GenJetsNoNuPruned"] ).src = mod["GenParticlesNoNu"]
jetSeq += getattr(proc, mod["GenJetsNoNuPruned"])
mod["PATJetsPrunedLabel"] = mod["PATJetsLabelPost"]+'Pruned'
addJetCollection(
proc,
labelName = mod["PATJetsPrunedLabel"],
jetSource = cms.InputTag( mod["PFJetsPruned"]),
algo = jetalgo,
rParam = jetSize,
jetCorrections = JEC if JEC is not None else None,
pvSource = cms.InputTag( pvLabel ),
btagDiscriminators = ['None'],
genJetCollection = cms.InputTag( mod["GenJetsNoNu"]),
getJetMCFlavour = False, # jet flavor should always be disabled for groomed jets
genParticles = cms.InputTag(genParticlesLabel),
outputModules = ['outputFile']
)
mod["PATJetsPruned"] = patJets+mod["PATJetsPrunedLabel"]
mod["selPATJetsPruned"] = selPatJets+mod["PATJetsPrunedLabel"]
_addProcessAndTask(proc, mod["selPATJetsPruned"], selectedPatJets.clone(src=mod["PATJetsPruned"], cut=Cut))
mod["PATSubjetsPrunedLabel"] = mod["PATJetsPrunedLabel"]+'Subjets'
addJetCollection(
proc,
labelName = mod["PATSubjetsPrunedLabel"],
jetSource = cms.InputTag( mod["PFJetsPruned"], 'SubJets'),
algo = jetalgo, # needed for subjet b tagging
rParam = jetSize, # needed for subjet b tagging
jetCorrections = subJEC if subJEC is not None else None,
pfCandidates = cms.InputTag( pfCand ),
pvSource = cms.InputTag( pvLabel),
svSource = cms.InputTag( svLabel ),
muSource = cms.InputTag( muLabel ),
elSource = cms.InputTag( elLabel ),
getJetMCFlavour = GetSubjetMCFlavour,
genParticles = cms.InputTag(genParticlesLabel),
btagDiscriminators = subjetBTagDiscriminators,
btagInfos = bTagInfos,
genJetCollection = cms.InputTag( mod["GenJetsNoNuPruned"],'SubJets'),
explicitJTA = True, # needed for subjet b tagging
svClustering = True, # needed for subjet b tagging
fatJets=cms.InputTag(mod["PFJets"]), # needed for subjet flavor clustering
groomedFatJets=cms.InputTag(mod["PFJetsPruned"]), # needed for subjet flavor clustering
outputModules = ['outputFile']
)
mod["PATSubjetsPruned"] = patJets+mod["PATSubjetsPrunedLabel"]
mod["selPATSubjetsPruned"] = selPatJets+mod["PATSubjetsPrunedLabel"]
_addProcessAndTask(proc, mod["selPATSubjetsPruned"], selectedPatJets.clone(src=mod["PATSubjetsPruned"], cut=CutSubjet))
## Establish references between PATified fat jets and subjets using the BoostedJetMerger
mod["selPATJetsPrunedPacked"] = mod["selPATJetsPruned"]+'Packed'
_addProcessAndTask(proc, mod["selPATJetsPrunedPacked"],
cms.EDProducer("BoostedJetMerger",
jetSrc=cms.InputTag(mod["selPATJetsPruned"]),
subjetSrc=cms.InputTag(mod["selPATSubjetsPruned"]),
))
jetSeq += getattr(proc, mod["selPATJetsPrunedPacked"])
elemToKeep += [ 'keep *_'+mod["selPATJetsPrunedPacked"]+'_SubJets_*' ]
toolsUsed.append( mod["selPATJetsPrunedPacked"]+':SubJets' )
## Pack fat jets with subjets
mod["packedPATJetsPruned"] = 'packedPatJets'+mod["PATSubjetsPrunedLabel"]
_addProcessAndTask(proc, mod["packedPATJetsPruned"],
cms.EDProducer("JetSubstructurePacker",
jetSrc=cms.InputTag(mod["selPATJets"]),
distMax = cms.double( jetSize ),
fixDaughters = cms.bool(False),
algoTags = cms.VInputTag(
cms.InputTag(mod["selPATJetsPrunedPacked"])
),
algoLabels =cms.vstring('Pruned')
)
)
jetSeq += getattr(proc, mod["packedPATJetsPruned"])
elemToKeep += [ 'keep *_'+mod["packedPATJetsPruned"]+'_*_*' ]
if verbosity>=2: print('|---- jetToolBox: Creating '+mod["packedPATJetsPruned"]+' collection with Pruned subjets.')
if addTrimming:
mod["PFJetsTrimmed"] = mod["PFJets"]+'Trimmed'
mod["TrimmedMass"] = mod["PFJets"]+'TrimmedMass'
_addProcessAndTask(proc, mod["PFJetsTrimmed"],
ak8PFJetsCHSTrimmed.clone(
rParam = jetSize,
src = cms.InputTag( mod["PFJetsConstituentsColonOrUpdate"] ),
jetAlgorithm = algorithm,
rFilt= rFiltTrim,
trimPtFracMin= ptFrac) )
_addProcessAndTask(proc, mod["TrimmedMass"],
ak8PFJetsCHSTrimmedMass.clone(
src = cms.InputTag( mod["PFJetsOrUpdate"] ),
matched = cms.InputTag( mod["PFJetsTrimmed"]),
distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_'+mod["TrimmedMass"]+'_*_*']
jetSeq += getattr(proc, mod["PFJetsTrimmed"])
jetSeq += getattr(proc, mod["TrimmedMass"])
getattr( proc, mod["PATJets"]).userData.userFloats.src += [mod["TrimmedMass"]]
toolsUsed.append( mod["TrimmedMass"] )
if addFiltering:
mod["PFJetsFiltered"] = mod["PFJets"]+'Filtered'
mod["FilteredMass"] = mod["PFJets"]+'FilteredMass'
_addProcessAndTask(proc, mod["PFJetsFiltered"],
ak8PFJetsCHSFiltered.clone(
src = cms.InputTag( mod["PFJetsConstituentsColonOrUpdate"] ),
rParam = jetSize,
jetAlgorithm = algorithm,
rFilt= rfilt,
nFilt= nfilt ) )
_addProcessAndTask(proc, mod["FilteredMass"],
ak8PFJetsCHSFilteredMass.clone(
src = cms.InputTag( mod["PFJetsOrUpdate"] ),
matched = cms.InputTag( mod["PFJetsFiltered"]),
distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_'+mod["FilteredMass"]+'_*_*']
jetSeq += getattr(proc, mod["PFJetsFiltered"])
jetSeq += getattr(proc, mod["FilteredMass"])
getattr( proc, patJets+jetALGO+'PF'+PUMethod+postFix).userData.userFloats.src += [mod["FilteredMass"]]
toolsUsed.append( mod["FilteredMass"] )
if addCMSTopTagger :
if 'CA' in jetALGO :
mod["PFJetsCMSTopTag"] = mod["PFJets"].replace(jetalgo,"cmsTopTag")
_addProcessAndTask(proc, mod["PFJetsCMSTopTag"],
cms.EDProducer("CATopJetProducer",
PFJetParameters.clone(
src = cms.InputTag( mod["PFJetsConstituentsColonOrUpdate"] ),
doAreaFastjet = cms.bool(True),
doRhoFastjet = cms.bool(False),
jetPtMin = cms.double(100.0)
),
AnomalousCellParameters,
CATopJetParameters.clone( jetCollInstanceName = cms.string("SubJets"),
verbose = cms.bool(False),
algorithm = cms.int32(1), # 0 = KT, 1 = CA, 2 = anti-KT
tagAlgo = cms.int32(0), #0=legacy top
useAdjacency = cms.int32(2), # modified adjacency
centralEtaCut = cms.double(2.5), # eta for defining "central" jets
sumEtBins = cms.vdouble(0,1600,2600), # sumEt bins over which cuts vary. vector={bin 0 lower bound, bin 1 lower bound, ...}
rBins = cms.vdouble(0.8,0.8,0.8), # Jet distance paramter R. R values depend on sumEt bins.
ptFracBins = cms.vdouble(0.05,0.05,0.05), # minimum fraction of central jet pt for subjets (deltap)
deltarBins = cms.vdouble(0.19,0.19,0.19), # Applicable only if useAdjacency=1. deltar adjacency values for each sumEtBin
nCellBins = cms.vdouble(1.9,1.9,1.9),
),
jetAlgorithm = cms.string("CambridgeAachen"),
rParam = cms.double(jetSize),
writeCompound = cms.bool(True)
)
)
mod["CATopTagInfos"] = "CATopTagInfos"+postFix
_addProcessAndTask(proc, mod["CATopTagInfos"],
cms.EDProducer("CATopJetTagger",
src = cms.InputTag(mod["PFJetsCMSTopTag"]),
TopMass = cms.double(171),
TopMassMin = cms.double(0.),
TopMassMax = cms.double(250.),
WMass = cms.double(80.4),
WMassMin = cms.double(0.0),
WMassMax = cms.double(200.0),
MinMassMin = cms.double(0.0),
MinMassMax = cms.double(200.0),
verbose = cms.bool(False)
)
)
mod["PATJetsCMSTopTagLabel"] = 'CMSTopTag'+PUMethod+postFix
addJetCollection(
proc,
labelName = mod["PATJetsCMSTopTagLabel"],
jetSource = cms.InputTag(mod["PFJetsCMSTopTag"]),
jetCorrections = JEC if JEC is not None else None,
pfCandidates = cms.InputTag( pfCand ),
pvSource = cms.InputTag( pvLabel),
svSource = cms.InputTag( svLabel ),
muSource = cms.InputTag( muLabel ),
elSource = cms.InputTag( elLabel ),
btagDiscriminators = bTagDiscriminators,
btagInfos = bTagInfos,
genJetCollection = cms.InputTag(mod["GenJetsNoNu"]),
getJetMCFlavour = False, # jet flavor should always be disabled for groomed jets
genParticles = cms.InputTag(genParticlesLabel)
)
mod["PATJetsCMSTopTag"] = patJets+mod["PATJetsCMSTopTagLabel"]
mod["selPATJetsCMSTopTag"] = selPatJets+mod["PATJetsCMSTopTagLabel"]
getattr(proc,mod["PATJetsCMSTopTag"]).addTagInfos = True
getattr(proc,mod["PATJetsCMSTopTag"]).tagInfoSources = cms.VInputTag( cms.InputTag(mod["CATopTagInfos"]))
_addProcessAndTask(proc, mod["selPATJetsCMSTopTag"], selectedPatJets.clone(src=mod["PATJetsCMSTopTag"], cut=Cut))
mod["PATSubjetsCMSTopTagLabel"] = mod["PATJetsCMSTopTagLabel"]+'Subjets'
addJetCollection(
proc,
labelName = mod["PATSubjetsCMSTopTagLabel"],
jetSource = cms.InputTag(mod["PFJetsCMSTopTag"], 'SubJets'),
algo = jetalgo, # needed for subjet b tagging
rParam = jetSize, # needed for subjet b tagging
jetCorrections = subJEC if subJEC is not None else None,
pfCandidates = cms.InputTag( pfCand ),
pvSource = cms.InputTag( pvLabel),
svSource = cms.InputTag( svLabel ),
muSource = cms.InputTag( muLabel ),
elSource = cms.InputTag( elLabel ),
btagDiscriminators = bTagDiscriminators,
btagInfos = bTagInfos,
genJetCollection = cms.InputTag( mod["GenJetsNoNu"]),
getJetMCFlavour = GetSubjetMCFlavour,
explicitJTA = True, # needed for subjet b tagging
svClustering = True, # needed for subjet b tagging
fatJets=cms.InputTag(mod["PFJets"]), # needed for subjet flavor clustering
groomedFatJets=cms.InputTag(mod["PATJetsCMSTopTag"]), # needed for subjet flavor clustering
genParticles = cms.InputTag(genParticlesLabel)
)
mod["PATSubjetsCMSTopTag"] = patJets+mod["PATSubjetsCMSTopTagLabel"]
mod["selPATSubjetsCMSTopTag"] = selPatJets+mod["PATSubjetsCMSTopTagLabel"]
_addProcessAndTask(proc, mod["selPATSubjetsCMSTopTag"], selectedPatJets.clone(src=mod["PATSubjetsCMSTopTag"], cut=Cut))
mod["PATJetsCMSTopTagPacked"] = mod["PATJetsCMSTopTag"]+'Packed'
_addProcessAndTask(proc, mod["PATJetsCMSTopTagPacked"],
cms.EDProducer("BoostedJetMerger",
jetSrc=cms.InputTag(mod["PATJetsCMSTopTag"]),
subjetSrc=cms.InputTag(mod["PATSubjetsCMSTopTag"])
))
jetSeq += getattr(proc, mod["PATJetsCMSTopTagPacked"])
elemToKeep += [ 'keep *_'+mod["PATJetsCMSTopTagPacked"]+'_*_*' ]
toolsUsed.append( mod["PATJetsCMSTopTagPacked"] )
else:
raise ValueError('|---- jetToolBox: CMS recommends CambridgeAachen for CMS Top Tagger, you are using '+algorithm+'. JetToolbox will not run CMS Top Tagger.')
if addMassDrop :
if 'CA' in jetALGO :
mod["PFJetsMassDrop"] = mod["PFJets"]+'MassDropFiltered'
mod["MassDropFilteredMass"] = mod["PFJetsMassDrop"]+'Mass'
_addProcessAndTask(proc, mod["PFJetsMassDrop"],
ca15PFJetsCHSMassDropFiltered.clone(
rParam = jetSize,
src = cms.InputTag( mod["PFJetsConstituentsColonOrUpdate"] ),
) )
_addProcessAndTask(proc, mod["MassDropFilteredMass"], ak8PFJetsCHSPrunedMass.clone(src=cms.InputTag(mod["PFJets"]),
matched = cms.InputTag(mod["PFJetsMassDrop"]), distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_'+mod["MassDropFilteredMass"]+'_*_*' ]
getattr( proc, mod["PATJets"]).userData.userFloats.src += [ mod["MassDropFilteredMass"] ]
jetSeq += getattr(proc, mod["PFJetsMassDrop"])
jetSeq += getattr(proc, mod["MassDropFilteredMass"])
toolsUsed.append( mod["MassDropFilteredMass"] )
else:
raise ValueError('|---- jetToolBox: CMS recommends CambridgeAachen for Mass Drop, you are using '+algorithm+'. JetToolbox will not run Mass Drop.')
if addHEPTopTagger:
if ( jetSize >= 1. ) and ( 'CA' in jetALGO ):
mod["PFJetsHEPTopTag"] = mod["PFJets"].replace(jetalgo,"hepTopTag")
mod["PFJetsHEPTopTagMass"] = mod["PFJetsHEPTopTag"]+'Mass'+jetALGO
_addProcessAndTask(proc, mod["PFJetsHEPTopTag"], hepTopTagPFJetsCHS.clone(src=cms.InputTag(mod["PFJetsConstituentsColonOrUpdate"])))
_addProcessAndTask(proc, mod["PFJetsHEPTopTagMass"], ak8PFJetsCHSPrunedMass.clone(src=cms.InputTag(mod["PFJets"]),
matched = cms.InputTag(mod["PFJetsHEPTopTag"]), distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_'+mod["PFJetsHEPTopTagMass"]+'_*_*' ]
getattr( proc, mod["PATJets"]).userData.userFloats.src += [ mod["PFJetsHEPTopTagMass"] ]
jetSeq += getattr(proc, mod["PFJetsHEPTopTag"])
jetSeq += getattr(proc, mod["PFJetsHEPTopTagMass"])
toolsUsed.append( mod["PFJetsHEPTopTagMass"] )
else:
raise ValueError('|---- jetToolBox: CMS recommends CambridgeAachen w/ jet cone size > 1.0 for HEPTopTagger, you are using '+algorithm+'. JetToolbox will not run HEP TopTagger.')
####### Nsubjettiness
if addNsub:
from RecoJets.JetProducers.nJettinessAdder_cfi import Njettiness
rangeTau = range(1,maxTau+1)
mod["Njettiness"] = 'Njettiness'+mod["SubstructureLabel"]
_addProcessAndTask(proc, mod["Njettiness"],
Njettiness.clone( src = cms.InputTag( mod["PFJetsOrUpdate"] ),
Njets=cms.vuint32(rangeTau), # 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( jetSize ), # 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
elemToKeep += [ 'keep *_'+mod["Njettiness"]+'_*_*' ]
for tau in rangeTau: getattr( proc, mod["PATJets"]).userData.userFloats.src += [mod["Njettiness"]+':tau'+str(tau) ]
jetSeq += getattr(proc, mod["Njettiness"])
toolsUsed.append( mod["Njettiness"] )
####### Nsubjettiness
if addNsubSubjets:
from RecoJets.JetProducers.nJettinessAdder_cfi import Njettiness
mod["NsubGroomer"] = ''
mod["NsubSubjets"] = ''
mod["NsubPATSubjets"] = ''
if addSoftDropSubjets or updateCollectionSubjets:
mod["NsubGroomer"] = mod["PFJetsSoftDrop"]
mod["NsubSubjets"] = mod["PATSubjetsSoftDropLabel"]
mod["NsubPATSubjets"] = mod["PATSubjetsSoftDrop"]
if updateCollectionSubjets:
if verbosity>=2: print('|---- jetToolBox: Using updateCollection option. ASSUMING MINIAOD collection '+ updateCollectionSubjets +' for Nsubjettiness of subjets.')
elif addPrunedSubjets:
mod["NsubGroomer"] = mod["PFJetsPruned"]
mod["NsubSubjets"] = mod["PATSubjetsPrunedLabel"]
mod["NsubPATSubjets"] = mod["PATSubjetsPruned"]
else:
raise ValueError('|---- jetToolBox: Nsubjettiness of subjets needs a Subjet collection. Or create one using addSoftDropSubjets option, or updateCollection.')
mod["Nsubjettiness"] = 'Nsubjettiness'+mod["NsubSubjets"]
rangeTau = range(1,subjetMaxTau+1)
_addProcessAndTask(proc, mod["Nsubjettiness"],
Njettiness.clone( src = cms.InputTag( ( mod["NsubGroomer"] if not updateCollectionSubjets else updateCollectionSubjets ), 'SubJets' ),
Njets=cms.vuint32(rangeTau), # 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( jetSize ), # 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
elemToKeep += [ 'keep *_'+mod["Nsubjettiness"]+'_*_*' ]
for tau in rangeTau: getattr( proc, ( mod["NsubPATSubjets"] if not updateCollectionSubjets else patSubJets ) ).userData.userFloats.src += [mod["Nsubjettiness"]+':tau'+str(tau) ]
jetSeq += getattr(proc, mod["Nsubjettiness"])
toolsUsed.append( mod["Nsubjettiness"] )
###### QGTagger
if addQGTagger:
if ( 'ak4' in jetalgo ) and ( PUMethod not in ['Puppi','CS','SK'] ) :
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
proc.load('RecoJets.JetProducers.QGTagger_cfi') ## In 74X you need to run some stuff before.
mod["QGTagger"] = 'QGTagger'+mod["PATJetsLabelPost"]
_addProcessAndTask(proc, mod["QGTagger"],
QGTagger.clone(
srcJets = cms.InputTag( mod["PFJetsOrUpdate"] ), # Could be reco::PFJetCollection or pat::JetCollection (both AOD and miniAOD)
jetsLabel = cms.string('QGL_AK4PF'+QGjetsLabel) # Other options (might need to add an ESSource for it): see https://twiki.cern.ch/twiki/bin/viewauth/CMS/QGDataBaseVersion
)
)
elemToKeep += [ 'keep *_'+mod["QGTagger"]+'_*_*' ]
getattr( proc, mod["PATJets"]).userData.userFloats.src += [mod["QGTagger"]+':qgLikelihood']
jetSeq += getattr(proc, mod["QGTagger"])
toolsUsed.append( mod["QGTagger"] )
else:
raise ValueError('|---- jetToolBox: QGTagger is optimized for ak4 jets with CHS. NOT running QGTagger')
####### Pileup JetID
if addPUJetID:
if ( 'ak4' in jetalgo ) and ( PUMethod not in ['CS','SK'] ):
if PUMethod=="Puppi" and verbosity>=1: print('|---- jetToolBox: PUJetID is not yet optimized for ak4 PFjets with PUPPI. USE ONLY FOR TESTING.')
from RecoJets.JetProducers.pileupjetidproducer_cfi import pileupJetIdCalculator,pileupJetIdEvaluator
mod["PUJetIDCalc"] = mod["PATJetsLabelPost"]+'pileupJetIdCalculator'
_addProcessAndTask(proc, mod["PUJetIDCalc"],
pileupJetIdCalculator.clone(
jets = cms.InputTag( mod["PFJetsOrUpdate"] ),
rho = cms.InputTag("fixedGridRhoFastjetAll"),
vertexes = cms.InputTag(pvLabel),
applyJec = cms.bool(True),
inputIsCorrected = cms.bool(False)
))
mod["PUJetIDEval"] = mod["PATJetsLabelPost"]+'pileupJetIdEvaluator'
_addProcessAndTask(proc, mod["PUJetIDEval"],
pileupJetIdEvaluator.clone(
jetids = cms.InputTag(mod["PUJetIDCalc"]),
jets = cms.InputTag( mod["PFJetsOrUpdate"] ),
rho = cms.InputTag("fixedGridRhoFastjetAll"),
vertexes = cms.InputTag(pvLabel)
)
)
getattr( proc, mod["PATJets"]).userData.userFloats.src += [mod["PUJetIDEval"]+':fullDiscriminant']
getattr( proc, mod["PATJets"]).userData.userInts.src += [mod["PUJetIDEval"]+':cutbasedId',mod["PUJetIDEval"]+':fullId']
elemToKeep += ['keep *_'+mod["PUJetIDEval"]+'_*_*']
toolsUsed.append( mod["PUJetIDEval"] )
else:
raise ValueError('|---- jetToolBox: PUJetID is optimized for ak4 PFjets with CHS. NOT running PUJetID.')
###### Energy Correlation Functions
if addEnergyCorrFunc:
if PUMethod!="Puppi" or (addSoftDrop==False and addSoftDropSubjets==False):
raise ValueError("|---- jetToolBox: addEnergyCorrFunc only supported for Puppi w/ addSoftDrop or addSoftDropSubjets")
from RecoJets.JetProducers.ECF_cff import ecfNbeta1, ecfNbeta2
mod["ECFnb1"] = 'nb1'+mod["SubstructureLabel"]+'SoftDrop'
# mod["ECFnb2"] = 'nb2'+mod["SubstructureLabel"]+'SoftDrop'
_addProcessAndTask(proc, mod["ECFnb1"], ecfNbeta1.clone(src=cms.InputTag(mod["PFJetsSoftDrop"]), cuts=cms.vstring('', '', 'pt > 250')))
# _addProcessAndTask(proc, mod["ECFnb2"], ecfNbeta2.clone(src=cms.InputTag(mod["PFJetsSoftDrop"]), cuts=cms.vstring('', '', 'pt > 250')))
elemToKeep += [ 'keep *_' + mod["ECFnb1"] + '_*_*',
# 'keep *_'+mod["ECFnb2"]+'_*_*'
]
jetSeq += getattr(proc, mod["ECFnb1"])
# jetSeq += getattr(proc, mod["ECFnb2"])
# toolsUsed.extend([mod["ECFnb1"], mod["ECFnb2"]])
toolsUsed.extend([mod["ECFnb1"]])
# set up user floats
getattr(proc, mod["PATJetsSoftDrop"]).userData.userFloats.src += [
mod["ECFnb1"]+':ecfN2',
mod["ECFnb1"]+':ecfN3',
# mod["ECFnb2"]+':ecfN2',
# mod["ECFnb2"]+':ecfN3',
]
# rekey the groomed ECF value maps to the ungroomed reco jets, which will then be picked
# up by PAT in the user floats.
mod["PFJetsSoftDropValueMap"] = mod["PFJetsSoftDrop"]+'ValueMap'
_addProcessAndTask(proc, mod["PFJetsSoftDropValueMap"],
cms.EDProducer("RecoJetToPatJetDeltaRValueMapProducer",
src = cms.InputTag(mod["PFJets"]),
matched = cms.InputTag(mod["PATJetsSoftDrop"]),
distMax = cms.double(jetSize),
values = cms.vstring([
'userFloat("'+mod["ECFnb1"]+':ecfN2'+'")',
'userFloat("'+mod["ECFnb1"]+':ecfN3'+'")',
# 'userFloat("'+mod["ECFnb2"]+':ecfN2'+'")',
# 'userFloat("'+mod["ECFnb2"]+':ecfN3'+'")',
]),
valueLabels = cms.vstring( [
mod["ECFnb1"]+'N2',
mod["ECFnb1"]+'N3',
# mod["ECFnb2"]+'N2',
# mod["ECFnb2"]+'N3',
]),
)
)
getattr(proc, mod["PATJets"]).userData.userFloats.src += [
mod["PFJetsSoftDropValueMap"]+':'+mod["ECFnb1"]+'N2',
mod["PFJetsSoftDropValueMap"]+':'+mod["ECFnb1"]+'N3',
# mod["PFJetsSoftDropValueMap"]+':'+mod["ECFnb2"]+'N2',
# mod["PFJetsSoftDropValueMap"]+':'+mod["ECFnb2"]+'N3',
]
if addEnergyCorrFuncSubjets:
if PUMethod!="Puppi" or addSoftDropSubjets==False:
raise ValueError("|---- jetToolBox: addEnergyCorrFuncSubjets only supported for Puppi w/ addSoftDropSubjets")
from RecoJets.JetProducers.ECF_cff import ecfNbeta1, ecfNbeta2
mod["ECFnb1Subjets"] = 'nb1'+mod["SubstructureLabel"]+'SoftDropSubjets'
mod["ECFnb2Subjets"] = 'nb2'+mod["SubstructureLabel"]+'SoftDropSubjets'
_addProcessAndTask(proc, mod["ECFnb1Subjets"], ecfNbeta1.clone(src=cms.InputTag(mod["PFJetsSoftDrop"], 'SubJets')))
_addProcessAndTask(proc, mod["ECFnb2Subjets"], ecfNbeta2.clone(src=cms.InputTag(mod["PFJetsSoftDrop"], 'SubJets')))
elemToKeep += [ 'keep *_'+mod["ECFnb1Subjets"]+'_*_*', 'keep *_'+mod["ECFnb2Subjets"]+'_*_*']
jetSeq += getattr(proc, mod["ECFnb1Subjets"])
jetSeq += getattr(proc, mod["ECFnb2Subjets"])
toolsUsed.extend([mod["ECFnb1Subjets"],mod["ECFnb2Subjets"]])
# set up user floats
getattr(proc, mod["PATSubjetsSoftDrop"]).userData.userFloats.src += [
mod["ECFnb1Subjets"]+':ecfN2',
mod["ECFnb1Subjets"]+':ecfN3',
mod["ECFnb2Subjets"]+':ecfN2',
mod["ECFnb2Subjets"]+':ecfN3',
]
if hasattr(proc, 'patJetPartons'): proc.patJetPartons.particles = genParticlesLabel
_addProcessAndTask(proc, mod["selPATJets"], selectedPatJets.clone(src=mod["PATJets"], cut=Cut))
elemToKeep += [ 'keep *_'+mod["selPATJets"]+'_*_*' ]
elemToKeep += [ 'drop *_'+mod["selPATJets"]+'_calo*_*' ]
elemToKeep += [ 'drop *_'+mod["selPATJets"]+'_tagInfos_*' ]
if updateCollectionSubjets:
mod["PATSubjets"] = patJets+mod["PATSubjetsLabel"]
mod["selPATSubjets"] = selPatJets+mod["PATSubjetsLabel"]
_addProcessAndTask(proc, mod["selPATSubjets"], selectedPatJets.clone(src=mod["PATSubjets"], cut=Cut))
elemToKeep += [ 'keep *_'+mod["selPATSubjets"]+'__*' ]
if len(toolsUsed) > 0 and verbosity>=2: print('|---- jetToolBox: Running '+', '.join(toolsUsed)+'.')
if verbosity>=2: print('|---- jetToolBox: Creating '+mod["selPATJets"]+' collection.')
if updateCollectionSubjets and verbosity>=2: print('|---- jetToolBox: Creating '+mod["selPATSubjets"]+' collection.')
### "return"
setattr(proc, jetSequence, jetSeq)
if outputFile!='':
if hasattr(proc, outputFile): getattr(proc, outputFile).outputCommands += elemToKeep
else: setattr( proc, outputFile,
cms.OutputModule('PoolOutputModule',
fileName = cms.untracked.string('jettoolbox.root'),
outputCommands = cms.untracked.vstring( elemToKeep ) ) )
if associateTask:
from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask
task = getPatAlgosToolsTask(proc)
if hasattr(proc, 'endpath'):
getattr(proc, 'endpath').associate(task)
else:
setattr(proc, 'endpath', cms.EndPath(task))
if outputFile != '':
getattr(proc, 'endpath').insert(-1, getattr(proc, outputFile))
#### removing mc matching for data
if runOnData:
from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching
removeMCMatching(proc, names=['Jets'], outputModules=[outputFile])
if verbosity>=3:
print('|---- jetToolBox: List of modules created (and other internal names):')
for m in mod:
print(' '+m+' = '+mod[m])
def addFlashggPFCHSJets(process,
isData,
vertexIndex = 0,
#doQGTagging = True,
label ='',
debug = False):
setattr(process, 'selectedMuons' + label, cms.EDFilter("CandPtrSelector",
src = cms.InputTag("slimmedMuons"),
cut = cms.string('''abs(eta)<2.5 && pt>10. &&
(pfIsolationR04().sumChargedHadronPt+
max(0.,pfIsolationR04().sumNeutralHadronEt+
pfIsolationR04().sumPhotonEt-
0.50*pfIsolationR04().sumPUPt))/pt < 0.20 &&
(isPFMuon && (isGlobalMuon || isTrackerMuon) )''')))
setattr(process, 'selectedElectrons' + label, cms.EDFilter("CandPtrSelector",
src = cms.InputTag("slimmedElectrons"),
cut = cms.string('''abs(eta)<2.5 && pt>20. &&
gsfTrack.isAvailable() &&
gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2 &&
(pfIsolationVariables().sumChargedHadronPt+
max(0.,pfIsolationVariables().sumNeutralHadronEt+
pfIsolationVariables().sumPhotonEt-
0.5*pfIsolationVariables().sumPUPt))/pt < 0.15''')))
# Simple producer which just removes the Candidates which
# don't come from the legacy vertex according to the Flashgg Vertex Map
setattr(process,'flashggCHSLegacyVertexCandidates' + label,
cms.EDProducer('FlashggMultiCHSLegacyVertexCandProducer',
PFCandidatesTag = cms.InputTag('packedPFCandidates'),
DiPhotonTag = cms.InputTag('flashggDiPhotons'),
VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"),
VertexTag = cms.InputTag('offlineSlimmedPrimaryVertices'),
vertexIndex = cms.uint32(vertexIndex),
debug = cms.untracked.bool(debug)
)
)
setattr(process, 'pfCHSLeg' + label, cms.EDFilter("CandPtrSelector",
src = cms.InputTag('flashggCHSLegacyVertexCandidates' + label),
cut = cms.string('')))
# then remove the previously selected muons
setattr(process, 'pfNoMuonCHSLeg' + label, cms.EDProducer("CandPtrProjector",
src = cms.InputTag("pfCHSLeg" + label),
veto = cms.InputTag("selectedMuons" + label)))
# then remove the previously selected electrons
setattr(process, 'pfNoElectronsCHSLeg' + label, cms.EDProducer("CandPtrProjector",
src = cms.InputTag("pfNoMuonCHSLeg" + label),
veto = cms.InputTag("selectedElectrons" + label)))
#Import RECO jet producer for ak4 PF and GEN jet
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
setattr(process, 'ak4PFJetsCHSLeg' + label, ak4PFJets.clone ( src = 'pfNoElectronsCHSLeg' + label, doAreaFastjet = True))
if isData:
JECs = ['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual']
else:
JECs = ['L1FastJet', 'L2Relative', 'L3Absolute']
# NOTE: this is the 74X recipe for the jet clustering
addJetCollection(
process,
postfix = label,
labelName = 'AK4PFCHSLeg',
jetSource = cms.InputTag('ak4PFJetsCHSLeg' + label),
pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'),
pfCandidates = cms.InputTag('packedPFCandidates'),
svSource = cms.InputTag('slimmedSecondaryVertices'),
btagDiscriminators = [ flashggBTag ],
jetCorrections = ('AK4PFchs', JECs, 'None'),
genJetCollection = cms.InputTag('slimmedGenJets'),
genParticles = cms.InputTag('prunedGenParticles'),
# jet param
algo = 'AK', rParam = 0.4
)
#adjust PV used for Jet Corrections
#process.patJetCorrFactorsAK4PFCHSLeg.primaryVertices = "offlineSlimmedPrimaryVertices"
getattr(process, 'patJetCorrFactorsAK4PFCHSLeg' + label).primaryVertices = "offlineSlimmedPrimaryVertices"
if not hasattr(process,"QGPoolDBESSource"):
process.QGPoolDBESSource = cms.ESSource("PoolDBESSource",
CondDBSetup,
toGet = cms.VPSet(),
connect = cms.string('sqlite:QGL_'+qgDatabaseVersion+'.db')
)
process.es_prefer_qg = cms.ESPrefer('PoolDBESSource','QGPoolDBESSource')
for type in ['AK4PFchs']:#,'AK4PFchs_antib']:
process.QGPoolDBESSource.toGet.extend(cms.VPSet(cms.PSet(
record = cms.string('QGLikelihoodRcd'),
tag = cms.string('QGLikelihoodObject_'+qgDatabaseVersion+'_'+type),
label = cms.untracked.string('QGL_'+type)
)))
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
setattr( process, 'QGTaggerPFCHS' + label,
QGTagger.clone( srcJets = 'patJetsAK4PFCHSLeg' + label ,jetsLabel = 'QGL_AK4PFchs', vertexIndex = cms.uint32(vertexIndex),
srcVertexCollection = 'offlineSlimmedPrimaryVertices'))
from RecoJets.JetProducers.PileupJetIDParams_cfi import full_80x_chs
flashggJets = cms.EDProducer('FlashggJetProducer',
DiPhotonTag = cms.InputTag('flashggDiPhotons'),
VertexTag = cms.InputTag('offlineSlimmedPrimaryVertices'),
JetTag = cms.InputTag('patJetsAK4PFCHSLeg' + label),
VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"),
qgVariablesInputTag = cms.InputTag('QGTaggerPFCHS'+label, 'qgLikelihood'),
ComputeSimpleRMS = cms.bool(True),
PileupJetIdParameters = full_80x_chs,
rho = cms.InputTag("fixedGridRhoFastjetAll"),
JetCollectionIndex = cms.uint32(vertexIndex),
Debug = cms.untracked.bool(False)
)
setattr( process, 'flashggPFCHSJets'+ label, flashggJets)
# randomize Jets
from flashgg.MicroAOD.flashggRandomizedJetProducer_cfi import flashggRandomizedJets
flashggRandomizedPFCHSJets = flashggRandomizedJets.clone()
flashggRandomizedPFCHSJets.src = "flashggPFCHSJets" + label
setattr(process.RandomNumberGeneratorService, 'flashggRandomizedPFCHSJets' + label, cms.PSet(initialSeed = cms.untracked.uint32(36423784 + int(label))))
setattr( process, 'flashggRandomizedPFCHSJets' + label, flashggRandomizedPFCHSJets )
flashggSelectedJets = cms.EDFilter("FLASHggJetSelector",
src = cms.InputTag( 'flashggRandomizedPFCHSJets' + label ),
cut = cms.string("pt > 15.")
)
setattr( process, 'flashggSelectedPFCHSJets'+label, flashggSelectedJets )
def addFlashggPFCHSJets(process,
vertexIndex=0,
doQGTagging=True,
label='',
debug=False):
setattr(
process, 'selectedMuons' + label,
cms.EDFilter("CandPtrSelector",
src=cms.InputTag("slimmedMuons"),
cut=cms.string('''abs(eta)<2.5 && pt>10. &&
(pfIsolationR04().sumChargedHadronPt+
max(0.,pfIsolationR04().sumNeutralHadronEt+
pfIsolationR04().sumPhotonEt-
0.50*pfIsolationR04().sumPUPt))/pt < 0.20 &&
(isPFMuon && (isGlobalMuon || isTrackerMuon) )'''
)))
setattr(
process, 'selectedElectrons' + label,
cms.EDFilter("CandPtrSelector",
src=cms.InputTag("slimmedElectrons"),
cut=cms.string('''abs(eta)<2.5 && pt>20. &&
gsfTrack.isAvailable() &&
gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2 &&
(pfIsolationVariables().sumChargedHadronPt+
max(0.,pfIsolationVariables().sumNeutralHadronEt+
pfIsolationVariables().sumPhotonEt-
0.5*pfIsolationVariables().sumPUPt))/pt < 0.15'''
)))
# Simple producer which just removes the Candidates which
# don't come from the legacy vertex according to the Flashgg Vertex Map
setattr(
process, 'flashggCHSLegacyVertexCandidates' + label,
cms.EDProducer(
'FlashggMultiCHSLegacyVertexCandProducer',
PFCandidatesTag=cms.InputTag('packedPFCandidates'),
DiPhotonTag=cms.InputTag('flashggDiPhotons'),
VertexCandidateMapTag=cms.InputTag("flashggVertexMapForCHS"),
VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'),
vertexIndex=cms.untracked.uint32(vertexIndex),
debug=cms.untracked.bool(debug)))
setattr(
process, 'pfCHSLeg' + label,
cms.EDFilter("CandPtrSelector",
src=cms.InputTag('flashggCHSLegacyVertexCandidates' +
label),
cut=cms.string('')))
# then remove the previously selected muons
setattr(
process, 'pfNoMuonCHSLeg' + label,
cms.EDProducer("CandPtrProjector",
src=cms.InputTag("pfCHSLeg" + label),
veto=cms.InputTag("selectedMuons" + label)))
# then remove the previously selected electrons
setattr(
process, 'pfNoElectronsCHSLeg' + label,
cms.EDProducer("CandPtrProjector",
src=cms.InputTag("pfNoMuonCHSLeg" + label),
veto=cms.InputTag("selectedElectrons" + label)))
#Import RECO jet producer for ak4 PF and GEN jet
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
#from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets
setattr(
process, 'ak4PFJetsCHSLeg' + label,
ak4PFJets.clone(src='pfNoElectronsCHSLeg' + label, doAreaFastjet=True))
#process.ak4GenJetsLeg = ak4GenJets.clone( src = 'packedGenParticles')
# NOTE: this is the 74X recipe for the jet clustering
addJetCollection(
process,
postfix=label,
labelName='AK4PFCHSLeg',
jetSource=cms.InputTag('ak4PFJetsCHSLeg' + label),
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)
#adjust PV used for Jet Corrections
#process.patJetCorrFactorsAK4PFCHSLeg.primaryVertices = "offlineSlimmedPrimaryVertices"
getattr(process, 'patJetCorrFactorsAK4PFCHSLeg' +
label).primaryVertices = "offlineSlimmedPrimaryVertices"
# Flashgg Jet producer using the collection created with function above.
flashggJets = cms.EDProducer(
'FlashggJetProducer',
DiPhotonTag=cms.InputTag('flashggDiPhotons'),
VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'),
JetTag=cms.InputTag('patJetsAK4PFCHSLeg' + label),
VertexCandidateMapTag=cms.InputTag("flashggVertexMapForCHS"),
# PileupJetIdParameters = cms.PSet(pu_jetid)
)
setattr(process, 'flashggPFCHSJets' + label, flashggJets)
if doQGTagging:
from RecoJets.JetProducers.QGTagger_cfi import QGTagger
setattr(
process, 'QGTaggerPFCHS' + label,
QGTagger.clone(srcJets='flashggPFCHSJets' + label,
jetsLabel='ak4PFJetsCHS'))
flashggSelectedJets = cms.EDFilter("FLASHggJetSelector",
src=cms.InputTag('flashggPFCHSJets' +
label),
cut=cms.string("pt > 15."))
setattr(process, 'flashggSelectedPFCHSJets' + label, flashggSelectedJets)
