def addFlashggPF(process): print "JET PRODUCER :: Flashgg PF producer ::" from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets process.ak4PFJets = ak4PFJets.clone (src = 'packedPFCandidates', doAreaFastjet = True) process.ak4GenJets = ak4GenJets.clone(src = 'packedGenParticles') ## cluster the jets addJetCollection( process, labelName = 'AK4PF', jetSource = cms.InputTag('ak4PFJets'), pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), pfCandidates = cms.InputTag('packedPFCandidates'), svSource = cms.InputTag('slimmedSecondaryVertices'), btagDiscriminators = [ flashggBTag ], jetCorrections = ('AK4PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'), genJetCollection = cms.InputTag('ak4GenJets'), genParticles = cms.InputTag('prunedGenParticles'), # jet param algo = 'AK', rParam = 0.4 ) ## adjust MC matching process.patJetGenJetMatchAK4PF.matched = "ak4GenJets" process.patJetPartonMatchAK4PF.matched = "prunedGenParticles" #process.patJetPartons.particles = "prunedGenParticles" #adjust PV used for Jet Corrections process.patJetCorrFactorsAK4PF.primaryVertices = "offlineSlimmedPrimaryVertices"
def addAK4Jets(process, addPAT=False): process.ak4PFJets = ak4PF.clone(src='packedPFCandidates') process.ak4PFJets.doAreaFastjet = cms.bool(True) if addPAT: addJetCollection( process, postfix = "", labelName = 'AK4PF', jetSource = cms.InputTag('ak4PFJets'), # trackSource = cms.InputTag('unpackedTracksAndVertices'), pvSource = cms.InputTag('unpackedTracksAndVertices'), jetCorrections = ('AK4PF', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'Type-2'), btagDiscriminators = ['combinedSecondaryVertexBJetTags'], algo = 'AK', rParam = 0.4 ) process.patJetGenJetMatchAK4PF.matched = "slimmedGenJets" process.patJetPartonMatchAK4PF.matched = "prunedGenParticles" process.patJetPartons.particles = "prunedGenParticles" process.patJetPartonsLegacy.src = "prunedGenParticles" process.patJetCorrFactorsAK4PF.primaryVertices = "offlineSlimmedPrimaryVertices" process.impactParameterTagInfosAK4PF.primaryVertex = cms.InputTag("unpackedTracksAndVertices") # process.inclusiveSecondaryVertexFinderTagInfosAK4PF.extSVCollection = cms.InputTag("unpackedTracksAndVertices","secondary","") # process.combinedSecondaryVertexBJetTagsAK4PF.trackMultiplicityMin = 1 process.jetTracksAssociatorAtVertexAK4PF.tracks = cms.InputTag("unpackedTracksAndVertices") process.pileupJetIdMET = pileupJetIdMET.clone() process.pileupJetIdFull = pileupJetIdFull.clone() process.patJetsAK4PF.userData.userFloats.src = [ cms.InputTag("pileupJetIdMET:met53xDiscriminant"), cms.InputTag("pileupJetIdFull:full53xDiscriminant")] process.jetSequenceAK4 = cms.Sequence( process.ak4PFJets + process.unpackedTracksAndVertices + process.jetTracksAssociatorAtVertexAK4PF + process.patJetCorrFactorsAK4PF + process.pileupJetIdMET + process.pileupJetIdFull + process.patJetChargeAK4PF + process.patJetPartons + process.patJetPartonMatchAK4PF + process.patJetGenJetMatchAK4PF + process.patJetFlavourAssociationAK4PF + process.patJetPartonsLegacy + process.patJetPartonAssociationLegacyAK4PF + process.patJetFlavourAssociationLegacyAK4PF + # process.inclusiveSecondaryVertexFinderTagInfosAK4PF + process.impactParameterTagInfosAK4PF + process.secondaryVertexTagInfosAK4PF + process.combinedSecondaryVertexBJetTagsAK4PF + process.patJetsAK4PF ) else: process.jetSequenceAK4 = cms.Sequence( process.ak4PFJets ) return process.jetSequenceAK4
def addFlashggPFCHSLegJets(process): #process.load("Configuration.StandardSequences.Geometry_cff") #process.myPrefer = cms.ESPrefer("CaloSubdetectorGeometry" [,"ZDC" # [,ZdcGeometryFromDBEP = cms.vstring("<C++ data type>[/<data label>]"[,...])] # ) # load various necessary plugins. process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff") process.load('PhysicsTools.PatAlgos.slimming.unpackedTracksAndVertices_cfi') # leptons to remove as per default CHS workflow process.selectedMuons = cms.EDFilter("CandPtrSelector", src = cms.InputTag("slimmedMuons"), cut = cms.string('''abs(eta)<2.5 && pt>10. && (pfIsolationR04().sumChargedHadronPt+ max(0.,pfIsolationR04().sumNeutralHadronEt+ pfIsolationR04().sumPhotonEt- 0.50*pfIsolationR04().sumPUPt))/pt < 0.20 && (isPFMuon && (isGlobalMuon || isTrackerMuon) )''')) process.selectedElectrons = cms.EDFilter("CandPtrSelector", src = cms.InputTag("slimmedElectrons"), cut = cms.string('''abs(eta)<2.5 && pt>20. && gsfTrack.isAvailable() && gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2 && (pfIsolationVariables().sumChargedHadronPt+ max(0.,pfIsolationVariables().sumNeutralHadronEt+ pfIsolationVariables().sumPhotonEt- 0.5*pfIsolationVariables().sumPUPt))/pt < 0.15''')) # Simple producer which just removes the Candidates which don't come from the legacy vertex according to the Flashgg Vertex Map process.flashggCHSLegacyVertexCandidates = cms.EDProducer('FlashggCHSLegacyVertexCandidateProducer', PFCandidatesTag=cms.untracked.InputTag('packedPFCandidates'), DiPhotonTag=cms.untracked.InputTag('flashggDiPhotons'), VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"), VertexTag=cms.untracked.InputTag('offlineSlimmedPrimaryVertices') ) process.pfCHSLeg = cms.EDFilter("CandPtrSelector", src = cms.InputTag("flashggCHSLegacyVertexCandidates"), cut = cms.string("")) # then remove the previously selected muons process.pfNoMuonCHSLeg = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfCHSLeg"), veto = cms.InputTag("selectedMuons")) # then remove the previously selected electrons process.pfNoElectronsCHSLeg = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfNoMuonCHSLeg"), veto = cms.InputTag("selectedElectrons")) #Import RECO jet producer for ak4 PF and GEN jet from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets process.ak4PFJetsCHSLeg = ak4PFJets.clone(src = 'pfNoElectronsCHSLeg', doAreaFastjet = True) process.ak4GenJetsLeg = ak4GenJets.clone(src = 'packedGenParticles') # cluster the jets addJetCollection( process, postfix = "", labelName = 'AK4PFCHSLeg', pfCandidates = cms.InputTag('packedPFCandidates'), jetSource = cms.InputTag('ak4PFJetsCHSLeg'), #trackSource = cms.InputTag('unpackedTracksAndVertices'), pvSource = cms.InputTag('unpackedTracksAndVertices'), jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'), #btagDiscriminators = [ 'combinedSecondaryVertexBJetTags' ] btagDiscriminators = [ 'pfJetProbabilityBJetTags' ] ,algo= 'AK', rParam = 0.4 ) # adjust MC matching process.patJetGenJetMatchAK4PFCHSLeg.matched = "ak4GenJetsLeg" process.patJetPartonMatchAK4PFCHSLeg.matched = "prunedGenParticles" process.patJetPartons.particles = "prunedGenParticles" # adjust PV collection used for Jet Corrections process.patJetCorrFactorsAK4PFCHSLeg.primaryVertices = "offlineSlimmedPrimaryVertices"
def addFlashggPF(process, doQGTagging = True, label ='', debug = False): from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets # process.ak4PFJets = ak4PFJets.clone (src = 'packedPFCandidates', doAreaFastjet = True) setattr(process, 'ak4PFJets' + label, ak4PFJets.clone (src = 'packedPFCandidates', doAreaFastjet = True)) # cluster the jets addJetCollection( process, postfix = label, labelName = 'AK4PF' , jetSource = cms.InputTag('ak4PFJets'+label), pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), pfCandidates = cms.InputTag('packedPFCandidates'), svSource = cms.InputTag('slimmedSecondaryVertices'), elSource = cms.InputTag("slimmedElectrons"), muSource = cms.InputTag("slimmedMuons"), runIVF = True, btagDiscriminators = [ flashggBTag, flashggCMVABTag , flashggDeepCSVb, flashggDeepCSVbb, flashggDeepCSVc, flashggDeepCSVudsg, ], jetCorrections = ('AK4PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'), genJetCollection = cms.InputTag('slimmedGenJets'), genParticles = cms.InputTag('prunedGenParticles'), algo = 'AK', rParam = 0.4 ) # adjust PV used for Jet Corrections # getattr(process, 'patJetCorrFactors'+_labelName+label) getattr(process, 'patJetCorrFactorsAK4PF' + label).primaryVertices = "offlineSlimmedPrimaryVertices" #process.patJetCorrFactorsAK4PF.primaryVertices = "offlineSlimmedPrimaryVertices" print ' --> patJetCorrFactorsAK4PF == ', getattr(process, 'patJetCorrFactorsAK4PF' + label) print ' --> patJetsAK4PF == ', getattr(process, 'patJetsAK4PF' + label) flashggJetsPF = cms.EDProducer('FlashggJetProducer', DiPhotonTag=cms.InputTag('flashggDiPhotons'), VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'), JetTag=cms.InputTag('patJetsAK4PF' + label ), VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"), # PileupJetIdParameters=cms.PSet(pu_jetid), ) setattr(process, 'flashggJetsPF' + label, flashggJetsPF) if doQGTagging: from RecoJets.JetProducers.QGTagger_cfi import QGTagger setattr(process, 'QGTaggerPF' + label, QGTagger.clone( srcJets = 'flashggJetsPF' + label ,jetsLabel = 'QGL_AK4PF')) return getattr(process, 'flashggJetsPF' + label)
rho=cms.InputTag('hiFJRhoProducer', 'mapToRho'), rhom=cms.InputTag('hiFJRhoProducer', 'mapToRhoM'), csRParam=cms.double(-1.), csAlpha=cms.double(2.), writeJetsWithConst=cms.bool(True), jetCollInstanceName=cms.string("pfParticlesCs")) akCs4PFJets.jetPtMin = cms.double(0.0) akCs4PFJets.doAreaFastjet = cms.bool(True) akCs4PFJets.useExplicitGhosts = cms.bool(True) akCs4PFJets.GhostArea = cms.double(0.005) # legacy pu subtraction akULPu4PFJets = akPu4PFJets.clone(minimumTowersFraction=cms.double(0.0)) # jets for deriving jec ak4PFJECJets = ak4PFJets.clone(doSubEvent=cms.bool(True)) akPu4PFJECJets = akPu4PFJets.clone(doSubEvent=cms.bool(True)) akCs4PFJECJets = akCs4PFJets.clone(doSubEvent=cms.bool(True)) # jets for legacy hi reco: using unlinked particle flow objects ak4HIPFJets = ak4PFJets.clone(src='particleFlowTmp') akPu4HIPFJets = akPu4PFJets.clone(src='particleFlowTmp') akCs4HIPFJets = cms.EDProducer("CSJetProducer", PFJetParameters, AnomalousCellParameters, jetAlgorithm=cms.string("AntiKt"), rParam=cms.double(0.4),
dataTier=cms.untracked.string('')), dropMetaData=cms.untracked.string('ALL'), fastCloning=cms.untracked.bool(False), overrideInputFileSplitLevels=cms.untracked.bool(True)) if options.reclusterTrackJets: process.MessageLogger.destinations = [ 'cerr' ] # temporarily avoid a lot of printouts process.MessageLogger.cerr.threshold = cms.untracked.string( 'ERROR') # temporarily avoid a lot of printouts process.pfChargedCHS = cms.EDFilter("CandPtrSelector", src=cms.InputTag("packedPFCandidates"), cut=cms.string("fromPV && charge!=0")) from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.ak4PFChargedJetsCHS = ak4PFJets.clone(src='pfChargedCHS', doAreaFastjet=True) from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection addJetCollection(process, postfix="", labelName='AK4ChargedPFCHS', jetSource=cms.InputTag('ak4PFChargedJetsCHS'), pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'), pfCandidates=cms.InputTag('packedPFCandidates'), svSource=cms.InputTag('slimmedSecondaryVertices'), btagDiscriminators=['None'], jetCorrections=('AK4PFchs', [], 'None'), genJetCollection=cms.InputTag('slimmedGenJets'), genParticles=cms.InputTag('prunedGenParticles'), algo='AK', rParam=0.4) process.MessageLogger.cerr.FwkReport.reportEvery = 1000
def reclusterZinv(self, process, cleanedCandidates, suff): # skip all jet smearing for data from TreeMaker.TreeMaker.JetDepot import JetDepot doJERsmearing = self.geninfo ### AK8 detour # https://twiki.cern.ch/CMS/JetToolbox from JMEAnalysis.JetToolbox.jetToolbox_cff import jetToolbox listBTagInfos = ['pfInclusiveSecondaryVertexFinderTagInfos','pfImpactParameterTagInfos'] listBtagDiscriminatorsAK8 = [ 'pfBoostedDoubleSecondaryVertexAK8BJetTags', ] listBtagDiscriminatorsSubjetAK8 = [ 'pfCombinedInclusiveSecondaryVertexV2BJetTags', ] jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute'] if self.residual: jecLevels.append("L2L3Residual") jetToolbox(process, 'ak8', 'jetSequence', 'out', PUMethod = 'Puppi', miniAOD = True, runOnMC = self.geninfo, postFix='Clean', newPFCollection = True, nameNewPFCollection = cleanedCandidates.value(), Cut = 'pt>170.', addPruning = True, addSoftDropSubjets = True, addNsub = True, maxTau = 3, bTagInfos = listBTagInfos, bTagDiscriminators = listBtagDiscriminatorsAK8, subjetBTagDiscriminators = listBtagDiscriminatorsSubjetAK8, JETCorrLevels = jecLevels, subJETCorrLevels = jecLevels, addEnergyCorrFunc = False, associateTask = False, verbosity = 2 if self.verbose else 0, ) JetAK8CleanTag = cms.InputTag("packedPatJetsAK8PFPuppiCleanSoftDrop") if doJERsmearing: # do central smearing and replace jet tag process, _, JetAK8CleanTag = JetDepot(process, JetTag=JetAK8CleanTag, jecUncDir=0, doSmear=doJERsmearing, jerUncDir=0, storeJer=2, ) # get puppi-specific multiplicities from PhysicsTools.PatAlgos.patPuppiJetSpecificProducer_cfi import patPuppiJetSpecificProducer process.puppiSpecificAK8Clean = patPuppiJetSpecificProducer.clone( src = JetAK8CleanTag ) # update userfloats (used for jet ID, including ID for JEC/JER variations) from TreeMaker.TreeMaker.addJetInfo import addJetInfo process, JetAK8CleanTag = addJetInfo(process, JetAK8CleanTag, ['puppiSpecificAK8Clean:puppiMultiplicity','puppiSpecificAK8Clean:neutralPuppiMultiplicity','puppiSpecificAK8Clean:neutralHadronPuppiMultiplicity', 'puppiSpecificAK8Clean:photonPuppiMultiplicity','puppiSpecificAK8Clean:HFHadronPuppiMultiplicity','puppiSpecificAK8Clean:HFEMPuppiMultiplicity']) process = self.makeJetVarsAK8(process, JetTag=JetAK8CleanTag, suff='AK8Clean', storeProperties=1, doECFs=False, # currently disabled doDeepAK8=False, # currently disabled doDeepDoubleB=False, # currently disabled puppiSpecific="puppiSpecificAK8Clean", ) # update some userfloat names process.JetPropertiesAK8Clean.prunedMass = cms.vstring('ak8PFJetsPuppiCleanPrunedMass') process.JetPropertiesAK8Clean.softDropMass = cms.vstring('SoftDrop') process.JetPropertiesAK8Clean.NsubjettinessTau1 = cms.vstring('NjettinessAK8PuppiClean:tau1') process.JetPropertiesAK8Clean.NsubjettinessTau2 = cms.vstring('NjettinessAK8PuppiClean:tau2') process.JetPropertiesAK8Clean.NsubjettinessTau3 = cms.vstring('NjettinessAK8PuppiClean:tau3') process.JetPropertiesAK8Clean.subjets = cms.vstring('SoftDrop') process.JetPropertiesAK8Clean.SJbDiscriminatorCSV = cms.vstring('SoftDrop','pfCombinedInclusiveSecondaryVertexV2BJetTags') process.JetPropertiesAK8Clean.neutralHadronPuppiMultiplicity = cms.vstring("puppiSpecificAK8Clean:neutralHadronPuppiMultiplicity") process.JetPropertiesAK8Clean.neutralPuppiMultiplicity = cms.vstring("puppiSpecificAK8Clean:neutralPuppiMultiplicity") process.JetPropertiesAK8Clean.photonPuppiMultiplicity = cms.vstring("puppiSpecificAK8Clean:photonPuppiMultiplicity") # process.JetPropertiesAK8Clean.ecfN2b1 = cms.vstring('ak8PFJetsPuppiCleanSoftDropValueMap:nb1AK8PuppiCleanSoftDropN2') # process.JetPropertiesAK8Clean.ecfN3b1 = cms.vstring('ak8PFJetsPuppiCleanSoftDropValueMap:nb1AK8PuppiCleanSoftDropN3') # process.JetPropertiesAK8Clean.ecfN2b2 = cms.vstring('ak8PFJetsPuppiCleanSoftDropValueMap:nb2AK8PuppiCleanSoftDropN2') # process.JetPropertiesAK8Clean.ecfN3b2 = cms.vstring('ak8PFJetsPuppiCleanSoftDropValueMap:nb2AK8PuppiCleanSoftDropN3') ### end AK8 detour # do CHS for jet clustering cleanedCandidatesCHS = cms.EDFilter("CandPtrSelector", src = cleanedCandidates, cut = cms.string("fromPV") ) setattr(process,"cleanedCandidatesCHS"+suff,cleanedCandidatesCHS) # make the RECO jets from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets ak4PFJetsClean = ak4PFJets.clone( src = cms.InputTag("cleanedCandidatesCHS"+suff), doAreaFastjet = True ) setattr(process,"ak4PFJetsClean"+suff,ak4PFJetsClean) # turn the RECO jets into PAT jets # for a full list & description of parameters see: # PhysicsTools/PatAlgos/python/tools/jetTools.py from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute'] if self.residual: jecLevels.append("L2L3Residual") btagDiscs = ['pfCombinedInclusiveSecondaryVertexV2BJetTags','pfDeepCSVDiscriminatorsJetTags:BvsAll'] addJetCollection( process, labelName = 'AK4PFCLEAN'+suff, jetSource = cms.InputTag('ak4PFJetsClean'+suff), pfCandidates = cleanedCandidates, pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), svSource = cms.InputTag('slimmedSecondaryVertices'), algo = 'AK', rParam = 0.4, getJetMCFlavour = True, # seems to be enough for hadronFlavour() #genJetCollection = cms.InputTag('slimmedGenJets'), genParticles = cms.InputTag('prunedGenParticles'), # likely needed for hadronFlavour().... jetCorrections = ('AK4PFchs', jecLevels, 'None'), btagDiscriminators = btagDiscs, muSource = cms.InputTag("slimmedMuons"), elSource = cms.InputTag("slimmedElectrons") ) # turn on/off GEN matching getattr(process,'patJetsAK4PFCLEAN'+suff).addGenPartonMatch = cms.bool(False) getattr(process,'patJetsAK4PFCLEAN'+suff).addGenJetMatch = cms.bool(False) # turn off some flags for data getattr(process,'patJetsAK4PFCLEAN'+suff).addJetFlavourInfo = cms.bool(self.geninfo) getattr(process,'patJetsAK4PFCLEAN'+suff).getJetMCFlavour = cms.bool(self.geninfo) # apply pt cut to final jet collection (done in slimmedJets) reclusteredJets = cms.EDFilter("PATJetSelector", src = cms.InputTag("patJetsAK4PFCLEAN"+suff), cut = cms.string("pt>10.") ) setattr(process,'reclusteredJets'+suff,reclusteredJets) JetTagClean = cms.InputTag("reclusteredJets"+suff) # recalculate MET from cleaned candidates and reclustered jets postfix="clean"+suff from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD runMetCorAndUncFromMiniAOD( process, isData=not self.geninfo, # controls gen met jetCollUnskimmed='patJetsAK4PFCLEAN'+suff, pfCandColl=cleanedCandidates.value(), recoMetFromPFCs=True, # to recompute reclusterJets=False, # without reclustering reapplyJEC=False, fixEE2017=self.doMETfix, postfix=postfix, ) METTag = cms.InputTag('slimmedMETs'+postfix) if self.doMETfix: runMetCorAndUncFromMiniAOD( process, isData=not self.geninfo, # controls gen met jetCollUnskimmed='patJetsAK4PFCLEAN'+suff, pfCandColl=cleanedCandidates.value(), recoMetFromPFCs=True, # to recompute reclusterJets=False, # without reclustering reapplyJEC=False, postfix=postfix+'Orig', computeMETSignificance=False, ) METTagOrig = cms.InputTag('slimmedMETs'+postfix+'Orig') else: METTagOrig = None # isolated tracks from TreeMaker.Utils.trackIsolationMaker_cfi import trackIsolationFilter IsolatedElectronTracksVetoClean = trackIsolationFilter.clone( doTrkIsoVeto = False, vertexInputTag = cms.InputTag("goodVertices"), pfCandidatesTag = cleanedCandidates, dR_ConeSize = cms.double(0.3), dz_CutValue = cms.double(0.1), minPt_PFCandidate = cms.double(5.0), isoCut = cms.double(0.2), pdgId = cms.int32(11), mTCut = cms.double(100.), METTag = METTag, ) setattr(process,"IsolatedElectronTracksVetoClean"+suff,IsolatedElectronTracksVetoClean) IsolatedMuonTracksVetoClean = trackIsolationFilter.clone( doTrkIsoVeto = False, vertexInputTag = cms.InputTag("goodVertices"), pfCandidatesTag = cleanedCandidates, dR_ConeSize = cms.double(0.3), dz_CutValue = cms.double(0.1), minPt_PFCandidate = cms.double(5.0), isoCut = cms.double(0.2), pdgId = cms.int32(13), mTCut = cms.double(100.), METTag = METTag, ) setattr(process,"IsolatedMuonTracksVetoClean"+suff,IsolatedMuonTracksVetoClean) IsolatedPionTracksVetoClean = trackIsolationFilter.clone( doTrkIsoVeto = False, vertexInputTag = cms.InputTag("goodVertices"), pfCandidatesTag = cleanedCandidates, dR_ConeSize = cms.double(0.3), dz_CutValue = cms.double(0.1), minPt_PFCandidate = cms.double(10.0), isoCut = cms.double(0.1), pdgId = cms.int32(211), mTCut = cms.double(100.), METTag = METTag, ) setattr(process,"IsolatedPionTracksVetoClean"+suff,IsolatedPionTracksVetoClean) self.VarsInt.extend(['IsolatedElectronTracksVetoClean'+suff+':isoTracks(isoElectronTracksclean'+suff+')']) self.VarsInt.extend(['IsolatedMuonTracksVetoClean'+suff+':isoTracks(isoMuonTracksclean'+suff+')']) self.VarsInt.extend(['IsolatedPionTracksVetoClean'+suff+':isoTracks(isoPionTracksclean'+suff+')']) if doJERsmearing: # do central smearing and replace jet tag process, _, JetTagClean = JetDepot(process, JetTag=JetTagClean, jecUncDir=0, doSmear=doJERsmearing, jerUncDir=0, storeJer=2, ) # make the event variables process = self.makeJetVars( process, JetTag = JetTagClean, suff=postfix, storeProperties=1, METfix=self.doMETfix, ) from TreeMaker.Utils.metdouble_cfi import metdouble METclean = metdouble.clone( METTag = METTag, JetTag = cms.InputTag('HTJets'+postfix) ) setattr(process,"METclean"+suff,METclean) self.VarsDouble.extend(['METclean'+suff+':Pt(METclean'+suff+')','METclean'+suff+':Phi(METPhiclean'+suff+')','METclean'+suff+':Significance(METSignificanceclean'+suff+')']) # self.VarsDouble.extend(['METclean'+suff+':RawPt(RawMETclean'+suff+')','METclean'+suff+':RawPhi(RawMETPhiclean'+suff+')']) if self.doMETfix: METcleanOrig = METclean.clone( METTag = METTagOrig ) setattr(process,"METclean"+suff+"Orig",METcleanOrig) self.VarsDouble.extend(['METclean'+suff+'Orig:Pt(METclean'+suff+'Orig)','METclean'+suff+'Orig:Phi(METPhiclean'+suff+'Orig)']) # self.VarsDouble.extend(['METclean'+suff+'Orig:RawPt(RawMETclean'+suff+'Orig)','METclean'+suff+'Orig:RawPhi(RawMETPhiclean'+suff+'Orig)']) return process
src = cms.InputTag("packedGenParticlesForJetsNoNu"), usePruning = cms.bool(True), writeCompound = cms.bool(True), jetCollInstanceName=cms.string("SubJets") ) ## Select charged hadron subtracted packed PF candidates process.pfCHS = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV")) from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets ## Fat PFJets from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.ak8PFJetsCHS = ak4PFJets.clone( rParam = cms.double(0.8), src = cms.InputTag("pfCHS"), doAreaFastjet = cms.bool(True), jetPtMin = cms.double(100.) ) process.ak8PFJetsCHSConstituents = cms.EDFilter("MiniAODJetConstituentSelector", src = cms.InputTag("ak8PFJetsCHS"), cut = cms.string("pt > 100.0") ) ## Pruned fat PFJets (two jet collections are produced, fat jets and subjets) from RecoJets.JetProducers.ak5PFJetsPruned_cfi import ak5PFJetsPruned process.ak8PFJetsCHSPruned = ak5PFJetsPruned.clone( rParam = cms.double(0.8), src = cms.InputTag("ak8PFJetsCHSConstituents", "constituents"), doAreaFastjet = cms.bool(True), writeCompound = cms.bool(True),
applyJec = cms.bool(True), jetids = cms.InputTag("pileupJetIdCalculator"), rho = cms.InputTag("fixedGridRhoFastjetAll"), jets = cms.InputTag("calibratedAK4PFJetsForPFMVAMEt"), runMvas = cms.bool(True) ) process.mvaMetSequence = cms.Sequence(process.leptonPreSelectionSequence + process.ak4PFJets + process.calibratedAK4PFJetsForPFMVAMEt + process.puJetIdForPFMVAMEt + process.mvaMETDiTau + process.mvaMETTauMu + process.mvaMETTauEle + process.mvaMETMuEle + process.mvaMETMuMu + process.mvaMETEleEle) else: from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.chs = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV")) process.ak4PFJetsCHS = ak4PFJets.clone(src = 'chs', doAreaFastjet = True) process.load("JetMETCorrections.Configuration.DefaultJEC_cff") if runOnData: process.calibratedAK4PFJetsCHSForPFMVAMEt = cms.EDProducer("PFJetCorrectionProducer", src = cms.InputTag("ak4PFJetsCHS"), correctors = cms.vstring('ak4PFCHSL1FastL2L3Residual') ) else: process.calibratedAK4PFJetsCHSForPFMVAMEt = cms.EDProducer("PFJetCorrectionProducer", src = cms.InputTag("ak4PFJetsCHS"), correctors = cms.vstring('ak4PFCHSL1FastL2L3') ) from RecoJets.JetProducers.PileupJetID_cfi import pileupJetId
#TFileService for output process.TFileService = cms.Service("TFileService", fileName = cms.string("razor_11_11_Calo_TTbar_Lepton.root"), closeFileFast = cms.untracked.bool(True) ) #get global tag from Configuration.AlCa.GlobalTag_condDBv2 import GlobalTag process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc_GRun', '') #create AK4 charged-hadron subtracted jets process.load("CommonTools.ParticleFlow.pfNoPileUpJME_cff") from RecoJets.Configuration.RecoPFJets_cff import ak4PFJetsCHS from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.ak4PFJets = ak4PFJets.clone() process.ak4PFJetsCHS = ak4PFJets.clone(src = 'pfNoPileUpJME', doAreaFastjet = True) #declare analyzer module process.razorTriggerAnalysis = cms.EDAnalyzer("RazorTriggerAnalyzer", trigSummary = cms.InputTag("hltTriggerSummaryAOD"), pfMETCollection = cms.InputTag("pfMet"), pfJetCollection = cms.InputTag("ak4PFJetsCHS"), TriggerResults = cms.InputTag('TriggerResults','','reHLT'), TriggerPath = cms.string('HLT_RsqMR300_Rsq0p09_MR200_v1'), TriggerFilter = cms.InputTag('hltRsqMR300Rsq0p09MR200', '', 'reHLT'), #the last filter in the path #CaloFilter = cms.InputTag('hltRsqMRNoMinRsqNoMinMRNoMinCalo', '', 'reHLT'), #filter implementing cuts on calo MR and Rsq CaloFilter = cms.InputTag('hltRsqMR200Rsq0p01MR100Calo', '', 'reHLT'), #filter implementing cuts on calo MR and Rsq hemispheres = cms.InputTag('hemispheres') )
# now add to the preSequence preSeq += process.makePatMetPuppi preSeq += process.myPuppiJetSequence process.skimEventProducer.pupMetTag = cms.InputTag("patMetPuppi") # the name selectedPatJetsAK4PFPuppi found looking at the "processDump.py" and looking for patjetproducer process.skimEventProducer.secondJetTag = cms.InputTag("selectedPatJetsAK4PFPuppi") #process.skimEventProducer.secondJetTag = cms.InputTag("patJetsAK4selectedPatJetsPuppi") if options.doSoftActivity: # Add trackjets process.chargedPackedPFCandidates = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("charge != 0 && abs(eta) < 2.5 && pt > 0.3 && fromPV >= 2")) from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.ak4TrackJets = ak4PFJets.clone(src = cms.InputTag('chargedPackedPFCandidates'), jetPtMin = cms.double(1.0)) process.trackJetSequence = cms.Sequence(process.chargedPackedPFCandidates * process.ak4TrackJets) preSeq += process.trackJetSequence # Make pat track-jets from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection addJetCollection( process, labelName = 'AK4PFTrack', jetSource = cms.InputTag('ak4TrackJets'), algo = 'AK', rParam = 0.4, jetCorrections = None, pfCandidates = cms.InputTag( 'packedPFCandidates' ),
process.load('CommonTools/PileupAlgos/PhotonPuppi_cff') process.puppiPhoton.weightsName = 'puppiNoLep' process.puppiForMET = cms.EDProducer("CandViewMerger", src=cms.VInputTag('puppiPhoton')) process.puppiSequence += process.puppi process.puppiSequence += process.puppiNoLep process.puppiSequence += process.puppiPhoton process.puppiSequence += process.puppiForMET # recompute ak4 jets from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets from PhysicsTools.PatAlgos.tools.pfTools import * process.ak4PFJetsPuppi = ak4PFJets.clone(src=cms.InputTag('puppiNoLep')) process.puppiJetMETSequence += process.ak4PFJetsPuppi if not isData: process.packedGenParticlesForJetsNoNu = cms.EDFilter( "CandPtrSelector", src=cms.InputTag("packedGenParticles"), cut=cms.string( "abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16")) process.ak4GenJetsNoNu = ak4GenJets.clone( src='packedGenParticlesForJetsNoNu') process.puppiJetMETSequence += process.packedGenParticlesForJetsNoNu process.puppiJetMETSequence += process.ak4GenJetsNoNu # btag and patify jets for access later addJetCollection( process,
import FWCore.ParameterSet.Config as cms from RecoJets.JetProducers.PFJetParameters_cfi import * from RecoJets.JetProducers.AnomalousCellParameters_cfi import * from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets from RecoJets.JetProducers.ak5PFJetsTrimmed_cfi import ak5PFJetsTrimmed from RecoJets.JetProducers.ak5PFJetsFiltered_cfi import ak5PFJetsFiltered, ak5PFJetsMassDropFiltered from RecoJets.JetProducers.ak5PFJetsPruned_cfi import ak5PFJetsPruned from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters ak8PFJetsCS = ak4PFJets.clone( rParam=cms.double(0.8), useConstituentSubtraction=cms.bool(True), csRParam=cms.double(0.4), csRho_EtaMax=ak4PFJets. Rho_EtaMax, # Just use the same eta for both C.S. and rho by default useExplicitGhosts=cms.bool(True), doAreaFastjet=cms.bool(True), jetPtMin=cms.double(100.0)) ak8PFJetsCSConstituents = cms.EDProducer("PFJetConstituentSelector", src=cms.InputTag("ak8PFJetsCS"), cut=cms.string("pt > 100.0")) ak8PFJetsCSPruned = ak5PFJetsPruned.clone(rParam=0.8, jetPtMin=15.0, src=cms.InputTag( "ak8PFJetsCSConstituents", "constituents")) ak8PFJetsCSTrimmed = ak5PFJetsTrimmed.clone(rParam=0.8,
def initFatJets(process, isData): adaptPVs(process, pvCollection=cms.InputTag('offlineSlimmedPrimaryVertices')) isMC = not isData ######################################## ## INITIAL SETUP ## ######################################## jetCorrectionsAK4 = ('AK4PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None') jetCorrectionsAK8 = ('AK8PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None') if isData: jetCorrectionsAK4[1].append('L2L3Residual') jetCorrectionsAK8[1].append('L2L3Residual') ## Various collection names genParticles = 'prunedGenParticles' jetSource = 'ak4PFJets' genJetCollection = 'ak4GenJetsNoNu' pfCandidates = 'packedPFCandidates' pvSource = 'offlineSlimmedPrimaryVertices' svSource = 'slimmedSecondaryVertices' muSource = 'slimmedMuons' elSource = 'slimmedElectrons' PFjetAlgo = "AK4" ## Load standard PAT objects process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff") process.load( "PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff") bTagInfos = [ 'pfImpactParameterTagInfos', 'pfSecondaryVertexTagInfos', 'pfInclusiveSecondaryVertexFinderTagInfos', 'softPFMuonsTagInfos', 'softPFElectronsTagInfos' ] ## b-tag discriminators bTagDiscriminators = [ 'pfCombinedSecondaryVertexV2BJetTags', 'pfCombinedInclusiveSecondaryVertexV2BJetTags' ] process.pfCHS = cms.EDFilter("CandPtrSelector", src=cms.InputTag("packedPFCandidates"), cut=cms.string("fromPV")) if isMC: process.packedGenParticlesForJetsNoNu = cms.EDFilter( "CandPtrSelector", src=cms.InputTag("packedGenParticles"), cut=cms.string( "abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16")) process.ak4GenJetsNoNu = ak4GenJets.clone( src='packedGenParticlesForJetsNoNu') process.ak4PFJets = ak4PFJets.clone(src='pfCHS', doAreaFastjet=True) postfix = 'PFlow' ## Switch the default jet collection (done in order to use the above specified b-tag infos and discriminators) switchJetCollection(process, jetSource=cms.InputTag(jetSource), pfCandidates=cms.InputTag(pfCandidates), pvSource=cms.InputTag(pvSource), svSource=cms.InputTag(svSource), muSource=cms.InputTag(muSource), elSource=cms.InputTag(elSource), btagInfos=bTagInfos, btagDiscriminators=bTagDiscriminators, jetCorrections=jetCorrectionsAK4, genJetCollection=cms.InputTag(genJetCollection), genParticles=cms.InputTag(genParticles), postfix=postfix) if isMC: process.fatjetInitSequence = cms.Sequence( process.packedGenParticlesForJetsNoNu + process.ak4GenJetsNoNu) else: process.fatjetInitSequence = cms.Sequence() process.fatjetInitSequence += process.pfCHS process.fatjetInitSequence += process.ak4PFJets return process.fatjetInitSequence
def makeFatJets(process, isData, pfCandidates, algoLabel, jetRadius): isMC = not isData postfix = 'PFlow' if pfCandidates == 'particleFlow': # mini aod needs a different config pfCandidates = 'pfCHS' if pfCandidates == 'pfCHS': puMethod = 'CHS' else: puMethod = 'Puppi' rLabel = algoLabel + str(int(jetRadius * 10)) neroLabel = rLabel + puMethod if algoLabel == 'CA': jetAlgo = 'CambridgeAachen' else: jetAlgo = 'AntiKt' if jetRadius < 1: sdZcut = 0.1 sdBeta = 0.0 else: sdZcut = 0.2 sdBeta = 1.0 setattr(process, neroLabel + 'Sequence', cms.Sequence()) newSeq = getattr(process, neroLabel + 'Sequence') ## Various collection names genParticles = 'prunedGenParticles' pvSource = 'offlineSlimmedPrimaryVertices' svSource = 'slimmedSecondaryVertices' muSource = 'slimmedMuons' elSource = 'slimmedElectrons' bTagInfos = [ 'pfImpactParameterTagInfos', 'pfSecondaryVertexTagInfos', 'pfInclusiveSecondaryVertexFinderTagInfos', 'softPFMuonsTagInfos', 'softPFElectronsTagInfos' ] ## b-tag discriminators bTagDiscriminators = [ 'pfCombinedSecondaryVertexV2BJetTags', 'pfCombinedInclusiveSecondaryVertexV2BJetTags' ] bTagInfosSubjets = [ 'pfImpactParameterTagInfos', 'pfSecondaryVertexTagInfos', 'pfInclusiveSecondaryVertexFinderTagInfos', 'softPFMuonsTagInfos', 'softPFElectronsTagInfos' ] ## b-tag discriminators bTagDiscriminatorsSubjets = [ 'pfCombinedSecondaryVertexV2BJetTags', 'pfCombinedInclusiveSecondaryVertexV2BJetTags' ] bTagInfosSubjets = ['None'] bTagDiscriminatorsSubjets = ['None'] ### jet clustering ### ######################################## ## REMAKE JETS ## ######################################## addingGenJets = False if not (hasattr(process, "genJetsNoNu" + rLabel)) and isMC: addingGenJets = True setattr( process, "genJetsNoNu" + rLabel, ak4GenJets.clone( jetAlgorithm=cms.string(jetAlgo), rParam=cms.double(jetRadius), src=cms.InputTag("packedGenParticlesForJetsNoNu"))) setattr( process, "PFJets" + neroLabel, ak4PFJets.clone(jetAlgorithm=cms.string(jetAlgo), rParam=cms.double(jetRadius), src=cms.InputTag(pfCandidates), srcPVs=cms.InputTag(pvSource), doAreaFastjet=cms.bool(True), jetPtMin=cms.double(150))) if not (hasattr(process, "genJetsNoNuSoftDrop" + rLabel)) and isMC: addingGenJets = True setattr( process, "genJetsNoNuSoftDrop" + rLabel, getattr(process, 'genJetsNoNu' + rLabel).clone( R0=cms.double(jetRadius), useSoftDrop=cms.bool(True), zcut=cms.double(sdZcut), beta=cms.double(sdBeta), writeCompound=cms.bool(True), jetCollInstanceName=cms.string("SubJets"))) setattr( process, "PFJets" + "SoftDrop" + neroLabel, getattr(process, 'PFJets' + neroLabel).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"), jetPtMin=cms.double(150))) if addingGenJets and not (isData): newSeq += getattr(process, 'genJetsNoNu' + rLabel) newSeq += getattr(process, 'genJetsNoNuSoftDrop' + rLabel) newSeq += getattr(process, 'PFJets' + neroLabel) newSeq += getattr(process, 'PFJets' + "SoftDrop" + neroLabel) ######################################## ## SUBSTRUCTURE ## ####################################### setattr( process, neroLabel + 'Njettiness', Njettiness.clone(src=cms.InputTag('PFJets' + neroLabel), R0=cms.double(jetRadius), Njets=cms.vuint32(1, 2, 3, 4))) setattr( process, neroLabel + 'SDKinematics', cms.EDProducer( 'RecoJetDeltaRValueMapProducer', src=cms.InputTag('PFJets' + neroLabel), matched=cms.InputTag('PFJets' + "SoftDrop" + neroLabel), distMax=cms.double(1.5), values=cms.vstring('mass'), valueLabels=cms.vstring('Mass'), )) newSeq += getattr(process, neroLabel + 'SDKinematics') newSeq += getattr(process, neroLabel + 'Njettiness') ### subjet b-tagging ### setattr( process, neroLabel + 'PFImpactParameterTagInfos', pfImpactParameterTagInfos.clone( jets=cms.InputTag('PFJets' + "SoftDrop" + neroLabel, 'SubJets'), maxDeltaR=cms.double(jetRadius), primaryVertex=cms.InputTag('offlineSlimmedPrimaryVertices'), candidates=cms.InputTag('packedPFCandidates'))) setattr( process, neroLabel + 'PFInclusiveSecondaryVertexFinderTagInfos', pfInclusiveSecondaryVertexFinderTagInfos.clone( trackIPTagInfos=cms.InputTag(neroLabel + 'PFImpactParameterTagInfos'), extSVCollection=cms.InputTag('slimmedSecondaryVertices'))) setattr( process, neroLabel + 'PFCombinedInclusiveSecondaryVertexV2BJetTags', pfCombinedInclusiveSecondaryVertexV2BJetTags.clone( tagInfos=cms.VInputTag( cms.InputTag(neroLabel + "PFImpactParameterTagInfos"), cms.InputTag(neroLabel + "PFInclusiveSecondaryVertexFinderTagInfos")))) newSeq += getattr(process, neroLabel + 'PFImpactParameterTagInfos') newSeq += getattr(process, neroLabel + 'PFInclusiveSecondaryVertexFinderTagInfos') newSeq += getattr( process, neroLabel + 'PFCombinedInclusiveSecondaryVertexV2BJetTags') bTagInfos = ['None'] bTagDiscriminators = ['None'] ######################################## ## MAKE PAT JETS ## ######################################## addJetCollection( process, labelName='PF' + neroLabel, jetSource=cms.InputTag('PFJets' + neroLabel), algo=algoLabel, # needed for jet flavor clustering rParam=jetRadius, # needed for jet flavor clustering pfCandidates=cms.InputTag('packedPFCandidates'), pvSource=cms.InputTag(pvSource), svSource=cms.InputTag(svSource), muSource=cms.InputTag(muSource), elSource=cms.InputTag(elSource), btagInfos=bTagInfos, btagDiscriminators=bTagDiscriminators, genJetCollection=cms.InputTag('genJetsNoNu' + rLabel), genParticles=cms.InputTag(genParticles), getJetMCFlavour=False, # jet flavor disabled ) getattr(process, 'selectedPatJetsPF' + neroLabel).cut = cms.string("abs(eta) < " + str(2.5)) ## SOFT DROP ## addJetCollection( process, labelName='SoftDropPF' + neroLabel, jetSource=cms.InputTag('PFJets' + "SoftDrop" + neroLabel), pfCandidates=cms.InputTag('packedPFCandidates'), algo=algoLabel, rParam=jetRadius, btagInfos=['None'], btagDiscriminators=['None'], genJetCollection=cms.InputTag('genJetsNoNu' + rLabel), genParticles=cms.InputTag(genParticles), getJetMCFlavour=False, # jet flavor disabled ) addJetCollection( process, labelName='SoftDropSubjetsPF' + neroLabel, jetSource=cms.InputTag('PFJets' + "SoftDrop" + neroLabel, 'SubJets'), algo=algoLabel, rParam=jetRadius, pfCandidates=cms.InputTag('packedPFCandidates'), pvSource=cms.InputTag(pvSource), svSource=cms.InputTag(svSource), muSource=cms.InputTag(muSource), elSource=cms.InputTag(elSource), btagInfos=bTagInfosSubjets, btagDiscriminators=bTagDiscriminatorsSubjets, genJetCollection=cms.InputTag('genJetsNoNuSoftDrop' + rLabel, 'SubJets'), genParticles=cms.InputTag(genParticles), explicitJTA=True, # needed for subjet b tagging svClustering=True, # needed for subjet b tagging fatJets=cms.InputTag('PFJets' + neroLabel), # needed for subjet flavor clustering groomedFatJets=cms.InputTag( 'PFJets' + "SoftDrop" + neroLabel), # needed for subjet flavor clustering runIVF=False, getJetMCFlavour=False, # jet flavor disabled ) isMC = not (isData) if isMC: newSeq += getattr(process, 'patJetPartonMatchPF' + neroLabel) newSeq += getattr(process, 'patJetGenJetMatchPF' + neroLabel) newSeq += getattr(process, 'patJetsPF' + neroLabel) newSeq += getattr(process, 'selectedPatJetsPF' + neroLabel) if isMC: newSeq += getattr(process, 'patJetPartonMatchSoftDropPF' + neroLabel) newSeq += getattr(process, 'patJetGenJetMatchSoftDropPF' + neroLabel) newSeq += getattr(process, 'patJetsSoftDropPF' + neroLabel) newSeq += getattr(process, 'selectedPatJetsSoftDropPF' + neroLabel) if isMC: newSeq += getattr(process, 'patJetPartonMatchSoftDropSubjetsPF' + neroLabel) newSeq += getattr(process, 'patJetGenJetMatchSoftDropSubjetsPF' + neroLabel) newSeq += getattr(process, 'patJetsSoftDropSubjetsPF' + neroLabel) newSeq += getattr(process, 'selectedPatJetsSoftDropSubjetsPF' + neroLabel) setattr( process, "selectedPatJetsSoftDropPF" + "Packed" + neroLabel, cms.EDProducer( "BoostedJetMerger", jetSrc=cms.InputTag("selectedPatJetsSoftDropPF" + neroLabel), subjetSrc=cms.InputTag("selectedPatJetsSoftDropSubjetsPF" + neroLabel))) ## PACK ## setattr( process, "packedPatJetsPF" + neroLabel, cms.EDProducer("JetSubstructurePacker", jetSrc=cms.InputTag('selectedPatJetsPF' + neroLabel), distMax=cms.double(jetRadius), algoTags=cms.VInputTag(), algoLabels=cms.vstring(), fixDaughters=cms.bool(False))) getattr(process, "packedPatJetsPF" + neroLabel).algoTags.append( cms.InputTag('selectedPatJetsSoftDropPF' + "Packed" + neroLabel)) getattr(process, "packedPatJetsPF" + neroLabel).algoLabels.append('SoftDrop') getattr(process, 'patJetsPF' + neroLabel).userData.userFloats.src += [ neroLabel + 'Njettiness:tau1' ] getattr(process, 'patJetsPF' + neroLabel).userData.userFloats.src += [ neroLabel + 'Njettiness:tau2' ] getattr(process, 'patJetsPF' + neroLabel).userData.userFloats.src += [ neroLabel + 'Njettiness:tau3' ] getattr(process, 'patJetsPF' + neroLabel).userData.userFloats.src += [ neroLabel + 'Njettiness:tau4' ] getattr(process, 'patJetsPF' + neroLabel).userData.userFloats.src += [ neroLabel + 'SDKinematics:Mass' ] for m in ['patJetsPF' + neroLabel, 'patJetsSoftDropSubjetsPF' + neroLabel]: if hasattr(process, m) and getattr(getattr(process, m), 'addBTagInfo'): setattr(getattr(process, m), 'addTagInfos', cms.bool(True)) #if hasattr(process,m): # setattr( getattr(process,m), 'addJetFlavourInfo', cms.bool(True)) newSeq += cms.Sequence( getattr(process, 'selectedPatJetsSoftDropPF' + "Packed" + neroLabel) + getattr(process, 'packedPatJetsPF' + neroLabel)) if isData: removeMCMatching(process, ['All'], outputModules=[]) return newSeq
# Path and EndPath definitions process.L1simulation_step = cms.Path(process.SimL1Emulator) process.endjob_step = cms.EndPath(process.endOfProcess) process.FEVTDEBUGHLToutput_step = cms.EndPath(process.FEVTDEBUGHLToutput) ################################################# ## Remake jets ################################################# ## Select charged hadron subtracted packed PF candidates process.pfCHS = cms.EDFilter("CandPtrSelector", src=cms.InputTag("packedPFCandidates"), cut=cms.string("fromPV")) from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets ## Define PFJetsCHS process.ak4PFJetsCHS = ak4PFJets.clone(src='pfCHS') ################################################# # load the standard PAT config process.load("PhysicsTools.PatAlgos.patSequences_cff") # load the coreTools of PAT from PhysicsTools.PatAlgos.tools.jetTools import * addJetCollection( process, labelName='NewSlimmedJets', jetSource=cms.InputTag('ak4PFJetsCHS'), pfCandidates=cms.InputTag("packedPFCandidates"), explicitJTA=False, svClustering=False,
import FWCore.ParameterSet.Config as cms from RecoMET.METProducers.pfMet_cfi import pfMet as _pfMet _pfMet.calculateSignificance = False l1PFMetCalo = _pfMet.clone(src="l1pfCandidates:Calo") l1PFMetPF = _pfMet.clone(src="l1pfCandidates:PF") l1PFMetPuppi = _pfMet.clone(src="l1pfCandidates:Puppi") l1PFMets = cms.Sequence(l1PFMetCalo + l1PFMetPF + l1PFMetPuppi) from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets as _ak4PFJets _ak4PFJets.doAreaFastjet = False ak4PFL1Calo = _ak4PFJets.clone(src='l1pfCandidates:Calo') ak4PFL1PF = _ak4PFJets.clone(src='l1pfCandidates:PF') ak4PFL1Puppi = _ak4PFJets.clone(src='l1pfCandidates:Puppi') _correctedJets = cms.EDProducer( "L1TCorrectedPFJetProducer", jets=cms.InputTag("_tag_"), correctorFile=cms.string( "L1Trigger/Phase2L1ParticleFlow/data/jecs/jecs.PU200.root"), correctorDir=cms.string("_dir_"), copyDaughters=cms.bool(False)) # Using phase2_hgcalV10 to customize the config for all 106X samples, since there's no other modifier for it from Configuration.Eras.Modifier_phase2_hgcalV10_cff import phase2_hgcalV10 phase2_hgcalV10.toModify( _correctedJets, correctorFile= "L1Trigger/Phase2L1ParticleFlow/data/jecs/jecs.PU200_106X.root") from Configuration.Eras.Modifier_phase2_hgcalV11_cff import phase2_hgcalV11 phase2_hgcalV11.toModify(
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
process = cms.Process("S2") process.source = cms.Source("PoolSource", fileNames = cms.untracked.vstring("file:patTuple_mini.root") ) from PhysicsTools.PatAlgos.patInputFiles_cff import filesRelValProdTTbarPileUpMINIAODSIM process.source.fileNames = filesRelValProdTTbarPileUpMINIAODSIM process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) ) from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets process.chs = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV")) process.ak4PFJets = ak4PFJets.clone(src = 'packedPFCandidates', doAreaFastjet = True) # no idea while doArea is false by default, but it's True in RECO so we have to set it process.ak4PFJetsCHS = ak4PFJets.clone(src = 'chs', doAreaFastjet = True) # no idea while doArea is false by default, but it's True in RECO so we have to set it process.ak4GenJets = ak4GenJets.clone(src = 'packedGenParticles') process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff") process.load("Configuration.EventContent.EventContent_cff") process.load('Configuration.StandardSequences.Geometry_cff') process.load('Configuration.StandardSequences.MagneticField_38T_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') from Configuration.AlCa.GlobalTag import GlobalTag process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc') from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection addJetCollection( process, postfix = "",
extension=cms.bool( False), # this is the main table for the AK8 constituents variables=cms.PSet(CandVars)) jetReclusterSequence = cms.Sequence(finalJetsAK8Constituents) jetReclusterMCSequence = cms.Sequence(genJetsAK8Constituents) jetReclusterTable = cms.Sequence(finalJetsAK8ConstituentsTable) jetReclusterMCTable = cms.Sequence(genJetsAK8ParticleTable) from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets pfCHSCandsNew = cms.EDFilter("CandPtrSelector", src=cms.InputTag("packedPFCandidates"), cut=cms.string("fromPV")) ak4PFCHSreco = ak4PFJets.clone(src='pfCHSCandsNew', jetPtMin=15., rParam=cms.double(0.4)) ak4jetTable = cms.EDProducer( "SimpleCandidateFlatTableProducer", src=cms.InputTag("ak4PFCHSreco"), cut=cms.string(""), #we should not filter on cross linked collections name=cms.string("Jetak4PFCHS"), doc=cms.string( "Jetak4PFCHS, i.e. ak4 PFJets CHS (plain reco, i.e. without JEC applied)" ), singleton=cms.bool(False), # the number of entries is variable extension=cms.bool(False), # this is the main table for the jets variables=cms.PSet( P4Vars, area=Var("jetArea()", float,
import FWCore.ParameterSet.Config as cms from RecoJets.JetProducers.PFJetParameters_cfi import * from RecoJets.JetProducers.AnomalousCellParameters_cfi import * from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets ak4PFJetsFiltered = ak4PFJets.clone( useFiltering = cms.bool(True), nFilt = cms.int32(3), rFilt = cms.double(0.3), useExplicitGhosts = cms.bool(True), writeCompound = cms.bool(True), jetCollInstanceName=cms.string("SubJets") ) ak4PFJetsMassDropFiltered = ak4PFJetsFiltered.clone( useMassDropTagger = cms.bool(True), muCut = cms.double(0.667), yCut = cms.double(0.08), writeCompound = cms.bool(True), jetCollInstanceName=cms.string("SubJets") )
**mvaMETTauMu.parameters_()) process.mvaMETMuMu.srcLeptons = cms.VInputTag( cms.InputTag("muonPreSelectionMuEle", "", ""), cms.InputTag("muonPreSelectionMuEle", "", "")) process.mvaMETEleEle = cms.EDProducer('PFMETProducerMVATauTau', **mvaMETTauMu.parameters_()) process.mvaMETEleEle.srcLeptons = cms.VInputTag( cms.InputTag("electronPreSelectionMuEle", "", ""), cms.InputTag("electronPreSelectionMuEle", "", "")) from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.chs = cms.EDFilter("CandPtrSelector", src=cms.InputTag("packedPFCandidates"), cut=cms.string("fromPV")) process.ak4PFJetsCHS = ak4PFJets.clone(src='chs', doAreaFastjet=True) #from JetMETCorrections.Configuration.DefaultJEC_cff import ak4PFJetsL1FastL2L3 process.load("JetMETCorrections.Configuration.DefaultJEC_cff") if runOnData: process.calibratedAK4PFJetsCHSForPFMVAMEt = cms.EDProducer( "PFJetCorrectionProducer", src=cms.InputTag("ak4PFJetsCHS"), correctors=cms.vstring('ak4PFCHSL1FastL2L3Residual')) else: process.calibratedAK4PFJetsCHSForPFMVAMEt = cms.EDProducer( "PFJetCorrectionProducer", src=cms.InputTag("ak4PFJetsCHS"), correctors=cms.vstring('ak4PFCHSL1FastL2L3'))
pdgids = cms.vint32 (22,11,211,130), weight = cms.double(1.), useValueMap = cms.bool(False), weightsName = cms.InputTag('puppi'), ) process.puppiForMET.puppiCandName = 'puppiMerged' process.puppiSequence += process.puppi process.puppiSequence += process.pfCandNoLep process.puppiSequence += process.pfCandLep process.puppiSequence += process.puppiNoLep process.puppiSequence += process.puppiMerged process.puppiSequence += process.puppiForMET # recompute ak4 jets for corrections from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.ak4PFJetsPuppi = ak4PFJets.clone(src=cms.InputTag('puppiNoLep')) process.puppiMetSequence += process.ak4PFJetsPuppi # compute puppi MET from RecoMET.METProducers.PFMET_cfi import pfMet process.pfMETPuppi = pfMet.clone() process.pfMETPuppi.src = cms.InputTag('puppiForMET') process.pfMETPuppi.calculateSignificance = False process.puppiMetSequence += process.pfMETPuppi # correct puppi jets jeclabel = 'DATA' if isData else 'MC' process.jec = cms.ESSource("PoolDBESSource", CondDBSetup, toGet = cms.VPSet( cms.PSet(record = cms.string('JetCorrectionsRecord'),
pfCandSrc = "muonCleanedPackedPFCandidates" process.recoMuonsForJetCleaning = cms.EDFilter( 'PATMuonRefSelector', src=cms.InputTag('slimmedMuons'), cut=cms.string('pt > 3.0 && isPFMuon && (isGlobalMuon || isTrackerMuon)'), ) process.muonCleanedPackedPFCandidates = cms.EDProducer( "MuonCleanedPackedCandidateProducer", src=cms.InputTag("recoMuonsForJetCleaning"), pfCandSrc=cms.InputTag("packedPFCandidates"), ) from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.ak4PFJetsMuonCleaned = ak4PFJets.clone( src=cms.InputTag('muonCleanedPackedPFCandidates')) from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import _patJets patJetsNew = _patJets.clone( jetSource=cms.InputTag(recoJetSrc), addJetCorrFactors=cms.bool(False), jetCorrFactorsSource=cms.VInputTag(), addBTagInfo=cms.bool(False), addDiscriminators=cms.bool(False), discriminatorSources=cms.VInputTag(), addAssociatedTracks=cms.bool(False), addJetCharge=cms.bool(False), addGenPartonMatch=cms.bool(False), embedGenPartonMatch=cms.bool(False), addGenJetMatch=cms.bool(False), getJetMCFlavour=cms.bool(False),
# the cofigurations # process.load("flashgg/MicroAOD/flashggVertexMaps_cfi") # flashggTkVtxMap_cfi.py process.load("flashgg/MicroAOD/flashggTkVtxMap_cfi") process.load("flashgg/MicroAOD/flashggPhotons_cfi") process.load("flashgg/MicroAOD/flashggDiPhotons_cfi") process.load("flashgg/MicroAOD/flashggPreselectedDiPhotons_cfi") process.load("flashgg/MicroAOD/flashggElectrons_cfi") # Import RECO jet producer for ak4 PF and GEN jet from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets process.ak4PFJets = ak4PFJets.clone(src = 'packedPFCandidates', doAreaFastjet = True) process.ak4GenJets = ak4GenJets.clone(src = 'packedGenParticles') # The following is make patJets, but EI is done with the above process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff") process.load("Configuration.EventContent.EventContent_cff") process.load('Configuration.StandardSequences.Geometry_cff') process.load('Configuration.StandardSequences.MagneticField_38T_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') process.GlobalTag.globaltag = 'PLS170_V7AN1::All' from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection addJetCollection( process, postfix = "", labelName = 'AK4PF',
storedDiscriminators = set( [x.value() for x in patJetsDefault.discriminatorSources]) print "INFO: Removing b-tag discriminators already stored in MiniAOD (with the exception of JP taggers)" jptaggers = { i for i in bTagDiscriminators if 'ProbabilityBJetTags' in i or i.startswith('pfDeepCSV') } bTagDiscriminators = (bTagDiscriminators - storedDiscriminators) | jptaggers print "bTagDiscriminators are" print bTagDiscriminators ## Reco jets from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.ak4Jets = ak4PFJets.clone(src=cms.InputTag('pfCHS'), doAreaFastjet=True, srcPVs=cms.InputTag(pvSource)) ## Load standard PAT objects (here we only need PAT muons but the framework will figure out what it needs to run using the unscheduled mode) process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff") process.load("PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff") from PhysicsTools.PatAlgos.tools.jetTools import * updateJetCollection(process, jetSource=cms.InputTag(jetSource), jetCorrections=jetCorrectionsAK4, pfCandidates=cms.InputTag(pfCandidates), pvSource=cms.InputTag(pvSource), svSource=cms.InputTag(svSource), muSource=cms.InputTag(muSource),
fileName=cms.untracked.string("corMETMiniAOD.root"), dataset=cms.untracked.PSet(filterName=cms.untracked.string(""), dataTier=cms.untracked.string("")), dropMetaData=cms.untracked.string("ALL"), fastCloning=cms.untracked.bool(False), overrideInputFileSplitLevels=cms.untracked.bool(True), ) if options.reclusterTrackJets: process.MessageLogger.destinations = ["cerr"] # temporarily avoid a lot of printouts process.MessageLogger.cerr.threshold = cms.untracked.string("ERROR") # temporarily avoid a lot of printouts process.pfChargedCHS = cms.EDFilter( "CandPtrSelector", src=cms.InputTag("packedPFCandidates"), cut=cms.string("fromPV && charge!=0") ) from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.ak4PFChargedJetsCHS = ak4PFJets.clone(src="pfChargedCHS", doAreaFastjet=True) from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection addJetCollection( process, postfix="", labelName="AK4ChargedPFCHS", jetSource=cms.InputTag("ak4PFChargedJetsCHS"), pvSource=cms.InputTag("offlineSlimmedPrimaryVertices"), pfCandidates=cms.InputTag("packedPFCandidates"), svSource=cms.InputTag("slimmedSecondaryVertices"), btagDiscriminators=["None"], jetCorrections=("AK4PFchs", [], "None"), genJetCollection=cms.InputTag("slimmedGenJets"), genParticles=cms.InputTag("prunedGenParticles"), algo="AK",
import FWCore.ParameterSet.Config as cms from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets #PFCHS pfCHS = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV")) # make GEN jets AK4GenJets = ak4GenJets.clone( rParam = 0.4 ) AK4GenJets.src = cms.InputTag('packedGenParticles'); AK8GenJets = ak4GenJets.clone( rParam = 0.8 ) AK8GenJets.src = cms.InputTag('packedGenParticles'); AK4PFchsJets = ak4PFJets.clone(); AK4PFchsJets.src = cms.InputTag('pfCHS','','JRA'); AK8PFchsJets = ak4PFJets.clone( rParam = 0.8 ); AK8PFchsJets.src = cms.InputTag('pfCHS','','JRA'); AK4PFJetsPuppi = ak4PFJetsPuppi.clone( ) AK4PFJetsPuppi.src = cms.InputTag('puppi','','JRA') #PFJetParameters AK8PFJetsPuppi = ak4PFJetsPuppi.clone( rParam = 0.8 ) AK8PFJetsPuppi.src = cms.InputTag('puppi','','JRA') #PFJetParameters
def addFlashggPFCHSJets(process, isData, vertexIndex = 0, #doQGTagging = True, label ='', debug = False): setattr(process, 'selectedMuons' + label, cms.EDFilter("CandPtrSelector", src = cms.InputTag("slimmedMuons"), cut = cms.string('''abs(eta)<2.5 && pt>10. && (pfIsolationR04().sumChargedHadronPt+ max(0.,pfIsolationR04().sumNeutralHadronEt+ pfIsolationR04().sumPhotonEt- 0.50*pfIsolationR04().sumPUPt))/pt < 0.20 && (isPFMuon && (isGlobalMuon || isTrackerMuon) )'''))) setattr(process, 'selectedElectrons' + label, cms.EDFilter("CandPtrSelector", src = cms.InputTag("slimmedElectrons"), cut = cms.string('''abs(eta)<2.5 && pt>20. && gsfTrack.isAvailable() && gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2 && (pfIsolationVariables().sumChargedHadronPt+ max(0.,pfIsolationVariables().sumNeutralHadronEt+ pfIsolationVariables().sumPhotonEt- 0.5*pfIsolationVariables().sumPUPt))/pt < 0.15'''))) # Simple producer which just removes the Candidates which # don't come from the legacy vertex according to the Flashgg Vertex Map setattr(process,'flashggCHSLegacyVertexCandidates' + label, cms.EDProducer('FlashggMultiCHSLegacyVertexCandProducer', PFCandidatesTag = cms.InputTag('packedPFCandidates'), DiPhotonTag = cms.InputTag('flashggDiPhotons'), VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"), VertexTag = cms.InputTag('offlineSlimmedPrimaryVertices'), vertexIndex = cms.uint32(vertexIndex), debug = cms.untracked.bool(debug) ) ) setattr(process, 'pfCHSLeg' + label, cms.EDFilter("CandPtrSelector", src = cms.InputTag('flashggCHSLegacyVertexCandidates' + label), cut = cms.string(''))) # then remove the previously selected muons setattr(process, 'pfNoMuonCHSLeg' + label, cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfCHSLeg" + label), veto = cms.InputTag("selectedMuons" + label))) # then remove the previously selected electrons setattr(process, 'pfNoElectronsCHSLeg' + label, cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfNoMuonCHSLeg" + label), veto = cms.InputTag("selectedElectrons" + label))) #Import RECO jet producer for ak4 PF and GEN jet from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets setattr(process, 'ak4PFJetsCHSLeg' + label, ak4PFJets.clone ( src = 'pfNoElectronsCHSLeg' + label, doAreaFastjet = True)) if isData: JECs = ['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual'] else: JECs = ['L1FastJet', 'L2Relative', 'L3Absolute'] # NOTE: this is the 74X recipe for the jet clustering addJetCollection( process, postfix = label, labelName = 'AK4PFCHSLeg', jetSource = cms.InputTag('ak4PFJetsCHSLeg' + label), pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), pfCandidates = cms.InputTag('packedPFCandidates'), svSource = cms.InputTag('slimmedSecondaryVertices'), btagDiscriminators = [ flashggBTag ], jetCorrections = ('AK4PFchs', JECs, 'None'), genJetCollection = cms.InputTag('slimmedGenJets'), genParticles = cms.InputTag('prunedGenParticles'), # jet param algo = 'AK', rParam = 0.4 ) #adjust PV used for Jet Corrections #process.patJetCorrFactorsAK4PFCHSLeg.primaryVertices = "offlineSlimmedPrimaryVertices" getattr(process, 'patJetCorrFactorsAK4PFCHSLeg' + label).primaryVertices = "offlineSlimmedPrimaryVertices" if not hasattr(process,"QGPoolDBESSource"): process.QGPoolDBESSource = cms.ESSource("PoolDBESSource", CondDBSetup, toGet = cms.VPSet(), connect = cms.string('sqlite:QGL_'+qgDatabaseVersion+'.db') ) process.es_prefer_qg = cms.ESPrefer('PoolDBESSource','QGPoolDBESSource') for type in ['AK4PFchs']:#,'AK4PFchs_antib']: process.QGPoolDBESSource.toGet.extend(cms.VPSet(cms.PSet( record = cms.string('QGLikelihoodRcd'), tag = cms.string('QGLikelihoodObject_'+qgDatabaseVersion+'_'+type), label = cms.untracked.string('QGL_'+type) ))) from RecoJets.JetProducers.QGTagger_cfi import QGTagger setattr( process, 'QGTaggerPFCHS' + label, QGTagger.clone( srcJets = 'patJetsAK4PFCHSLeg' + label ,jetsLabel = 'QGL_AK4PFchs', vertexIndex = cms.uint32(vertexIndex), srcVertexCollection = 'offlineSlimmedPrimaryVertices')) from RecoJets.JetProducers.PileupJetIDParams_cfi import full_80x_chs flashggJets = cms.EDProducer('FlashggJetProducer', DiPhotonTag = cms.InputTag('flashggDiPhotons'), VertexTag = cms.InputTag('offlineSlimmedPrimaryVertices'), JetTag = cms.InputTag('patJetsAK4PFCHSLeg' + label), VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"), qgVariablesInputTag = cms.InputTag('QGTaggerPFCHS'+label, 'qgLikelihood'), ComputeSimpleRMS = cms.bool(True), PileupJetIdParameters = full_80x_chs, rho = cms.InputTag("fixedGridRhoFastjetAll"), JetCollectionIndex = cms.uint32(vertexIndex), Debug = cms.untracked.bool(False) ) setattr( process, 'flashggPFCHSJets'+ label, flashggJets) # randomize Jets from flashgg.MicroAOD.flashggRandomizedJetProducer_cfi import flashggRandomizedJets flashggRandomizedPFCHSJets = flashggRandomizedJets.clone() flashggRandomizedPFCHSJets.src = "flashggPFCHSJets" + label setattr(process.RandomNumberGeneratorService, 'flashggRandomizedPFCHSJets' + label, cms.PSet(initialSeed = cms.untracked.uint32(36423784 + int(label)))) setattr( process, 'flashggRandomizedPFCHSJets' + label, flashggRandomizedPFCHSJets ) flashggSelectedJets = cms.EDFilter("FLASHggJetSelector", src = cms.InputTag( 'flashggRandomizedPFCHSJets' + label ), cut = cms.string("pt > 15.") ) setattr( process, 'flashggSelectedPFCHSJets'+label, flashggSelectedJets )
process.ak4PuppiL1FastjetCorrector * process.ak4PuppiL2RelativeCorrector * process.ak4PuppiL3AbsoluteCorrector * process.ak4PuppiResidualCorrector * process.ak4PuppiL1FastL2L3ResidualCorrector ) if isData: process.puppiSequence += process.ak4PuppiL1FastL2L3ResidualChain else: process.puppiSequence += process.ak4PuppiL1FastL2L3Chain ### MET corrections ### from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.AK4PFJetsPuppi = ak4PFJets.clone( src=cms.InputTag("puppinolep"), jetAlgorithm=cms.string("AntiKt"), rParam=cms.double(0.4), jetPtMin=cms.double(20) ) process.puppiSequence += process.AK4PFJetsPuppi process.puppiMETCorr = cms.EDProducer( "PFJetMETcorrInputProducer", src=cms.InputTag("AK4PFJetsPuppi"), offsetCorrLabel=cms.InputTag("ak4PuppiL1FastjetCorrector"), jetCorrLabel=cms.InputTag("ak4PuppiL1FastL2L3Corrector"), jetCorrLabelRes=cms.InputTag("ak4PuppiL1FastL2L3ResidualCorrector"), jetCorrEtaMax=cms.double(9.9), type1JetPtThreshold=cms.double(15.0), skipEM=cms.bool(True), skipEMfractionThreshold=cms.double(0.90), skipMuons=cms.bool(True), skipMuonSelection=cms.string("isGlobalMuon | isStandAloneMuon"),
AK4FlavorPuppi = cms.EDProducer( "JetFlavourClustering", jets=cms.InputTag("AK4PFJetsPuppi"), bHadrons=cms.InputTag("selectedHadronsAndPartons", "bHadrons"), cHadrons=cms.InputTag("selectedHadronsAndPartons", "cHadrons"), partons=cms.InputTag("selectedHadronsAndPartons", "algorithmicPartons"), jetAlgorithm=cms.string("AntiKt"), rParam=cms.double(0.4), ghostRescaling=cms.double(1e-18), hadronFlavourHasPriority=cms.bool(True)) # take the default AK4 PFJet producer and modify accordingly for cone size and clustering algorithm from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets AK4PFJetsPuppi = ak4PFJets.clone(src=cms.InputTag('puppi'), jetAlgorithm=cms.string("AntiKt"), rParam=cms.double(0.4), jetPtMin=cms.double(1)) # Pruned AK4caPFJetsPrunedPuppi = AK4PFJetsPuppi.clone( cms.PSet(nFilt=cms.int32(2), zcut=cms.double(0.1), rcut_factor=cms.double(0.5)), jetAlgorithm=cms.string("CambridgeAachen"), usePruning=cms.bool(True), useExplicitGhosts=cms.bool(True), writeCompound=cms.bool(True), jetCollInstanceName=cms.string("SubJets")) # Trimmed AK4caPFJetsTrimmedPuppi = AK4PFJetsPuppi.clone(
## Options and Output Report process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(options.wantSummary), allowUnscheduled = cms.untracked.bool(False) ) ################################################# ## Remake jets ################################################# ## Select charged hadron subtracted packed PF candidates process.pfCHS = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV")) from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets ## Define PFJetsCHS process.ak4PFJetsCHS = ak4PFJets.clone(src = 'pfCHS') ################################################# ## Jet collection we'll be using jetCollection=cms.InputTag("ak4PFJetsCHS") ## Load b-tagging modules process.load("RecoBTag.Configuration.RecoBTag_cff") process.pfImpactParameterTagInfos.jets = jetCollection process.softPFMuonsTagInfos.jets = jetCollection process.softPFElectronsTagInfos.jets = jetCollection process.btagSeq = cms.Sequence( # impact parameters and IP-only algorithms process.pfImpactParameterTagInfos *
def adaptTauToMiniAODReReco(process, reclusterJets=True): # TRYING TO MAKE THINGS MINIAOD COMPATIBLE, FROM THE START, TO THE END, 1 BY 1 #print '[adaptTauToMiniAODReReco]: Start' jetCollection = 'slimmedJets' # Add new jet collections if reclustering is demanded if reclusterJets: jetCollection = 'patJetsPAT' from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.ak4PFJetsPAT = ak4PFJets.clone( src=cms.InputTag("packedPFCandidates")) # trivial PATJets from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import _patJets process.patJetsPAT = _patJets.clone( jetSource=cms.InputTag("ak4PFJetsPAT"), addJetCorrFactors=cms.bool(False), jetCorrFactorsSource=cms.VInputTag(), addBTagInfo=cms.bool(False), addDiscriminators=cms.bool(False), discriminatorSources=cms.VInputTag(), addAssociatedTracks=cms.bool(False), addJetCharge=cms.bool(False), addGenPartonMatch=cms.bool(False), embedGenPartonMatch=cms.bool(False), addGenJetMatch=cms.bool(False), getJetMCFlavour=cms.bool(False), addJetFlavourInfo=cms.bool(False), ) process.miniAODTausTask.add(process.ak4PFJetsPAT) process.miniAODTausTask.add(process.patJetsPAT) # so this adds all tracks to jet in some deltaR region. we don't have tracks so don't need it :D # process.ak4PFJetTracksAssociatorAtVertex.jets = cms.InputTag(jetCollection) # Remove ak4PFJetTracksAssociatorAtVertex from recoTauCommonSequence # Remove pfRecoTauTagInfoProducer from recoTauCommonSequence since it uses the jet-track association # HOWEVER, may use https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMiniAOD2017#Isolated_Tracks # probably needs recovery of the two modules above process.recoTauAK4Jets08RegionPAT = cms.EDProducer( "RecoTauPatJetRegionProducer", deltaR=process.recoTauAK4PFJets08Region.deltaR, maxJetAbsEta=process.recoTauAK4PFJets08Region.maxJetAbsEta, minJetPt=process.recoTauAK4PFJets08Region.minJetPt, pfCandAssocMapSrc=cms.InputTag(""), pfCandSrc=cms.InputTag("packedPFCandidates"), src=cms.InputTag(jetCollection)) process.recoTauPileUpVertices.src = cms.InputTag( "offlineSlimmedPrimaryVertices") # Redefine recoTauCommonTask # with redefined region and PU vertices, and w/o track-to-vertex associator and tauTagInfo (the two latter are probably obsolete and not needed at all) process.recoTauCommonTask = cms.Task(process.recoTauAK4Jets08RegionPAT, process.recoTauPileUpVertices) for moduleName in process.TauReco.moduleNames(): convertModuleToMiniAODInput(process, moduleName) # Adapt TauPiZeros producer process.ak4PFJetsLegacyHPSPiZeros.builders[ 0].qualityCuts.primaryVertexSrc = cms.InputTag( "offlineSlimmedPrimaryVertices") process.ak4PFJetsLegacyHPSPiZeros.jetSrc = cms.InputTag(jetCollection) # Adapt TauChargedHadrons producer for builder in process.ak4PFJetsRecoTauChargedHadrons.builders: builder.qualityCuts.primaryVertexSrc = cms.InputTag( "offlineSlimmedPrimaryVertices") if builder.name.value( ) == 'tracks': #replace plugin based on generalTracks by one based on lostTracks builder.name = 'lostTracks' builder.plugin = 'PFRecoTauChargedHadronFromLostTrackPlugin' builder.srcTracks = cms.InputTag("lostTracks") process.ak4PFJetsRecoTauChargedHadrons.jetSrc = cms.InputTag(jetCollection) # Adapt combinatoricRecoTau producer process.combinatoricRecoTaus.jetRegionSrc = 'recoTauAK4Jets08RegionPAT' process.combinatoricRecoTaus.jetSrc = jetCollection # Adapt builders for builder in process.combinatoricRecoTaus.builders: for name, value in builder.parameters_().items(): if name == 'qualityCuts': builder.qualityCuts.primaryVertexSrc = 'offlineSlimmedPrimaryVertices' elif name == 'pfCandSrc': builder.pfCandSrc = 'packedPFCandidates' # Adapt supported modifiers and remove unsupported ones modifiersToRemove_ = cms.VPSet() for mod in process.combinatoricRecoTaus.modifiers: if mod.name.value() == 'elec_rej': modifiersToRemove_.append(mod) continue elif mod.name.value() == 'TTIworkaround': modifiersToRemove_.append(mod) continue for name, value in mod.parameters_().items(): if name == 'qualityCuts': mod.qualityCuts.primaryVertexSrc = 'offlineSlimmedPrimaryVertices' for mod in modifiersToRemove_: process.combinatoricRecoTaus.modifiers.remove(mod) #print "\t\t Removing '%s' modifier from 'combinatoricRecoTaus'" %mod.name.value() # Redefine tau PV producer process.hpsPFTauPrimaryVertexProducer.__dict__[ '_TypedParameterizable__type'] = 'PFTauMiniAODPrimaryVertexProducer' process.hpsPFTauPrimaryVertexProducer.PVTag = 'offlineSlimmedPrimaryVertices' process.hpsPFTauPrimaryVertexProducer.packedCandidatesTag = cms.InputTag( "packedPFCandidates") process.hpsPFTauPrimaryVertexProducer.lostCandidatesTag = cms.InputTag( "lostTracks") # Redefine tau SV producer process.hpsPFTauSecondaryVertexProducer = cms.EDProducer( "PFTauSecondaryVertexProducer", PFTauTag=cms.InputTag("hpsPFTauProducer")) # Remove RecoTau producers which are not supported (yet?), i.e. against-e/mu discriminats for moduleName in process.TauReco.moduleNames(): if 'ElectronRejection' in moduleName or 'MuonRejection' in moduleName: if 'ByDeadECALElectronRejection' in moduleName: continue process.miniAODTausTask.remove(getattr(process, moduleName)) # Instead add against-mu discriminants which are MiniAOD compatible from RecoTauTag.RecoTau.hpsPFTauDiscriminationByMuonRejectionSimple_cff import hpsPFTauDiscriminationByMuonRejectionSimple process.hpsPFTauDiscriminationByMuonRejectionSimple = hpsPFTauDiscriminationByMuonRejectionSimple process.miniAODTausTask.add( process.hpsPFTauDiscriminationByMuonRejectionSimple) ##### # PAT part in the following process.tauGenJets.GenParticles = cms.InputTag("prunedGenParticles") process.tauMatch.matched = cms.InputTag("prunedGenParticles") # Remove unsupported tauIDs for name, src in process.patTaus.tauIDSources.parameters_().items(): if name.find('againstElectron') > -1 or name.find('againstMuon') > -1: if name.find('againstElectronDeadECAL') > -1: continue delattr(process.patTaus.tauIDSources, name) # Add MiniAOD specific ones setattr( process.patTaus.tauIDSources, 'againstMuonLooseSimple', cms.PSet(inputTag=cms.InputTag( 'hpsPFTauDiscriminationByMuonRejectionSimple'), provenanceConfigLabel=cms.string('IDWPdefinitions'), idLabel=cms.string('ByLooseMuonRejectionSimple'))) setattr( process.patTaus.tauIDSources, 'againstMuonTightSimple', cms.PSet(inputTag=cms.InputTag( 'hpsPFTauDiscriminationByMuonRejectionSimple'), provenanceConfigLabel=cms.string('IDWPdefinitions'), idLabel=cms.string('ByTightMuonRejectionSimple'))) # Run TauIDs (anti-e && deepTau) on top of selectedPatTaus _updatedTauName = 'selectedPatTausNewIDs' _noUpdatedTauName = 'selectedPatTausNoNewIDs' import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig tauIdEmbedder = tauIdConfig.TauIDEmbedder( process, debug=False, updatedTauName=_updatedTauName, toKeep=['againstEle2018', 'deepTau2017v2p1']) tauIdEmbedder.runTauID() setattr(process, _noUpdatedTauName, process.selectedPatTaus.clone()) process.miniAODTausTask.add(getattr(process, _noUpdatedTauName)) delattr(process, 'selectedPatTaus') process.deepTau2017v2p1.taus = _noUpdatedTauName process.patTauDiscriminationByElectronRejectionMVA62018Raw.PATTauProducer = _noUpdatedTauName process.patTauDiscriminationByElectronRejectionMVA62018.PATTauProducer = _noUpdatedTauName process.selectedPatTaus = getattr( process, _updatedTauName).clone(src=_noUpdatedTauName) process.newTauIDsTask = cms.Task(process.rerunMvaIsolationTask, process.selectedPatTaus) process.miniAODTausTask.add(process.newTauIDsTask)
import FWCore.ParameterSet.Config as cms from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets ############################################################################## # Standard AK8 Jets#################################################### ########################## ak8PFJets = ak4PFJets.clone(rParam=cms.double(0.8), jetPtMin=cms.double(50.0)) ############################################################################## # AK8 jets with various pileup subtraction schemes ############################################################################## ak8PFJetsPuppi = ak8PFJets.clone(src=cms.InputTag("puppi")) ak8PFJetsCHS = ak8PFJets.clone(src=cms.InputTag("pfNoPileUpJME")) from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018 pp_on_AA_2018.toModify(ak8PFJetsCHS, src="pfNoPileUpJMEHI", inputEtMin=9999) ak8PFJetsCS = ak8PFJets.clone( useConstituentSubtraction=cms.bool(True), csRParam=cms.double(0.4), csRho_EtaMax=ak8PFJets. Rho_EtaMax, # Just use the same eta for both C.S. and rho by default useExplicitGhosts=cms.bool(True), doAreaFastjet=cms.bool(True), jetPtMin=cms.double(100.0)) ############################################################################## # Preclustered constituents for substructure, various subtraction schemes
import FWCore.ParameterSet.Config as cms from RecoJets.JetProducers.PFJetParameters_cfi import * from RecoJets.JetProducers.AnomalousCellParameters_cfi import * from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets ak4PFJetsPuppi = ak4PFJets.clone( src = cms.InputTag("puppi") )
pfMet.calculateSignificance = False l1MetCalo = pfMet.clone(src="l1pfProducer:Calo") l1MetTK = pfMet.clone(src="l1pfProducer:TK") l1MetTKV = pfMet.clone(src="l1pfProducer:TKVtx") l1MetTightTK = pfMet.clone(src="l1pfProducerTightTK:TK") l1MetTightTKV = pfMet.clone(src="l1pfProducerTightTK:TKVtx") l1MetPF = pfMet.clone(src="l1pfProducer:PF") l1MetPuppi = pfMet.clone(src="l1pfProducer:Puppi") l1PFMets = cms.Sequence(l1MetCalo + l1MetTK + l1MetTKV + l1MetPF + l1MetPuppi + l1MetTightTK + l1MetTightTKV) phase2_SimL1Emulator += l1PFMets # PF Jets # ######################################################################## from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets ak4L1Calo = ak4PFJets.clone(src='l1pfProducer:Calo') ak4L1TK = ak4PFJets.clone(src='l1pfProducer:TK') ak4L1TKV = ak4PFJets.clone(src='l1pfProducer:TKVtx') ak4L1TightTK = ak4PFJets.clone(src='l1pfProducerTightTK:TK') ak4L1TightTKV = ak4PFJets.clone(src='l1pfProducerTightTK:TKVtx') ak4L1PF = ak4PFJets.clone(src='l1pfProducer:PF') ak4L1Puppi = ak4PFJets.clone(src='l1pfProducer:Puppi') l1PFJets = cms.Sequence(ak4L1Calo + ak4L1TK + ak4L1TKV + ak4L1PF + ak4L1Puppi + ak4L1TightTK + ak4L1TightTKV) phase2_SimL1Emulator += l1PFJets from Configuration.Eras.Modifier_phase2_trigger_cff import phase2_trigger phase2_trigger.toReplaceWith(SimL1Emulator, phase2_SimL1Emulator)
groomedJets = cms.InputTag("AK8caPFJetsSoftDropCHS"), subjets = cms.InputTag("AK8caPFJetsSoftDropCHS", "SubJets"), bHadrons = cms.InputTag("selectedHadronsAndPartons","bHadrons"), cHadrons = cms.InputTag("selectedHadronsAndPartons","cHadrons"), partons = cms.InputTag("selectedHadronsAndPartons","algorithmicPartons"), jetAlgorithm = cms.string("AntiKt"), rParam = cms.double(0.8), ghostRescaling = cms.double(1e-18), hadronFlavourHasPriority = cms.bool(True) ) # take the default AK4 PFJet producer and modify accordingly for cone size and clustering algorithm from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets AK8PFJetsCHS = ak4PFJets.clone( src = cms.InputTag('pfNoPileUpJME'), jetAlgorithm = cms.string("AntiKt"), rParam = cms.double(0.8), jetPtMin = cms.double(150) ) # Pruned AK8caPFJetsPrunedCHS = AK8PFJetsCHS.clone( cms.PSet(nFilt = cms.int32(2), zcut = cms.double(0.1), rcut_factor = cms.double(0.5)), jetAlgorithm = cms.string("CambridgeAachen"), usePruning = cms.bool(True), useExplicitGhosts = cms.bool(True), writeCompound = cms.bool(True), jetCollInstanceName = cms.string("SubJets") )
def makeFatJets(process, isData, label, candidates, ptMin=100.): """ @param label: AK8PFchs, CA15PFPuppi, etc. """ matches = re.match('(AK|CA)([0-9]+)PF(.+)', label) if not matches: raise RuntimeError('Unknown algo label ' + label) algo = matches.group(1) + matches.group(2) # set up radius and algoName from the input label radius = float(matches.group(2)) * 0.1 if matches.group(1) == 'CA': algoName = 'CambridgeAachen' elif matches.group(1) == 'AK': algoName = 'AntiKt' pu = matches.group(3) if pu == 'chs': jecLabel = 'AK8PFchs' # regardless of jet algo elif pu == 'Puppi': jecLabel = 'AK8PFPuppi' # regardless of jet algo else: raise RuntimeError('Unknown PU mitigation ' + pu) sdZcut, sdBeta = sdParams(radius) sequence = cms.Sequence() # Callable object that adds the second argument to process and sequence with label attached as suffix addattr = AddAttr(process, sequence, label) ######################################## ## REMAKE JETS ## ######################################## pfJets = addattr( 'pfJets', ak4PFJets.clone(jetAlgorithm=cms.string(algoName), rParam=cms.double(radius), src=cms.InputTag(candidates), jetPtMin=cms.double(ptMin))) pfJetsSoftDrop = addattr( 'pfJetsSoftDrop', ak4PFJets.clone(jetAlgorithm=cms.string(algoName), rParam=cms.double(radius), src=cms.InputTag(candidates), jetPtMin=cms.double(ptMin), useSoftDrop=cms.bool(True), R0=cms.double(radius), zcut=cms.double(sdZcut), beta=cms.double(sdBeta), writeCompound=cms.bool(True), useExplicitGhosts=cms.bool(True), jetCollInstanceName=cms.string("SubJets"))) subjets = cms.InputTag(pfJetsSoftDrop.getModuleLabel(), 'SubJets') pfJetsPruned = addattr( 'pfJetsPruned', ak4PFJets.clone( jetAlgorithm=cms.string(algoName), rParam=cms.double(radius), src=cms.InputTag(candidates), jetPtMin=cms.double(ptMin), usePruning=cms.bool(True), useExplicitGhosts=cms.bool(True), writeCompound=cms.bool(True), zcut=cms.double(0.1), # no idea if these parameters are correct rcut_factor=cms.double(0.5), nFilt=cms.int32(2), jetCollInstanceName=cms.string("SubJets"))) ######################################## ## SUBSTRUCTURE ## ####################################### Njettiness = addattr( 'Njettiness', nJettinessAdder_cfi.Njettiness.clone(src=pfJets, R0=cms.double(radius), Njets=cms.vuint32(1, 2, 3, 4))) sdKinematics = addattr( 'sdKinematics', cms.EDProducer('RecoJetDeltaRValueMapProducer', src=pfJets, matched=pfJetsSoftDrop, distMax=cms.double(radius), values=cms.vstring('mass'), valueLabels=cms.vstring('Mass'))) prunedKinematics = addattr( 'prunedKinematics', cms.EDProducer('RecoJetDeltaRValueMapProducer', src=pfJets, matched=pfJetsPruned, distMax=cms.double(radius), values=cms.vstring('mass'), valueLabels=cms.vstring('Mass'))) ### subjet qg-tagging ### subQGTag = addattr( 'subQGTag', QGTagger.clone(srcJets=subjets, jetsLabel=cms.string('QGL_AK4PFchs'))) ### subjet b-tagging ### # sets up process.pfCombinedInclusiveSecondaryVertexV2BJetTags(label)Subjets (and necessary inputs) sequence += setupBTag( process, jetCollection=subjets, suffix=label + 'Subjets', vsuffix='', tags=['pfCombinedInclusiveSecondaryVertexV2BJetTags']) ######################################## ## MAKE PAT JETS ## ######################################## ## MAIN JET ## jecLevels = ['L1FastJet', 'L2Relative', 'L3Absolute'] if isData: jecLevels.append('L2L3Residual') jetCorrFactors = addattr( 'jetCorrFactors', jetUpdater_cff.patJetCorrFactors.clone(src=pfJets, payload=jecLabel, levels=jecLevels, primaryVertices=pvSource)) if not isData: genJetMatch = addattr( 'genJetMatch', patJetGenJetMatch.clone(src=pfJets, maxDeltaR=radius, matched='genJetsNoNu' + algo)) patJets = addattr( 'patJets', jetProducer_cfi.patJets.clone(jetSource=pfJets, addJetCorrFactors=True, addBTagInfo=False, addAssociatedTracks=False, addJetCharge=False, addGenPartonMatch=False, addGenJetMatch=(not isData), getJetMCFlavour=False, addJetFlavourInfo=False)) patJetsMod = addattr.last patJetsMod.jetCorrFactorsSource = [jetCorrFactors] if not isData: patJetsMod.genJetMatch = genJetMatch for tau in ['tau1', 'tau2', 'tau3', 'tau4']: patJetsMod.userData.userFloats.src.append(Njettiness.getModuleLabel() + ':' + tau) patJetsMod.userData.userFloats.src.append(sdKinematics.getModuleLabel() + ':Mass') patJetsMod.userData.userFloats.src.append( prunedKinematics.getModuleLabel() + ':Mass') selectedPatJets = addattr( 'selectedPatJets', jetSelector_cfi.selectedPatJets.clone(src=patJets, cut='abs(eta) < 2.5')) ## SOFT DROP ## patJetsSoftDrop = addattr( 'patJetsSoftDrop', jetProducer_cfi._patJets.clone(jetSource=pfJetsSoftDrop, addJetCorrFactors=False, addBTagInfo=False, addAssociatedTracks=False, addJetCharge=False, addGenPartonMatch=False, addGenJetMatch=False, getJetMCFlavour=False, addJetFlavourInfo=False)) selectedPatJetsSoftDrop = addattr( 'selectedPatJetsSoftDrop', jetSelector_cfi.selectedPatJets.clone(src=patJetsSoftDrop, cut='abs(eta) < 2.5')) if not isData: genSubjetsMatch = addattr( 'genSubjetMatch', patJetGenJetMatch.clone(src=subjets, maxDeltaR=0.4, matched='genJetsNoNuSoftDrop' + algo + ':SubJets')) patSubjets = addattr( 'patSubjets', jetProducer_cfi._patJets.clone( jetSource=subjets, addJetCorrFactors=False, addBTagInfo=True, discriminatorSources=[ 'pfCombinedInclusiveSecondaryVertexV2BJetTags' + label + 'Subjets' ], addAssociatedTracks=False, addJetCharge=False, addGenPartonMatch=False, addGenJetMatch=(not isData), getJetMCFlavour=False, addJetFlavourInfo=False)) patSubjetsMod = addattr.last patSubjetsMod.userData.userFloats.src.append( cms.InputTag(subQGTag.getModuleLabel(), 'qgLikelihood')) if not isData: patSubjetsMod.genJetMatch = genSubjetsMatch ## MERGE SUBJETS BACK ## jetMerger = addattr( 'jetMerger', cms.EDProducer("BoostedJetMerger", jetSrc=selectedPatJetsSoftDrop, subjetSrc=patSubjets)) ## PACK ## addattr( 'packedPatJets', cms.EDProducer("JetSubstructurePacker", jetSrc=selectedPatJets, distMax=cms.double(radius), algoTags=cms.VInputTag(jetMerger), algoLabels=cms.vstring('SoftDrop'), fixDaughters=cms.bool(False))) return sequence
def addFlashggPFCHSJets(process, vertexIndex = 0, doQGTagging = True, label ='', debug = False): setattr(process, 'selectedMuons' + label, cms.EDFilter("CandPtrSelector", src = cms.InputTag("slimmedMuons"), cut = cms.string('''abs(eta)<2.5 && pt>10. && (pfIsolationR04().sumChargedHadronPt+ max(0.,pfIsolationR04().sumNeutralHadronEt+ pfIsolationR04().sumPhotonEt- 0.50*pfIsolationR04().sumPUPt))/pt < 0.20 && (isPFMuon && (isGlobalMuon || isTrackerMuon) )'''))) setattr(process, 'selectedElectrons' + label, cms.EDFilter("CandPtrSelector", src = cms.InputTag("slimmedElectrons"), cut = cms.string('''abs(eta)<2.5 && pt>20. && gsfTrack.isAvailable() && gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2 && (pfIsolationVariables().sumChargedHadronPt+ max(0.,pfIsolationVariables().sumNeutralHadronEt+ pfIsolationVariables().sumPhotonEt- 0.5*pfIsolationVariables().sumPUPt))/pt < 0.15'''))) # Simple producer which just removes the Candidates which # don't come from the legacy vertex according to the Flashgg Vertex Map setattr(process,'flashggCHSLegacyVertexCandidates' + label, cms.EDProducer('FlashggMultiCHSLegacyVertexCandProducer', PFCandidatesTag = cms.InputTag('packedPFCandidates'), DiPhotonTag = cms.InputTag('flashggDiPhotons'), VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"), VertexTag = cms.InputTag('offlineSlimmedPrimaryVertices'), vertexIndex = cms.untracked.uint32(vertexIndex), debug = cms.untracked.bool(debug) ) ) setattr(process, 'pfCHSLeg' + label, cms.EDFilter("CandPtrSelector", src = cms.InputTag('flashggCHSLegacyVertexCandidates' + label), cut = cms.string(''))) # then remove the previously selected muons setattr(process, 'pfNoMuonCHSLeg' + label, cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfCHSLeg" + label), veto = cms.InputTag("selectedMuons" + label))) # then remove the previously selected electrons setattr(process, 'pfNoElectronsCHSLeg' + label, cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfNoMuonCHSLeg" + label), veto = cms.InputTag("selectedElectrons" + label))) #Import RECO jet producer for ak4 PF and GEN jet from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets #from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets setattr(process, 'ak4PFJetsCHSLeg' + label, ak4PFJets.clone ( src = 'pfNoElectronsCHSLeg' + label, doAreaFastjet = True)) #process.ak4GenJetsLeg = ak4GenJets.clone( src = 'packedGenParticles') # NOTE: this is the 74X recipe for the jet clustering addJetCollection( process, postfix = label, labelName = 'AK4PFCHSLeg', jetSource = cms.InputTag('ak4PFJetsCHSLeg' + label), pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), pfCandidates = cms.InputTag('packedPFCandidates'), svSource = cms.InputTag('slimmedSecondaryVertices'), btagDiscriminators = [ flashggBTag ], jetCorrections = ('AK4PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'), genJetCollection = cms.InputTag('slimmedGenJets'), genParticles = cms.InputTag('prunedGenParticles'), # jet param algo = 'AK', rParam = 0.4 ) #adjust PV used for Jet Corrections #process.patJetCorrFactorsAK4PFCHSLeg.primaryVertices = "offlineSlimmedPrimaryVertices" getattr(process, 'patJetCorrFactorsAK4PFCHSLeg' + label).primaryVertices = "offlineSlimmedPrimaryVertices" # Flashgg Jet producer using the collection created with function above. flashggJets = cms.EDProducer('FlashggJetProducer', DiPhotonTag = cms.InputTag('flashggDiPhotons'), VertexTag = cms.InputTag('offlineSlimmedPrimaryVertices'), JetTag = cms.InputTag('patJetsAK4PFCHSLeg' + label), VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"), # PileupJetIdParameters = cms.PSet(pu_jetid) ) setattr( process, 'flashggPFCHSJets'+ label, flashggJets) if doQGTagging: from RecoJets.JetProducers.QGTagger_cfi import QGTagger setattr( process, 'QGTaggerPFCHS' + label, QGTagger.clone( srcJets = 'flashggPFCHSJets' + label ,jetsLabel = 'ak4PFJetsCHS')) flashggSelectedJets = cms.EDFilter("FLASHggJetSelector", src = cms.InputTag( 'flashggPFCHSJets'+ label ), cut = cms.string("pt > 15.") ) setattr( process, 'flashggSelectedPFCHSJets'+label, flashggSelectedJets )
def nanoAOD_recalibrateMETs(process, isData): # add DeepMETs nanoAOD_DeepMET_switch = cms.PSet(ResponseTune_Graph=cms.untracked.string( 'RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2018.pb')) for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016: modifier.toModify( nanoAOD_DeepMET_switch, ResponseTune_Graph=cms.untracked.string( "RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2016.pb" )) print("add DeepMET Producers") process.load('RecoMET.METPUSubtraction.deepMETProducer_cfi') process.deepMETsResolutionTune = process.deepMETProducer.clone() process.deepMETsResponseTune = process.deepMETProducer.clone() process.deepMETsResponseTune.graph_path = nanoAOD_DeepMET_switch.ResponseTune_Graph.value( ) runMetCorAndUncFromMiniAOD(process, isData=isData) process.nanoSequenceCommon.insert(2, cms.Sequence(process.fullPatMetSequence)) from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD makePuppiesFromMiniAOD(process, True) process.puppiNoLep.useExistingWeights = True process.puppi.useExistingWeights = True run2_nanoAOD_106Xv1.toModify(process.puppiNoLep, useExistingWeights=False) run2_nanoAOD_106Xv1.toModify(process.puppi, useExistingWeights=False) print("will make Puppies on top of MINIAOD") # makePuppiesFromMiniAOD(process,True) # call this before in the global customizer otherwise it would reset photon IDs in VID nanoAOD_PuppiV15_switch = cms.PSet( recoMetFromPFCs=cms.untracked.bool(False), reclusterJets=cms.untracked.bool(False), ) run2_nanoAOD_106Xv1.toModify(nanoAOD_PuppiV15_switch, recoMetFromPFCs=True, reclusterJets=True) if nanoAOD_PuppiV15_switch.reclusterJets: from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask, addToProcessAndTask task = getPatAlgosToolsTask(process) addToProcessAndTask( 'ak4PuppiJets', ak4PFJets.clone(src='puppi', doAreaFastjet=True, jetPtMin=10.), process, task) from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection addJetCollection( process, labelName='Puppi', jetSource=cms.InputTag('ak4PuppiJets'), algo='AK', rParam=0.4, genJetCollection=cms.InputTag('slimmedGenJets'), jetCorrections=('AK4PFPuppi', [ 'L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual' ], 'None'), pfCandidates=cms.InputTag('packedPFCandidates'), pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'), svSource=cms.InputTag('slimmedSecondaryVertices'), muSource=cms.InputTag('slimmedMuons'), elSource=cms.InputTag('slimmedElectrons'), genParticles=cms.InputTag('prunedGenParticles'), getJetMCFlavour=False) process.patJetsPuppi.addGenPartonMatch = cms.bool(False) process.patJetsPuppi.addGenJetMatch = cms.bool(False) print("nanoAOD_PuppiV15_switch.reclusterJets is true") runMetCorAndUncFromMiniAOD( process, isData=isData, metType="Puppi", postfix="Puppi", jetFlavor="AK4PFPuppi", recoMetFromPFCs=bool(nanoAOD_PuppiV15_switch.recoMetFromPFCs), reclusterJets=bool(nanoAOD_PuppiV15_switch.reclusterJets)) process.nanoSequenceCommon.insert( 2, cms.Sequence(process.puppiMETSequence + process.fullPatMetSequencePuppi)) return process
import FWCore.ParameterSet.Config as cms from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy from Configuration.Eras.Modifier_run2_nanoAOD_92X_cff import run2_nanoAOD_92X from PhysicsTools.NanoAOD.common_cff import * ##################### User floats producers, selectors ########################## from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets chsForSATkJets = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string('charge()!=0 && pvAssociationQuality()>=5 && vertexRef().key()==0')) softActivityJets = ak4PFJets.clone(src = 'chsForSATkJets', doAreaFastjet = False, jetPtMin=1) softActivityJets10 = cms.EDFilter("CandPtrSelector", src = cms.InputTag("chsForSATkJets"), cut = cms.string('pt>10')) softActivityJets5 = cms.EDFilter("CandPtrSelector", src = cms.InputTag("chsForSATkJets"), cut = cms.string('pt>5')) softActivityJets2 = cms.EDFilter("CandPtrSelector", src = cms.InputTag("chsForSATkJets"), cut = cms.string('pt>2')) looseJetId = cms.EDProducer("PatJetIDValueMapProducer", filterParams=cms.PSet( version = cms.string('WINTER16'), quality = cms.string('LOOSE'), ), src = cms.InputTag("slimmedJets") ) tightJetId = cms.EDProducer("PatJetIDValueMapProducer", filterParams=cms.PSet( version = cms.string('WINTER16'), quality = cms.string('TIGHT'), ), src = cms.InputTag("slimmedJets") )
import FWCore.ParameterSet.Config as cms from RecoJets.JetProducers.PFJetParameters_cfi import * from RecoJets.JetProducers.AnomalousCellParameters_cfi import * from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets ak4PFJetsSoftDrop = ak4PFJets.clone( useSoftDrop=cms.bool(True), zcut=cms.double(0.1), beta=cms.double(0.0), R0=cms.double(0.4), useExplicitGhosts=cms.bool(True), writeCompound=cms.bool(True), jetCollInstanceName=cms.string("SubJets"), )
def adaptTauToMiniAODReReco(self, reclusterJets=True): # TRYING TO MAKE THINGS MINIAOD COMPATIBLE, FROM THE START, TO THE END, 1 BY 1 #print '[adaptTauToMiniAODReReco]: Start' jetCollection = 'slimmedJets' # Add new jet collections if reclustering is demanded if self.runBoosted: jetCollection = 'boostedTauSeedsPAT' + self.postfix from RecoTauTag.Configuration.boostedHPSPFTaus_cff import ca8PFJetsCHSprunedForBoostedTaus setattr( self.process, 'ca8PFJetsCHSprunedForBoostedTausPAT' + self.postfix, ca8PFJetsCHSprunedForBoostedTaus.clone( src='packedPFCandidates', jetCollInstanceName='subJetsForSeedingBoostedTausPAT')) setattr( self.process, 'boostedTauSeedsPAT' + self.postfix, cms.EDProducer( "PATBoostedTauSeedsProducer", subjetSrc=cms.InputTag( 'ca8PFJetsCHSprunedForBoostedTausPAT' + self.postfix, 'subJetsForSeedingBoostedTausPAT'), pfCandidateSrc=cms.InputTag('packedPFCandidates'), verbosity=cms.int32(0))) self.miniAODTausTask.add( getattr(self.process, 'ca8PFJetsCHSprunedForBoostedTausPAT' + self.postfix)) self.miniAODTausTask.add( getattr(self.process, 'boostedTauSeedsPAT' + self.postfix)) elif reclusterJets: jetCollection = 'patJetsPAT' + self.postfix from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets setattr(self.process, 'ak4PFJetsPAT' + self.postfix, ak4PFJets.clone(src="packedPFCandidates")) # trivial PATJets from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import _patJets setattr( self.process, 'patJetsPAT' + self.postfix, _patJets.clone( jetSource="ak4PFJetsPAT" + self.postfix, addJetCorrFactors=False, jetCorrFactorsSource=[], addBTagInfo=False, addDiscriminators=False, discriminatorSources=[], addAssociatedTracks=False, addJetCharge=False, addGenPartonMatch=False, embedGenPartonMatch=False, addGenJetMatch=False, getJetMCFlavour=False, addJetFlavourInfo=False, )) self.miniAODTausTask.add( getattr(self.process, 'ak4PFJetsPAT' + self.postfix)) self.miniAODTausTask.add( getattr(self.process, 'patJetsPAT' + self.postfix)) # so this adds all tracks to jet in some deltaR region. we don't have tracks so don't need it :D # self.process.ak4PFJetTracksAssociatorAtVertex.jets = cms.InputTag(jetCollection) # Remove ak4PFJetTracksAssociatorAtVertex from recoTauCommonSequence # Remove pfRecoTauTagInfoProducer from recoTauCommonSequence since it uses the jet-track association # HOWEVER, may use https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMiniAOD2017#Isolated_Tracks # probably needs recovery of the two modules above self.miniAODTausTask.remove( getattr(self.process, 'ak4PFJetTracksAssociatorAtVertex' + self.postfix)) self.miniAODTausTask.remove( getattr(self.process, 'pfRecoTauTagInfoProducer' + self.postfix)) self.miniAODTausTask.remove( getattr(self.process, 'recoTauAK4PFJets08Region' + self.postfix)) setattr( self.process, 'recoTauAK4Jets08RegionPAT' + self.postfix, cms.EDProducer( "RecoTauPatJetRegionProducer", deltaR=self.process.recoTauAK4PFJets08Region.deltaR, maxJetAbsEta=self.process.recoTauAK4PFJets08Region. maxJetAbsEta, minJetPt=self.process.recoTauAK4PFJets08Region.minJetPt, pfCandAssocMapSrc=cms.InputTag(""), pfCandSrc=cms.InputTag("packedPFCandidates"), src=cms.InputTag(jetCollection))) _jetRegionProducer = getattr( self.process, 'recoTauAK4Jets08RegionPAT' + self.postfix) self.miniAODTausTask.add(_jetRegionProducer) if self.runBoosted: _jetRegionProducer.pfCandAssocMapSrc = cms.InputTag( jetCollection, 'pfCandAssocMapForIsolation') getattr(self.process, 'recoTauPileUpVertices' + self.postfix).src = "offlineSlimmedPrimaryVertices" for moduleName in self.miniAODTausTask.moduleNames(): self.convertModuleToMiniAODInput(moduleName) # Adapt TauPiZeros producer _piZeroProducer = getattr(self.process, 'ak4PFJetsLegacyHPSPiZeros' + self.postfix) for builder in _piZeroProducer.builders: builder.qualityCuts.primaryVertexSrc = "offlineSlimmedPrimaryVertices" _piZeroProducer.jetSrc = jetCollection # Adapt TauChargedHadrons producer _chargedHadronProducer = getattr( self.process, 'ak4PFJetsRecoTauChargedHadrons' + self.postfix) for builder in _chargedHadronProducer.builders: builder.qualityCuts.primaryVertexSrc = "offlineSlimmedPrimaryVertices" if builder.name.value( ) == 'tracks': #replace plugin based on generalTracks by one based on lostTracks builder.name = 'lostTracks' builder.plugin = 'PFRecoTauChargedHadronFromLostTrackPlugin' builder.srcTracks = "lostTracks" if self.runBoosted: builder.dRcone = 0.3 builder.dRconeLimitedToJetArea = True _chargedHadronProducer.jetSrc = jetCollection # Adapt combinatoricRecoTau producer _combinatoricRecoTauProducer = getattr( self.process, 'combinatoricRecoTaus' + self.postfix) _combinatoricRecoTauProducer.jetRegionSrc = 'recoTauAK4Jets08RegionPAT' + self.postfix _combinatoricRecoTauProducer.jetSrc = jetCollection # Adapt builders for builder in _combinatoricRecoTauProducer.builders: for name, value in builder.parameters_().items(): if name == 'qualityCuts': builder.qualityCuts.primaryVertexSrc = 'offlineSlimmedPrimaryVertices' elif name == 'pfCandSrc': builder.pfCandSrc = 'packedPFCandidates' # Adapt supported modifiers and remove unsupported ones _modifiersToRemove = cms.VPSet() for mod in _combinatoricRecoTauProducer.modifiers: if mod.name.value() == 'elec_rej': _modifiersToRemove.append(mod) continue elif mod.name.value() == 'TTIworkaround': _modifiersToRemove.append(mod) continue for name, value in mod.parameters_().items(): if name == 'qualityCuts': mod.qualityCuts.primaryVertexSrc = 'offlineSlimmedPrimaryVertices' for mod in _modifiersToRemove: _combinatoricRecoTauProducer.modifiers.remove(mod) #print "\t\t Removing '%s' modifier from 'combinatoricRecoTaus'" %mod.name.value() # Redefine tau PV producer _tauPVProducer = getattr( self.process, 'hpsPFTauPrimaryVertexProducer' + self.postfix) _tauPVProducer.__dict__[ '_TypedParameterizable__type'] = 'PFTauMiniAODPrimaryVertexProducer' _tauPVProducer.PVTag = 'offlineSlimmedPrimaryVertices' _tauPVProducer.packedCandidatesTag = cms.InputTag("packedPFCandidates") _tauPVProducer.lostCandidatesTag = cms.InputTag("lostTracks") # Redefine tau SV producer setattr( self.process, 'hpsPFTauSecondaryVertexProducer' + self.postfix, cms.EDProducer("PFTauSecondaryVertexProducer", PFTauTag=cms.InputTag("hpsPFTauProducer" + self.postfix))) # Remove RecoTau producers which are not supported (yet?), i.e. against-e/mu discriminats for moduleName in self.miniAODTausTask.moduleNames(): if 'ElectronRejection' in moduleName or 'MuonRejection' in moduleName: if 'ByDeadECALElectronRejection' in moduleName: continue self.miniAODTausTask.remove(getattr(self.process, moduleName)) # Instead add against-mu discriminants which are MiniAOD compatible from RecoTauTag.RecoTau.hpsPFTauDiscriminationByMuonRejectionSimple_cff import hpsPFTauDiscriminationByMuonRejectionSimple setattr( self.process, 'hpsPFTauDiscriminationByMuonRejectionSimple' + self.postfix, hpsPFTauDiscriminationByMuonRejectionSimple.clone( PFTauProducer="hpsPFTauProducer" + self.postfix)) _tauIDAntiMuSimple = getattr( self.process, 'hpsPFTauDiscriminationByMuonRejectionSimple' + self.postfix) if self.runBoosted: _tauIDAntiMuSimple.dRmuonMatch = 0.1 self.miniAODTausTask.add(_tauIDAntiMuSimple) ##### # PAT part in the following getattr(self.process, 'tauGenJets' + self.postfix).GenParticles = "prunedGenParticles" getattr(self.process, 'tauMatch' + self.postfix).matched = "prunedGenParticles" # Remove unsupported tauIDs _patTauProducer = getattr(self.process, 'patTaus' + self.postfix) for name, src in _patTauProducer.tauIDSources.parameters_().items(): if name.find('againstElectron') > -1 or name.find( 'againstMuon') > -1: if name.find('againstElectronDeadECAL') > -1: continue delattr(_patTauProducer.tauIDSources, name) # Add MiniAOD specific ones setattr( _patTauProducer.tauIDSources, 'againstMuonLooseSimple', cms.PSet(inputTag=cms.InputTag( 'hpsPFTauDiscriminationByMuonRejectionSimple' + self.postfix), provenanceConfigLabel=cms.string('IDWPdefinitions'), idLabel=cms.string('ByLooseMuonRejectionSimple'))) setattr( _patTauProducer.tauIDSources, 'againstMuonTightSimple', cms.PSet(inputTag=cms.InputTag( 'hpsPFTauDiscriminationByMuonRejectionSimple' + self.postfix), provenanceConfigLabel=cms.string('IDWPdefinitions'), idLabel=cms.string('ByTightMuonRejectionSimple'))) # Run TauIDs (anti-e && deepTau) on top of selectedPatTaus _updatedTauName = 'selectedPatTausNewIDs' + self.postfix _noUpdatedTauName = 'selectedPatTausNoNewIDs' + self.postfix toKeep = ['againstEle2018'] if not self.runBoosted: toKeep.append('deepTau2017v2p1') import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig tauIdEmbedder = tauIdConfig.TauIDEmbedder( self.process, debug=False, originalTauName=_noUpdatedTauName, updatedTauName=_updatedTauName, postfix="MiniAODTaus" + self.postfix, toKeep=toKeep) tauIdEmbedder.runTauID() setattr( self.process, _noUpdatedTauName, getattr(self.process, 'selectedPatTaus' + self.postfix).clone()) self.miniAODTausTask.add(getattr(self.process, _noUpdatedTauName)) delattr(self.process, 'selectedPatTaus' + self.postfix) setattr(self.process, 'selectedPatTaus' + self.postfix, getattr(self.process, _updatedTauName).clone()) delattr(self.process, _updatedTauName) setattr( self.process, 'newTauIDsTask' + self.postfix, cms.Task( getattr(self.process, 'rerunMvaIsolationTaskMiniAODTaus' + self.postfix), getattr(self.process, 'selectedPatTaus' + self.postfix))) self.miniAODTausTask.add( getattr(self.process, 'newTauIDsTask' + self.postfix))
groomedJets = cms.InputTag("AK8caPFJetsSoftDropPuppi"), subjets = cms.InputTag("AK8caPFJetsSoftDropPuppi", "SubJets"), bHadrons = cms.InputTag("selectedHadronsAndPartons","bHadrons"), cHadrons = cms.InputTag("selectedHadronsAndPartons","cHadrons"), partons = cms.InputTag("selectedHadronsAndPartons","algorithmicPartons"), jetAlgorithm = cms.string("AntiKt"), rParam = cms.double(0.8), ghostRescaling = cms.double(1e-18), hadronFlavourHasPriority = cms.bool(True) ) # take the default AK4 PFJet producer and modify accordingly for cone size and clustering algorithm from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets AK8PFJetsPuppi = ak4PFJets.clone( src = cms.InputTag('puppi'), jetAlgorithm = cms.string("AntiKt"), rParam = cms.double(0.8), jetPtMin = cms.double(150) ) # Pruned AK8caPFJetsPrunedPuppi = AK8PFJetsPuppi.clone( cms.PSet(nFilt = cms.int32(2), zcut = cms.double(0.1), rcut_factor = cms.double(0.5)), jetAlgorithm = cms.string("AntiKt"), usePruning = cms.bool(True), useExplicitGhosts = cms.bool(True), writeCompound = cms.bool(True), jetCollInstanceName = cms.string("SubJets") )
0.5*pfIsolationVariables().sumPUPt))/pt < 0.15''')) ## Do projections process.pfCHS = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("fromPV")) process.pfNoMuonCHS = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfCHS"), veto = cms.InputTag("selectedMuons")) process.pfNoElectronsCHS = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfNoMuonCHS"), veto = cms.InputTag("selectedElectrons")) process.pfNoMuon = cms.EDProducer("CandPtrProjector", src = cms.InputTag("packedPFCandidates"), veto = cms.InputTag("selectedMuons")) process.pfNoElectrons = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfNoMuon"), veto = cms.InputTag("selectedElectrons")) process.packedGenParticlesForJetsNoNu = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedGenParticles"), cut = cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16")) process.ak4GenJetsNoNu = ak4GenJets.clone(src = 'packedGenParticlesForJetsNoNu') if options.useTTbarFilter: if options.usePFchs: process.ak4PFJets = ak4PFJets.clone(src = 'pfCHS', doAreaFastjet = True) else: process.ak4PFJets = ak4PFJets.clone(src = 'packedPFCandidates', doAreaFastjet = True) else: if options.usePFchs: if options.useTopProjections: process.ak4PFJets = ak4PFJets.clone(src = 'pfNoElectronsCHS', doAreaFastjet = True) else: process.ak4PFJets = ak4PFJets.clone(src = 'pfCHS', doAreaFastjet = True) else: if options.useTopProjections: process.ak4PFJets = ak4PFJets.clone(src = 'pfNoElectrons', doAreaFastjet = True) else: process.ak4PFJets = ak4PFJets.clone(src = 'packedPFCandidates', doAreaFastjet = True) from PhysicsTools.PatAlgos.tools.jetTools import *
def addFlashggPFCHS0(process): print "JET PRODUCER :: Flashgg PFCHS producer ::" # leptons to remove as per default CHS workflow # select the isolated leptons : electrons + muons process.selectedMuons = cms.EDFilter("CandPtrSelector", src = cms.InputTag("slimmedMuons"), cut = cms.string('''abs(eta)<2.5 && pt>10. && (pfIsolationR04().sumChargedHadronPt+ max(0.,pfIsolationR04().sumNeutralHadronEt+ pfIsolationR04().sumPhotonEt- 0.50*pfIsolationR04().sumPUPt))/pt < 0.20 && (isPFMuon && (isGlobalMuon || isTrackerMuon) )''')) process.selectedElectrons = cms.EDFilter("CandPtrSelector", src = cms.InputTag("slimmedElectrons"), cut = cms.string('''abs(eta)<2.5 && pt>20. && gsfTrack.isAvailable() && gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2 && (pfIsolationVariables().sumChargedHadronPt+ max(0.,pfIsolationVariables().sumNeutralHadronEt+ pfIsolationVariables().sumPhotonEt- 0.5*pfIsolationVariables().sumPUPt))/pt < 0.15''')) # Simple producer which just removes the Candidates which # don't come from the legacy vertex according to the Flashgg Vertex Map process.flashggCHSLegacyVertexCandidates = cms.EDProducer('FlashggCHSLegacyVertexCandidateProducer', PFCandidatesTag = cms.InputTag('packedPFCandidates'), DiPhotonTag = cms.InputTag('flashggDiPhotons'), VertexCandidateMapTag = cms.InputTag("flashggVertexMapForCHS"), VertexTag = cms.InputTag('offlineSlimmedPrimaryVertices') ) process.pfCHS0 = cms.EDFilter("CandPtrSelector", src = cms.InputTag("flashggCHSLegacyVertexCandidates"), cut = cms.string("")) # then remove the previously selected muons process.pfNoMuonCHS0 = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfCHS0"), veto = cms.InputTag("selectedMuons")) # then remove the previously selected electrons process.pfNoElectronsCHS0 = cms.EDProducer("CandPtrProjector", src = cms.InputTag("pfNoMuonCHS0"), veto = cms.InputTag("selectedElectrons")) #Import RECO jet producer for ak4 PF and GEN jet from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.ak4PFJetsCHS0 = ak4PFJets.clone ( src = 'pfNoElectronsCHS0', doAreaFastjet = True) # NOTE : these line are from the new Jet recipe # The following is make patJets, but EI is done with the above process.load("Configuration.StandardSequences.MagneticField_cff") process.load("Configuration.Geometry.GeometryRecoDB_cff") process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") # cluster the jets # NOTE: this is the 74X recipe for the jet clustering addJetCollection( process, labelName = 'AK4PFCHS0', jetSource = cms.InputTag('ak4PFJetsCHS0'), pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), pfCandidates = cms.InputTag('packedPFCandidates'), svSource = cms.InputTag('slimmedSecondaryVertices'), btagDiscriminators = [ flashggBTag ], jetCorrections = ('AK4PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'), genParticles = cms.InputTag('prunedGenParticles'), genJetCollection = cms.InputTag('slimmedGenJets'), # jet param algo = 'AK', rParam = 0.4 ) #adjust PV used for Jet Corrections process.patJetCorrFactorsAK4PFCHS0.primaryVertices = "offlineSlimmedPrimaryVertices"
record = cms.string('JetCorrectionsRecord'), tag = cms.string('JetCorrectorParametersCollection_Summer19UL18_V5_DATA_AK4PFchs'), label = cms.untracked.string('AK4PFchs') ), cms.PSet( record = cms.string('JetCorrectionsRecord'), tag = cms.string('JetCorrectorParametersCollection_Summer19UL18_V5_DATA_AK4PFPuppi'), label = cms.untracked.string('AK4PFPuppi') ), ) ) process.es_prefer_jec = cms.ESPrefer('PoolDBESSource', 'jec') isMC = False from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.ak4PuppiJets = ak4PFJets.clone (src = 'puppi', doAreaFastjet = True, jetPtMin = 2.) from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection addJetCollection(process,labelName = 'Puppi', jetSource = cms.InputTag('ak4PuppiJets'), algo = 'AK', rParam=0.4, genJetCollection=cms.InputTag('slimmedGenJets'), jetCorrections = ('AK4PFPuppi', ['L1FastJet\ ', 'L2Relative', 'L3Absolute','L2L3Residual'], 'None'),pfCandidates = cms.InputTag('packedPFCandidates'), pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), svSource = cms.InputTag('slimmedSecondaryVertices'), muSource =cms.InputTag( 'slimmedMuons'), elSource = cms.InputTag('slimmedElectrons'), genParticles= cms.InputTag('prunedGenParticles'), getJetMCFlavour=False ) process.patJetsPuppi.addGenPartonMatch = cms.bool(isMC) process.patJetsPuppi.addGenJetMatch = cms.bool(isMC) UpdatePuppiTuneV15(process, runOnMC=False)
import FWCore.ParameterSet.Config as cms from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets ############################################################################## # Standard AK8 Jets#################################################### ########################## ak8PFJets = ak4PFJets.clone( rParam = cms.double(0.8), jetPtMin = cms.double(50.0) ) ############################################################################## # AK8 jets with various pileup subtraction schemes ############################################################################## ak8PFJetsPuppi = ak8PFJets.clone( src = cms.InputTag("puppi") ) ak8PFJetsCHS = ak8PFJets.clone( src = cms.InputTag("pfNoPileUpJME") ) ak8PFJetsCS = ak8PFJets.clone( useConstituentSubtraction = cms.bool(True), csRParam = cms.double(0.4), csRho_EtaMax = ak8PFJets.Rho_EtaMax, # Just use the same eta for both C.S. and rho by default useExplicitGhosts = cms.bool(True), doAreaFastjet = cms.bool(True),
from Configuration.Eras.Modifier_run2_jme_2017_cff import run2_jme_2017 from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy from PhysicsTools.NanoAOD.common_cff import * from RecoJets.JetProducers.ak4PFJetsBetaStar_cfi import * ##################### User floats producers, selectors ########################## from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets chsForSATkJets = cms.EDFilter( "CandPtrSelector", src=cms.InputTag("packedPFCandidates"), cut=cms.string( 'charge()!=0 && pvAssociationQuality()>=5 && vertexRef().key()==0')) softActivityJets = ak4PFJets.clone(src='chsForSATkJets', doAreaFastjet=False, jetPtMin=1) softActivityJets10 = cms.EDFilter("CandPtrSelector", src=cms.InputTag("softActivityJets"), cut=cms.string('pt>10')) softActivityJets5 = cms.EDFilter("CandPtrSelector", src=cms.InputTag("softActivityJets"), cut=cms.string('pt>5')) softActivityJets2 = cms.EDFilter("CandPtrSelector", src=cms.InputTag("softActivityJets"), cut=cms.string('pt>2')) from PhysicsTools.PatAlgos.recoLayer0.jetCorrFactors_cfi import * # Note: Safe to always add 'L2L3Residual' as MC contains dummy L2L3Residual corrections (always set to 1) # (cf. https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#CMSSW_7_6_4_and_above ) jetCorrFactorsNano = patJetCorrFactors.clone(
def addStandardPuppiJets(process, label ='', useLocalJEC = True, dbfile = 'flashgg/MetaData/data/PuppiJEC/PY8_RunIISpring15DR74_bx50_MC.db', debug = False): print ':: Running a standard PUPPI : --' from CommonTools.PileupAlgos.Puppi_cff import puppi from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection # from RecoJets.JetProducers.PileupJetIDParams_cfi import cutbased_new as pu_jetid from flashgg.MicroAOD.flashggJets_cfi import flashggBTag setattr(process, 'flashggStdPuppi' + label, puppi.clone( candName = cms.InputTag('packedPFCandidates'), vertexName = cms.InputTag('offlineSlimmedPrimaryVertices'), )) setattr(process, 'ak4PFJetsStdPuppi' + label, ak4PFJets.clone ( src = cms.InputTag('flashggStdPuppi'), doAreaFastjet = True )) if useLocalJEC : print ':: using a local JEC dbfile for PUPPI :', print ' -- ', dbfile from flashgg.MicroAOD.flashggJetTools_cfi import loadLocalJECDBfile loadLocalJECDBfile(process, dbfile = os.environ['CMSSW_BASE'] + '/src/' + dbfile, tag = 'JetCorrectorParametersCollection_PY8_RunIISpring15DR74_bx50_MC_AK4PUPPI', label = 'AK4PFPuppi') addJetCollection( process, postfix = 'std' + label, labelName = 'AK4PUPPI', jetSource = cms.InputTag('ak4PFJetsStdPuppi'), pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), pfCandidates = cms.InputTag('packedPFCandidates'), svSource = cms.InputTag('slimmedSecondaryVertices'), btagDiscriminators = [ flashggBTag ], jetCorrections = ('AK4PFchs',['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'), genJetCollection = cms.InputTag('slimmedGenJets'), genParticles = cms.InputTag('prunedGenParticles'), # jet param algo = 'AK', rParam = 0.4 ) getattr(process, 'patJetCorrFactorsAK4PUPPIstd' + label).primaryVertices = "offlineSlimmedPrimaryVertices" setattr(process, 'flashggStdPUPPIJets', cms.EDProducer('FlashggJetProducer', DiPhotonTag = cms.InputTag('flashggDiPhotons'), VertexTag = cms.InputTag('offlineSlimmedPrimaryVertices'), JetTag = cms.InputTag('patJetsAK4PUPPIstd' + label), VertexCandidateMapTag = cms.InputTag("flashggVertexMapForPUPPI"), UsePuppi = cms.untracked.bool(True), # PileupJetIdParameters = cms.PSet(pu_jetid)) ) ) setattr(process, 'selectedFlashggStdPUPPIJets' + label, cms.EDFilter("FLASHggJetSelector", src = cms.InputTag( 'flashggStdPUPPIJets'), cut = cms.string("pt > 15.")) )
process.packedGenParticlesForJetsNoNu = cms.EDFilter( "CandPtrSelector", src=cms.InputTag("packedGenParticles"), cut=cms.string("abs(pdgId) != 12 && abs(pdgId) != 14 && abs(pdgId) != 16")) ## Define GenJets from RecoJets.JetProducers.ak4GenJets_cfi import ak4GenJets process.ak4GenJetsNoNu = ak4GenJets.clone(src='packedGenParticlesForJetsNoNu') from RecoJets.JetProducers.ak5GenJets_cfi import ak5GenJets process.ak8GenJetsNoNu = ak5GenJets.clone(src='packedGenParticlesForJetsNoNu', rParam=0.8) ## Standard AK4 and AK8 jets without CHS from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets process.ak4PFJets = ak4PFJets.clone( src='packedPFCandidates', doAreaFastjet=True) #HERE!!! add jetPtMin = (fatjet_ptmin) process.ak8PFJets = ak4PFJets.clone(src='packedPFCandidates', rParam=0.8, doAreaFastjet=True, jetPtMin=fatjet_ptmin) ## Pruned AK8 without CHS from RecoJets.JetProducers.ak4PFJetsPruned_cfi import ak4PFJetsPruned process.ak8PFJetsPruned = ak4PFJetsPruned.clone(rParam=0.8, doAreaFastjet=True, src='packedPFCandidates', jetPtMin=fatjet_ptmin) ## Softdrop AK8 without CHS from RecoJets.JetProducers.ak4PFJetsSoftDrop_cfi import ak4PFJetsSoftDrop
import FWCore.ParameterSet.Config as cms from RecoJets.JetProducers.PFJetParameters_cfi import * from RecoJets.JetProducers.AnomalousCellParameters_cfi import * from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets ak4PFJetsCHSCS = ak4PFJets.clone( src = cms.InputTag("pfNoPileUpJME"), useConstituentSubtraction = cms.bool(True), csRParam = cms.double(0.4), csRho_EtaMax = ak4PFJets.Rho_EtaMax, # Just use the same eta for both C.S. and rho by default useExplicitGhosts = cms.bool(True), doAreaFastjet = cms.bool(True), jetPtMin = cms.double(100.0) )
src=cms.InputTag("pfCHS"), veto=cms.InputTag("selectedMuons")) process.pfNoElectronsCHS = cms.EDProducer( "CandPtrProjector", src=cms.InputTag("pfNoMuonCHS"), veto=cms.InputTag("selectedElectrons")) process.pfNoMuon = cms.EDProducer("CandPtrProjector", src=cms.InputTag("packedPFCandidates"), veto=cms.InputTag("selectedMuons")) process.pfNoElectrons = cms.EDProducer("CandPtrProjector", src=cms.InputTag("pfNoMuon"), veto=cms.InputTag("selectedElectrons")) process.ak4PFJets = ak4PFJets.clone( src='pfNoElectrons', doAreaFastjet=True ) # no idea while doArea is false by default, but it's True in RECO so we have to set it process.ak4PFJetsCHS = ak4PFJets.clone( src='pfNoElectronsCHS', doAreaFastjet=True ) # no idea while doArea is false by default, but it's True in RECO so we have to set it process.ak4GenJets = ak4GenJets.clone(src='packedGenParticles') # The following is make patJets, but EI is done with the above process.load("PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff") process.load("Configuration.EventContent.EventContent_cff") process.load('Configuration.StandardSequences.Geometry_cff') process.load('Configuration.StandardSequences.MagneticField_38T_cff') process.load( 'Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') from Configuration.AlCa.GlobalTag import GlobalTag process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc')
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 addFlashggPuppiJets( process, vertexIndex=0, doQGTagging=True, label='', useLocalJEC=True, dbfile='flashgg/MetaData/data/PuppiJEC/PY8_RunIISpring15DR74_bx50_MC.db', debug=False): from CommonTools.PileupAlgos.flashggPuppi_cff import flashggPuppi from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets # fill the puppi parameters setattr( process, 'flashggPuppi' + label, flashggPuppi.clone( candName=cms.InputTag('packedPFCandidates'), vertexName=cms.InputTag('offlineSlimmedPrimaryVertices'), diPhotonTag=cms.InputTag('flashggDiPhotons'), VertexCandidateMapTag=cms.InputTag('flashggVertexMapForPUPPI'), vertexIndex=cms.uint32(vertexIndex), debug=cms.untracked.bool(debug))) setattr( process, 'ak4PFJetsPuppi' + label, ak4PFJets.clone(src=cms.InputTag('flashggPuppi' + label), doAreaFastjet=True)) if useLocalJEC: print ':: using a local JEC dbfile for PUPPI :', print '\t -- ', dbfile from flashgg.MicroAOD.flashggJetTools_cfi import loadLocalJECDBfile loadLocalJECDBfile( process, dbfile=os.environ['CMSSW_BASE'] + '/src/' + dbfile, tag= 'JetCorrectorParametersCollection_PY8_RunIISpring15DR74_bx50_MC_AK4PUPPI', label='AK4PFPuppi') # do jet clustering addJetCollection( process, postfix = label, labelName = 'AK4PUPPI', jetSource = cms.InputTag('ak4PFJetsPuppi' + label), pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), pfCandidates = cms.InputTag('packedPFCandidates'), svSource = cms.InputTag('slimmedSecondaryVertices'),\ elSource = cms.InputTag("slimmedElectrons"), muSource = cms.InputTag("slimmedMuons"), runIVF = True, btagDiscriminators = [ flashggBTag, flashggCMVABTag ], jetCorrections = ('AK4PFPuppi',['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'), genJetCollection = cms.InputTag('slimmedGenJets'), genParticles = cms.InputTag('prunedGenParticles'), # jet param algo = 'AK', rParam = 0.4 ) getattr(process, 'patJetCorrFactorsAK4PUPPI' + label).primaryVertices = "offlineSlimmedPrimaryVertices" setattr( process, 'flashggPUPPIJets' + label, cms.EDProducer( 'FlashggJetProducer', DiPhotonTag=cms.InputTag('flashggDiPhotons'), VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'), JetTag=cms.InputTag('patJetsAK4PUPPI' + label), VertexCandidateMapTag=cms.InputTag("flashggVertexMapForPUPPI"), UsePuppi=cms.untracked.bool(True), ComputeSimpleRMS=cms.bool(True), ComputeRegVars=cms.bool(False) # PileupJetIdParameters = cms.PSet(pu_jetid) )) # randomize Jets from flashgg.MicroAOD.flashggRandomizedJetProducer_cfi import flashggRandomizedJets flashggRandomizedPUPPIJets = flashggRandomizedJets.clone() flashggRandomizedPUPPIJets.src = "flashggPUPPIJets" + label setattr(process.RandomNumberGeneratorService, 'flashggRandomizedPUPPIJets' + label, cms.PSet(initialSeed=cms.untracked.uint32(36421523 + int(label)))) setattr(process, 'flashggRandomizedPUPPIJets' + label, flashggRandomizedPUPPIJets) setattr( process, 'selectedFlashggPUPPIJets' + label, cms.EDFilter("FLASHggJetSelector", src=cms.InputTag('flashggRandomizedPUPPIJets' + label), cut=cms.string("pt > 15.")))
def addFlashggPuppiJets(process, vertexIndex = 0, doQGTagging = True, label ='', useLocalJEC = True, dbfile = 'flashgg/MetaData/data/PuppiJEC/PY8_RunIISpring15DR74_bx50_MC.db', debug = False): from CommonTools.PileupAlgos.flashggPuppi_cff import flashggPuppi from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets # fill the puppi parameters setattr(process, 'flashggPuppi' + label, flashggPuppi.clone( candName = cms.InputTag('packedPFCandidates'), vertexName = cms.InputTag('offlineSlimmedPrimaryVertices'), diPhotonTag = cms.InputTag('flashggDiPhotons'), VertexCandidateMapTag = cms.InputTag('flashggVertexMapForPUPPI'), vertexIndex = cms.uint32(vertexIndex), debug = cms.untracked.bool(debug) ) ) setattr ( process, 'ak4PFJetsPuppi' + label, ak4PFJets.clone ( src = cms.InputTag('flashggPuppi' + label), doAreaFastjet = True) ) if useLocalJEC : print ':: using a local JEC dbfile for PUPPI :', print '\t -- ', dbfile from flashgg.MicroAOD.flashggJetTools_cfi import loadLocalJECDBfile loadLocalJECDBfile(process, dbfile = os.environ['CMSSW_BASE'] + '/src/' + dbfile, tag = 'JetCorrectorParametersCollection_PY8_RunIISpring15DR74_bx50_MC_AK4PUPPI', label = 'AK4PFPuppi') # do jet clustering addJetCollection( process, postfix = label, labelName = 'AK4PUPPI', jetSource = cms.InputTag('ak4PFJetsPuppi' + label), pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), pfCandidates = cms.InputTag('packedPFCandidates'), svSource = cms.InputTag('slimmedSecondaryVertices'), btagDiscriminators = [ flashggBTag ], jetCorrections = ('AK4PFPuppi',['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'), genJetCollection = cms.InputTag('slimmedGenJets'), genParticles = cms.InputTag('prunedGenParticles'), # jet param algo = 'AK', rParam = 0.4 ) getattr(process, 'patJetCorrFactorsAK4PUPPI' + label).primaryVertices = "offlineSlimmedPrimaryVertices" setattr( process,'flashggPUPPIJets'+ label, cms.EDProducer('FlashggJetProducer', DiPhotonTag = cms.InputTag('flashggDiPhotons'), VertexTag = cms.InputTag('offlineSlimmedPrimaryVertices'), JetTag = cms.InputTag('patJetsAK4PUPPI' + label), VertexCandidateMapTag = cms.InputTag("flashggVertexMapForPUPPI"), UsePuppi = cms.untracked.bool(True), ComputeSimpleRMS = cms.bool(True) # PileupJetIdParameters = cms.PSet(pu_jetid) )) # randomize Jets from flashgg.MicroAOD.flashggRandomizedJetProducer_cfi import flashggRandomizedJets flashggRandomizedPUPPIJets = flashggRandomizedJets.clone() flashggRandomizedPUPPIJets.src = "flashggPUPPIJets" + label setattr(process.RandomNumberGeneratorService, 'flashggRandomizedPUPPIJets' + label, cms.PSet(initialSeed = cms.untracked.uint32(36421523 + int(label)))) setattr( process, 'flashggRandomizedPUPPIJets' + label, flashggRandomizedPUPPIJets ) setattr( process, 'selectedFlashggPUPPIJets'+ label, cms.EDFilter("FLASHggJetSelector", src = cms.InputTag( 'flashggRandomizedPUPPIJets'+ label ), cut = cms.string("pt > 15.") ))
def addFlashggPFCHSJets( process, isData, vertexIndex=0, #doQGTagging = True, label='', debug=False): setattr( process, 'selectedMuons' + label, cms.EDFilter("CandPtrSelector", src=cms.InputTag("slimmedMuons"), cut=cms.string('''abs(eta)<2.5 && pt>10. && (pfIsolationR04().sumChargedHadronPt+ max(0.,pfIsolationR04().sumNeutralHadronEt+ pfIsolationR04().sumPhotonEt- 0.50*pfIsolationR04().sumPUPt))/pt < 0.20 && (isPFMuon && (isGlobalMuon || isTrackerMuon) )''' ))) setattr( process, 'selectedElectrons' + label, cms.EDFilter("CandPtrSelector", src=cms.InputTag("slimmedElectrons"), cut=cms.string('''abs(eta)<2.5 && pt>20. && gsfTrack.isAvailable() && gsfTrack.hitPattern().numberOfLostHits(\'MISSING_INNER_HITS\') < 2 && (pfIsolationVariables().sumChargedHadronPt+ max(0.,pfIsolationVariables().sumNeutralHadronEt+ pfIsolationVariables().sumPhotonEt- 0.5*pfIsolationVariables().sumPUPt))/pt < 0.15''' ))) # Simple producer which just removes the Candidates which # don't come from the legacy vertex according to the Flashgg Vertex Map setattr( process, 'flashggCHSLegacyVertexCandidates' + label, cms.EDProducer( 'FlashggMultiCHSLegacyVertexCandProducer', PFCandidatesTag=cms.InputTag('packedPFCandidates'), DiPhotonTag=cms.InputTag('flashggDiPhotons'), VertexCandidateMapTag=cms.InputTag("flashggVertexMapForCHS"), VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'), vertexIndex=cms.uint32(vertexIndex), debug=cms.untracked.bool(debug))) setattr( process, 'pfCHSLeg' + label, cms.EDFilter("CandPtrSelector", src=cms.InputTag('flashggCHSLegacyVertexCandidates' + label), cut=cms.string(''))) # then remove the previously selected muons setattr( process, 'pfNoMuonCHSLeg' + label, cms.EDProducer("CandPtrProjector", src=cms.InputTag("pfCHSLeg" + label), veto=cms.InputTag("selectedMuons" + label))) # then remove the previously selected electrons setattr( process, 'pfNoElectronsCHSLeg' + label, cms.EDProducer("CandPtrProjector", src=cms.InputTag("pfNoMuonCHSLeg" + label), veto=cms.InputTag("selectedElectrons" + label))) #Import RECO jet producer for ak4 PF and GEN jet from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets setattr( process, 'ak4PFJetsCHSLeg' + label, ak4PFJets.clone(src='pfNoElectronsCHSLeg' + label, doAreaFastjet=True)) if isData: JECs = ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual'] else: JECs = ['L1FastJet', 'L2Relative', 'L3Absolute'] # NOTE: this is the 74X recipe for the jet clustering addJetCollection( process, postfix=label, labelName='AK4PFCHSLeg', jetSource=cms.InputTag('ak4PFJetsCHSLeg' + label), pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'), pfCandidates=cms.InputTag('packedPFCandidates'), svSource=cms.InputTag('slimmedSecondaryVertices'), elSource=cms.InputTag("slimmedElectrons"), muSource=cms.InputTag("slimmedMuons"), runIVF=True, btagDiscriminators=[flashggBTag, flashggCMVABTag], jetCorrections=('AK4PFchs', JECs, 'None'), genJetCollection=cms.InputTag('slimmedGenJets'), genParticles=cms.InputTag('prunedGenParticles'), # jet param algo='AK', rParam=0.4 #btagInfos = ['pfImpactParameterTagInfos', 'pfSecondaryVertexTagInfos', 'pfInclusiveSecondaryVertexFinderTagInfos', 'softPFMuonsTagInfos', 'softPFElectronsTagInfos'] #Extra Btagging Info ) #Recalculate btagging info getattr(process, 'patJetsAK4PFCHSLeg' + label).addTagInfos = True #adjust PV used for Jet Corrections #process.patJetCorrFactorsAK4PFCHSLeg.primaryVertices = "offlineSlimmedPrimaryVertices" getattr(process, 'patJetCorrFactorsAK4PFCHSLeg' + label).primaryVertices = "offlineSlimmedPrimaryVertices" if not hasattr(process, "QGPoolDBESSource"): process.QGPoolDBESSource = cms.ESSource( "PoolDBESSource", CondDBSetup, toGet=cms.VPSet(), connect=cms.string('sqlite:QGL_' + qgDatabaseVersion + '.db')) process.es_prefer_qg = cms.ESPrefer('PoolDBESSource', 'QGPoolDBESSource') for type in ['AK4PFchs']: #,'AK4PFchs_antib']: process.QGPoolDBESSource.toGet.extend( cms.VPSet( cms.PSet(record=cms.string('QGLikelihoodRcd'), tag=cms.string('QGLikelihoodObject_' + qgDatabaseVersion + '_' + type), label=cms.untracked.string('QGL_' + type)))) from RecoJets.JetProducers.QGTagger_cfi import QGTagger setattr( process, 'QGTaggerPFCHS' + label, QGTagger.clone(srcJets='patJetsAK4PFCHSLeg' + label, jetsLabel='QGL_AK4PFchs', vertexIndex=cms.uint32(vertexIndex), srcVertexCollection='offlineSlimmedPrimaryVertices')) from RecoJets.JetProducers.PileupJetIDParams_cfi import full_80x_chs flashggJets = cms.EDProducer( 'FlashggJetProducer', DiPhotonTag=cms.InputTag('flashggDiPhotons'), VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'), JetTag=cms.InputTag('patJetsAK4PFCHSLeg' + label), VertexCandidateMapTag=cms.InputTag("flashggVertexMapForCHS"), qgVariablesInputTag=cms.InputTag('QGTaggerPFCHS' + label, 'qgLikelihood'), ComputeSimpleRMS=cms.bool(True), ComputeRegVars=cms.bool(True), PileupJetIdParameters=full_80x_chs, rho=cms.InputTag("fixedGridRhoFastjetAll"), JetCollectionIndex=cms.uint32(vertexIndex), Debug=cms.untracked.bool(False), DoPuJetID=cms.bool(False)) setattr(process, 'flashggPFCHSJets' + label, flashggJets) # randomize Jets from flashgg.MicroAOD.flashggRandomizedJetProducer_cfi import flashggRandomizedJets flashggRandomizedPFCHSJets = flashggRandomizedJets.clone() flashggRandomizedPFCHSJets.src = "flashggPFCHSJets" + label setattr(process.RandomNumberGeneratorService, 'flashggRandomizedPFCHSJets' + label, cms.PSet(initialSeed=cms.untracked.uint32(36423784 + int(label)))) setattr(process, 'flashggRandomizedPFCHSJets' + label, flashggRandomizedPFCHSJets) flashggSelectedJets = cms.EDFilter( "FLASHggJetSelector", src=cms.InputTag('flashggRandomizedPFCHSJets' + label), cut=cms.string("pt > 15.")) setattr(process, 'flashggSelectedPFCHSJets' + label, flashggSelectedJets)
groomedJets = cms.InputTag("CA8caPFJetsSoftDropPuppi"), subjets = cms.InputTag("CA8caPFJetsSoftDropPuppi", "SubJets"), bHadrons = cms.InputTag("selectedHadronsAndPartons","bHadrons"), cHadrons = cms.InputTag("selectedHadronsAndPartons","cHadrons"), partons = cms.InputTag("selectedHadronsAndPartons","algorithmicPartons"), jetAlgorithm = cms.string("CambridgeAachen"), rParam = cms.double(0.8), ghostRescaling = cms.double(1e-18), hadronFlavourHasPriority = cms.bool(True) ) # take the default AK4 PFJet producer and modify accordingly for cone size and clustering algorithm from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets CA8PFJetsPuppi = ak4PFJets.clone( src = cms.InputTag('puppi'), jetAlgorithm = cms.string("CambridgeAachen"), rParam = cms.double(0.8), jetPtMin = cms.double(150) ) # Pruned CA8caPFJetsPrunedPuppi = CA8PFJetsPuppi.clone( cms.PSet(nFilt = cms.int32(2), zcut = cms.double(0.1), rcut_factor = cms.double(0.5)), jetAlgorithm = cms.string("CambridgeAachen"), usePruning = cms.bool(True), useExplicitGhosts = cms.bool(True), writeCompound = cms.bool(True), jetCollInstanceName = cms.string("SubJets") )
def addStandardPuppiJets( process, label='', useLocalJEC=True, dbfile='flashgg/MetaData/data/PuppiJEC/PY8_RunIISpring15DR74_bx50_MC.db', debug=False): print ':: Running a standard PUPPI : --' from CommonTools.PileupAlgos.Puppi_cff import puppi from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection # from RecoJets.JetProducers.PileupJetIDParams_cfi import cutbased_new as pu_jetid from flashgg.MicroAOD.flashggJets_cfi import flashggBTag setattr( process, 'flashggStdPuppi' + label, puppi.clone( candName=cms.InputTag('packedPFCandidates'), vertexName=cms.InputTag('offlineSlimmedPrimaryVertices'), )) setattr( process, 'ak4PFJetsStdPuppi' + label, ak4PFJets.clone(src=cms.InputTag('flashggStdPuppi'), doAreaFastjet=True)) if useLocalJEC: print ':: using a local JEC dbfile for PUPPI :', print ' -- ', dbfile from flashgg.MicroAOD.flashggJetTools_cfi import loadLocalJECDBfile loadLocalJECDBfile( process, dbfile=os.environ['CMSSW_BASE'] + '/src/' + dbfile, tag= 'JetCorrectorParametersCollection_PY8_RunIISpring15DR74_bx50_MC_AK4PUPPI', label='AK4PFPuppi') addJetCollection( process, postfix='std' + label, labelName='AK4PUPPI', jetSource=cms.InputTag('ak4PFJetsStdPuppi'), pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'), pfCandidates=cms.InputTag('packedPFCandidates'), svSource=cms.InputTag('slimmedSecondaryVertices'), btagDiscriminators=[flashggBTag], jetCorrections=('AK4PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'), genJetCollection=cms.InputTag('slimmedGenJets'), genParticles=cms.InputTag('prunedGenParticles'), # jet param algo='AK', rParam=0.4) getattr(process, 'patJetCorrFactorsAK4PUPPIstd' + label).primaryVertices = "offlineSlimmedPrimaryVertices" setattr( process, 'flashggStdPUPPIJets', cms.EDProducer( 'FlashggJetProducer', DiPhotonTag=cms.InputTag('flashggDiPhotons'), VertexTag=cms.InputTag('offlineSlimmedPrimaryVertices'), JetTag=cms.InputTag('patJetsAK4PUPPIstd' + label), VertexCandidateMapTag=cms.InputTag("flashggVertexMapForPUPPI"), UsePuppi=cms.untracked.bool(True), # PileupJetIdParameters = cms.PSet(pu_jetid)) )) setattr( process, 'selectedFlashggStdPUPPIJets' + label, cms.EDFilter("FLASHggJetSelector", src=cms.InputTag('flashggStdPUPPIJets'), cut=cms.string("pt > 15.")))