particleFlowIncDSA = _pfcandmerger.clone(src=cms.VInputTag(
cms.InputTag("filteredPFCandsFwdPtr"),
cms.InputTag("dsaMuPFCandFork", "nonMatched"),
))
ffPFCandsMatchAndMergeSeq = cms.Sequence(dsaMuPFCandFork + particleFlowIncDSA)
###############################################################################
ffLeptonJetCHS = ak4PFJets.clone(
src=cms.InputTag("particleFlowIncDSA"),
rParam=cms.double(0.4),
jetAlgorithm=cms.string("AntiKt"),
# radiusPU=cms.double(0.4),
# useFiltering=cms.bool(True),
# nFilt=cms.int32(3),
# rFilt=cms.double(0.3),
# usePruning=cms.bool(True),
# useTrimming=cms.bool(True),
# rFilt=cms.double(0.2),
# trimPtFracMin=cms.double(0.03),
)
ffLeptonJet = _jetconstituentsubtractor.clone()
ffLeptonJetProd = cms.Sequence(ffLeptonJetCHS + ffLeptonJet)
ffLeptonJetFilter = cms.Sequence(ffLeptonJetFwdPtrs + filteredLeptonJet +
ffLeptonJetCountFilter)
# if switches["recoStuff"]["usingCHS"] == False:
# ffLeptonJet = ffLeptonJetCHS.clone()
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',
'combinedSecondaryVertexBJetTags',
'pfCombinedSecondaryVertexSoftLeptonBJetTags',
'pfPositiveCombinedSecondaryVertexBJetTags',
'pfNegativeCombinedSecondaryVertexBJetTags'
]
#,'pfCombinedSecondaryVertexBJetTags','pfCombinedMVABJetTags','pfCombinedSecondaryVertexSoftLeptonBJetTags','pfPositiveCombinedSecondaryVertexBJetTags','pfNegativeCombinedSecondaryVertexBJetTags']
#,'pfCombinedInclusiveSecondaryVertexBJetTags'
#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', 'L2L3Residual']
#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']
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)
#--------------------------------------------------------------------------------
# produce collection of "toy" PFCandidates
process.toyPFCandidates = cms.EDProducer("ToyPFCandidateProducer",
src = cms.InputTag('genParticles')
)
process.dumpPATTauSequence += process.toyPFCandidates
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
# run jet reconstruction on "toy" PFCandidates
from RecoJets.Configuration.RecoPFJets_cff import ak4PFJets
process.ak4ToyPFJets = ak4PFJets.clone(
src = cms.InputTag('toyPFCandidates', 'pfCandidates')
)
process.dumpPATTauSequence += process.ak4ToyPFJets
#--------------------------------------------------------------------------------
#--------------------------------------------------------------------------------
# run tau reconstruction on "toy" PFCandidates
process.genTauMatchedPFJets = cms.EDFilter("PFJetAntiOverlapSelector",
src = cms.InputTag('ak4ToyPFJets'),
srcNotToBeFiltered = cms.VInputTag('selectedTauGenJets'),
dRmin = cms.double(0.3),
invert = cms.bool(True),
filter = cms.bool(False)
)
process.dumpPATTauSequence += process.genTauMatchedPFJets
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','combinedSecondaryVertexBJetTags','pfCombinedSecondaryVertexSoftLeptonBJetTags','pfPositiveCombinedSecondaryVertexBJetTags','pfNegativeCombinedSecondaryVertexBJetTags']
#,'pfCombinedSecondaryVertexBJetTags','pfCombinedMVABJetTags','pfCombinedSecondaryVertexSoftLeptonBJetTags','pfPositiveCombinedSecondaryVertexBJetTags','pfNegativeCombinedSecondaryVertexBJetTags']
#,'pfCombinedInclusiveSecondaryVertexBJetTags'
#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','L2L3Residual']
#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']
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, outputFile,
PUMethod='CHS', #### Options: Puppi, CS, SK, Plain
JETCorrPayload='None', JETCorrLevels = [ 'None' ],
subJETCorrPayload='None', subJETCorrLevels = [ 'None' ],
miniAOD=True,
Cut = '',
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,
addQJets=False
):
###############################################################################
####### Verifying some inputs and defining variables
###############################################################################
print '|---- jetToolbox: Initialyzing...'
supportedJetAlgos = { 'ak': 'AntiKt', 'ca' : 'CambridgeAachen', 'kt' : 'Kt' }
recommendedJetAlgos = [ 'ak4', 'ak8', 'ca4', 'ca8', 'ca10' ]
payloadList = [ 'AK1PFchs', 'AK2PFchs', 'AK3PFchs', 'AK4PFchs', 'AK5PFchs', 'AK6PFchs', 'AK7PFchs', 'AK8PFchs', 'AK9PFchs', 'AK10PFchs' ]
JECLevels = [ 'L1Offset', 'L1FastJet', 'L1JPTOffset', 'L2Relative', 'L3Absolute', 'L5Falvour', 'L7Parton' ]
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,'.'
if JETCorrPayload not in payloadList:
if( int(size) > 10 ):
size = '10'
print '|---- jetToolbox: For jets bigger than 1.0, the jet corrections are AK10PFchs.'
if not 'None' in JETCorrPayload: print '|---- jetToolBox: Payload given for Jet corrections ('+JETCorrPayload+') is not correct. Using a default AK'+size+'PFchs instead.'
JETCorrPayload = 'AK'+size+'PFchs'
else: print '|---- jetToolBox: Using '+JETCorrPayload+' payload for jet corrections.'
if not set(JETCorrLevels).issubset(set(JECLevels)) :
if not 'None' in JETCorrLevels: print '|---- jetToolbox: JEC levels given ( '+' '.join(JETCorrLevels)+' ) are incorrect. Using the default levels: L1FastJet, L2Relative, L3Absolute.'
JETCorrLevels = ['L1FastJet', 'L2Relative', 'L3Absolute']
print '|---- jetToolBox: Applying these jet corrections: ( '+JETCorrPayload+', '+' '.join(JETCorrLevels)+' )'
JEC = ( JETCorrPayload, JETCorrLevels , 'None')
if addPrunedSubjets or addSoftDropSubjets or addCMSTopTagger:
if subJETCorrPayload not in payloadList:
if not 'None' in subJETCorrPayload: print '|---- jetToolBox: Payload given for subjet corrections ('+JETCorrPayload+') is not correct. Using default AK4PFchs instead.'
subJETCorrPayload = 'AK4PFchs'
if not set(subJETCorrLevels).issubset(set(JECLevels)) or not subJETCorrLevels:
if not 'None' in subJETCorrLevels: print '|---- jetToolbox: Subjet JEC levels given ( '+' '.join(subJETCorrLevels)+' ) are incorrect. Using the default levels: L1FastJet, L2Relative, L3Absolute.'
subJETCorrLevels = ['L1FastJet', 'L2Relative', 'L3Absolute']
print '|---- jetToolBox: Applying these subjet corrections: ( '+subJETCorrPayload+', '+' '.join(subJETCorrLevels)+' )'
subJEC = ( subJETCorrPayload, subJETCorrLevels , 'None')
#################################################################################
####### 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 = 'packedPFCandidates'
setattr( proc, 'chs', cms.EDFilter('CandPtrSelector', src = cms.InputTag('packedPFCandidates'), cut = cms.string('fromPV')) )
jetSeq += getattr(proc, 'chs')
## 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' )
#fixedGridRhoFastjetAll.pfCandidatesTag = 'packedPFCandidates'
#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 = 'particleFlow'
svLabel = 'inclusiveSecondaryVertices'
proc.load('RecoJets.Configuration.GenJetParticles_cff')
proc.load('CommonTools.ParticleFlow.pfNoPileUpJME_cff')
setattr( proc, jetalgo+'GenJetsNoNu', ak4GenJets.clone( src = 'genParticlesForJetsNoNu', rParam = jetSize, jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, jetalgo+'GenJetsNoNu' )
## b-tag discriminators
bTagDiscriminators = [
'pfTrackCountingHighEffBJetTags',
'pfTrackCountingHighPurBJetTags',
'pfJetProbabilityBJetTags',
'pfJetBProbabilityBJetTags',
'pfSimpleSecondaryVertexHighEffBJetTags',
'pfSimpleSecondaryVertexHighPurBJetTags',
'pfCombinedSecondaryVertexBJetTags',
'pfCombinedInclusiveSecondaryVertexV2BJetTags'
]
#### Creating PATjets
if 'Puppi' in PUMethod:
proc.load('CommonTools.PileupAlgos.Puppi_cff')
from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi
setattr( proc, jetalgo+'PFJetsPuppi',
ak4PFJetsPuppi.clone( doAreaFastjet = True,
rParam = jetSize,
jetAlgorithm = algorithm ) )
if miniAOD:
puppi.candName = cms.InputTag('packedPFCandidates')
puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
jetSeq += getattr(proc, 'puppi' )
jetSeq += getattr(proc, jetalgo+'PFJetsPuppi' )
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 = 'chs'
jetSeq += getattr(proc, jetalgo+'PFJetsCS' )
#setattr( proc, jetalgo+'PFJetsCSConstituents', ak8PFJetsCSConstituents.clone( src = cms.InputTag(jetalgo+'PFJetsCS') ) )
jetSeq += getattr(proc, jetalgo+'PFJetsCS' )
elif 'SK' in PUMethod:
proc.load('CommonTools.PileupAlgos.softKiller_cfi')
from RecoJets.JetProducers.ak4PFJetsSK_cfi import ak4PFJetsSK
setattr( proc, jetalgo+'PFJetsSK',
ak4PFJetsSK.clone( rParam = jetSize,
jetAlgorithm = algorithm ) )
if miniAOD: getattr( proc, 'softKiller' ).PFCandidates = cms.InputTag('packedPFCandidates')
jetSeq += getattr(proc, 'softKiller' )
jetSeq += getattr(proc, jetalgo+'PFJetsSK' )
elif 'CHS' in PUMethod:
setattr( proc, jetalgo+'PFJetsCHS',
ak4PFJetsCHS.clone(
doAreaFastjet = True,
rParam = jetSize,
jetAlgorithm = algorithm ) )
if miniAOD: getattr( proc, jetalgo+'PFJetsCHS').src = 'chs'
jetSeq += getattr(proc, jetalgo+'PFJetsCHS' )
else:
PUMethod = ''
setattr( proc, jetalgo+'PFJets',
ak4PFJets.clone(
doAreaFastjet = True,
rParam = jetSize,
jetAlgorithm = algorithm ) )
if miniAOD: getattr( proc, jetalgo+'PFJets').src = 'packedPFCandidates'
jetSeq += getattr(proc, jetalgo+'PFJets' )
#if miniAOD: setattr( proc, jetalgo+'PFJets'+PUMethod+'Constituents', cms.EDFilter("MiniAODJetConstituentSelector", src = cms.InputTag( jetalgo+'PFJets'+PUMethod ), cut = cms.string( 'pt > 100.0 ' ) ))
#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, #( 'AK'+size+'PFchs', cms.vstring( ['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
pfCandidates = cms.InputTag( pfCand ), #'packedPFCandidates'),
svSource = cms.InputTag( svLabel ), #'slimmedSecondaryVertices'),
genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
pvSource = cms.InputTag( pvLabel ), #'offlineSlimmedPrimaryVertices'),
btagDiscriminators = bTagDiscriminators,
outputModules = ['outputFile']
)
getattr( proc, 'patJetCorrFactors'+jetALGO+'PF'+PUMethod ).primaryVertices = pvLabel #'offlineSlimmedPrimaryVertices'
getattr( proc, 'jetTracksAssociatorAtVertex'+jetALGO+'PF'+PUMethod ).tracks = tvLabel # 'unpackedTracksAndVertices'
if 'CS' in PUMethod: getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod ).getJetMCFlavour = False
else: getattr(proc,'patJetPartons').particles = cms.InputTag( genParticlesLabel ) #'prunedGenParticles')
getattr(proc,'patJetPartonMatch'+jetALGO+'PF'+PUMethod).matched = cms.InputTag( genParticlesLabel ) #'prunedGenParticles')
if miniAOD:
if hasattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod):
getattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod).extSVCollection = cms.InputTag( svLabel ) #'slimmedSecondaryVertices')
getattr(proc,'patJets'+jetALGO+'PF'+PUMethod).addAssociatedTracks = cms.bool(False) # needs to be disabled since there is no track collection present in MiniAOD
getattr(proc,'patJets'+jetALGO+'PF'+PUMethod).addJetCharge = cms.bool(False) # needs to be disabled since there is no track collection present in MiniAOD
if addSoftDrop or addSoftDropSubjets:
setattr( proc, jetalgo+'PFJets'+PUMethod+'SoftDrop',
ak8PFJetsCHSSoftDrop.clone(
rParam = jetSize,
jetAlgorithm = algorithm,
useExplicitGhosts=True,
zcut=zCutSD,
beta=betaCut,
writeCompound = cms.bool(True),
jetCollInstanceName=cms.string('SubJets') ) )
if miniAOD: getattr( proc, jetalgo+'PFJets'+PUMethod+'SoftDrop').src = 'chs'
setattr( proc, jetalgo+'PFJets'+PUMethod+'SoftDropLinks',
ak8PFJetsCHSSoftDropLinks.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod),
matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'SoftDrop'),
distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'SoftDropLinks_*_*']
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'SoftDrop' )
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'SoftDropLinks' )
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'SoftDropLinks']
toolsUsed.append( jetalgo+'PFJets'+PUMethod+'SoftDropLinks' )
if addSoftDropSubjets:
setattr( proc, jetalgo+'GenJetsNoNuSoftDrop',
ak4GenJets.clone(
SubJetParameters,
useSoftDrop = cms.bool(True),
rParam = jetSize,
jetAlgorithm = algorithm,
useExplicitGhosts=cms.bool(True),
#zcut=cms.double(zCutSD),
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,
btagDiscriminators = ['None'],
genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
getJetMCFlavour = False,
outputModules = ['outputFile']
)
getattr( proc, 'patJetCorrFactors'+jetALGO+'PF'+PUMethod+'SoftDrop' ).primaryVertices = pvLabel #'offlineSlimmedPrimaryVertices'
getattr(proc,'patJetPartonMatch'+jetALGO+'PF'+PUMethod+'SoftDrop').matched = cms.InputTag( genParticlesLabel ) #'prunedGenParticles')
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,
pfCandidates = cms.InputTag( pfCand ),
pvSource = cms.InputTag( pvLabel),
svSource = cms.InputTag( svLabel ),
btagDiscriminators = bTagDiscriminators,
genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNuSoftDrop','SubJets'),
getJetMCFlavour = False,
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']
)
if miniAOD:
getattr( proc,'patJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets').addAssociatedTracks = cms.bool(False)
getattr( proc,'patJets'+jetALGO+'PF'+PUMethod+'SoftDropSubjets').addJetCharge = cms.bool(False)
if hasattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod+'SoftDropSubjets'):
getattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod+'SoftDropSubjets').extSVCollection = cms.InputTag( svLabel )
getattr(proc,'patJetCorrFactors'+jetALGO+'PF'+PUMethod+'SoftDropSubjets' ).primaryVertices = pvLabel
getattr(proc,'patJetPartonMatch'+jetALGO+'PF'+PUMethod+'SoftDropSubjets').matched = cms.InputTag( genParticlesLabel )
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(
rParam = jetSize,
jetAlgorithm = algorithm,
zcut=zCut,
rcut_factor=rCut,
writeCompound = cms.bool(True),
doAreaFastjet = cms.bool(True),
jetCollInstanceName=cms.string('SubJets') ) )
if miniAOD: getattr( proc, jetalgo+'PFJets'+PUMethod+'Pruned').src = 'chs'
setattr( proc, jetalgo+'PFJets'+PUMethod+'PrunedLinks',
ak8PFJetsCHSPrunedLinks.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+'PrunedLinks' )
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'PrunedLinks']
elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'PrunedLinks_*_*']
toolsUsed.append( jetalgo+'PFJets'+PUMethod+'PrunedLinks' )
if addPrunedSubjets:
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,
btagDiscriminators = ['None'],
genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
getJetMCFlavour = False,
outputModules = ['outputFile']
)
getattr( proc, 'patJetCorrFactors'+jetALGO+'PF'+PUMethod+'Pruned' ).primaryVertices = pvLabel
getattr(proc,'patJetPartonMatch'+jetALGO+'PF'+PUMethod+'Pruned').matched = cms.InputTag( genParticlesLabel )
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,
pfCandidates = cms.InputTag( pfCand ),
pvSource = cms.InputTag( pvLabel),
svSource = cms.InputTag( svLabel ),
btagDiscriminators = bTagDiscriminators,
genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNuPruned','SubJets'),
getJetMCFlavour = False,
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']
)
getattr(proc,'patJetPartonMatch'+jetALGO+'PF'+PUMethod+'PrunedSubjets').matched = cms.InputTag( genParticlesLabel )
getattr(proc,'patJetCorrFactors'+jetALGO+'PF'+PUMethod+'PrunedSubjets' ).primaryVertices = pvLabel
if miniAOD:
if hasattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod+'PrunedSubjets'):
getattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod+'PrunedSubjets').extSVCollection = cms.InputTag( svLabel )
getattr( proc,'patJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets').addAssociatedTracks = cms.bool(False)
getattr( proc,'patJets'+jetALGO+'PF'+PUMethod+'PrunedSubjets').addJetCharge = cms.bool(False)
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( #src = 'chs',
rParam = jetSize,
jetAlgorithm = algorithm,
rFilt= rFiltTrim,
trimPtFracMin= ptFrac) )
if miniAOD: getattr( proc, jetalgo+'PFJets'+PUMethod+'Trimmed').src = 'chs'
setattr( proc, jetalgo+'PFJets'+PUMethod+'TrimmedLinks',
ak8PFJetsCHSTrimmedLinks.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod),
matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Trimmed'),
distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'TrimmedLinks_*_*']
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Trimmed' )
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'TrimmedLinks' )
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'TrimmedLinks']
toolsUsed.append( jetalgo+'PFJets'+PUMethod+'TrimmedLinks' )
if addFiltering:
setattr( proc, jetalgo+'PFJets'+PUMethod+'Filtered',
ak8PFJetsCHSFiltered.clone( #src = 'chs',
rParam = jetSize,
jetAlgorithm = algorithm,
rFilt= rfilt,
nFilt= nfilt ) )
if miniAOD: getattr( proc, jetalgo+'PFJets'+PUMethod+'Filtered').src = 'chs'
setattr( proc, jetalgo+'PFJets'+PUMethod+'FilteredLinks',
ak8PFJetsCHSFilteredLinks.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod),
matched = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Filtered'),
distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'FilteredLinks_*_*']
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'Filtered' )
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'FilteredLinks' )
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'FilteredLinks']
toolsUsed.append( jetalgo+'PFJets'+PUMethod+'FilteredLinks' )
if addCMSTopTagger :
if 'CA' in jetALGO :
setattr( proc, 'cmsTopTagPFJets'+PUMethod,
cms.EDProducer("CATopJetProducer",
PFJetParameters.clone( #src = cms.InputTag("chs"), #ak8PFJetsCHSConstituents", "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)
)
)
if miniAOD: getattr( proc, 'cmsTopTagPFJets'+PUMethod ).src = 'chs'
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,
pfCandidates = cms.InputTag( pfCand ),
pvSource = cms.InputTag( pvLabel),
svSource = cms.InputTag( svLabel ),
btagDiscriminators = bTagDiscriminators,
genJetCollection = cms.InputTag(jetalgo+'GenJetsNoNu'),
getJetMCFlavour = False
)
getattr(proc,'patJetPartonMatchCMSTopTag'+PUMethod).matched = cms.InputTag( genParticlesLabel )
if hasattr(proc,'pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag'+PUMethod):
getattr(proc,'pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag'+PUMethod).extSVCollection = cms.InputTag( svLabel )
getattr(proc,'patJetsCMSTopTag'+PUMethod).addTagInfos = True
getattr(proc,'patJetsCMSTopTag'+PUMethod).tagInfoSources = cms.VInputTag( cms.InputTag('CATopTagInfos'))
getattr(proc,'patJetCorrFactorsCMSTopTag'+PUMethod ).primaryVertices = pvLabel
getattr(proc,'patJetsCMSTopTag'+PUMethod).addAssociatedTracks = cms.bool(False)
getattr(proc,'patJetsCMSTopTag'+PUMethod).addJetCharge = cms.bool(False)
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,
pfCandidates = cms.InputTag( pfCand ),
pvSource = cms.InputTag( pvLabel),
svSource = cms.InputTag( svLabel ),
btagDiscriminators = bTagDiscriminators,
genJetCollection = cms.InputTag( jetalgo+'GenJetsNoNu'),
#getJetMCFlavour = False,
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
)
getattr(proc,'patJetPartonMatchCMSTopTag'+PUMethod+'Subjets').matched = cms.InputTag( genParticlesLabel ) #'prunedGenParticles')
if hasattr(proc,'pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag'+PUMethod+'Subjets'):
getattr(proc,'pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag'+PUMethod+'Subjets').extSVCollection = cms.InputTag(svLabel)
getattr(proc,'patJetCorrFactorsCMSTopTag'+PUMethod+'Subjets' ).primaryVertices = pvLabel
getattr(proc,'patJetsCMSTopTag'+PUMethod+'Subjets').addAssociatedTracks = cms.bool(False)
getattr(proc,'patJetsCMSTopTag'+PUMethod+'Subjets').addJetCharge = cms.bool(False)
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 '|----- 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 ) )
if miniAOD: getattr( proc, jetalgo+'PFJets'+PUMethod+'MassDropFiltered').src = 'chs'
setattr( proc, jetalgo+'PFJets'+PUMethod+'MassDropFilteredLinks', ak8PFJetsCHSPrunedLinks.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod),
matched = cms.InputTag(jetalgo+'PFJets'+PUMethod+'MassDropFiltered'), distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_'+jetalgo+'PFJets'+PUMethod+'MassDropFilteredLinks_*_*' ]
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ jetalgo+'PFJets'+PUMethod+'MassDropFilteredLinks' ]
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'MassDropFiltered' )
jetSeq += getattr(proc, jetalgo+'PFJets'+PUMethod+'MassDropFilteredLinks' )
else: print '|----- CMS recommends CambridgeAachen for Mass Drop, you are using '+algorithm+'. JetToolbox will not run Mass Drop.'
toolsUsed.append( jetalgo+'PFJets'+PUMethod+'MassDropFilteredLinks' )
if addHEPTopTagger:
if ( jetSize >= 1. ) and ( 'CA' in jetALGO ):
if miniAOD: setattr( proc, 'hepTopTagPFJets'+PUMethod, hepTopTagPFJetsCHS.clone( src = 'chs' ) )
else:
setattr( proc, jetalgo+'PFJets'+PUMethod+'Constituents', ak8PFJetsCHSConstituents.clone( src = jetalgo+'PFJets'+PUMethod ) )
setattr( proc, 'hepTopTagPFJets'+PUMethod, hepTopTagPFJetsCHS.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod+'Constituents', 'constituents' ) ) )
setattr( proc, 'hepTopTagPFJets'+PUMethod+'Links'+jetALGO, ak8PFJetsCHSPrunedLinks.clone( src = cms.InputTag( jetalgo+'PFJets'+PUMethod),
matched = cms.InputTag("hepTopTagPFJets"+PUMethod), distMax = cms.double( jetSize ) ) )
elemToKeep += [ 'keep *_hepTopTagPFJets'+PUMethod+'Links'+jetALGO+'_*_*' ]
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += [ 'hepTopTagPFJets'+PUMethod+'Links'+jetALGO ]
jetSeq += getattr(proc, 'hepTopTagPFJets'+PUMethod )
jetSeq += getattr(proc, 'hepTopTagPFJets'+PUMethod+'Links'+jetALGO )
toolsUsed.append( 'hepTopTagPFJets'+PUMethod+'Links'+jetALGO )
else: print '|----- 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:
#This is the old way before 731
### 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 )
'''
### This is for 731 or higher
if 'ak4' in jetalgo:
proc.load('RecoJets.JetProducers.QGTagger_cfi')
proc.QGTagger.srcJets = cms.InputTag(jetalgo+'PFJets'+PUMethod) # Could be reco::PFJetCollection or pat::JetCollection (both AOD and miniAOD)
proc.QGTagger.jetsLabel = cms.string('QGL_AK4PFchs') # Other options (might need to add an ESSource for it): see https://twiki.cern.ch/twiki/bin/viewauth/CMS/QGDataBaseVersion
elemToKeep += [ 'keep *_QGTagger_*_*' ]
getattr( proc, 'patJets'+jetALGO+'PF'+PUMethod).userData.userFloats.src += ['QJetsAdder'+jetALGO+':qgLikelihood']
jetSeq += getattr(proc, 'QGTagger' )
else:
'QGTagger is optimized for ak4 jets.'
'''
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_*' ]
print '|---- jetToolBox: Running '+', '.join(toolsUsed)+'.'
### "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 ) ) )
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 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])
pfCand = "combPFdSA"
svLabel = "inclusiveCandidateSecondaryVertices"
# runOnMC
process.load("RecoJets.Configuration.GenJetParticles_cff")
# mod['GenJetsNoNu']
process.ak4GenJetsNoNu = ak4GenJets.clone(
src="genParticlesForJetsNoNu",
rParam=jetSize, # 0.4
jetAlgorithm=algorithm, # AntiKt
)
# mod["PFJets"]
process.ak4PFJetsComb = ak4PFJets.clone(
src=pfCand, # combPFdSA
doAreaFastjet=True,
rParam=jetSize, # 0.4
jetAlgorithm=algorithm, # AntiKt
)
# mod['PFJetsConstituents']
process.ak4PFJetsCombConstituents = cms.EDProducer(
"PFJetConstituentSelector",
src=cms.InputTag(mod["PFJets"]), # ak4PFJetsComb
cut=cms.string(Cut), #
)
# http://cmslxr.fnal.gov/source/PhysicsTools/PatAlgos/python/tools/jetTools.py#0896
addJetCollection(
proc,
labelName=mod["PATJetsLabel"],
jetSource=cms.InputTag(mod["PFJets"]),
def jetToolbox( proc, jetType, jetSequence,PUMethod=''):
JETCorrPayload='None'
JETCorrLevels = [ 'None' ]
#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()
print 'Running processes with: '+str(jetALGO)+' PF '+PUMethod+' jet algorithm with radius parameter '+str(jetSize)
JETCorrPayload = 'AK'+size+'PFchs'
#JETCorrLevels = ['L1FastJet', 'L2Relative', 'L3Absolute']
JETCorrLevels = [] #No JEC corrections
JEC = ( JETCorrPayload, JETCorrLevels , 'None')
#################################################################################
####### Toolbox start
#################################################################################
elemToKeep = []
jetSeq = cms.Sequence()
genParticlesLabel = ''
pvLabel = ''
tvLabel = ''
toolsUsed = []
#### For MiniAOD
genParticlesLabel = 'prunedGenParticles'
pvLabel = 'offlineSlimmedPrimaryVertices'
svLabel = 'slimmedSecondaryVertices'
tvLabel = 'unpackedTracksAndVertices'
pfCand = 'packedPFCandidates'
setattr( proc, 'chs', cms.EDFilter('CandPtrSelector', src = cms.InputTag('packedPFCandidates'), cut = cms.string('fromPV')) )
jetSeq += getattr(proc, 'chs')
### Filter out neutrinos from packed GenParticles
#setattr( proc, 'packedGenParticlesForJets',
#cms.EDFilter("CandPtrSelector",
#src = cms.InputTag("packedGenParticles"),
#cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16")
#))
#jetSeq += getattr(proc, 'packedGenParticlesForJets' )
setattr( proc, jetalgo+'GenJets',
ak4GenJets.clone( src = 'packedGenParticles', #'packedGenParticlesForJets',
rParam = jetSize,
jetAlgorithm = algorithm ) )
jetSeq += getattr(proc, jetalgo+'GenJets' )
#fixedGridRhoFastjetAll.pfCandidatesTag = 'packedPFCandidates'
#for Inclusive Vertex Finder
proc.load('PhysicsTools.PatAlgos.slimming.unpackedTracksAndVertices_cfi')
#### Creating PATjets
if 'CHS' in PUMethod:
setattr( proc, jetalgo+'PFJetsCHS',
ak4PFJetsCHS.clone(
doAreaFastjet = True,
rParam = jetSize,
jetAlgorithm = algorithm ) )
getattr( proc, jetalgo+'PFJetsCHS').src = 'chs'
jetSeq += getattr(proc, jetalgo+'PFJetsCHS' )
else:
PUMethod = ''
setattr( proc, jetalgo+'PFJets',
ak4PFJets.clone(
doAreaFastjet = True,
rParam = jetSize,
jetAlgorithm = algorithm ) )
getattr( proc, jetalgo+'PFJets').src = 'packedPFCandidates'
jetSeq += getattr(proc, jetalgo+'PFJets' )
addJetCollection(
proc,
labelName = jetALGO+'PF'+PUMethod,
jetSource = cms.InputTag( jetalgo+'PFJets'+PUMethod),
algo = jetalgo,
rParam = jetSize,
jetCorrections = JEC, #( 'AK'+size+'PFchs', cms.vstring( ['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
pfCandidates = cms.InputTag( pfCand ), #'packedPFCandidates'),
svSource = cms.InputTag( svLabel ), #'slimmedSecondaryVertices'),
genJetCollection = cms.InputTag( jetalgo+'GenJets'),
pvSource = cms.InputTag( pvLabel )#'offlineSlimmedPrimaryVertices'),
)
getattr( proc, 'patJetCorrFactors'+jetALGO+'PF'+PUMethod ).primaryVertices = pvLabel #'offlineSlimmedPrimaryVertices'
#getattr( proc, 'jetTracksAssociatorAtVertex'+jetALGO+'PF'+PUMethod ).tracks = tvLabel # 'unpackedTracksAndVertices'
getattr(proc,'patJetPartons').particles = cms.InputTag( genParticlesLabel ) #'prunedGenParticles')
getattr(proc,'patJetPartonMatch'+jetALGO+'PF'+PUMethod).matched = cms.InputTag( genParticlesLabel ) #'prunedGenParticles')
if hasattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod):
getattr(proc,'pfInclusiveSecondaryVertexFinderTagInfos'+jetALGO+'PF'+PUMethod).extSVCollection = cms.InputTag( svLabel ) #'slimmedSecondaryVertices')
getattr(proc,'patJets'+jetALGO+'PF'+PUMethod).addAssociatedTracks = cms.bool(False) # needs to be disabled since there is no track collection present in MiniAOD
getattr(proc,'patJets'+jetALGO+'PF'+PUMethod).addJetCharge = cms.bool(False) # needs to be disabled since there is no track collection present in MiniAOD
elemToKeep += [ 'keep *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_*_*' ]
#elemToKeep += [ 'drop *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_calo*_*' ]
#elemToKeep += [ 'drop *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_tagInfos_*' ]
### "return"
setattr(proc, jetSequence, jetSeq)
"pt > 0. & abs(eta) < 5"
), #MB dummy cuts (in practice PFtaus are reconstructed for Pt>~10 and |eta|<2.4
filter=cms.bool(runOnSignal))
process.dumpPATTauSequence += process.selectedTauGenJets
#--------------------------------------------------------------------------------
# produce collection of "toy" PFCandidates
process.load("RecoTauTag.GenTauAnalysisTools.toyPFCandidates_cfi")
process.dumpPATTauSequence += process.toyPFCandidates
#--------------------------------------------------------------------------------
# run jet reconstruction on "toy" PFCandidates
from RecoJets.Configuration.RecoPFJets_cff import ak4PFJets
process.ak4ToyPFJets = ak4PFJets.clone(
src=cms.InputTag('toyPFCandidates', 'pfCandidates'))
process.dumpPATTauSequence += process.ak4ToyPFJets
#--------------------------------------------------------------------------------
# run tau reconstruction on "toy" PFCandidates
if runOnSignal:
process.genTauMatchedPFJets = cms.EDFilter(
"PFJetAntiOverlapSelector",
src=cms.InputTag('ak4ToyPFJets'),
srcNotToBeFiltered=cms.VInputTag('selectedTauGenJets'),
dRmin=cms.double(0.3),
invert=cms.bool(True),
filter=cms.bool(False))
process.dumpPATTauSequence += process.genTauMatchedPFJets
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
def jetToolbox(
proc,
jetType,
jetSequence,
outputFile,
PUMethod="CHS", #### Options: Puppi, CS, SK, Plain
miniAOD=True,
JETCorrPayload="None",
JETCorrLevels=["None"],
GetJetMCFlavour=True,
Cut="",
subJETCorrPayload="None",
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,
):
###############################################################################
####### Verifying some inputs and defining variables
###############################################################################
print "|---- jetToolbox: Initialyzing collection..."
supportedJetAlgos = {"ak": "AntiKt", "ca": "CambridgeAachen", "kt": "Kt"}
recommendedJetAlgos = ["ak4", "ak8", "ca4", "ca8", "ca10"]
payloadList = [
"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"]
jetAlgo = ""
algorithm = ""
size = ""
for type, tmpAlgo in supportedJetAlgos.iteritems():
if type in jetType.lower():
jetAlgo = type
algorithm = tmpAlgo
size = jetType.replace(type, "")
jetSize = 0.0
if int(size) in range(0, 20):
jetSize = int(size) / 10.0
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 = "packedPFCandidates"
setattr(
proc,
"chs",
cms.EDFilter("CandPtrSelector", src=cms.InputTag("packedPFCandidates"), cut=cms.string("fromPV")),
)
jetSeq += getattr(proc, "chs")
## 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 = "particleFlow"
svLabel = "inclusiveSecondaryVertices"
proc.load("RecoJets.Configuration.GenJetParticles_cff")
proc.load("CommonTools.ParticleFlow.pfNoPileUpJME_cff")
setattr(
proc,
jetalgo + "GenJetsNoNu",
ak4GenJets.clone(src="genParticlesForJetsNoNu", rParam=jetSize, jetAlgorithm=algorithm),
)
jetSeq += getattr(proc, jetalgo + "GenJetsNoNu")
## b-tag discriminators
bTagDiscriminators = [
"pfTrackCountingHighEffBJetTags",
"pfTrackCountingHighPurBJetTags",
"pfJetProbabilityBJetTags",
"pfJetBProbabilityBJetTags",
"pfSimpleSecondaryVertexHighEffBJetTags",
"pfSimpleSecondaryVertexHighPurBJetTags",
"pfCombinedSecondaryVertexV2BJetTags",
"pfCombinedSecondaryVertexBJetTags",
#'pfcombinedInclusiveSecondaryVertexV2BJetTags',
#'pfCombinedSecondaryVertexSoftLeptonBJetTags',
#'pfCombinedMVABJetTags'
]
#### Creating PATjets
if "Puppi" in PUMethod:
proc.load("CommonTools.PileupAlgos.Puppi_cff")
from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi
setattr(
proc,
jetalgo + "PFJetsPuppi",
ak4PFJetsPuppi.clone(doAreaFastjet=True, rParam=jetSize, jetAlgorithm=algorithm),
)
if miniAOD:
puppi.candName = cms.InputTag("packedPFCandidates")
puppi.vertexName = cms.InputTag("offlineSlimmedPrimaryVertices")
jetSeq += getattr(proc, "puppi")
jetSeq += getattr(proc, jetalgo + "PFJetsPuppi")
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 = 'chs'
if miniAOD:
getattr(proc, jetalgo + "PFJetsCS").src = "packedPFCandidates"
# 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")
elif "SK" in PUMethod:
proc.load("CommonTools.PileupAlgos.softKiller_cfi")
from RecoJets.JetProducers.ak4PFJetsSK_cfi import ak4PFJetsSK
setattr(proc, jetalgo + "PFJetsSK", ak4PFJetsSK.clone(rParam=jetSize, jetAlgorithm=algorithm))
if miniAOD:
getattr(proc, "softKiller").PFCandidates = cms.InputTag("packedPFCandidates")
jetSeq += getattr(proc, "softKiller")
jetSeq += getattr(proc, jetalgo + "PFJetsSK")
elif "CHS" in PUMethod:
setattr(
proc, jetalgo + "PFJetsCHS", ak4PFJetsCHS.clone(doAreaFastjet=True, rParam=jetSize, jetAlgorithm=algorithm)
)
if miniAOD:
getattr(proc, jetalgo + "PFJetsCHS").src = "chs"
jetSeq += getattr(proc, jetalgo + "PFJetsCHS")
else:
PUMethod = ""
setattr(proc, jetalgo + "PFJets", ak4PFJets.clone(doAreaFastjet=True, rParam=jetSize, jetAlgorithm=algorithm))
if miniAOD:
getattr(proc, jetalgo + "PFJets").src = "packedPFCandidates"
jetSeq += getattr(proc, jetalgo + "PFJets")
if 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")
### Jet Corrections
if JETCorrPayload not in payloadList:
if not set(JETCorrLevels).issubset(set(JECLevels)):
if "CHS" in PUMethod:
JEC = ("AK" + size + "PFchs", ["L1FastJet", "L2Relative", "L3Absolute"], "None")
elif "Plain" in PUMethod:
JEC = ("AK" + size + "PF", ["L1FastJet", "L2Relative", "L3Absolute"], "None")
else:
JEC = None
if "None" in JETCorrPayload:
print "|---- jetToolBox: No JEC provided, jetToolbox is using the recommended corrections for this PU method: " + str(
JEC
)
else:
print '|---- jetToolBox: JEC payload provided ("' + JETCorrPayload + '") is wrong, jetToolbox is using the recommended corrections for this PU method: ' + str(
JEC
)
else:
if "CHS" in PUMethod:
JEC = ("AK" + size + "PFchs", JETCorrLevels, "None")
elif "Plain" in PUMethod:
JEC = ("AK" + size + "PF", JETCorrLevels, "None")
else:
JEC = None
if "None" in JETCorrPayload:
print "|---- jetToolBox: No JEC payload provided, jetToolbox is using the recommended payload. Using JEC: " + str(
JEC
)
else:
print '|---- jetToolBox: JEC payload provided ("' + JETCorrPayload + '") is wrong, jetToolbox is using the recommended corrections for this PU method: ' + str(
JEC
)
else:
if not set(JETCorrLevels).issubset(set(JECLevels)):
if ("CHS" in PUMethod) or ("Plain" in PUMethod):
JEC = (JETCorrPayload, ["L1FastJet", "L2Relative", "L3Absolute"], "None")
else:
JEC = None
print "|---- jetToolBox: JEC levels are not provided or wrong, jetToolbox is using the recommended levels for this PU method: " + str(
JEC
)
else:
JEC = (JETCorrPayload, JETCorrLevels, "None")
print "|---- jetToolBox: JEC payload and levels provided by user. Using JEC: " + str(JEC)
if addPrunedSubjets or addSoftDropSubjets or addCMSTopTagger:
if subJETCorrPayload not in payloadList:
if not set(subJETCorrLevels).issubset(set(JECLevels)):
if "CHS" in PUMethod:
subJEC = ("AK4PFchs", ["L1FastJet", "L2Relative", "L3Absolute"], "None")
elif "Plain" in PUMethod:
subJEC = ("AK4PF", ["L1FastJet", "L2Relative", "L3Absolute"], "None")
else:
subJEC = None
if "None" in subJETCorrPayload:
print "|---- jetToolBox: No subJEC provided, jetToolbox is using the recommended corrections for this PU method: " + str(
subJEC
)
else:
print '|---- jetToolBox: subJEC payload provided ("' + subJETCorrPayload + '") is wrong, jetToolbox is using the recommended corrections for this PU method: ' + str(
subJEC
)
else:
if "CHS" in PUMethod:
subJEC = ("AK4PFchs", subJETCorrLevels, "None")
elif "Plain" in PUMethod:
subJEC = ("AK4PF", subJETCorrLevels, "None")
else:
subJEC = None
if "None" in subJETCorrPayload:
print "|---- jetToolBox: No subJEC payload provided, jetToolbox is using the recommended payload. Using subJEC: " + str(
subJEC
)
else:
print '|---- jetToolBox: subJEC payload provided ("' + subJETCorrPayload + '") is wrong, jetToolbox is using the recommended corrections for this PU method: ' + str(
subJEC
)
else:
if not set(subJETCorrLevels).issubset(set(JECLevels)):
if ("CHS" in PUMethod) or ("Plain" in PUMethod):
subJEC = (subJETCorrPayload, ["L1FastJet", "L2Relative", "L3Absolute"], "None")
else:
subJEC = None
print "|---- jetToolBox: subJEC levels are not provided or wrong, jetToolbox is using the recommended levels for this PU method: " + str(
subJEC
)
else:
subJEC = (subJETCorrPayload, subJETCorrLevels, "None")
print "|---- jetToolBox: subJEC payload and levels provided by user. Using subJEC: " + str(subJEC)
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), #'packedPFCandidates'),
svSource=cms.InputTag(svLabel), #'slimmedSecondaryVertices'),
genJetCollection=cms.InputTag(jetalgo + "GenJetsNoNu"),
pvSource=cms.InputTag(pvLabel), #'offlineSlimmedPrimaryVertices'),
btagDiscriminators=bTagDiscriminators,
getJetMCFlavour=GetJetMCFlavour,
outputModules=["outputFile"],
)
if JEC is not None:
getattr(
proc, "patJetCorrFactors" + jetALGO + "PF" + PUMethod
).primaryVertices = pvLabel #'offlineSlimmedPrimaryVertices'
if "CS" in PUMethod:
getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).getJetMCFlavour = False
else:
getattr(proc, "patJetPartons").particles = cms.InputTag(genParticlesLabel) #'prunedGenParticles')
getattr(proc, "patJetPartonMatch" + jetALGO + "PF" + PUMethod).matched = cms.InputTag(
genParticlesLabel
) #'prunedGenParticles')
if miniAOD:
if hasattr(proc, "pfInclusiveSecondaryVertexFinderTagInfos" + jetALGO + "PF" + PUMethod):
getattr(
proc, "pfInclusiveSecondaryVertexFinderTagInfos" + jetALGO + "PF" + PUMethod
).extSVCollection = cms.InputTag(
svLabel
) #'slimmedSecondaryVertices')
getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).addAssociatedTracks = cms.bool(
False
) # needs to be disabled since there is no track collection present in MiniAOD
getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).addJetCharge = cms.bool(
False
) # needs to be disabled since there is no track collection present in MiniAOD
#### Grommers
if addSoftDrop or addSoftDropSubjets:
setattr(
proc,
jetalgo + "PFJets" + PUMethod + "SoftDrop",
ak8PFJetsCHSSoftDrop.clone(
src=cms.InputTag(jetalgo + "PFJets" + PUMethod + "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:
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,
btagDiscriminators=["None"],
genJetCollection=cms.InputTag(jetalgo + "GenJetsNoNu"),
getJetMCFlavour=GetJetMCFlavour,
outputModules=["outputFile"],
)
if JEC is not None:
getattr(proc, "patJetCorrFactors" + jetALGO + "PF" + PUMethod + "SoftDrop").primaryVertices = pvLabel
getattr(proc, "patJetPartonMatch" + jetALGO + "PF" + PUMethod + "SoftDrop").matched = cms.InputTag(
genParticlesLabel
) #'prunedGenParticles')
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,
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"],
)
if miniAOD:
getattr(proc, "patJets" + jetALGO + "PF" + PUMethod + "SoftDropSubjets").addAssociatedTracks = cms.bool(
False
)
getattr(proc, "patJets" + jetALGO + "PF" + PUMethod + "SoftDropSubjets").addJetCharge = cms.bool(False)
if hasattr(
proc, "pfInclusiveSecondaryVertexFinderTagInfos" + jetALGO + "PF" + PUMethod + "SoftDropSubjets"
):
getattr(
proc, "pfInclusiveSecondaryVertexFinderTagInfos" + jetALGO + "PF" + PUMethod + "SoftDropSubjets"
).extSVCollection = cms.InputTag(svLabel)
if subJEC is not None:
getattr(
proc, "patJetCorrFactors" + jetALGO + "PF" + PUMethod + "SoftDropSubjets"
).primaryVertices = pvLabel
getattr(proc, "patJetPartonMatch" + jetALGO + "PF" + PUMethod + "SoftDropSubjets").matched = cms.InputTag(
genParticlesLabel
)
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"),
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:
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,
btagDiscriminators=["None"],
genJetCollection=cms.InputTag(jetalgo + "GenJetsNoNu"),
getJetMCFlavour=GetJetMCFlavour,
outputModules=["outputFile"],
)
if JEC is not None:
getattr(proc, "patJetCorrFactors" + jetALGO + "PF" + PUMethod + "Pruned").primaryVertices = pvLabel
getattr(proc, "patJetPartonMatch" + jetALGO + "PF" + PUMethod + "Pruned").matched = cms.InputTag(
genParticlesLabel
)
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,
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"],
)
getattr(proc, "patJetPartonMatch" + jetALGO + "PF" + PUMethod + "PrunedSubjets").matched = cms.InputTag(
genParticlesLabel
)
if subJEC is not None:
getattr(
proc, "patJetCorrFactors" + jetALGO + "PF" + PUMethod + "PrunedSubjets"
).primaryVertices = pvLabel
if miniAOD:
if hasattr(
proc, "pfInclusiveSecondaryVertexFinderTagInfos" + jetALGO + "PF" + PUMethod + "PrunedSubjets"
):
getattr(
proc, "pfInclusiveSecondaryVertexFinderTagInfos" + jetALGO + "PF" + PUMethod + "PrunedSubjets"
).extSVCollection = cms.InputTag(svLabel)
getattr(proc, "patJets" + jetALGO + "PF" + PUMethod + "PrunedSubjets").addAssociatedTracks = cms.bool(
False
)
getattr(proc, "patJets" + jetALGO + "PF" + PUMethod + "PrunedSubjets").addJetCharge = cms.bool(False)
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"),
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"),
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"),
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.0),
TopMassMax=cms.double(250.0),
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=GetJetMCFlavour,
)
getattr(proc, "patJetPartonMatchCMSTopTag" + PUMethod).matched = cms.InputTag(genParticlesLabel)
if hasattr(proc, "pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag" + PUMethod):
getattr(
proc, "pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag" + PUMethod
).extSVCollection = cms.InputTag(svLabel)
getattr(proc, "patJetsCMSTopTag" + PUMethod).addTagInfos = True
getattr(proc, "patJetsCMSTopTag" + PUMethod).tagInfoSources = cms.VInputTag(cms.InputTag("CATopTagInfos"))
if JEC is not None:
getattr(proc, "patJetCorrFactorsCMSTopTag" + PUMethod).primaryVertices = pvLabel
getattr(proc, "patJetsCMSTopTag" + PUMethod).addAssociatedTracks = cms.bool(False)
getattr(proc, "patJetsCMSTopTag" + PUMethod).addJetCharge = cms.bool(False)
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
)
getattr(proc, "patJetPartonMatchCMSTopTag" + PUMethod + "Subjets").matched = cms.InputTag(
genParticlesLabel
) #'prunedGenParticles')
if hasattr(proc, "pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag" + PUMethod + "Subjets"):
getattr(
proc, "pfInclusiveSecondaryVertexFinderTagInfosCMSTopTag" + PUMethod + "Subjets"
).extSVCollection = cms.InputTag(svLabel)
if subJEC is not None:
getattr(proc, "patJetCorrFactorsCMSTopTag" + PUMethod + "Subjets").primaryVertices = pvLabel
getattr(proc, "patJetsCMSTopTag" + PUMethod + "Subjets").addAssociatedTracks = cms.bool(False)
getattr(proc, "patJetsCMSTopTag" + PUMethod + "Subjets").addJetCharge = cms.bool(False)
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")
),
)
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.0) and ("CA" in jetALGO):
setattr(
proc,
"hepTopTagPFJets" + PUMethod,
hepTopTagPFJetsCHS.clone(src=cms.InputTag(jetalgo + "PFJets" + PUMethod + "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:
"""
#This is the old way before 731
### 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 )
"""
### This is for 731 or higher
if "ak4" in jetalgo:
proc.load("RecoJets.JetProducers.QGTagger_cfi")
proc.QGTagger.srcJets = cms.InputTag(
jetalgo + "PFJets" + PUMethod
) # Could be reco::PFJetCollection or pat::JetCollection (both AOD and miniAOD)
proc.QGTagger.jetsLabel = cms.string(
"QGL_AK4PFchs"
) # Other options (might need to add an ESSource for it): see https://twiki.cern.ch/twiki/bin/viewauth/CMS/QGDataBaseVersion
elemToKeep += ["keep *_QGTagger_*_*"]
getattr(proc, "patJets" + jetALGO + "PF" + PUMethod).userData.userFloats.src += ["QGTagger:qgLikelihood"]
jetSeq += getattr(proc, "QGTagger")
else:
print "|---- jetToolBox: QGTagger is optimized for ak4 jets."
####### 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),
),
)
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."
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_*"]
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),
),
)
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,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 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)
idName=cms.string("cutBasedPhotonID-Fall17-94X-V2-loose"))
## merge into a single collection
from Firefighter.recoStuff.PFCandMerger_cfi import pfcandfwdptrmerger as _pfcandmerger
leptonjetSources = _pfcandmerger.clone(src=cms.VInputTag(
cms.InputTag("leptonjetSourcePFMuon", "inclusive"),
cms.InputTag("leptonjetSourceDSAMuon", "inclusive"),
cms.InputTag("leptonjetSourcePFElectron", "inclusive"),
cms.InputTag("leptonjetSourcePFPhoton"),
))
## anti-kt cluster
from RecoJets.Configuration.RecoPFJets_cff import ak4PFJets
leptonjet = ak4PFJets.clone(
src=cms.InputTag("leptonjetSources"),
rParam=cms.double(0.4),
jetAlgorithm=cms.string("AntiKt"),
)
## produce additional valueMaps
leptonjetExtra = cms.EDProducer(
"LeptonjetValueMapProducer",
src=cms.InputTag("leptonjet"),
ak4jet=cms.InputTag("ak4PFJetsCHS"),
jetCorrector=cms.InputTag("ak4PFCHSL1FastL2L3Corrector"),
jetid=jetiddefs,
)
## clustering sequence
leptonjetClusteringSeq = cms.Sequence(leptonjetSourcePFMuon + dsamuonExtraSeq +
leptonjetSourceDSAMuon +
def jetToolbox(proc, jetType, jetSequence, PUMethod=''):
JETCorrPayload = 'None'
JETCorrLevels = ['None']
#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()
print 'Running processes with: ' + str(
jetALGO
) + ' PF ' + PUMethod + ' jet algorithm with radius parameter ' + str(
jetSize)
JETCorrPayload = 'AK' + size + 'PFchs'
#JETCorrLevels = ['L1FastJet', 'L2Relative', 'L3Absolute']
JETCorrLevels = [] #No JEC corrections
JEC = (JETCorrPayload, JETCorrLevels, 'None')
#################################################################################
####### Toolbox start
#################################################################################
elemToKeep = []
jetSeq = cms.Sequence()
genParticlesLabel = ''
pvLabel = ''
tvLabel = ''
toolsUsed = []
#### For MiniAOD
genParticlesLabel = 'prunedGenParticles'
pvLabel = 'offlineSlimmedPrimaryVertices'
svLabel = 'slimmedSecondaryVertices'
tvLabel = 'unpackedTracksAndVertices'
pfCand = 'packedPFCandidates'
setattr(
proc, 'chs',
cms.EDFilter('CandPtrSelector',
src=cms.InputTag('packedPFCandidates'),
cut=cms.string('fromPV')))
jetSeq += getattr(proc, 'chs')
### Filter out neutrinos from packed GenParticles
#setattr( proc, 'packedGenParticlesForJets',
#cms.EDFilter("CandPtrSelector",
#src = cms.InputTag("packedGenParticles"),
#cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16")
#))
#jetSeq += getattr(proc, 'packedGenParticlesForJets' )
setattr(
proc,
jetalgo + 'GenJets',
ak4GenJets.clone(
src='packedGenParticles', #'packedGenParticlesForJets',
rParam=jetSize,
jetAlgorithm=algorithm))
jetSeq += getattr(proc, jetalgo + 'GenJets')
#fixedGridRhoFastjetAll.pfCandidatesTag = 'packedPFCandidates'
#for Inclusive Vertex Finder
proc.load('PhysicsTools.PatAlgos.slimming.unpackedTracksAndVertices_cfi')
#### Creating PATjets
if 'CHS' in PUMethod:
setattr(
proc, jetalgo + 'PFJetsCHS',
ak4PFJetsCHS.clone(doAreaFastjet=True,
rParam=jetSize,
jetAlgorithm=algorithm))
getattr(proc, jetalgo + 'PFJetsCHS').src = 'chs'
jetSeq += getattr(proc, jetalgo + 'PFJetsCHS')
else:
PUMethod = ''
setattr(
proc, jetalgo + 'PFJets',
ak4PFJets.clone(doAreaFastjet=True,
rParam=jetSize,
jetAlgorithm=algorithm))
getattr(proc, jetalgo + 'PFJets').src = 'packedPFCandidates'
jetSeq += getattr(proc, jetalgo + 'PFJets')
addJetCollection(
proc,
labelName=jetALGO + 'PF' + PUMethod,
jetSource=cms.InputTag(jetalgo + 'PFJets' + PUMethod),
algo=jetalgo,
rParam=jetSize,
jetCorrections=
JEC, #( 'AK'+size+'PFchs', cms.vstring( ['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
pfCandidates=cms.InputTag(pfCand), #'packedPFCandidates'),
svSource=cms.InputTag(svLabel), #'slimmedSecondaryVertices'),
genJetCollection=cms.InputTag(jetalgo + 'GenJets'),
pvSource=cms.InputTag(pvLabel) #'offlineSlimmedPrimaryVertices'),
)
getattr(
proc, 'patJetCorrFactors' + jetALGO + 'PF' +
PUMethod).primaryVertices = pvLabel #'offlineSlimmedPrimaryVertices'
#getattr( proc, 'jetTracksAssociatorAtVertex'+jetALGO+'PF'+PUMethod ).tracks = tvLabel # 'unpackedTracksAndVertices'
getattr(proc, 'patJetPartons').particles = cms.InputTag(
genParticlesLabel) #'prunedGenParticles')
getattr(proc, 'patJetPartonMatch' +
jetALGO + 'PF' + PUMethod).matched = cms.InputTag(
genParticlesLabel) #'prunedGenParticles')
if hasattr(
proc, 'pfInclusiveSecondaryVertexFinderTagInfos' + jetALGO + 'PF' +
PUMethod):
getattr(
proc, 'pfInclusiveSecondaryVertexFinderTagInfos' + jetALGO + 'PF' +
PUMethod).extSVCollection = cms.InputTag(
svLabel) #'slimmedSecondaryVertices')
getattr(
proc, 'patJets' + jetALGO + 'PF' + PUMethod
).addAssociatedTracks = cms.bool(
False
) # needs to be disabled since there is no track collection present in MiniAOD
getattr(
proc, 'patJets' + jetALGO + 'PF' + PUMethod
).addJetCharge = cms.bool(
False
) # needs to be disabled since there is no track collection present in MiniAOD
elemToKeep += [
'keep *_selectedPatJets' + jetALGO + 'PF' + PUMethod + '_*_*'
]
#elemToKeep += [ 'drop *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_calo*_*' ]
#elemToKeep += [ 'drop *_selectedPatJets'+jetALGO+'PF'+PUMethod+'_tagInfos_*' ]
### "return"
setattr(proc, jetSequence, jetSeq)
def jetToolbox( proc, jetType, jetSequence,PUMethod=''):
JETCorrPayload='None'
JETCorrLevels = [ 'None' ]
#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+'PFchs'
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,
rParam = jetSize,
jetCorrections = JEC, #( 'AK'+size+'PFchs', cms.vstring( ['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
pfCandidates = cms.InputTag( 'particleFlow' ), #'packedPFCandidates'),
svSource = cms.InputTag('slimmedSecondaryVertices'),
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')
))
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')
)
)
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']
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)
