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")
)
# 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' ),
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.")))
