def addFatJet(process): from RecoJets.JetProducers.ak5PFJets_cfi import ak5PFJets process.ca8PFJetsCHS = ak5PFJets.clone( src = 'pfNoPileUp', jetPtMin = cms.double(10.0), doAreaFastjet = cms.bool(True), rParam = cms.double(0.8), jetAlgorithm = cms.string("CambridgeAachen"), ) jetSource = 'ca8PFJetsCHS' # corrections from PhysicsTools.PatAlgos.recoLayer0.jetCorrFactors_cfi import patJetCorrFactors process.patJetCorrFactorsCA8CHS = patJetCorrFactors.clone() process.patJetCorrFactorsCA8CHS.src = jetSource # will need to add L2L3 corrections in the cfg process.patJetCorrFactorsCA8CHS.levels = ['L1FastJet', 'L2Relative', 'L3Absolute'] process.patJetCorrFactorsCA8CHS.payload = 'AK7PFchs' process.patJetCorrFactorsCA8CHS.useRho = True # pat jet from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import patJets process.patJetsCA8CHS = patJets.clone() process.patJetsCA8CHS.jetSource = jetSource process.patJetsCA8CHS.addJetCharge = False process.patJetsCA8CHS.embedCaloTowers = False process.patJetsCA8CHS.embedPFCandidates = False process.patJetsCA8CHS.addAssociatedTracks = False process.patJetsCA8CHS.addBTagInfo = False process.patJetsCA8CHS.addDiscriminators = False process.patJetsCA8CHS.getJetMCFlavour = False process.patJetsCA8CHS.jetCorrFactorsSource = cms.VInputTag(cms.InputTag('patJetCorrFactorsCA8CHS')) process.patJetsCA8CHS.genPartonMatch = cms.InputTag('patJetPartonMatchCA8CHS') process.patJetsCA8CHS.genJetMatch = cms.InputTag('patJetGenJetMatchCA8CHS') from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.selectedPatJetsCA8CHS = selectedPatJets.clone() process.selectedPatJetsCA8CHS.src = 'patJetsCA8CHS' process.selectedPatJetsCA8CHS.cut = 'pt()>20' #process.jetMCSequenceCA8CHS = cms.Sequence( #process.patJetPartonMatchCA8CHS + #process.genParticlesForJetsNoNu + #process.ca8GenJetsNoNu + #process.patJetGenJetMatchCA8CHS #) process.PATJetSequenceCA8CHS = cms.Sequence( process.ca8PFJetsCHS + #process.jetMCSequenceCA8CHS + process.patJetCorrFactorsCA8CHS #process.patJetsCA8CHS + #process.selectedPatJetsCA8CHS ) process.PATJetPathCA8CHS = cms.Path ( process.PATJetSequenceCA8CHS )
#process.es_prefer_jec = cms.ESPrefer('PoolDBESSource','jec') process.load("PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cff") process.patJetCorrFactorsReapplyJEC = process.patJetCorrFactorsUpdated.clone( src=cms.InputTag("slimmedJets"), levels=['L1FastJet', 'L2Relative', 'L3Absolute'], payload='AK4PFchs') process.load("PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cff") process.patJetsReapplyJEC = process.patJetsUpdated.clone( jetSource=cms.InputTag("slimmedJets"), jetCorrFactorsSource=cms.VInputTag( cms.InputTag("patJetCorrFactorsReapplyJEC"))) from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.goodJets = selectedPatJets.clone(src='patJetsReapplyJEC', cut='pt>30 & abs(eta)<2.4') process.load('RecoJets.JetProducers.QGTagger_cfi') process.QGTagger.srcJets = cms.InputTag('goodJets') process.QGTagger.jetsLabel = cms.string('QGL_AK4PFchs') ##-------------------- User analyzer -------------------------------- process.hadtop = cms.EDAnalyzer( 'TTHFlatTreeProducer', jets=cms.InputTag('goodJets'), muons=cms.InputTag('slimmedMuons'), electrons=cms.InputTag('slimmedElectrons'), met=cms.InputTag('slimmedMETs'), vertices=cms.InputTag('offlineSlimmedPrimaryVertices'), rho=cms.InputTag('fixedGridRhoFastjetAll'), nJetsMin=cms.int32(6),
def jetToolbox(proc, jetType, jetSequence): # See PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py for further options bTagDiscriminators = [ 'pfDeepCSVJetTags:probb', 'pfDeepCSVJetTags:probc', 'pfDeepCSVJetTags:probudsg', 'pfDeepCSVJetTags:probbb', #'pfDeepFlavourJetTags:probb', #'pfDeepFlavourJetTags:probc', #'pfDeepFlavourJetTags:probg', #'pfDeepFlavourJetTags:probuds', #'pfDeepFlavourJetTags:probbb', #'pfTrackCountingHighEffBJetTags', 'pfJetProbabilityBJetTags', #'pfSimpleSecondaryVertexHighEffBJetTags', 'pfCombinedCvsLJetTags', 'pfCombinedCvsBJetTags', 'pfBoostedDoubleSecondaryVertexAK8BJetTags', #'pfCombinedSecondaryVertexV2BJetTags', 'pfCombinedInclusiveSecondaryVertexV2BJetTags', 'pfCombinedMVAV2BJetTags', 'pfJetProbabilityBJetTags' ] print '|---- jetToolbox: Initialyzing collection...' algorithm = 'AntiKt' # CambridgeAachen' , 'Kt' size = jetType[-1:] #[-1:] takes the last char from string 'akX' jetSize = float('0.' + jetType[-1:]) jetALGO = jetType.upper() jetalgo = jetType.lower() PUMethod = 'CHS' jetNAME = jetALGO + 'PF' + PUMethod jetname = jetalgo + 'PFJets' + PUMethod gjetname = jetalgo + 'GenJetsNoNu' print 'Running processes with: ' + jetNAME + ' jet algorithm with radius parameter ' + str( jetSize) JEC = ('AK' + size + 'PF' + PUMethod.lower(), ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None') print '|---- jetToolBox: Applying these corrections: ' + str(JEC) ################################################################################# ####### Toolbox start ################################################################################# jetSeq = cms.Sequence() # Creating GenJets proc.load('RecoJets.Configuration.GenJetParticles_cff') setattr( proc, gjetname, ak4GenJets.clone(src='genParticlesForJetsNoNu', rParam=jetSize, jetAlgorithm=algorithm)) jetSeq += getattr(proc, gjetname) # Creating AK4PFJetsCHS proc.load('CommonTools.ParticleFlow.pfNoPileUpJME_cff') setattr( proc, jetname, ak4PFJetsCHS.clone(src=cms.InputTag('pfNoPileUpJME'), doAreaFastjet=True, rParam=jetSize, jetAlgorithm=algorithm)) jetSeq += getattr(proc, jetname) #### Creating PATjets addJetCollection( proc, labelName=jetNAME, jetSource=cms.InputTag(jetname), algo=jetalgo, rParam=jetSize, btagDiscriminators=bTagDiscriminators, jetCorrections=JEC, pfCandidates=cms.InputTag('particleFlow'), #redundant (default) svSource=cms.InputTag( 'inclusiveCandidateSecondaryVertices'), # redundant (default) pvSource=cms.InputTag( 'offlinePrimaryVertices'), # redundant (default) getJetMCFlavour=True, # redundant (default) genJetCollection=cms.InputTag(gjetname), jetTrackAssociation=True) getattr(proc, 'patJets' + jetNAME).addTagInfos = cms.bool(True) getattr(proc, 'patJets' + jetNAME).addAssociatedTracks = cms.bool(True) setattr( proc, 'QGTagger' + jetNAME, QGTagger.clone(srcJets=cms.InputTag(jetname), jetsLabel=cms.string('QGL_AK4PFchs'))) getattr(proc, 'patJets' + jetNAME).userData.userFloats.src += [ 'QGTagger' + jetNAME + ':qgLikelihood' ] jetSeq += getattr(proc, 'QGTagger' + jetNAME) getattr(proc, 'patJetPartons').particles = cms.InputTag('genParticles') # This is already done in addJetCollection, but I worry that the changes done to patJets do not get updated to selectedPatJets setattr(proc, 'selectedPatJets' + jetNAME, selectedPatJets.clone(src='patJets' + jetNAME)) # return setattr(proc, jetSequence, jetSeq)
def jetToolbox( proc, jetType, jetSequence,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, 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])
selectedElectrons = selectedPatElectrons.clone( src = cms.InputTag( 'patElectrons' ) , cut = '' # electronCut ) standAloneElectronVetoFilter = cms.EDFilter( "PATCandViewCountFilter" , src = cms.InputTag( 'selectedElectrons' ) , minNumber = cms.uint32( 0 ) , maxNumber = cms.uint32( 0 ) ) # Step 4 selectedJets = selectedPatJets.clone( src = cms.InputTag( 'patJets' ) , cut = '' # jetCut ) signalVeryTightJets = selectedPatJets.clone( src = cms.InputTag( 'selectedJets' ) , cut = '' # veryTightJetCut ) standAloneSignalVeryTightJetsFilter = cms.EDFilter( "PATCandViewCountFilter" , src = cms.InputTag( 'signalVeryTightJets' ) , minNumber = cms.uint32( 1 ) , maxNumber = cms.uint32( 99 ) ) signalTightJets = selectedPatJets.clone(
levels=['L1FastJet', 'L2Relative', 'L3Absolute'], payload='AK4PFPuppi') process.patJetsReapplyJEC = process.updatedPatJets.clone( jetSource=cms.InputTag("slimmedJets"), jetCorrFactorsSource=cms.VInputTag( cms.InputTag("patJetCorrFactorsReapplyJEC"))) process.patJetsReapplyJECPuppi = process.updatedPatJets.clone( jetSource=cms.InputTag("slimmedJetsPuppi"), jetCorrFactorsSource=cms.VInputTag( cms.InputTag("patJetCorrFactorsReapplyJECPuppi"))) #--- define the good jets ------------------------------- from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.goodJets = selectedPatJets.clone(src='patJetsReapplyJEC', cut='pt > 20 && abs(eta) < 5.0') process.goodJetsPuppi = selectedPatJets.clone(src='patJetsReapplyJECPuppi', cut='pt > 20 && abs(eta) < 5.0') #---- Tight JetID ----------------------------------------------------- tight_abs_eta_2p6_chs_puppi = """((neutralHadronEnergyFraction < 0.90 && neutralEmEnergyFraction < 0.90 && numberOfDaughters > 1) && (chargedHadronEnergyFraction > 0 && chargedMultiplicity > 0) && abs(eta) <= 2.6)""" tight_abs_eta_2p6_2p7_chs = """((neutralHadronEnergyFraction < 0.90 && neutralEmEnergyFraction < 0.99 && chargedMultiplicity > 0) && abs(eta) > 2.6 && abs(eta) <= 2.7)""" tight_abs_eta_2p7_3p0_chs = """(neutralEmEnergyFraction > 0.01 && neutralEmEnergyFraction < 0.99 && neutralMultiplicity > 2 && abs(eta) > 2.7 && abs(eta) <= 3.0 )""" tight_abs_eta_3p0_chs = """(neutralHadronEnergyFraction > 0.2 && neutralEmEnergyFraction < 0.90 && neutralMultiplicity > 10 && abs(eta) > 3.0 )""" tight_abs_eta_2p6_2p7_puppi = """((neutralHadronEnergyFraction < 0.90 && neutralEmEnergyFraction < 0.99) && abs(eta) > 2.6 && abs(eta) <= 2.7)"""
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)
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), ), )
## configure process options process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) #------------------------------------------------- # tagAndProbeAnalysis analysis #------------------------------------------------- ## muon selector from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets ## produce collection of well defined jets process.selectedJets = selectedPatJets.clone(src = 'selectedPatJets', cut = 'pt>30 & abs(eta)<3 & emEnergyFraction<0.95' ) ## muon selector from PhysicsTools.PatAlgos.selectionLayer1.muonSelector_cfi import selectedPatMuons ## as probe requirement choose standalonMuon process.probeMuons = selectedPatMuons.clone(src = 'selectedPatMuons', cut = 'standAloneMuon.isNull=0' ) ## as test requirement choose combinedMuon process.testMuons = selectedPatMuons.clone(src = 'probeMuons', cut = 'combinedMuon.isNull=0' )
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 makeFatJets(process, src, algoLabel, jetRadius, colLabel, jetPtMin=150., btagLabel=''): rLabel = algoLabel + '%d' % (int(jetRadius * 10)) # 'ak8' if algoLabel.lower() == 'ca': jetAlgo = 'CambridgeAachen' elif algoLabel.lower() == 'ak': jetAlgo = 'AntiKt' else: raise RuntimeError('Unknown jet algo ' + algoLabel) if jetRadius < 1.: sdZcut = 0.1 sdBeta = 0.0 else: sdZcut = 0.15 sdBeta = 1.0 ## Used for btagging & jet clustering (pvSource) ## CMS uses the particleFlow collection to compute the btag info regardless of the jet source collection. pfSource = 'particleFlow' pvSource = 'offlinePrimaryVertices' ######################################## ## CLUSTER JETS ## ######################################## jets = ak4PFJets.clone(jetAlgorithm=cms.string(jetAlgo), rParam=cms.double(jetRadius), src=cms.InputTag(src), srcPVs=cms.InputTag(pvSource), doAreaFastjet=cms.bool(True), jetPtMin=cms.double(jetPtMin)) jetsName = rLabel + colLabel # 'ak8PFJetsCHS' setattr(process, jetsName, jets) softDropJets = jets.clone(useSoftDrop=cms.bool(True), R0=cms.double(jetRadius), zcut=cms.double(sdZcut), beta=cms.double(sdBeta), writeCompound=cms.bool(True), useExplicitGhosts=cms.bool(True), jetCollInstanceName=cms.string("SubJets")) softDropJetsName = jetsName + 'SoftDrop' setattr(process, softDropJetsName, softDropJets) softDropSubjetsName = softDropJetsName + 'Subjets' clustering = cms.Sequence(jets + softDropJets) ######################################## ## SUBSTRUCTURE ## ######################################## njettiness = Njettiness.clone(src=cms.InputTag(jetsName), R0=cms.double(jetRadius), Njets=cms.vuint32(1, 2, 3, 4)) njettinessName = 'njettiness' + jetsName setattr(process, njettinessName, njettiness) sdKinematics = cms.EDProducer( 'RecoJetDeltaRValueMapProducer', src=cms.InputTag(jetsName), matched=cms.InputTag(softDropJetsName), distMax=cms.double(1.5), values=cms.vstring('mass'), valueLabels=cms.vstring('Mass'), ) sdKinematicsName = 'sdKinematics' + jetsName setattr(process, sdKinematicsName, sdKinematics) substructure = cms.Sequence(njettiness + sdKinematics) if btagLabel != '': ####################################### ## FATJET BTAGGING ## ####################################### initBTag(process, btagLabel, pfSource, pvSource) btags = [ 'pfJetProbabilityBJetTags', 'pfJetBProbabilityBJetTags', 'pfCombinedSecondaryVertexV2BJetTags', 'pfCombinedInclusiveSecondaryVertexV2BJetTags', 'pfCombinedMVAV2BJetTags' ] btagInfos = [] btagging = setupBTag(process, jetsName, jetsName, btagLabel, tags=btags, addedTagInfos=btagInfos) doubleBtags = ['pfBoostedDoubleSecondaryVertexBJetTags'] doubleBtagging = setupDoubleBTag(process, jetsName, jetsName, btagLabel, rLabel.lower(), addedTagInfos=btagInfos) ####################################### ## SUBJET BTAGGING ## ####################################### # Product: std::vector<reco::CandIPTagInfo> # IPTagInfo object contains a reference to jet subjetIpTagInfos = btag.pfImpactParameterTagInfos.clone( jets=cms.InputTag(softDropJetsName, 'SubJets'), primaryVertex=cms.InputTag(pvSource), candidates=cms.InputTag(pfSource), # explicitJTA = cms.bool(True) ) subjetIpTagInfosName = 'pfImpactParameterTagInfos' + softDropSubjetsName setattr(process, subjetIpTagInfosName, subjetIpTagInfos) # Product: std::vector<TemplatedSecondaryVertexTagInfo<reco::CandIPTagInfo, reco::VertexCompositePtrCandidate>> subjetInclSVFinderTagInfos = btag.pfInclusiveSecondaryVertexFinderTagInfos.clone( trackIPTagInfos=cms.InputTag(subjetIpTagInfosName), extSVCollection=cms.InputTag( 'inclusiveCandidateSecondaryVertices' + btagLabel), # useSVClustering = cms.bool(True), # jetAlgorithm = cms.string(jetAlgo), # rParam = cms.double(jetRadius), # fatJets = cms.InputTag(jetsName), # groomedFatJets = cms.InputTag(softDropJetsName) ) subjetInclSVFinderTagInfosName = 'pfInclusiveSecondaryVertexFinderTagInfos' + softDropSubjetsName setattr(process, subjetInclSVFinderTagInfosName, subjetInclSVFinderTagInfos) # Product: JetTagCollection (aka reco::JetFloatAssociation::Container aka edm::AssociationVector<reco::JetRefBaseProd, std::vector<float>>) # Uses the internal reference to the jet in the TagInfos object to create an AssociationVector subjetBjetTags = btag.pfCombinedInclusiveSecondaryVertexV2BJetTags.clone( tagInfos=cms.VInputTag( cms.InputTag(subjetIpTagInfosName), cms.InputTag(subjetInclSVFinderTagInfosName))) subjetBjetTagsName = 'pfCombinedInclusiveSecondaryVertexV2BJetTags' + softDropSubjetsName setattr(process, subjetBjetTagsName, subjetBjetTags) subjetBTagging = cms.Sequence(subjetIpTagInfos + subjetInclSVFinderTagInfos + subjetBjetTags) else: btagging = cms.Sequence() doubleBtagging = cms.Sequence() subjetBTagging = cms.Sequence() ######################################## ## MAKE PAT JETS ## ######################################## patJets = _patJets.clone(jetSource=cms.InputTag(jetsName), getJetMCFlavour=cms.bool(False), addGenJetMatch=cms.bool(False), addGenPartonMatch=cms.bool(False), addJetFlavourInfo=cms.bool(False), addAssociatedTracks=cms.bool(False), addJetCharge=cms.bool(False), addJetCorrFactors=cms.bool(False), addBTagInfo=cms.bool(True), addTagInfos=cms.bool(True), addDiscriminators=cms.bool(True), tagInfoSources=cms.VInputTag( [cms.InputTag(name) for name in btagInfos]), discriminatorSources=cms.VInputTag([ cms.InputTag(name + jetsName) for name in btags + doubleBtags ])) patJets.userData.userFloats.src = [ cms.InputTag(njettinessName + ':tau1'), cms.InputTag(njettinessName + ':tau2'), cms.InputTag(njettinessName + ':tau3'), cms.InputTag(njettinessName + ':tau4'), cms.InputTag(sdKinematicsName + ':Mass') ] patJetsName = 'pat' + jetsName setattr(process, patJetsName, patJets) selectedJets = selectedPatJets.clone(src=cms.InputTag(patJetsName)) selectedJetsName = 'selectedPat' + jetsName setattr(process, selectedJetsName, selectedJets) patSoftDropJets = _patJets.clone(jetSource=cms.InputTag(softDropJetsName), getJetMCFlavour=cms.bool(False), addGenJetMatch=cms.bool(False), addGenPartonMatch=cms.bool(False), addJetFlavourInfo=cms.bool(False), addTagInfos=cms.bool(False), addBTagInfo=cms.bool(False), addDiscriminators=cms.bool(False), addAssociatedTracks=cms.bool(False), addJetCharge=cms.bool(False), addJetCorrFactors=cms.bool(False)) patSoftDropJetsName = 'pat' + softDropJetsName setattr(process, patSoftDropJetsName, patSoftDropJets) selectedSoftDropJets = selectedPatJets.clone( src=cms.InputTag(patSoftDropJetsName)) selectedSoftDropJetsName = 'selectedPat' + softDropJetsName setattr(process, selectedSoftDropJetsName, selectedSoftDropJets) patSoftDropSubjets = _patJets.clone( jetSource=cms.InputTag(softDropJetsName, 'SubJets'), getJetMCFlavour=cms.bool(False), addGenJetMatch=cms.bool(False), addGenPartonMatch=cms.bool(False), addJetFlavourInfo=cms.bool(False), addAssociatedTracks=cms.bool(False), addJetCharge=cms.bool(False), addJetCorrFactors=cms.bool(False), addBTagInfo=cms.bool(True), addDiscriminators=cms.bool(True), addTagInfos=cms.bool(False), discriminatorSources=cms.VInputTag(cms.InputTag(subjetBjetTagsName))) patSoftDropSubjetsName = 'pat' + softDropJetsName + 'Subjets' setattr(process, patSoftDropSubjetsName, patSoftDropSubjets) selectedSoftDropSubjets = selectedPatJets.clone( src=cms.InputTag(patSoftDropSubjetsName)) selectedSoftDropSubjetsName = 'selectedPat' + softDropSubjetsName setattr(process, selectedSoftDropSubjetsName, selectedSoftDropSubjets) pat = cms.Sequence(patJets + selectedJets + patSoftDropJets + selectedSoftDropJets + patSoftDropSubjets + selectedSoftDropSubjets) ############################################### ## Pack subjets back into fat jets ## ############################################### packedSoftDropJets = cms.EDProducer( 'BoostedJetMerger', jetSrc=cms.InputTag(selectedSoftDropJetsName), subjetSrc=cms.InputTag(selectedSoftDropSubjetsName)) packedSoftDropJetsName = 'packed' + softDropJetsName setattr(process, packedSoftDropJetsName, packedSoftDropJets) packedPatJets = cms.EDProducer('JetSubstructurePacker', jetSrc=cms.InputTag(selectedJetsName), distMax=cms.double(jetRadius), algoTags=cms.VInputTag( cms.InputTag(packedSoftDropJetsName)), algoLabels=cms.vstring('SoftDrop'), fixDaughters=cms.bool(False)) packedPatJetsName = 'packed' + jetsName setattr(process, packedPatJetsName, packedPatJets) packing = cms.Sequence(packedSoftDropJets + packedPatJets) ############################## ## Return a sequence ## ############################## sequence = cms.Sequence(clustering + substructure + btagging + doubleBtagging + subjetBTagging + pat + packing) return sequence
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 makeFatJets(process, src, algoLabel, jetRadius, colLabel, jetPtMin = 150., btagLabel = ''): rLabel = algoLabel + '%d' % (int(jetRadius * 10)) # 'ak8' if algoLabel.lower() == 'ca': jetAlgo = 'CambridgeAachen' elif algoLabel.lower() == 'ak': jetAlgo = 'AntiKt' else: raise RuntimeError('Unknown jet algo ' + algoLabel) if jetRadius < 1.: sdZcut = 0.1 sdBeta = 0.0 else: sdZcut = 0.15 sdBeta = 1.0 ## Used for btagging & jet clustering (pvSource) ## CMS uses the particleFlow collection to compute the btag info regardless of the jet source collection. pfSource = 'particleFlow' pvSource = 'offlinePrimaryVertices' ######################################## ## CLUSTER JETS ## ######################################## jets = ak4PFJets.clone( jetAlgorithm = cms.string(jetAlgo), rParam = cms.double(jetRadius), src = cms.InputTag(src), srcPVs = cms.InputTag(pvSource), doAreaFastjet = cms.bool(True), jetPtMin = cms.double(jetPtMin) ) jetsName = rLabel + colLabel # 'ak8PFJetsCHS' setattr(process, jetsName, jets) softDropJets = jets.clone( useSoftDrop = cms.bool(True), R0 = cms.double(jetRadius), zcut = cms.double(sdZcut), beta = cms.double(sdBeta), writeCompound = cms.bool(True), useExplicitGhosts = cms.bool(True), jetCollInstanceName = cms.string("SubJets") ) softDropJetsName = jetsName + 'SoftDrop' setattr(process, softDropJetsName, softDropJets) softDropSubjetsName = softDropJetsName + 'Subjets' clustering = cms.Sequence( jets + softDropJets ) ######################################## ## SUBSTRUCTURE ## ######################################## njettiness = Njettiness.clone( src = cms.InputTag(jetsName), R0 = cms.double(jetRadius), Njets = cms.vuint32(1,2,3,4) ) njettinessName = 'njettiness' + jetsName setattr(process, njettinessName, njettiness) sdKinematics = cms.EDProducer('RecoJetDeltaRValueMapProducer', src = cms.InputTag(jetsName), matched = cms.InputTag(softDropJetsName), distMax = cms.double(1.5), values = cms.vstring('mass'), valueLabels = cms.vstring('Mass'), ) sdKinematicsName = 'sdKinematics' + jetsName setattr(process, sdKinematicsName, sdKinematics) substructure = cms.Sequence( njettiness + sdKinematics ) if btagLabel != '': ####################################### ## FATJET BTAGGING ## ####################################### initBTag(process, btagLabel, pfSource, pvSource) btags = [ 'pfJetProbabilityBJetTags', 'pfJetBProbabilityBJetTags', 'pfCombinedSecondaryVertexV2BJetTags', 'pfCombinedInclusiveSecondaryVertexV2BJetTags', 'pfCombinedMVAV2BJetTags' ] btagInfos = [] btagging = setupBTag(process, jetsName, jetsName, btagLabel, tags = btags, addedTagInfos = btagInfos) doubleBtags = [ 'pfBoostedDoubleSecondaryVertexBJetTags' ] doubleBtagging = setupDoubleBTag(process, jetsName, jetsName, btagLabel, rLabel.lower(), addedTagInfos = btagInfos) ####################################### ## SUBJET BTAGGING ## ####################################### # Product: std::vector<reco::CandIPTagInfo> # IPTagInfo object contains a reference to jet subjetIpTagInfos = btag.pfImpactParameterTagInfos.clone( jets = cms.InputTag(softDropJetsName, 'SubJets'), primaryVertex = cms.InputTag(pvSource), candidates = cms.InputTag(pfSource), # explicitJTA = cms.bool(True) ) subjetIpTagInfosName = 'pfImpactParameterTagInfos' + softDropSubjetsName setattr(process, subjetIpTagInfosName, subjetIpTagInfos) # Product: std::vector<TemplatedSecondaryVertexTagInfo<reco::CandIPTagInfo, reco::VertexCompositePtrCandidate>> subjetInclSVFinderTagInfos = btag.pfInclusiveSecondaryVertexFinderTagInfos.clone( trackIPTagInfos = cms.InputTag(subjetIpTagInfosName), extSVCollection = cms.InputTag('inclusiveCandidateSecondaryVertices' + btagLabel), # useSVClustering = cms.bool(True), # jetAlgorithm = cms.string(jetAlgo), # rParam = cms.double(jetRadius), # fatJets = cms.InputTag(jetsName), # groomedFatJets = cms.InputTag(softDropJetsName) ) subjetInclSVFinderTagInfosName = 'pfInclusiveSecondaryVertexFinderTagInfos' + softDropSubjetsName setattr(process, subjetInclSVFinderTagInfosName, subjetInclSVFinderTagInfos) # Product: JetTagCollection (aka reco::JetFloatAssociation::Container aka edm::AssociationVector<reco::JetRefBaseProd, std::vector<float>>) # Uses the internal reference to the jet in the TagInfos object to create an AssociationVector subjetBjetTags = btag.pfCombinedInclusiveSecondaryVertexV2BJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag(subjetIpTagInfosName), cms.InputTag(subjetInclSVFinderTagInfosName) ) ) subjetBjetTagsName = 'pfCombinedInclusiveSecondaryVertexV2BJetTags' + softDropSubjetsName setattr(process, subjetBjetTagsName, subjetBjetTags) subjetBTagging = cms.Sequence( subjetIpTagInfos + subjetInclSVFinderTagInfos + subjetBjetTags ) else: btagging = cms.Sequence() doubleBtagging = cms.Sequence() subjetBTagging = cms.Sequence() ######################################## ## MAKE PAT JETS ## ######################################## patJets = _patJets.clone( jetSource = cms.InputTag(jetsName), getJetMCFlavour = cms.bool(False), addGenJetMatch = cms.bool(False), addGenPartonMatch = cms.bool(False), addJetFlavourInfo = cms.bool(False), addAssociatedTracks = cms.bool(False), addJetCharge = cms.bool(False), addJetCorrFactors = cms.bool(False), addBTagInfo = cms.bool(True), addTagInfos = cms.bool(True), addDiscriminators = cms.bool(True), tagInfoSources = cms.VInputTag([cms.InputTag(name) for name in btagInfos]), discriminatorSources = cms.VInputTag([cms.InputTag(name + jetsName) for name in btags + doubleBtags]) ) patJets.userData.userFloats.src = [ cms.InputTag(njettinessName + ':tau1'), cms.InputTag(njettinessName + ':tau2'), cms.InputTag(njettinessName + ':tau3'), cms.InputTag(njettinessName + ':tau4'), cms.InputTag(sdKinematicsName + ':Mass') ] patJetsName = 'pat' + jetsName setattr(process, patJetsName, patJets) selectedJets = selectedPatJets.clone( src = cms.InputTag(patJetsName) ) selectedJetsName = 'selectedPat' + jetsName setattr(process, selectedJetsName, selectedJets) patSoftDropJets = _patJets.clone( jetSource = cms.InputTag(softDropJetsName), getJetMCFlavour = cms.bool(False), addGenJetMatch = cms.bool(False), addGenPartonMatch = cms.bool(False), addJetFlavourInfo = cms.bool(False), addTagInfos = cms.bool(False), addBTagInfo = cms.bool(False), addDiscriminators = cms.bool(False), addAssociatedTracks = cms.bool(False), addJetCharge = cms.bool(False), addJetCorrFactors = cms.bool(False) ) patSoftDropJetsName = 'pat' + softDropJetsName setattr(process, patSoftDropJetsName, patSoftDropJets) selectedSoftDropJets = selectedPatJets.clone( src = cms.InputTag(patSoftDropJetsName) ) selectedSoftDropJetsName = 'selectedPat' + softDropJetsName setattr(process, selectedSoftDropJetsName, selectedSoftDropJets) patSoftDropSubjets = _patJets.clone( jetSource = cms.InputTag(softDropJetsName, 'SubJets'), getJetMCFlavour = cms.bool(False), addGenJetMatch = cms.bool(False), addGenPartonMatch = cms.bool(False), addJetFlavourInfo = cms.bool(False), addAssociatedTracks = cms.bool(False), addJetCharge = cms.bool(False), addJetCorrFactors = cms.bool(False), addBTagInfo = cms.bool(True), addDiscriminators = cms.bool(True), addTagInfos = cms.bool(False), discriminatorSources = cms.VInputTag( cms.InputTag(subjetBjetTagsName) ) ) patSoftDropSubjetsName = 'pat' + softDropJetsName + 'Subjets' setattr(process, patSoftDropSubjetsName, patSoftDropSubjets) selectedSoftDropSubjets = selectedPatJets.clone( src = cms.InputTag(patSoftDropSubjetsName) ) selectedSoftDropSubjetsName = 'selectedPat' + softDropSubjetsName setattr(process, selectedSoftDropSubjetsName, selectedSoftDropSubjets) pat = cms.Sequence( patJets + selectedJets + patSoftDropJets + selectedSoftDropJets + patSoftDropSubjets + selectedSoftDropSubjets ) ############################################### ## Pack subjets back into fat jets ## ############################################### packedSoftDropJets = cms.EDProducer('BoostedJetMerger', jetSrc = cms.InputTag(selectedSoftDropJetsName), subjetSrc = cms.InputTag(selectedSoftDropSubjetsName) ) packedSoftDropJetsName = 'packed' + softDropJetsName setattr(process, packedSoftDropJetsName, packedSoftDropJets) packedPatJets = cms.EDProducer('JetSubstructurePacker', jetSrc = cms.InputTag(selectedJetsName), distMax = cms.double(jetRadius), algoTags = cms.VInputTag(cms.InputTag(packedSoftDropJetsName)), algoLabels = cms.vstring('SoftDrop'), fixDaughters = cms.bool(False) ) packedPatJetsName = 'packed' + jetsName setattr(process, packedPatJetsName, packedPatJets) packing = cms.Sequence( packedSoftDropJets + packedPatJets ) ############################## ## Return a sequence ## ############################## sequence = cms.Sequence( clustering + substructure + btagging + doubleBtagging + subjetBTagging + pat + packing ) return sequence
import FWCore.ParameterSet.Config as cms #______________________ Event-Selection _____________________________ from HLTrigger.HLTfilters.hltHighLevel_cfi import hltHighLevel hltFilter = hltHighLevel.clone( andOr = True, ## choose logical OR between Triggerbits HLTPaths = ['HLT_ZeroBias'], throw = False # tolerate triggers stated above, but not available ) #______________________ Object-Selection ____________________________ from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets from PhysicsTools.PatAlgos.selectionLayer1.electronSelector_cfi import selectedPatElectrons from PhysicsTools.PatAlgos.selectionLayer1.muonSelector_cfi import selectedPatMuons from PhysicsTools.PatAlgos.selectionLayer1.tauSelector_cfi import selectedPatTaus patJetSelector = selectedPatJets.clone( filter = cms.bool(False), src = "", cut = "") patElectronSelector = selectedPatElectrons.clone( filter = cms.bool(False), src = "", cut = "") patMuonSelector = selectedPatMuons.clone( filter = cms.bool(False), src = "", cut = "") patTauSelector = selectedPatTaus.clone( filter = cms.bool(False), src = "", cut = "") candStringSelector = cms.EDFilter("CandViewSelector", filter = cms.bool(False), src = cms.InputTag(""), cut = cms.string("") )
def addFatJet(process): from RecoJets.JetProducers.ak5PFJets_cfi import ak5PFJets process.ca8PFJetsCHS = ak5PFJets.clone( src='pfNoPileUp', jetPtMin=cms.double(10.0), doAreaFastjet=cms.bool(True), rParam=cms.double(0.8), jetAlgorithm=cms.string("CambridgeAachen"), ) jetSource = 'ca8PFJetsCHS' # corrections from PhysicsTools.PatAlgos.recoLayer0.jetCorrFactors_cfi import patJetCorrFactors process.patJetCorrFactorsCA8CHS = patJetCorrFactors.clone() process.patJetCorrFactorsCA8CHS.src = jetSource # will need to add L2L3 corrections in the cfg process.patJetCorrFactorsCA8CHS.levels = [ 'L1FastJet', 'L2Relative', 'L3Absolute' ] process.patJetCorrFactorsCA8CHS.payload = 'AK7PFchs' process.patJetCorrFactorsCA8CHS.useRho = True # pat jet from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import patJets process.patJetsCA8CHS = patJets.clone() process.patJetsCA8CHS.jetSource = jetSource process.patJetsCA8CHS.addJetCharge = False process.patJetsCA8CHS.embedCaloTowers = False process.patJetsCA8CHS.embedPFCandidates = False process.patJetsCA8CHS.addAssociatedTracks = False process.patJetsCA8CHS.addBTagInfo = False process.patJetsCA8CHS.addDiscriminators = False process.patJetsCA8CHS.getJetMCFlavour = False process.patJetsCA8CHS.jetCorrFactorsSource = cms.VInputTag( cms.InputTag('patJetCorrFactorsCA8CHS')) process.patJetsCA8CHS.genPartonMatch = cms.InputTag( 'patJetPartonMatchCA8CHS') process.patJetsCA8CHS.genJetMatch = cms.InputTag('patJetGenJetMatchCA8CHS') from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.selectedPatJetsCA8CHS = selectedPatJets.clone() process.selectedPatJetsCA8CHS.src = 'patJetsCA8CHS' process.selectedPatJetsCA8CHS.cut = 'pt()>20' #process.jetMCSequenceCA8CHS = cms.Sequence( #process.patJetPartonMatchCA8CHS + #process.genParticlesForJetsNoNu + #process.ca8GenJetsNoNu + #process.patJetGenJetMatchCA8CHS #) process.PATJetSequenceCA8CHS = cms.Sequence( process.ca8PFJetsCHS + #process.jetMCSequenceCA8CHS + process.patJetCorrFactorsCA8CHS #process.patJetsCA8CHS + #process.selectedPatJetsCA8CHS ) process.PATJetPathCA8CHS = cms.Path(process.PATJetSequenceCA8CHS)
def makeJets(process, isData, label, candidates, suffix): """ Light-weight version of pat addJetCollection. @labels: e.g. 'AK4PFPuppi' """ sequence = cms.Sequence() addattr = AddAttr(process, sequence, suffix) jets = addattr('ak4PFJets', ak4PFJets.clone(src=candidates, doAreaFastjet=True)) jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute'] if isData: jecLevels.append('L2L3Residual') jetCorrFactors = addattr( 'jetCorrFactors', patJetCorrFactors.clone(src=jets, payload=label, levels=jecLevels, primaryVertices=pvSource)) # btag should always use standard PF collection sequence += initBTag(process, '', pfSource, pvSource) sequence += setupBTag(process, jetCollection=jets, suffix=suffix, vsuffix='', muons=muons, electrons=electrons, tags=[ 'pfCombinedInclusiveSecondaryVertexV2BJetTags', 'pfCombinedMVAV2BJetTags', 'pfDeepCSVJetTags', 'pfDeepCMVAJetTags' ]) qgTagger = addattr('QGTagger', QGTagger.clone(srcJets=jets)) if not isData: genJetMatch = addattr( 'genJetMatch', patJetGenJetMatch.clone(src=jets, maxDeltaR=0.4, matched=genJets)) allPatJets = addattr('patJets', patJets.clone( jetSource = jets, addJetCorrFactors = True, jetCorrFactorsSource = [jetCorrFactors], addBTagInfo = True, discriminatorSources = [ cms.InputTag('pfCombinedInclusiveSecondaryVertexV2BJetTags' + suffix), cms.InputTag('pfCombinedMVAV2BJetTags' + suffix), ] + \ sum([[cms.InputTag('pfDeepCSVJetTags' + suffix, 'prob' + prob), cms.InputTag('pfDeepCMVAJetTags' + suffix, 'prob' + prob)] # for prob in ['udsg', 'b', 'c', 'bb', 'cc']], for prob in ['udsg', 'b', 'c', 'bb']], []), addAssociatedTracks = False, addJetCharge = False, addGenPartonMatch = False, addGenJetMatch = (not isData), getJetMCFlavour = False, addJetFlavourInfo = False ) ) addattr.last.userData.userFloats.src = [ qgTagger.getModuleLabel() + ':qgLikelihood' ] addattr.last.userData.userFloats.labelPostfixesToStrip = cms.vstring( suffix) if not isData: addattr.last.genJetMatch = genJetMatch selectedJets = addattr( 'selectedJets', selectedPatJets.clone(src=allPatJets, cut='pt > 15')) addattr('slimmedJets', slimmedJets.clone(src=selectedJets, rekeyDaughters='0')) return sequence
def jetToolbox( proc, jetType, jetSequence, 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 makeJets(process, isData, label, candidates, suffix): """ Light-weight version of pat addJetCollection. @labels: e.g. 'AK4PFPuppi' """ sequence = cms.Sequence() addattr = AddAttr(process, sequence, suffix) ak4PFJets = addattr('ak4PFJets', ak4PFJetsPuppi.clone( src = candidates, doAreaFastjet = True ) ) jecLevels= ['L1FastJet', 'L2Relative', 'L3Absolute'] if isData: jecLevels.append('L2L3Residual') jetCorrFactors = addattr('jetCorrFactors', patJetCorrFactors.clone( src = ak4PFJets, payload = label, levels = jecLevels, primaryVertices = pvSource ) ) # btag should always use standard PF collection sequence += initBTag(process, '', pfSource, pvSource) sequence += setupBTag( process, jetCollection = ak4PFJets, suffix = suffix, vsuffix = '', muons = muons, electrons = electrons, tags = ['pfCombinedInclusiveSecondaryVertexV2BJetTags'] ) if not isData: genJetMatch = addattr('genJetMatch', patJetGenJetMatch.clone( src = ak4PFJets, maxDeltaR = 0.4, matched = genJets ) ) allPatJets = addattr('patJets', patJets.clone( jetSource = ak4PFJets, addJetCorrFactors = True, jetCorrFactorsSource = [jetCorrFactors], addBTagInfo = True, discriminatorSources = [cms.InputTag('pfCombinedInclusiveSecondaryVertexV2BJetTags' + suffix)], addAssociatedTracks = False, addJetCharge = False, addGenPartonMatch = False, addGenJetMatch = (not isData), getJetMCFlavour = False, addJetFlavourInfo = False ) ) if not isData: addattr.last.genJetMatch = genJetMatch selectedJets = addattr('selectedJets', selectedPatJets.clone( src = allPatJets, cut = 'pt > 15' ) ) addattr('slimmedJets', slimmedJets.clone( src = selectedJets, rekeyDaughters = '0' ) ) return sequence
import FWCore.ParameterSet.Config as cms process = cms.Process("Jets") process.source = cms.Source("PoolSource", fileNames = cms.untracked.vstring( 'file:patTuple.root' ) ) process.MessageLogger = cms.Service("MessageLogger") ## prepare jet collections from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.goodCaloJets = selectedPatJets.clone(src='cleanPatJets', cut='pt>30 & abs(eta)<3') ## monitor jet collections from PhysicsTools.PatExamples.PatJetAnalyzer_cfi import analyzePatJets ## modules for jet response process.rawJets = analyzePatJets.clone(corrLevel='Uncorrected') process.relJets = analyzePatJets.clone(corrLevel='L2Relative') process.absJets = analyzePatJets.clone(corrLevel='L3Absolute') ## modules to compare calo and pflow jets process.caloJets = analyzePatJets.clone(src='goodCaloJets') process.pflowJets = analyzePatJets.clone(src='goodCaloJets') ## modules for shift in JES process.shiftedJets = analyzePatJets.clone(src='goodCaloJets') process.TFileService = cms.Service("TFileService", fileName = cms.string('analyzePatJets.root')
process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) ) ## configure process options process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) #------------------------------------------------- # top analysis #------------------------------------------------- # produce jet collection to be used for further analysis from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.leadingJets = selectedPatJets.clone() process.leadingJets.src = "selectedPatJets" process.leadingJets.cut = "pt > 20 & abs(eta) < 2.4 & 0.05 < emEnergyFraction & emEnergyFraction < 0.95" ## remove events with overlapping jets process.load("TopAnalysis.TopFilter.filters.JetOverlapEventFilter_cfi") process.filterJetOverlapEvent.src = "leadingJets" process.filterJetOverlapEvent.deltaR = 1.0 ## produce generated top event process.load("TopQuarkAnalysis.TopEventProducers.sequences.ttGenEvent_cff") ## produce reconstructed top events process.load("TopQuarkAnalysis.TopEventProducers.sequences.ttSemiLepEvtBuilder_cff") process.ttSemiLepJetPartonMatch.verbosity = 1 process.ttSemiLepEvent.verbosity = 1
process.patJetCorrFactorsReapplyJECAK8 = process.updatedPatJetCorrFactors.clone( src=cms.InputTag("slimmedJetsAK8"), levels=["L1FastJet", "L2Relative", "L3Absolute", "L2L3Residual"], payload="AK8PFchs", ) process.load("PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cff") process.patJetsReapplyJECAK8 = process.updatedPatJets.clone( jetSource=cms.InputTag("slimmedJetsAK8"), jetCorrFactorsSource=cms.VInputTag(cms.InputTag("patJetCorrFactorsReapplyJECAK8")), ) from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.goodJets = selectedPatJets.clone(src="patJetsReapplyJEC", cut="pt>30 & abs(eta)<2.4") ############# QGL ################# process.load("RecoJets.JetProducers.QGTagger_cfi") process.QGTagger.srcJets = cms.InputTag("goodJets") process.QGTagger.jetsLabel = cms.string("QGL_AK4PFchs") ##-------------------- User analyzer -------------------------------- process.boosted = cms.EDAnalyzer( "BoostedTTbarFlatTreeProducer", jets=cms.InputTag("patJetsReapplyJECAK8"), muons=cms.InputTag("slimmedMuons"), electrons=cms.InputTag("slimmedElectrons"), met=cms.InputTag("slimmedMETs"), vertices=cms.InputTag("offlineSlimmedPrimaryVertices"), rho=cms.InputTag("fixedGridRhoFastjetAll"),
# process.GlobalTag.globaltag = 'PHYS14_25_V1' ##-------------------- Define the source ---------------------------- process.maxEvents = cms.untracked.PSet(input=cms.untracked.int32(-1)) process.source = cms.Source( "PoolSource", fileNames=cms.untracked.vstring( "/store/mc/RunIISpring15DR74/TT_TuneCUETP8M1_13TeV-powheg-pythia8/MINIAODSIM/Asympt50ns_MCRUN2_74_V9A-v4/10000/00D2A247-2910-E511-9F3D-0CC47A4DEDD2.root" ), ) ############# Format MessageLogger ################# process.load("FWCore.MessageService.MessageLogger_cfi") process.MessageLogger.cerr.FwkReport.reportEvery = 1000 from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.goodJets = selectedPatJets.clone(src="slimmedJets", cut="pt>30 & abs(eta)<2.4") process.load("RecoJets.JetProducers.QGTagger_cfi") process.QGTagger.srcJets = cms.InputTag("slimmedJets") process.QGTagger.jetsLabel = cms.string("QGL_AK4PFchs") ##-------------------- User analyzer -------------------------------- process.hadtop = cms.EDAnalyzer( "TTbarFlatTreeProducer", jets=cms.InputTag("slimmedJets"), muons=cms.InputTag("slimmedMuons"), electrons=cms.InputTag("slimmedElectrons"), met=cms.InputTag("slimmedMETs"), vertices=cms.InputTag("offlineSlimmedPrimaryVertices"), rho=cms.InputTag("fixedGridRhoFastjetAll"), nJetsMin=cms.int32(6),
) #--- clean jets from leptons ----------------------------------- process. cleanedJets = cms.EDProducer('JetCleanedProducer', jets = cms.InputTag('patJetsReapplyJEC'), rho = cms.InputTag('fixedGridRhoFastjetAll'), muons = cms.InputTag('slimmedMuons'), electrons = cms.InputTag('slimmedElectrons'), vertices = cms.InputTag('offlineSlimmedPrimaryVertices'), minMuPt = cms.double(10), minElPt = cms.double(10) ) #--- finally define the good jets ------------------------------- from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.goodJets = selectedPatJets.clone(src='cleanedJets',cut='pt>30 & abs(eta)<2.4') process.load('RecoJets.JetProducers.QGTagger_cfi') process.QGTagger.srcJets = cms.InputTag('goodJets') process.QGTagger.jetsLabel = cms.string('QGL_AK4PFchs') ##-------------------- User analyzers -------------------------------- process.load('TopQuarkAnalysis.TopKinFitter.TtFullHadKinFitProducer_cfi') process.kinFitTtFullHadEvent.jets = 'goodJets' process.kinFitTtFullHadEvent.jetCorrectionLevel = 'L3Absolute' process.kinFitTtFullHadEvent.bTagAlgo = 'pfCombinedInclusiveSecondaryVertexV2BJetTags' process.kinFitTtFullHadEvent.minBTagValueBJet = 0.8484 process.kinFitTtFullHadEvent.maxBTagValueNonBJet = 0.8484 process.kinFitTtFullHadEvent.bTags = 2 process.kinFitTtFullHadEvent.maxNJets = 8
) process.shiftedJetsDown = process.shiftedJetsUp.clone(shiftJES = -1.0) process.shiftedJetsAK8Up = cms.EDProducer('JetShiftProducer', jets = cms.InputTag('patJetsReapplyJECAK8'), rho = cms.InputTag('fixedGridRhoFastjetAll'), payload = cms.untracked.string('AK8PFchs'), shiftJES = cms.untracked.double(1.0), doShift = cms.untracked.bool(True) ) process.shiftedJetsAK8Down = process.shiftedJetsAK8Up.clone(shiftJES = -1.0) #--- finally define the good jets ------------------------------- from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.goodJets = selectedPatJets.clone(src='patJetsReapplyJEC',cut='pt>30 & abs(eta)<2.4') process.goodSmearedJets = selectedPatJets.clone(src='smearedJets',cut='pt>30 & abs(eta)<2.4') process.goodSmearedJetsUp = selectedPatJets.clone(src='smearedJetsUp',cut='pt>30 & abs(eta)<2.4') process.goodSmearedJetsDown = selectedPatJets.clone(src='smearedJetsDown',cut='pt>30 & abs(eta)<2.4') process.goodShiftedJets = selectedPatJets.clone(src='shiftedJets',cut='pt>30 & abs(eta)<2.4') process.goodShiftedJetsUp = selectedPatJets.clone(src='shiftedJetsUp',cut='pt>30 & abs(eta)<2.4') process.goodShiftedJetsDown = selectedPatJets.clone(src='shiftedJetsDown',cut='pt>30 & abs(eta)<2.4') process.load('RecoJets.JetProducers.QGTagger_cfi') process.QGTagger.srcJets = cms.InputTag('goodJets') process.QGTagger.jetsLabel = cms.string('QGL_AK4PFchs') process.QGTaggerSmeared = process.QGTagger.clone(srcJets = 'goodSmearedJets') process.QGTaggerSmearedUp = process.QGTagger.clone(srcJets = 'goodSmearedJetsUp') process.QGTaggerSmearedDown = process.QGTagger.clone(srcJets = 'goodSmearedJetsDown') process.QGTaggerShiftedUp = process.QGTagger.clone(srcJets = 'goodShiftedJetsUp')
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 toolCode(self, process): """ Tool code implementation """ ## initialize parameters labelName='patJets'+self._parameters['labelName'].value postfix=self._parameters['postfix'].value jetSource=self._parameters['jetSource'].value algo=self._parameters['algo'].value jetCorrections=self._parameters['jetCorrections'].value btagDiscriminators=list(self._parameters['btagDiscriminators'].value) btagInfos=list(self._parameters['btagInfos'].value) jetTrackAssociation=self._parameters['jetTrackAssociation'].value outputModules=list(self._parameters['outputModules'].value) ## a list of all producer modules, which are already known to process knownModules = process.producerNames().split() ## determine whether btagging information is required or not if btagDiscriminators.count('None')>0: btagDiscriminators.remove('None') if btagInfos.count('None')>0: btagInfos.remove('None') bTagging=(len(btagDiscriminators)>0 or len(btagInfos)>0) ## construct postfix label for auxiliary modules; this postfix ## label will start with a capitalized first letter following ## the CMS nameing conventions and for improved readablility _labelName=labelName[:1].upper()+labelName[1:] #_labelName=labelName ## determine jet algorithm from jetSource; supported algo types ## are ak, kt, sc, ic. This loop expects that the algo type is ## followed by a single integer corresponding to the opening ## angle parameter dR times 10 (examples ak5, kt4, kt6, ...) _algo=algo #jetSource=cms.InputTag("ak5PFJets") for x in ["ak", "kt", "sc", "ic"]: if jetSource.getModuleLabel().lower().find(x)>-1: _algo=jetSource.getModuleLabel()[jetSource.getModuleLabel().lower().find(x):jetSource.getModuleLabel().lower().find(x)+3] #print _algo ## add new patJets to process (keep instance for later further modifications) from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import patJets if labelName in knownModules : _newPatJets=getattr(process, labelName+postfix) _newPatJets.jetSource=jetSource else : #setattr(process, labelName, patJets.clone(jetSource=jetSource)) setattr(process, labelName+postfix, patJets.clone(jetSource=jetSource)) _newPatJets=getattr(process, labelName+postfix) knownModules.append(labelName+postfix) ## add new selectedPatJets to process from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets if 'selected'+_labelName+postfix in knownModules : _newSelectedPatJets=getattr(process, 'selected'+_labelName+postfix) _newSelectedPatJets.src=labelName+postfix else : setattr(process, 'selected'+_labelName+postfix, selectedPatJets.clone(src=labelName+postfix)) knownModules.append('selected'+_labelName+postfix) ## set postfix label to '' if there is no labelName given. In this case all ## modules should keep there names w/o postfixes. This will cover the case ## of switchJectCollection if self._parameters['labelName'].value == '' : _labelName = '' ## add new patJetPartonMatch to process from PhysicsTools.PatAlgos.mcMatchLayer0.jetMatch_cfi import patJetPartonMatch if 'patJetPartonMatch'+_labelName+postfix in knownModules : _newPatJetPartonMatch=getattr(process, 'patJetPartonMatch'+_labelName+postfix) _newPatJetPartonMatch.src=jetSource else : setattr(process, 'patJetPartonMatch'+_labelName+postfix, patJetPartonMatch.clone(src=jetSource)) knownModules.append('patJetPartonMatch'+_labelName+postfix) ## add new patJetGenJetMatch to process from PhysicsTools.PatAlgos.mcMatchLayer0.jetMatch_cfi import patJetGenJetMatch if 'patJetGenJetMatch'+_labelName+postfix in knownModules : _newPatJetGenJetMatch=getattr(process, 'patJetGenJetMatch'+_labelName+postfix) _newPatJetGenJetMatch.src=jetSource _newPatJetGenJetMatch.matched=_algo.lower()+'GenJets'+postfix else : setattr(process, 'patJetGenJetMatch'+_labelName+postfix, patJetGenJetMatch.clone(src=jetSource, matched=_algo+'GenJets')) knownModules.append('patJetGenJetMatch'+_labelName+postfix) ## add new patJetPartonAssociation to process from PhysicsTools.PatAlgos.mcMatchLayer0.jetFlavourId_cff import patJetPartonAssociation if 'patJetPartonAssociation'+_labelName+postfix in knownModules : _newPatJetPartonAssociation=getattr(process, 'patJetPartonAssociation'+_labelName+postfix, patJetPartonAssociation.clone(jets=jetSource)) _newPatJetPartonAssociation.jets=jetSource else : setattr(process, 'patJetPartonAssociation'+_labelName+postfix, patJetPartonAssociation.clone(jets=jetSource)) knownModules.append('patJetPartonAssociation'+_labelName+postfix) ## add new patJetPartonAssociation to process from PhysicsTools.PatAlgos.mcMatchLayer0.jetFlavourId_cff import patJetFlavourAssociation if 'patJetFlavourAssociation'+_labelName+postfix in knownModules : _newPatJetFlavourAssociation=getattr(process, 'patJetFlavourAssociation'+_labelName+postfix, patJetFlavourAssociation.clone(srcByReference='patJetPartonAssociation'+_labelName+postfix)) _newPatJetFlavourAssociation.srcByReference='patJetPartonAssociation'+_labelName+postfix else: setattr(process, 'patJetFlavourAssociation'+_labelName+postfix, patJetFlavourAssociation.clone(srcByReference='patJetPartonAssociation'+_labelName+postfix)) knownModules.append('patJetFlavourAssociation'+_labelName+postfix) ## modify new patJets collection accordingly _newPatJets.genJetMatch.setModuleLabel('patJetGenJetMatch'+_labelName+postfix) _newPatJets.genPartonMatch.setModuleLabel('patJetPartonMatch'+_labelName+postfix) _newPatJets.JetPartonMapSource.setModuleLabel('patJetFlavourAssociation'+_labelName+postfix) ## add jetTrackAssociation for btagging (or jetTracksAssociation only) if required by user if (jetTrackAssociation or bTagging): ## add new jetTracksAssociationAtVertex to process from RecoJets.JetAssociationProducers.ak5JTA_cff import ak5JetTracksAssociatorAtVertex if 'jetTracksAssociationAtVertex'+_labelName+postfix in knownModules : _newJetTracksAssociationAtVertex=getattr(process, 'jetTracksAssociatorAtVertex'+_labelName+postfix) _newJetTracksAssociationAtVertex.jets=jetSource else: setattr(process, 'jetTracksAssociatorAtVertex'+_labelName+postfix, ak5JetTracksAssociatorAtVertex.clone(jets=jetSource)) knownModules.append('jetTracksAssociationAtVertex'+_labelName+postfix) ## add new patJetCharge to process from PhysicsTools.PatAlgos.recoLayer0.jetTracksCharge_cff import patJetCharge if 'patJetCharge'+_labelName+postfix in knownModules : _newPatJetCharge=getattr(process, 'patJetCharge'+_labelName+postfix) _newPatJetCharge.src='jetTracksAssociatorAtVertex'+_labelName+postfix else: setattr(process, 'patJetCharge'+_labelName+postfix, patJetCharge.clone(src = 'jetTracksAssociatorAtVertex'+_labelName+postfix)) knownModules.append('patJetCharge'+_labelName+postfix) ## modify new patJets collection accordingly _newPatJets.addAssociatedTracks=True _newPatJets.trackAssociationSource=cms.InputTag('jetTracksAssociatorAtVertex'+_labelName+postfix) _newPatJets.addJetCharge=True _newPatJets.jetChargeSource=cms.InputTag('patJetCharge'+_labelName+postfix) else: ## modify new patJets collection accordingly _newPatJets.addAssociatedTracks=False _newPatJets.trackAssociationSource='' _newPatJets.addJetCharge=False _newPatJets.jetChargeSource='' ## run btagging if required by user if (bTagging): ## expand tagInfos to what is explicitely required by user + implicit ## requirements that come in from one or the other discriminator requiredTagInfos = list(btagInfos) for btagDiscr in btagDiscriminators : for requiredTagInfo in supportedBtagDiscr[btagDiscr] : tagInfoCovered = False for tagInfo in requiredTagInfos : if requiredTagInfo == tagInfo : tagInfoCovered = True break if not tagInfoCovered : requiredTagInfos.append(requiredTagInfo) ## load sequences and setups needed fro btagging ## This loads all available btagger, but the ones we need are added to the process by hand lader. Only needed to get the ESProducer. Needs improvement #loadWithPostFix(process,"RecoBTag.Configuration.RecoBTag_cff",postfix) process.load("RecoBTag.Configuration.RecoBTag_cff") #addESProducers(process,'RecoBTag.Configuration.RecoBTag_cff') import RecoBTag.Configuration.RecoBTag_cff as btag ## prepare setups for simple secondary vertex infos setattr(process, "simpleSecondaryVertex2Trk", simpleSecondaryVertex2Trk) ## prepare setups for transient tracks setattr(process, "TransientTrackBuilderESProducer", TransientTrackBuilderESProducer) ## setup all required btagInfos : we give a dedicated treatment for all five different ## types of tagINfos here. A common treatment is possible but might require a more ## general approach anyway in coordination with the btaggin POG. for btagInfo in requiredTagInfos : if 'impactParameterTagInfos' in btagInfo : setattr(process, btagInfo+_labelName+postfix, btag.impactParameterTagInfos.clone(jetTracks = cms.InputTag('jetTracksAssociatorAtVertex'+_labelName+postfix))) if 'secondaryVertexTagInfos' in btagInfo : setattr(process, btagInfo+_labelName+postfix, btag.secondaryVertexTagInfos.clone(trackIPTagInfos = cms.InputTag('impactParameterTagInfos'+_labelName+postfix))) if 'secondaryVertexNegativeTagInfos' in btagInfo : setattr(process, btagInfo+_labelName+postfix, btag.secondaryVertexNegativeTagInfos.clone(trackIPTagInfos = cms.InputTag('impactParameterTagInfos'+_labelName+postfix))) if 'softElectronTagInfos' in btagInfo : setattr(process, btagInfo+_labelName+postfix, btag.softElectronTagInfos.clone(jets = cms.InputTag(_newJetCollection))) if 'softMuonTagInfos' in btagInfo : setattr(process, btagInfo+_labelName+postfix, btag.softMuonTagInfos.clone(jets = cms.InputTag(_newJetCollection))) ## setup all required btagDiscriminators for btagDiscr in btagDiscriminators : setattr(process, btagDiscr+_labelName+postfix, getattr(btag, btagDiscr).clone(tagInfos = cms.VInputTag( *[ cms.InputTag(x+_labelName+postfix) for x in supportedBtagDiscr[btagDiscr] ] ))) ## replace corresponding tags for pat jet production _newPatJets.tagInfoSources = cms.VInputTag( *[ cms.InputTag(x+_labelName+postfix) for x in btagInfos ] ) _newPatJets.discriminatorSources = cms.VInputTag( *[ cms.InputTag(x+_labelName+postfix) for x in btagDiscriminators ] ) else: _newPatJets.addBTagInfo = False ## adjust output module; these collections will be empty anyhow, but we do it to stay clean for outputModule in outputModules: if hasattr(process,outputModule): getattr(process,outputModule).outputCommands.append("drop *_"+'selected'+_labelName+postfix+"_tagInfos_*") ## add jet correction factors if required by user if (jetCorrections != None): ## check for the correct format if type(jetCorrections) != type(('PAYLOAD-LABEL',['CORRECTION-LEVEL-A','CORRECTION-LEVEL-B'], 'MET-LABEL')): raise ValueError, "In addJetCollection: 'jetCorrections' must be 'None' (as a python value w/o quotation marks), or of type ('PAYLOAD-LABEL', ['CORRECTION-LEVEL-A', \ 'CORRECTION-LEVEL-B', ...], 'MET-LABEL'). Note that 'MET-LABEL' can be set to 'None' (as a string in quotation marks) in case you do not want to apply MET(Type1) \ corrections." ## determine type of jet constituents from jetSource; supported ## jet constituent types are calo, pf, jpt, for pf also particleflow ## is aloowed as part of the jetSource label, which might be used ## in CommonTools.ParticleFlow _type="NONE" if jetCorrections[0].count('PF')>0: _type='PF' elif jetCorrections[0].count('Calo')>0: _type='Calo' elif jetCorrections[0].count('JPT')>0: _type='JPT' else: raise TypeError, "In addJetCollection: Jet energy corrections are only supported for PF, JPT and Calo jets." from PhysicsTools.PatAlgos.recoLayer0.jetCorrFactors_cfi import patJetCorrFactors if 'patJetCorrFactors'+_labelName+postfix in knownModules : _newPatJetCorrFactors=getattr(process, 'patJetCorrFactors'+_labelName+postfix) _newPatJetCorrFactors.src=jetSource else : setattr(process, 'patJetCorrFactors'+_labelName+postfix, patJetCorrFactors.clone(src=jetSource)) _newPatJetCorrFactors=getattr(process, "patJetCorrFactors"+_labelName+postfix) _newPatJetCorrFactors.payload=jetCorrections[0] _newPatJetCorrFactors.levels=jetCorrections[1] ## check whether L1Offset or L1FastJet is part of levels error=False for x in jetCorrections[1]: if x == 'L1Offset' : if not error : _newPatJetCorrFactors.useNPV=True _newPatJetCorrFactors.primaryVertices='offlinePrimaryVertices' ## we set this to True now as a L1 correction type should appear only once ## otherwise levels is miss configured error=True else: raise ValueError, "In addJetCollection: Correction levels for jet energy corrections are miss configured. An L1 correction type should appear not more than \ once. Check the list of correction levels you requested to be applied: ", jetCorrections[1] if x == 'L1FastJet' : if not error : if _type == "JPT" : raise TypeError, "In addJetCollection: L1FastJet corrections are only supported for PF and Calo jets." ## configure module _newPatJetCorrFactors.useRho=True _newPatJetCorrFactors.rho=cms.InputTag('kt6'+_type+'Jets', 'rho') ## we set this to True now as a L1 correction type should appear only once ## otherwise levels is miss configured error=True else: raise ValueError, "In addJetCollection: Correction levels for jet energy corrections are miss configured. An L1 correction type should appear not more than \ once. Check the list of correction levels you requested to be applied: ", jetCorrections[1] _newPatJets.jetCorrFactorsSource=cms.VInputTag(cms.InputTag('patJetCorrFactors'+_labelName+postfix)) ## configure MET(Type1) corrections if jetCorrections[2].lower() != 'none' and jetCorrections[2] != '': if not jetCorrections[2].lower() == 'type-1' and not jetCorrections[2].lower() == 'type-2': raise valueError, "In addJetCollection: Wrong choice of MET corrections for new jet collection. Possible choices are None (or empty string), Type-1, Type-2 (i.e.\ Type-1 and Type-2 corrections applied). This choice is not case sensitive. Your choice was: ", jetCorrections[2] if _type == "JPT": raise ValueError, "In addJecCollection: MET(type1) corrections are not supported for JPTJets. Please set the MET-LABEL to \"None\" (as string in quatiation \ marks) and use raw tcMET together with JPTJets." ## set up jet correctors for MET corrections from JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff import ak5PFL1Fastjet from JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff import ak5PFL1Offset from JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff import ak5PFL2Relative from JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff import ak5PFL3Absolute from JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff import ak5PFResidual setattr(process, jetCorrections[0]+'L1FastJet', ak5PFL1Fastjet.clone(algorithm=jetCorrections[0], srcRho=cms.InputTag('kt6'+_type+'Jets','rho'))) setattr(process, jetCorrections[0]+'L1Offset', ak5PFL1Offset.clone(algorithm=jetCorrections[0])) setattr(process, jetCorrections[0]+'L2Relative', ak5PFL2Relative.clone(algorithm=jetCorrections[0])) setattr(process, jetCorrections[0]+'L3Absolute', ak5PFL3Absolute.clone(algorithm=jetCorrections[0])) setattr(process, jetCorrections[0]+'L2L3Residual', ak5PFResidual.clone(algorithm=jetCorrections[0])) setattr(process, jetCorrections[0]+'CombinedCorrector', cms.ESProducer( 'JetCorrectionESChain', correctors = cms.vstring())) for x in jetCorrections[1]: if x != 'L1FastJet' and x != 'L1Offset' and x != 'L2Relative' and x != 'L3Absolute' and x != 'L2L3Residual': raise ValueError, 'In addJetCollection: Unsupported JEC for MET(Type1). Currently supported jet correction levels are L1FastJet, L1Offset, L2Relative, \ L3Asolute, L2L3Residual. Requested was:', x else: getattr(process, jetCorrections[0]+'CombinedCorrector').correctors.append(jetCorrections[0]+x) ## set up MET(Type1) correction modules if _type == 'Calo': from JetMETCorrections.Type1MET.caloMETCorrections_cff import caloJetMETcorr from JetMETCorrections.Type1MET.caloMETCorrections_cff import caloType1CorrectedMet from JetMETCorrections.Type1MET.caloMETCorrections_cff import caloType1p2CorrectedMet setattr(process,jetCorrections[0]+'JetMETcorr'+postfix, caloJetMETcorr.clone(src=jetSource,srcMET = "corMetGlobalMuons",jetCorrections = cms.string(jetCorrections[0]+'CombinedCorrector'+postfix))) setattr(process,jetCorrections[0]+'Type1CorMet'+postfix, caloType1CorrectedMet.clone(src = "corMetGlobalMuons"+postfix,srcType1Corrections = cms.VInputTag(cms.InputTag(jetCorrections[0]+'JetMETcorr'+postfix, 'type1')))) setattr(process,jetCorrections[0]+'Type1p2CorMet'+postfix,caloType1p2CorrectedMet.clone(src = "corMetGlobalMuons"+postfix,srcType1Corrections = cms.VInputTag(cms.InputTag(jetCorrections[0]+'JetMETcorr'+postfix, 'type1')),srcUnclEnergySums = cms.VInputTag(cms.InputTag(jetCorrections[0]+'JetMETcorr'+postfix, 'type2'),cms.InputTag(jetCorrections[0]+'JetMETcorr'+postfix, 'offset'),cms.InputTag('muonCaloMETcorr'+postfix)))) elif _type == 'PF': from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfCandsNotInJet from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfJetMETcorr from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfCandMETcorr from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfType1CorrectedMet from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfType1p2CorrectedMet setattr(process,jetCorrections[0]+'CandsNotInJet'+postfix,pfCandsNotInJet.clone(topCollection = jetSource)) setattr(process,jetCorrections[0]+'CandMETcorr'+postfix, pfCandMETcorr.clone(src = cms.InputTag(jetCorrections[0]+'CandsNotInJet'+postfix))) setattr(process,jetCorrections[0]+'JetMETcorr'+postfix, pfJetMETcorr.clone(src = jetSource)) setattr(process,jetCorrections[0]+'Type1CorMet'+postfix, pfType1CorrectedMet.clone(srcType1Corrections = cms.VInputTag(cms.InputTag(jetCorrections[0]+'JetMETcorr'+postfix, 'type1')))) setattr(process,jetCorrections[0]+'Type1p2CorMet'+postfix, pfType1p2CorrectedMet.clone(srcType1Corrections = cms.VInputTag(cms.InputTag(jetCorrections[0]+'JetMETcorr'+postfix, 'type1')),srcUnclEnergySums = cms.VInputTag(cms.InputTag(jetCorrections[0]+'JetMETcorr'+postfix, 'type2'),cms.InputTag(jetCorrections[0]+'JetMETcorr'+postfix, 'offset'),cms.InputTag(jetCorrections[0]+'CandMETcorr'+postfix)))) ## common configuration for Calo and PF if ('L1FastJet' in jetCorrections[1] or 'L1Fastjet' in jetCorrections[1]): getattr(process,jetCorrections[0]+'JetMETcorr'+postfix).offsetCorrLabel = cms.string(jetCorrections[0]+'L1FastJet') elif ('L1Offset' in jetCorrections[1]): getattr(process,jetCorrections[0]+'JetMETcorr'+postfix).offsetCorrLabel = cms.string(jetCorrections[0]+'L1Offset') else: getattr(process,jetCorrections[0]+'JetMETcorr'+postfix).offsetCorrLabel = cms.string('') from PhysicsTools.PatAlgos.producersLayer1.metProducer_cfi import patMETs if jetCorrections[2].lower() == 'type-1': setattr(process, 'patMETs'+_labelName+postfix, patMETs.clone(metSource = cms.InputTag(jetCorrections[0]+'Type1CorMet'+postfix), addMuonCorrections = False)) elif jetCorrections[2].lower() == 'type-1': setattr(process, 'patMETs'+_labelName+postfix, patMETs.clone(metSource = cms.InputTag(jetCorrections[0]+'Type1p2CorMet'+postfix), addMuonCorrections = False)) else: ## switch jetCorrFactors off _newPatJets.addJetCorrFactors=False
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 makeMET(process, isData, pfCandidates, jetSource, jetFlavor, postfix=''): """ @jetFlavor: e.g. 'ak4PFchs' Additional information (such as gen and calo mets) are added only if postfix is empty. """ sequence = cms.Sequence() # postfix is automatically added to the module names addattr = AddAttr(process, sequence, postfix) if postfix == '': # default MET - extract from input slimmedMETs pfMet = addattr( 'pfMet', cms.EDProducer("RecoMETExtractor", metSource=cms.InputTag( "slimmedMETs", processName=cms.InputTag.skipCurrentProcess()), correctionLevel=cms.string('raw'))) else: pfMet = addattr( 'pfMet', PFMET_cfi.pfMet.clone( src=pfCandidates, calculateSignificance=False # done in PAT )) cleanedJets = addattr( 'cleanedJetsForMET', cms.EDProducer( "PATJetCleanerForType1MET", src=cms.InputTag(jetSource), jetCorrEtaMax=cms.double(9.9), jetCorrLabel=cms.InputTag("L3Absolute"), jetCorrLabelRes=cms.InputTag("L2L3Residual"), offsetCorrLabel=cms.InputTag("L1FastJet"), skipEM=cms.bool(True), skipEMfractionThreshold=cms.double(0.9), skipMuonSelection=cms.string('isGlobalMuon | isStandAloneMuon'), skipMuons=cms.bool(True), type1JetPtThreshold=cms.double(15.0))) selectedJets = addattr( 'selectedJetsForMET', selectedPatJets.clone(src=cleanedJets, cut='pt > 15 && abs(eta) < 9.9')) crossCleanedJets = addattr('crossCleanedJetsForMET', cleanPatJets.clone(src=selectedJets)) ccJetsMod = addattr.last ccJetsMod.checkOverlaps.muons.src = muons ccJetsMod.checkOverlaps.electrons.src = electrons del ccJetsMod.checkOverlaps.photons del ccJetsMod.checkOverlaps.taus # not used at all and electrons are already cleaned del ccJetsMod.checkOverlaps.tkIsoElectrons patPFMet = addattr( 'patPFMet', patMET_cff.patPFMet.clone( metSource=pfMet, genMETSource='genMetTrue', srcPFCands=pfCandidates, computeMETSignificance=True, parameters=(METSignificanceParams_Data if isData else METSignificanceParams), srcJets=crossCleanedJets, srcLeptons=[electrons, muons, photons], addGenMET=(not isData and postfix == ''))) patPFMetT1Corr = addattr( 'patPFMetT1Corr', patMET_cff.patPFMetT1T2Corr.clone(src=crossCleanedJets)) patPFMetT1 = addattr( 'patPFMetT1', patMET_cff.patPFMetT1.clone(src=patPFMet, srcCorrections=[ cms.InputTag( patPFMetT1Corr.getModuleLabel(), 'type1') ])) pfCandsNoEle = addattr( 'pfCandsNoEle', cms.EDProducer("CandPtrProjector", src=cms.InputTag(pfCandidates), veto=electrons)) pfCandsNoEleMu = addattr( 'pfCandsNoEleMu', cms.EDProducer("CandPtrProjector", src=pfCandsNoEle, veto=muons)) pfCandsNoEleMuTau = addattr( 'pfCandsNoEleMuTau', cms.EDProducer("CandPtrProjector", src=pfCandsNoEleMu, veto=taus)) pfCandsNoEleMuTauGamma = addattr( 'pfCandsNoEleMuTauGamma', cms.EDProducer("CandPtrProjector", src=pfCandsNoEleMuTau, veto=photons)) pfCandsForUnclusteredUnc = addattr( 'pfCandsForUnclusteredUnc', cms.EDProducer("CandPtrProjector", src=pfCandsNoEleMuTauGamma, veto=crossCleanedJets)) for vsign, vname in [(1, 'Up'), (-1, 'Down')]: shiftConf = [('MuonEn', muons.value(), '((x<100)?(0.002+0*y):(0.05+0*y))'), ('ElectronEn', electrons.value(), '((abs(y)<1.479)?(0.006+0*x):(0.015+0*x))'), ('PhotonEn', photons.value(), '((abs(y)<1.479)?(0.01+0*x):(0.025+0*x))'), ('TauEn', taus.value(), '0.03+0*x*y'), ('UnclusteredEn', pfCandsForUnclusteredUnc.value(), ''), ('JetEn', crossCleanedJets.value(), '')] for part, coll, formula in shiftConf: if part == 'UnclusteredEn': shifted = addattr( 'shifted' + part + vname, cms.EDProducer( "ShiftedParticleProducer", src=pfCandsForUnclusteredUnc, binning=cms.VPSet( # charged PF hadrons - tracker resolution cms.PSet( binSelection=cms.string('charge!=0'), binUncertainty=cms.string( 'sqrt(pow(0.00009*x,2)+pow(0.0085/sqrt(sin(2*atan(exp(-y)))),2))' )), # neutral PF hadrons - HCAL resolution cms.PSet( binSelection=cms.string('pdgId==130'), energyDependency=cms.bool(True), binUncertainty=cms.string( '((abs(y)<1.3)?(min(0.25,sqrt(0.64/x+0.0025))):(min(0.30,sqrt(1.0/x+0.0016))))' )), # photon - ECAL resolution cms.PSet(binSelection=cms.string('pdgId==22'), energyDependency=cms.bool(True), binUncertainty=cms.string( 'sqrt(0.0009/x+0.000001)+0*y')), # HF particules - HF resolution cms.PSet(binSelection=cms.string( 'pdgId==1 || pdgId==2'), energyDependency=cms.bool(True), binUncertainty=cms.string( 'sqrt(1./x+0.0025)+0*y')), ), shiftBy=cms.double(float(vsign)))) elif part == 'JetEn': shifted = addattr( 'shifted' + part + vname, cms.EDProducer( 'SUEPShiftedPATJetProducer', src=crossCleanedJets, jetCorrPayloadName=cms.string(jetFlavor), jetCorrUncertaintyTag=cms.string('Uncertainty'), addResidualJES=cms.bool(isData), jetCorrLabelUpToL3=cms.InputTag( 'L3Absolute'), # use embedded correction factors jetCorrLabelUpToL3Res=cms.InputTag('L2L3Residual'), shiftBy=cms.double(float(vsign)))) else: shifted = addattr( 'shifted' + part + vname, cms.EDProducer("ShiftedParticleProducer", src=cms.InputTag(coll), uncertainty=cms.string(formula), shiftBy=cms.double(float(vsign)))) metCorrShifted = addattr( 'metCorrShifted' + part + vname, cms.EDProducer("ShiftedParticleMETcorrInputProducer", srcOriginal=cms.InputTag(coll), srcShifted=shifted)) addattr( 'patPFMetT1' + part + vname, patMET_cff.patPFMetT1.clone(src=patPFMetT1, srcCorrections=[metCorrShifted])) # Dummy JetResUp and JetResDown modules because PATJetSlimmer requires them # Jet smearing should be propagated to MET simply by using ptSmear(|Up|Down) branches at the ntuples level addattr('patPFMetT1JetResUp', getattr(process, 'patPFMetT1JetEnUp' + postfix).clone()) addattr('patPFMetT1JetResDown', getattr(process, 'patPFMetT1JetEnDown' + postfix).clone()) addattr( 'slimmedMETs', slimmedMETs.clone(src=patPFMetT1, rawVariation=patPFMet, t1Uncertainties="patPFMetT1%s" + postfix, runningOnMiniAOD=True)) slimmed = addattr.last if postfix == '': # default MET slimmed.caloMET = 'patCaloMet' else: del slimmed.caloMET del slimmed.t01Variation del slimmed.t1SmearedVarsAndUncs del slimmed.tXYUncForT1 del slimmed.tXYUncForRaw del slimmed.tXYUncForT01 del slimmed.tXYUncForT1Smear del slimmed.tXYUncForT01Smear return sequence
def toolCode(self, process): """ Tool code implementation """ ## initialize parameters labelName = "patJets" + self._parameters["labelName"].value postfix = self._parameters["postfix"].value jetSource = self._parameters["jetSource"].value algo = self._parameters["algo"].value jetCorrections = self._parameters["jetCorrections"].value btagDiscriminators = list(self._parameters["btagDiscriminators"].value) btagInfos = list(self._parameters["btagInfos"].value) jetTrackAssociation = self._parameters["jetTrackAssociation"].value outputModules = list(self._parameters["outputModules"].value) ## a list of all producer modules, which are already known to process knownModules = process.producerNames().split() ## determine whether btagging information is required or not if btagDiscriminators.count("None") > 0: btagDiscriminators.remove("None") if btagInfos.count("None") > 0: btagInfos.remove("None") bTagging = len(btagDiscriminators) > 0 or len(btagInfos) > 0 ## construct postfix label for auxiliary modules; this postfix ## label will start with a capitalized first letter following ## the CMS nameing conventions and for improved readablility _labelName = labelName[:1].upper() + labelName[1:] # _labelName=labelName ## determine jet algorithm from jetSource; supported algo types ## are ak, kt, sc, ic. This loop expects that the algo type is ## followed by a single integer corresponding to the opening ## angle parameter dR times 10 (examples ak5, kt4, kt6, ...) _algo = algo # jetSource=cms.InputTag("ak5PFJets") for x in ["ak", "kt", "sc", "ic"]: if jetSource.getModuleLabel().lower().find(x) > -1: _algo = jetSource.getModuleLabel()[ jetSource.getModuleLabel().lower().find(x) : jetSource.getModuleLabel().lower().find(x) + 3 ] # print _algo ## add new patJets to process (keep instance for later further modifications) from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import patJets if labelName in knownModules: _newPatJets = getattr(process, labelName + postfix) _newPatJets.jetSource = jetSource else: # setattr(process, labelName, patJets.clone(jetSource=jetSource)) setattr(process, labelName + postfix, patJets.clone(jetSource=jetSource)) _newPatJets = getattr(process, labelName + postfix) knownModules.append(labelName + postfix) ## add new selectedPatJets to process from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets if "selected" + _labelName + postfix in knownModules: _newSelectedPatJets = getattr(process, "selected" + _labelName + postfix) _newSelectedPatJets.src = labelName + postfix else: setattr(process, "selected" + _labelName + postfix, selectedPatJets.clone(src=labelName + postfix)) knownModules.append("selected" + _labelName + postfix) ## set postfix label to '' if there is no labelName given. In this case all ## modules should keep there names w/o postfixes. This will cover the case ## of switchJectCollection if self._parameters["labelName"].value == "": _labelName = "" ## add new patJetPartonMatch to process from PhysicsTools.PatAlgos.mcMatchLayer0.jetMatch_cfi import patJetPartonMatch if "patJetPartonMatch" + _labelName + postfix in knownModules: _newPatJetPartonMatch = getattr(process, "patJetPartonMatch" + _labelName + postfix) _newPatJetPartonMatch.src = jetSource else: setattr(process, "patJetPartonMatch" + _labelName + postfix, patJetPartonMatch.clone(src=jetSource)) knownModules.append("patJetPartonMatch" + _labelName + postfix) ## add new patJetGenJetMatch to process from PhysicsTools.PatAlgos.mcMatchLayer0.jetMatch_cfi import patJetGenJetMatch if "patJetGenJetMatch" + _labelName + postfix in knownModules: _newPatJetGenJetMatch = getattr(process, "patJetGenJetMatch" + _labelName + postfix) _newPatJetGenJetMatch.src = jetSource _newPatJetGenJetMatch.matched = _algo.lower() + "GenJets" + postfix else: setattr( process, "patJetGenJetMatch" + _labelName + postfix, patJetGenJetMatch.clone(src=jetSource, matched=_algo + "GenJets"), ) knownModules.append("patJetGenJetMatch" + _labelName + postfix) ## add new patJetPartonAssociation to process from PhysicsTools.PatAlgos.mcMatchLayer0.jetFlavourId_cff import patJetPartonAssociation if "patJetPartonAssociation" + _labelName + postfix in knownModules: _newPatJetPartonAssociation = getattr( process, "patJetPartonAssociation" + _labelName + postfix, patJetPartonAssociation.clone(jets=jetSource) ) _newPatJetPartonAssociation.jets = jetSource else: setattr( process, "patJetPartonAssociation" + _labelName + postfix, patJetPartonAssociation.clone(jets=jetSource) ) knownModules.append("patJetPartonAssociation" + _labelName + postfix) ## add new patJetPartonAssociation to process from PhysicsTools.PatAlgos.mcMatchLayer0.jetFlavourId_cff import patJetFlavourAssociation if "patJetFlavourAssociation" + _labelName + postfix in knownModules: _newPatJetFlavourAssociation = getattr( process, "patJetFlavourAssociation" + _labelName + postfix, patJetFlavourAssociation.clone(srcByReference="patJetPartonAssociation" + _labelName + postfix), ) _newPatJetFlavourAssociation.srcByReference = "patJetPartonAssociation" + _labelName + postfix else: setattr( process, "patJetFlavourAssociation" + _labelName + postfix, patJetFlavourAssociation.clone(srcByReference="patJetPartonAssociation" + _labelName + postfix), ) knownModules.append("patJetFlavourAssociation" + _labelName + postfix) ## modify new patJets collection accordingly _newPatJets.genJetMatch.setModuleLabel("patJetGenJetMatch" + _labelName + postfix) _newPatJets.genPartonMatch.setModuleLabel("patJetPartonMatch" + _labelName + postfix) _newPatJets.JetPartonMapSource.setModuleLabel("patJetFlavourAssociation" + _labelName + postfix) ## add jetTrackAssociation for btagging (or jetTracksAssociation only) if required by user if jetTrackAssociation or bTagging: ## add new jetTracksAssociationAtVertex to process from RecoJets.JetAssociationProducers.ak5JTA_cff import ak5JetTracksAssociatorAtVertex if "jetTracksAssociationAtVertex" + _labelName + postfix in knownModules: _newJetTracksAssociationAtVertex = getattr( process, "jetTracksAssociatorAtVertex" + _labelName + postfix ) _newJetTracksAssociationAtVertex.jets = jetSource else: setattr( process, "jetTracksAssociatorAtVertex" + _labelName + postfix, ak5JetTracksAssociatorAtVertex.clone(jets=jetSource), ) knownModules.append("jetTracksAssociationAtVertex" + _labelName + postfix) ## add new patJetCharge to process from PhysicsTools.PatAlgos.recoLayer0.jetTracksCharge_cff import patJetCharge if "patJetCharge" + _labelName + postfix in knownModules: _newPatJetCharge = getattr(process, "patJetCharge" + _labelName + postfix) _newPatJetCharge.src = "jetTracksAssociatorAtVertex" + _labelName + postfix else: setattr( process, "patJetCharge" + _labelName + postfix, patJetCharge.clone(src="jetTracksAssociatorAtVertex" + _labelName + postfix), ) knownModules.append("patJetCharge" + _labelName + postfix) ## modify new patJets collection accordingly _newPatJets.addAssociatedTracks = True _newPatJets.trackAssociationSource = cms.InputTag("jetTracksAssociatorAtVertex" + _labelName + postfix) _newPatJets.addJetCharge = True _newPatJets.jetChargeSource = cms.InputTag("patJetCharge" + _labelName + postfix) else: ## modify new patJets collection accordingly _newPatJets.addAssociatedTracks = False _newPatJets.trackAssociationSource = "" _newPatJets.addJetCharge = False _newPatJets.jetChargeSource = "" ## run btagging if required by user if bTagging: ## expand tagInfos to what is explicitely required by user + implicit ## requirements that come in from one or the other discriminator requiredTagInfos = list(btagInfos) for btagDiscr in btagDiscriminators: for requiredTagInfo in supportedBtagDiscr[btagDiscr]: tagInfoCovered = False for tagInfo in requiredTagInfos: if requiredTagInfo == tagInfo: tagInfoCovered = True break if not tagInfoCovered: requiredTagInfos.append(requiredTagInfo) ## load sequences and setups needed fro btagging ## This loads all available btagger, but the ones we need are added to the process by hand lader. Only needed to get the ESProducer. Needs improvement # loadWithPostFix(process,"RecoBTag.Configuration.RecoBTag_cff",postfix) process.load("RecoBTag.Configuration.RecoBTag_cff") # addESProducers(process,'RecoBTag.Configuration.RecoBTag_cff') import RecoBTag.Configuration.RecoBTag_cff as btag ## prepare setups for simple secondary vertex infos setattr(process, "simpleSecondaryVertex2Trk", simpleSecondaryVertex2Trk) ## prepare setups for transient tracks setattr(process, "TransientTrackBuilderESProducer", TransientTrackBuilderESProducer) ## setup all required btagInfos : we give a dedicated treatment for all five different ## types of tagINfos here. A common treatment is possible but might require a more ## general approach anyway in coordination with the btaggin POG. for btagInfo in requiredTagInfos: if "impactParameterTagInfos" in btagInfo: setattr( process, btagInfo + _labelName + postfix, btag.impactParameterTagInfos.clone( jetTracks=cms.InputTag("jetTracksAssociatorAtVertex" + _labelName + postfix) ), ) if "secondaryVertexTagInfos" in btagInfo: setattr( process, btagInfo + _labelName + postfix, btag.secondaryVertexTagInfos.clone( trackIPTagInfos=cms.InputTag("impactParameterTagInfos" + _labelName + postfix) ), ) if "secondaryVertexNegativeTagInfos" in btagInfo: setattr( process, btagInfo + _labelName + postfix, btag.secondaryVertexNegativeTagInfos.clone( trackIPTagInfos=cms.InputTag("impactParameterTagInfos" + _labelName + postfix) ), ) if "softElectronTagInfos" in btagInfo: setattr( process, btagInfo + _labelName + postfix, btag.softElectronTagInfos.clone(jets=cms.InputTag(_newJetCollection)), ) if "softMuonTagInfos" in btagInfo: setattr( process, btagInfo + _labelName + postfix, btag.softMuonTagInfos.clone(jets=cms.InputTag(_newJetCollection)), ) ## setup all required btagDiscriminators for btagDiscr in btagDiscriminators: setattr( process, btagDiscr + _labelName + postfix, getattr(btag, btagDiscr).clone( tagInfos=cms.VInputTag( *[cms.InputTag(x + _labelName + postfix) for x in supportedBtagDiscr[btagDiscr]] ) ), ) ## replace corresponding tags for pat jet production _newPatJets.tagInfoSources = cms.VInputTag(*[cms.InputTag(x + _labelName + postfix) for x in btagInfos]) _newPatJets.discriminatorSources = cms.VInputTag( *[cms.InputTag(x + _labelName + postfix) for x in btagDiscriminators] ) else: _newPatJets.addBTagInfo = False ## adjust output module; these collections will be empty anyhow, but we do it to stay clean for outputModule in outputModules: if hasattr(process, outputModule): getattr(process, outputModule).outputCommands.append( "drop *_" + "selected" + _labelName + postfix + "_tagInfos_*" ) ## add jet correction factors if required by user if jetCorrections != None: ## check for the correct format if type(jetCorrections) != type( ("PAYLOAD-LABEL", ["CORRECTION-LEVEL-A", "CORRECTION-LEVEL-B"], "MET-LABEL") ): raise ValueError, "In addJetCollection: 'jetCorrections' must be 'None' (as a python value w/o quotation marks), or of type ('PAYLOAD-LABEL', ['CORRECTION-LEVEL-A', \ 'CORRECTION-LEVEL-B', ...], 'MET-LABEL'). Note that 'MET-LABEL' can be set to 'None' (as a string in quotation marks) in case you do not want to apply MET(Type1) \ corrections." ## determine type of jet constituents from jetSource; supported ## jet constituent types are calo, pf, jpt, for pf also particleflow ## is aloowed as part of the jetSource label, which might be used ## in CommonTools.ParticleFlow _type = "NONE" if jetCorrections[0].count("PF") > 0: _type = "PF" elif jetCorrections[0].count("Calo") > 0: _type = "Calo" elif jetCorrections[0].count("JPT") > 0: _type = "JPT" else: raise TypeError, "In addJetCollection: Jet energy corrections are only supported for PF, JPT and Calo jets." from PhysicsTools.PatAlgos.recoLayer0.jetCorrFactors_cfi import patJetCorrFactors if "patJetCorrFactors" + _labelName + postfix in knownModules: _newPatJetCorrFactors = getattr(process, "patJetCorrFactors" + _labelName + postfix) _newPatJetCorrFactors.src = jetSource else: setattr(process, "patJetCorrFactors" + _labelName + postfix, patJetCorrFactors.clone(src=jetSource)) _newPatJetCorrFactors = getattr(process, "patJetCorrFactors" + _labelName + postfix) _newPatJetCorrFactors.payload = jetCorrections[0] _newPatJetCorrFactors.levels = jetCorrections[1] ## check whether L1Offset or L1FastJet is part of levels error = False for x in jetCorrections[1]: if x == "L1Offset": if not error: _newPatJetCorrFactors.useNPV = True _newPatJetCorrFactors.primaryVertices = "offlinePrimaryVertices" ## we set this to True now as a L1 correction type should appear only once ## otherwise levels is miss configured error = True else: raise ValueError, "In addJetCollection: Correction levels for jet energy corrections are miss configured. An L1 correction type should appear not more than \ once. Check the list of correction levels you requested to be applied: ", jetCorrections[ 1 ] if x == "L1FastJet": if not error: if _type == "JPT": raise TypeError, "In addJetCollection: L1FastJet corrections are only supported for PF and Calo jets." ## configure module _newPatJetCorrFactors.useRho = True _newPatJetCorrFactors.rho = cms.InputTag("kt6" + _type + "Jets", "rho") ## we set this to True now as a L1 correction type should appear only once ## otherwise levels is miss configured error = True else: raise ValueError, "In addJetCollection: Correction levels for jet energy corrections are miss configured. An L1 correction type should appear not more than \ once. Check the list of correction levels you requested to be applied: ", jetCorrections[ 1 ] _newPatJets.jetCorrFactorsSource = cms.VInputTag(cms.InputTag("patJetCorrFactors" + _labelName + postfix)) ## configure MET(Type1) corrections if jetCorrections[2].lower() != "none" and jetCorrections[2] != "": if not jetCorrections[2].lower() == "type-1" and not jetCorrections[2].lower() == "type-2": raise valueError, "In addJetCollection: Wrong choice of MET corrections for new jet collection. Possible choices are None (or empty string), Type-1, Type-2 (i.e.\ Type-1 and Type-2 corrections applied). This choice is not case sensitive. Your choice was: ", jetCorrections[ 2 ] if _type == "JPT": raise ValueError, 'In addJecCollection: MET(type1) corrections are not supported for JPTJets. Please set the MET-LABEL to "None" (as string in quatiation \ marks) and use raw tcMET together with JPTJets.' ## set up jet correctors for MET corrections from JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff import ak5PFL1Fastjet from JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff import ak5PFL1Offset from JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff import ak5PFL2Relative from JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff import ak5PFL3Absolute from JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff import ak5PFResidual setattr( process, jetCorrections[0] + "L1FastJet", ak5PFL1Fastjet.clone( algorithm=jetCorrections[0], srcRho=cms.InputTag("kt6" + _type + "Jets", "rho") ), ) setattr(process, jetCorrections[0] + "L1Offset", ak5PFL1Offset.clone(algorithm=jetCorrections[0])) setattr(process, jetCorrections[0] + "L2Relative", ak5PFL2Relative.clone(algorithm=jetCorrections[0])) setattr(process, jetCorrections[0] + "L3Absolute", ak5PFL3Absolute.clone(algorithm=jetCorrections[0])) setattr(process, jetCorrections[0] + "L2L3Residual", ak5PFResidual.clone(algorithm=jetCorrections[0])) setattr( process, jetCorrections[0] + "CombinedCorrector", cms.ESProducer("JetCorrectionESChain", correctors=cms.vstring()), ) for x in jetCorrections[1]: if ( x != "L1FastJet" and x != "L1Offset" and x != "L2Relative" and x != "L3Absolute" and x != "L2L3Residual" ): raise ValueError, "In addJetCollection: Unsupported JEC for MET(Type1). Currently supported jet correction levels are L1FastJet, L1Offset, L2Relative, \ L3Asolute, L2L3Residual. Requested was:", x else: getattr(process, jetCorrections[0] + "CombinedCorrector").correctors.append( jetCorrections[0] + x ) ## set up MET(Type1) correction modules if _type == "Calo": from JetMETCorrections.Type1MET.caloMETCorrections_cff import caloJetMETcorr from JetMETCorrections.Type1MET.caloMETCorrections_cff import caloType1CorrectedMet from JetMETCorrections.Type1MET.caloMETCorrections_cff import caloType1p2CorrectedMet setattr( process, jetCorrections[0] + "JetMETcorr" + postfix, caloJetMETcorr.clone( src=jetSource, srcMET="corMetGlobalMuons", jetCorrections=cms.string(jetCorrections[0] + "CombinedCorrector" + postfix), ), ) setattr( process, jetCorrections[0] + "Type1CorMet" + postfix, caloType1CorrectedMet.clone( src="corMetGlobalMuons" + postfix, srcType1Corrections=cms.VInputTag( cms.InputTag(jetCorrections[0] + "JetMETcorr" + postfix, "type1") ), ), ) setattr( process, jetCorrections[0] + "Type1p2CorMet" + postfix, caloType1p2CorrectedMet.clone( src="corMetGlobalMuons" + postfix, srcType1Corrections=cms.VInputTag( cms.InputTag(jetCorrections[0] + "JetMETcorr" + postfix, "type1") ), srcUnclEnergySums=cms.VInputTag( cms.InputTag(jetCorrections[0] + "JetMETcorr" + postfix, "type2"), cms.InputTag(jetCorrections[0] + "JetMETcorr" + postfix, "offset"), cms.InputTag("muonCaloMETcorr" + postfix), ), ), ) elif _type == "PF": from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfCandsNotInJet from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfJetMETcorr from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfCandMETcorr from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfType1CorrectedMet from JetMETCorrections.Type1MET.pfMETCorrections_cff import pfType1p2CorrectedMet setattr( process, jetCorrections[0] + "CandsNotInJet" + postfix, pfCandsNotInJet.clone(topCollection=jetSource), ) setattr( process, jetCorrections[0] + "CandMETcorr" + postfix, pfCandMETcorr.clone(src=cms.InputTag(jetCorrections[0] + "CandsNotInJet" + postfix)), ) setattr(process, jetCorrections[0] + "JetMETcorr" + postfix, pfJetMETcorr.clone(src=jetSource)) setattr( process, jetCorrections[0] + "Type1CorMet" + postfix, pfType1CorrectedMet.clone( srcType1Corrections=cms.VInputTag( cms.InputTag(jetCorrections[0] + "JetMETcorr" + postfix, "type1") ) ), ) setattr( process, jetCorrections[0] + "Type1p2CorMet" + postfix, pfType1p2CorrectedMet.clone( srcType1Corrections=cms.VInputTag( cms.InputTag(jetCorrections[0] + "JetMETcorr" + postfix, "type1") ), srcUnclEnergySums=cms.VInputTag( cms.InputTag(jetCorrections[0] + "JetMETcorr" + postfix, "type2"), cms.InputTag(jetCorrections[0] + "JetMETcorr" + postfix, "offset"), cms.InputTag(jetCorrections[0] + "CandMETcorr" + postfix), ), ), ) ## common configuration for Calo and PF if "L1FastJet" in jetCorrections[1] or "L1Fastjet" in jetCorrections[1]: getattr(process, jetCorrections[0] + "JetMETcorr" + postfix).offsetCorrLabel = cms.string( jetCorrections[0] + "L1FastJet" ) elif "L1Offset" in jetCorrections[1]: getattr(process, jetCorrections[0] + "JetMETcorr" + postfix).offsetCorrLabel = cms.string( jetCorrections[0] + "L1Offset" ) else: getattr(process, jetCorrections[0] + "JetMETcorr" + postfix).offsetCorrLabel = cms.string("") from PhysicsTools.PatAlgos.producersLayer1.metProducer_cfi import patMETs if jetCorrections[2].lower() == "type-1": setattr( process, "patMETs" + _labelName + postfix, patMETs.clone( metSource=cms.InputTag(jetCorrections[0] + "Type1CorMet" + postfix), addMuonCorrections=False, ), ) elif jetCorrections[2].lower() == "type-1": setattr( process, "patMETs" + _labelName + postfix, patMETs.clone( metSource=cms.InputTag(jetCorrections[0] + "Type1p2CorMet" + postfix), addMuonCorrections=False, ), ) else: ## switch jetCorrFactors off _newPatJets.addJetCorrFactors = False
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])
) process.patJetCorrFactorsReapplyJECAK8 = process.patJetCorrFactorsUpdated.clone( src = cms.InputTag("slimmedJetsAK8"), levels = ['L1FastJet','L2Relative','L3Absolute'], payload = 'AK4PFchs' ) process.load("PhysicsTools.PatAlgos.producersLayer1.jetUpdater_cff") process.patJetsReapplyJECAK8 = process.patJetsUpdated.clone( jetSource = cms.InputTag("slimmedJetsAK8"), jetCorrFactorsSource = cms.VInputTag(cms.InputTag("patJetCorrFactorsReapplyJECAK8")) ) from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.goodJets = selectedPatJets.clone(src='patJetsReapplyJEC',cut='pt>30 & abs(eta)<2.4') process.load('RecoJets.JetProducers.QGTagger_cfi') process.QGTagger.srcJets = cms.InputTag('goodJets') process.QGTagger.jetsLabel = cms.string('QGL_AK4PFchs') ##-------------------- User analyzer -------------------------------- process.hadtopBoost = cms.EDAnalyzer('BoostedTTbarFlatTreeProducer', jets = cms.InputTag('patJetsReapplyJECAK8'), muons = cms.InputTag('slimmedMuons'), electrons = cms.InputTag('slimmedElectrons'), met = cms.InputTag('slimmedMETs'), vertices = cms.InputTag('offlineSlimmedPrimaryVertices'), rho = cms.InputTag('fixedGridRhoFastjetAll'), massMin = cms.double(50), ptMin = cms.double(30),
doShift=cms.untracked.bool(True)) process.shiftedJetsDown = process.shiftedJetsUp.clone(shiftJES=-1.0) process.shiftedJetsAK8Up = cms.EDProducer( 'JetShiftProducer', jets=cms.InputTag('patJetsReapplyJECAK8'), rho=cms.InputTag('fixedGridRhoFastjetAll'), payload=cms.untracked.string('AK8PFchs'), shiftJES=cms.untracked.double(1.0), doShift=cms.untracked.bool(True)) process.shiftedJetsAK8Down = process.shiftedJetsAK8Up.clone(shiftJES=-1.0) #--- finally define the good jets ------------------------------- from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.goodJets = selectedPatJets.clone(src='patJetsReapplyJEC', cut='pt>30 & abs(eta)<2.4') process.goodSmearedJets = selectedPatJets.clone(src='smearedJets', cut='pt>30 & abs(eta)<2.4') process.goodSmearedJetsUp = selectedPatJets.clone(src='smearedJetsUp', cut='pt>30 & abs(eta)<2.4') process.goodSmearedJetsDown = selectedPatJets.clone(src='smearedJetsDown', cut='pt>30 & abs(eta)<2.4') process.goodShiftedJets = selectedPatJets.clone(src='shiftedJets', cut='pt>30 & abs(eta)<2.4') process.goodShiftedJetsUp = selectedPatJets.clone(src='shiftedJetsUp', cut='pt>30 & abs(eta)<2.4') process.goodShiftedJetsDown = selectedPatJets.clone(src='shiftedJetsDown', cut='pt>30 & abs(eta)<2.4') process.load('RecoJets.JetProducers.QGTagger_cfi') process.QGTagger.srcJets = cms.InputTag('goodJets')
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') process.GlobalTag.globaltag = '80X_dataRun2_2016SeptRepro_v7' ##-------------------- Define the source ---------------------------- process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(2000)) process.source = cms.Source("PoolSource", fileNames = cms.untracked.vstring( #"file:10B2302E-DA08-E611-884E-001E67DDD348.root") #"file:004A0552-3929-E611-BD44-0025905A48F0.root"), "file:00619786-8D7D-E711-9AB1-D4AE52A685A7.root"), ) ############# Format MessageLogger ################# process.load('FWCore.MessageService.MessageLogger_cfi') process.MessageLogger.cerr.FwkReport.reportEvery = 1000 from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets process.goodJets = selectedPatJets.clone(src='slimmedJets',cut='pt>30 & abs(eta)<2.4') process.load('RecoJets.JetProducers.QGTagger_cfi') process.QGTagger.srcJets = cms.InputTag('slimmedJets') process.QGTagger.jetsLabel = cms.string('QGL_AK4PFchs') from RecoJets.Configuration.RecoGenJets_cff import ak4GenJets, ak8GenJets genParticleCollection = 'prunedGenParticles' from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets from RecoJets.JetProducers.GenJetParameters_cfi import * process.ak8GenJetsCustom = ak4GenJets.clone( src = genParticleCollection, rParam = cms.double(0.8),
#______________________ Event-Selection _____________________________ from HLTrigger.HLTfilters.hltHighLevel_cfi import hltHighLevel hltFilter = hltHighLevel.clone( andOr=True, ## choose logical OR between Triggerbits HLTPaths=['HLT_ZeroBias'], throw=False # tolerate triggers stated above, but not available ) #______________________ Object-Selection ____________________________ from PhysicsTools.PatAlgos.selectionLayer1.jetSelector_cfi import selectedPatJets from PhysicsTools.PatAlgos.selectionLayer1.electronSelector_cfi import selectedPatElectrons from PhysicsTools.PatAlgos.selectionLayer1.muonSelector_cfi import selectedPatMuons from PhysicsTools.PatAlgos.selectionLayer1.tauSelector_cfi import selectedPatTaus patJetSelector = selectedPatJets.clone(filter=cms.bool(False), src="", cut="") patElectronSelector = selectedPatElectrons.clone(filter=cms.bool(False), src="", cut="") patMuonSelector = selectedPatMuons.clone(filter=cms.bool(False), src="", cut="") patTauSelector = selectedPatTaus.clone(filter=cms.bool(False), src="", cut="") candStringSelector = cms.EDFilter("CandViewSelector", filter=cms.bool(False), src=cms.InputTag(""), cut=cms.string(""))