def addBoostedTaus(process):
from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet
from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag
process.load("RecoTauTag.Configuration.boostedHPSPFTaus_cff")
patAlgosToolsTask = configtools.getPatAlgosToolsTask(process)
patAlgosToolsTask.add(process.boostedHPSPFTausTask)
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
process.ptau = cms.Path( process.PFTau )
process.PATTauSequence = cms.Sequence(process.PFTau+process.makePatTaus+process.selectedPatTaus)
process.PATTauSequenceBoosted = cloneProcessingSnippet(process,process.PATTauSequence, "Boosted", addToTask = True)
process.recoTauAK4PFJets08RegionBoosted.src = cms.InputTag('boostedTauSeeds')
process.recoTauAK4PFJets08RegionBoosted.pfCandSrc = cms.InputTag('particleFlow')
process.recoTauAK4PFJets08RegionBoosted.pfCandAssocMapSrc = cms.InputTag('boostedTauSeeds', 'pfCandAssocMapForIsolation')
process.ak4PFJetsLegacyHPSPiZerosBoosted.jetSrc = cms.InputTag('boostedTauSeeds')
process.ak4PFJetsRecoTauChargedHadronsBoosted.jetSrc = cms.InputTag('boostedTauSeeds')
process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRcone = cms.double(0.3)
process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRconeLimitedToJetArea = cms.bool(True)
process.combinatoricRecoTausBoosted.jetSrc = cms.InputTag('boostedTauSeeds')
process.combinatoricRecoTausBoosted.builders[0].pfCandSrc = cms.InputTag('particleFlow')
## Note JetArea is not defined for subjets (-> do not switch to True in hpsPFTauDiscriminationByLooseMuonRejection3Boosted, False is default)
## The restiction to jetArea is turned to dRMatch=0.1 (-> use explicitly this modified value)
process.hpsPFTauDiscriminationByMuonRejection3Boosted.dRmuonMatch = 0.1
massSearchReplaceAnyInputTag(process.PATTauSequenceBoosted,cms.InputTag("ak4PFJets"),cms.InputTag("boostedTauSeeds"))
process.slimmedTausBoosted = process.slimmedTaus.clone(src = cms.InputTag("selectedPatTausBoosted"))
patAlgosToolsTask.add(process.slimmedTausBoosted)
return process
def loadJetMETBTag(process):
task = getPatAlgosToolsTask(process)
import RecoJets.Configuration.RecoPFJets_cff
process.ak4PFJetsCHS = RecoJets.Configuration.RecoPFJets_cff.ak4PFJetsCHS.clone(
)
task.add(process.ak4PFJetsCHS)
process.ak8PFJetsCHS = RecoJets.Configuration.RecoPFJets_cff.ak8PFJetsCHS.clone(
)
task.add(process.ak8PFJetsCHS)
process.load("RecoMET.METProducers.pfMet_cfi")
task.add(process.pfMet)
process.load("RecoBTag.ImpactParameter.impactParameter_cff")
task.add(process.impactParameterTask)
process.load("RecoBTag.SecondaryVertex.secondaryVertex_cff")
task.add(process.secondaryVertexTask)
process.load("RecoBTag.SoftLepton.softLepton_cff")
task.add(process.softLeptonTask)
process.load("RecoBTag.Combined.combinedMVA_cff")
task.add(process.combinedMVATask)
process.load("RecoBTag.CTagging.cTagging_cff")
task.add(process.cTaggingTask)
process.load("RecoVertex.AdaptiveVertexFinder.inclusiveVertexing_cff")
task.add(process.inclusiveVertexingTask)
task.add(process.inclusiveCandidateVertexingTask)
task.add(process.inclusiveCandidateVertexingCvsLTask)
def nanoAOD_addDeepBTagFor80X(process):
print "Updating process to run DeepCSV btag on legacy 80X datasets"
updateJetCollection(
process,
jetSource=cms.InputTag('slimmedJets'),
jetCorrections=('AK4PFchs',
cms.vstring([
'L1FastJet', 'L2Relative', 'L3Absolute',
'L2L3Residual'
]), 'None'),
btagDiscriminators=[
'pfDeepCSVJetTags:probb', 'pfDeepCSVJetTags:probbb',
'pfDeepCSVJetTags:probc'
], ## to add discriminators
btagPrefix='')
process.load("Configuration.StandardSequences.MagneticField_cff")
process.looseJetId.src = "selectedUpdatedPatJets"
process.tightJetId.src = "selectedUpdatedPatJets"
process.tightJetIdLepVeto.src = "selectedUpdatedPatJets"
process.bJetVars.src = "selectedUpdatedPatJets"
process.slimmedJetsWithUserData.src = "selectedUpdatedPatJets"
process.qgtagger80x.srcJets = "selectedUpdatedPatJets"
patAlgosToolsTask = getPatAlgosToolsTask(process)
patAlgosToolsTask.add(process.updatedPatJets)
patAlgosToolsTask.add(process.patJetCorrFactors)
process.additionalendpath = cms.EndPath(patAlgosToolsTask)
return process
def miniAOD_customizeMC(process):
#slimmed pileup information
process.load('PhysicsTools.PatAlgos.slimming.slimmedAddPileupInfo_cfi')
task = getPatAlgosToolsTask(process)
task.add(process.slimmedAddPileupInfo)
process.muonMatch.matched = "prunedGenParticles"
process.electronMatch.matched = "prunedGenParticles"
process.electronMatch.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.photonMatch.matched = "prunedGenParticles"
process.photonMatch.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.tauMatch.matched = "prunedGenParticles"
process.tauGenJets.GenParticles = "prunedGenParticles"
#Boosted taus
process.tauMatchBoosted.matched = "prunedGenParticles"
process.tauGenJetsBoosted.GenParticles = "prunedGenParticles"
process.patJetPartons.particles = "prunedGenParticles"
process.patJetPartonMatch.matched = "prunedGenParticles"
process.patJetPartonMatch.mcStatus = [ 3, 23 ]
process.patJetGenJetMatch.matched = "slimmedGenJets"
process.patJetGenJetMatchAK8.matched = "slimmedGenJetsAK8"
process.patMuons.embedGenMatch = False
process.patElectrons.embedGenMatch = False
process.patPhotons.embedGenMatch = False
process.patTaus.embedGenMatch = False
process.patTausBoosted.embedGenMatch = False
process.patJets.embedGenPartonMatch = False
#also jet flavour must be switched
process.patJetFlavourAssociation.rParam = 0.4
def makeInputForPUPPIIsolationEgm(process):
task = getPatAlgosToolsTask(process)
addToProcessAndTask('egmPhotonPUPPIIsolation',
_egmPhotonPUPPIIsolationForPhotons.clone(), process,
task)
process.egmPhotonPUPPIIsolation.srcToIsolate = cms.InputTag(
"reducedEgamma", "reducedGedPhotons")
process.egmPhotonPUPPIIsolation.srcForIsolationCone = cms.InputTag(
"particleFlow")
process.egmPhotonPUPPIIsolation.puppiValueMap = cms.InputTag('puppi')
addToProcessAndTask('egmElectronPUPPIIsolation',
_egmElectronIsolationMiniAODPUPPI.clone(), process,
task)
process.egmElectronPUPPIIsolation.srcToIsolate = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.egmElectronPUPPIIsolation.srcForIsolationCone = cms.InputTag(
"packedPFCandidates")
addToProcessAndTask('egmElectronPUPPINoLeptonsIsolation',
_egmElectronIsolationMiniAODPUPPINoLeptons.clone(),
process, task)
process.egmElectronPUPPINoLeptonsIsolation.srcToIsolate = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.egmElectronPUPPINoLeptonsIsolation.srcForIsolationCone = cms.InputTag(
"packedPFCandidates")
def makePuppiesFromMiniAOD(process, createScheduledSequence=False):
task = getPatAlgosToolsTask(process)
from CommonTools.ParticleFlow.pfCHS_cff import packedPrimaryVertexAssociationJME
setattr(process, "packedPrimaryVertexAssociationJME",
packedPrimaryVertexAssociationJME.clone())
task.add(process.packedPrimaryVertexAssociationJME)
process.load('CommonTools.PileupAlgos.Puppi_cff')
task.add(process.puppi)
process.puppi.candName = 'packedPFCandidates'
process.puppi.clonePackedCands = True
process.puppi.vertexName = 'offlineSlimmedPrimaryVertices'
process.puppi.useExistingWeights = True
process.puppi.vertexAssociation = 'packedPrimaryVertexAssociationJME:original'
task.add(process.puppiNoLep)
process.puppiNoLep.candName = 'packedPFCandidates'
process.puppiNoLep.clonePackedCands = True
process.puppiNoLep.vertexName = 'offlineSlimmedPrimaryVertices'
process.puppiNoLep.useExistingWeights = True
process.puppiNoLep.vertexAssociation = 'packedPrimaryVertexAssociationJME:original'
#making a sequence for people running the MET tool in scheduled mode
if createScheduledSequence:
puppiMETTask = cms.Task(process.packedPrimaryVertexAssociationJME,
process.puppi, process.puppiNoLep)
setattr(process, "puppiMETTask", puppiMETTask)
puppiMETSequence = cms.Sequence(puppiMETTask)
setattr(process, "puppiMETSequence", puppiMETSequence)
def addDiscardedPFCandidates(process, inputCollection, verbose=False):
task = getPatAlgosToolsTask(process)
process.primaryVertexAssociationDiscardedCandidates = process.primaryVertexAssociation.clone(
particles = inputCollection,
)
task.add(process.primaryVertexAssociationDiscardedCandidates)
process.packedPFCandidatesDiscarded = process.packedPFCandidates.clone(
inputCollection = inputCollection,
PuppiNoLepSrc = cms.InputTag(""),
PuppiSrc = cms.InputTag(""),
secondaryVerticesForWhiteList = cms.VInputTag(),
vertexAssociator = cms.InputTag("primaryVertexAssociationDiscardedCandidates","original")
)
task.add(process.packedPFCandidatesDiscarded)
addKeepStatement(process, "keep patPackedCandidates_packedPFCandidates_*_*",
["keep patPackedCandidates_packedPFCandidatesDiscarded_*_*"],
verbose=verbose)
# Now make the mixed map for rekeying
from PhysicsTools.PatAlgos.slimming.packedPFCandidateRefMixer_cfi import packedPFCandidateRefMixer
process.oldPFCandToPackedOrDiscarded = packedPFCandidateRefMixer.clone(
pf2pf = cms.InputTag(inputCollection.moduleLabel),
pf2packed = cms.VInputTag(cms.InputTag("packedPFCandidates"), cms.InputTag("packedPFCandidatesDiscarded"))
)
task.add(process.oldPFCandToPackedOrDiscarded)
# Fix slimmed muon keying
process.slimmedMuons.pfCandidates = cms.VInputTag(cms.InputTag(inputCollection.moduleLabel), inputCollection)
process.slimmedMuons.packedPFCandidates = cms.VInputTag(cms.InputTag("packedPFCandidates"), cms.InputTag("packedPFCandidatesDiscarded"))
#MM point to uncleaned collection for hadronic taus, to avoid remaking them
#no impact expected, as no muons are included here
process.slimmedTaus.packedPFCandidates=cms.InputTag("packedPFCandidatesBackup")
def loadJetMETBTag(process):
task = getPatAlgosToolsTask(process)
import RecoJets.Configuration.RecoPFJets_cff
process.ak4PFJetsCHS = RecoJets.Configuration.RecoPFJets_cff.ak4PFJetsCHS.clone()
task.add(process.ak4PFJetsCHS)
process.ak8PFJetsCHS = RecoJets.Configuration.RecoPFJets_cff.ak8PFJetsCHS.clone()
task.add(process.ak8PFJetsCHS)
process.load("RecoMET.METProducers.PFMET_cfi")
task.add(process.pfMet)
process.load("RecoBTag.ImpactParameter.impactParameter_cff")
task.add(process.impactParameterTask)
process.load("RecoBTag.SecondaryVertex.secondaryVertex_cff")
task.add(process.secondaryVertexTask)
process.load("RecoBTag.SoftLepton.softLepton_cff")
task.add(process.softLeptonTask)
process.load("RecoBTag.Combined.combinedMVA_cff")
task.add(process.combinedMVATask)
process.load("RecoBTag.CTagging.cTagging_cff")
task.add(process.cTaggingTask)
process.load("RecoVertex.AdaptiveVertexFinder.inclusiveVertexing_cff")
task.add(process.inclusiveVertexingTask)
task.add(process.inclusiveCandidateVertexingTask)
task.add(process.inclusiveCandidateVertexingCvsLTask)
def cleanPfCandidates(process, verbose=False):
task = getPatAlgosToolsTask(process)
#add producer at the beginning of the schedule
process.load("CommonTools.ParticleFlow.pfCandidateRecalibrator_cfi")
task.add(process.pfCandidateRecalibrator)
replacePFCandidates = MassSearchReplaceAnyInputTagVisitor(
"particleFlow", "pfCandidateRecalibrator", verbose=verbose)
replacePFTmpPtrs = MassSearchReplaceAnyInputTagVisitor(
"particleFlowTmpPtrs", "particleFlowPtrs", verbose=verbose)
for everywhere in [
process.producers, process.filters, process.analyzers,
process.psets, process.vpsets
]:
for name, obj in six.iteritems(everywhere):
if obj != process.pfCandidateRecalibrator:
replacePFCandidates.doIt(obj, name)
replacePFTmpPtrs.doIt(obj, name)
process.load("CommonTools.ParticleFlow.pfEGammaToCandidateRemapper_cfi")
task.add(process.pfEGammaToCandidateRemapper)
process.pfEGammaToCandidateRemapper.pf2pf = cms.InputTag(
"pfCandidateRecalibrator")
process.reducedEgamma.gsfElectronsPFValMap = cms.InputTag(
"pfEGammaToCandidateRemapper", "electrons")
process.reducedEgamma.photonsPFValMap = cms.InputTag(
"pfEGammaToCandidateRemapper", "photons")
def UpdatePuppiTuneV13(process):
#
# Adapt for re-running PUPPI
#
print(
"customizePuppiTune_cff::UpdatePuppiTuneV13: Recomputing PUPPI with Tune v13, slimmedJetsPuppi and slimmedMETsPuppi"
)
from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask, addToProcessAndTask
task = getPatAlgosToolsTask(process)
from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppiesFromMiniAOD
makePuppiesFromMiniAOD(process, True)
process.puppi.useExistingWeights = False
process.puppiNoLep.useExistingWeights = False
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD
runMetCorAndUncFromMiniAOD(process,
isData=False,
metType="Puppi",
postfix="Puppi",
jetFlavor="AK4PFPuppi",
recoMetFromPFCs=True)
from PhysicsTools.PatAlgos.patPuppiJetSpecificProducer_cfi import patPuppiJetSpecificProducer
addToProcessAndTask(
'patPuppiJetSpecificProducer',
patPuppiJetSpecificProducer.clone(src=cms.InputTag("patJetsPuppi")),
process, task)
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
process,
labelName='PuppiJetSpecific',
jetSource=cms.InputTag('patJetsPuppi'),
)
process.updatedPatJetsPuppiJetSpecific.userData.userFloats.src = [
'patPuppiJetSpecificProducer:puppiMultiplicity',
'patPuppiJetSpecificProducer:neutralPuppiMultiplicity',
'patPuppiJetSpecificProducer:neutralHadronPuppiMultiplicity',
'patPuppiJetSpecificProducer:photonPuppiMultiplicity',
'patPuppiJetSpecificProducer:HFHadronPuppiMultiplicity',
'patPuppiJetSpecificProducer:HFEMPuppiMultiplicity'
]
addToProcessAndTask('slimmedJetsPuppi',
process.updatedPatJetsPuppiJetSpecific.clone(),
process, task)
del process.updatedPatJetsPuppiJetSpecific
process.puppiSequence = cms.Sequence(process.puppiMETSequence +
process.fullPatMetSequencePuppi +
process.patPuppiJetSpecificProducer +
process.slimmedJetsPuppi)
#
# Adapt for PUPPI tune V13
#
process.puppi.UseFromPVLooseTight = False
process.puppi.UseDeltaZCut = False
process.puppi.PtMaxCharged = 20.
process.puppi.EtaMaxCharged = 2.5
process.puppi.PtMaxNeutralsStartSlope = 20.
process.puppiNoLep.UseFromPVLooseTight = False
process.puppiNoLep.UseDeltaZCut = False
process.puppiNoLep.PtMaxCharged = 20.
process.puppiNoLep.EtaMaxCharged = 2.5
process.puppiNoLep.PtMaxNeutralsStartSlope = 20.
def addBoostedTaus(process):
from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet
from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag
process.load("RecoTauTag.Configuration.boostedHPSPFTaus_cff")
patAlgosToolsTask = configtools.getPatAlgosToolsTask(process)
patAlgosToolsTask.add(process.boostedHPSPFTausTask)
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
process.ptau = cms.Path( process.PFTau )
process.PATTauSequence = cms.Sequence(process.PFTau+process.makePatTaus+process.selectedPatTaus)
process.PATTauSequenceBoosted = cloneProcessingSnippet(process,process.PATTauSequence, "Boosted", addToTask = True)
process.recoTauAK4PFJets08RegionBoosted.src = cms.InputTag('boostedTauSeeds')
process.recoTauAK4PFJets08RegionBoosted.pfCandSrc = cms.InputTag('particleFlow')
process.recoTauAK4PFJets08RegionBoosted.pfCandAssocMapSrc = cms.InputTag('boostedTauSeeds', 'pfCandAssocMapForIsolation')
process.ak4PFJetsLegacyHPSPiZerosBoosted.jetSrc = cms.InputTag('boostedTauSeeds')
process.ak4PFJetsRecoTauChargedHadronsBoosted.jetSrc = cms.InputTag('boostedTauSeeds')
process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRcone = cms.double(0.3)
process.ak4PFJetsRecoTauChargedHadronsBoosted.builders[1].dRconeLimitedToJetArea = cms.bool(True)
process.combinatoricRecoTausBoosted.jetSrc = cms.InputTag('boostedTauSeeds')
process.combinatoricRecoTausBoosted.modifiers.remove(process.combinatoricRecoTausBoosted.modifiers[3])
#process.combinatoricRecoTausBoosted.builders[0].pfCandSrc = cms.InputTag('pfNoPileUpForBoostedTaus')
process.combinatoricRecoTausBoosted.builders[0].pfCandSrc = cms.InputTag('particleFlow')
#Note JetArea is not defined for subjets and restiction to jetArea is turned to dRMatch=0.1, so better use the latter explicitely
#process.hpsPFTauDiscriminationByLooseMuonRejection3Boosted.dRmuonMatchLimitedToJetArea = cms.bool(True)
#process.hpsPFTauDiscriminationByTightMuonRejection3Boosted.dRmuonMatchLimitedToJetArea = cms.bool(True)
process.hpsPFTauDiscriminationByLooseMuonRejection3Boosted.dRmuonMatch = 0.1
process.hpsPFTauDiscriminationByTightMuonRejection3Boosted.dRmuonMatch = 0.1
massSearchReplaceAnyInputTag(process.PATTauSequenceBoosted,cms.InputTag("ak4PFJets"),cms.InputTag("boostedTauSeeds"))
process.slimmedTausBoosted = process.slimmedTaus.clone(src = cms.InputTag("selectedPatTausBoosted"))
patAlgosToolsTask.add(process.slimmedTausBoosted)
return process
def nanoAOD_addDeepFlavourTagFor94X2016(process):
print "Updating process to run DeepFlavour btag on legacy 80X datasets"
updateJetCollection(
process,
jetSource=cms.InputTag('slimmedJets'),
jetCorrections=('AK4PFchs',
cms.vstring([
'L1FastJet', 'L2Relative', 'L3Absolute',
'L2L3Residual'
]), 'None'),
btagDiscriminators=[
'pfDeepFlavourJetTags:probb', 'pfDeepFlavourJetTags:probbb',
'pfDeepFlavourJetTags:problepb'
], ## to add discriminators
btagPrefix='')
process.load("Configuration.StandardSequences.MagneticField_cff")
process.looseJetId.src = "selectedUpdatedPatJets"
process.tightJetId.src = "selectedUpdatedPatJets"
process.tightJetIdLepVeto.src = "selectedUpdatedPatJets"
process.bJetVars.src = "selectedUpdatedPatJets"
process.slimmedJetsWithUserData.src = "selectedUpdatedPatJets"
process.qgtagger80x.srcJets = "selectedUpdatedPatJets"
process.pfDeepFlavourJetTags.graph_path = 'RecoBTag/Combined/data/DeepFlavourV03_10X_training/constant_graph.pb'
process.pfDeepFlavourJetTags.lp_names = [
"cpf_input_batchnorm/keras_learning_phase"
]
patAlgosToolsTask = getPatAlgosToolsTask(process)
patAlgosToolsTask.add(process.updatedPatJets)
patAlgosToolsTask.add(process.patJetCorrFactors)
process.additionalendpath = cms.EndPath(patAlgosToolsTask)
return process
def makePuppiesFromMiniAOD( process, createScheduledSequence=False ):
task = getPatAlgosToolsTask(process)
process.load('CommonTools.PileupAlgos.Puppi_cff')
task.add(process.puppi)
process.puppi.candName = cms.InputTag('packedPFCandidates')
process.puppi.clonePackedCands = cms.bool(True)
process.puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
process.puppi.useExistingWeights = cms.bool(True)
process.pfNoLepPUPPI = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("abs(pdgId) != 13 && abs(pdgId) != 11 && abs(pdgId) != 15"))
task.add(process.pfNoLepPUPPI)
process.pfLeptonsPUPPET = cms.EDFilter("CandPtrSelector", src = cms.InputTag("packedPFCandidates"), cut = cms.string("abs(pdgId) == 13 || abs(pdgId) == 11 || abs(pdgId) == 15"))
task.add(process.pfLeptonsPUPPET)
addToProcessAndTask('puppiNoLep', process.puppi.clone(), process, task)
process.puppiNoLep.candName = cms.InputTag('pfNoLepPUPPI')
process.puppiNoLep.useWeightsNoLep = cms.bool(True)
process.puppiNoLep.useExistingWeights = cms.bool(True)
process.puppiMerged = cms.EDProducer("CandViewMerger",src = cms.VInputTag( 'puppiNoLep','pfLeptonsPUPPET'))
task.add(process.puppiMerged)
process.load('CommonTools.PileupAlgos.PhotonPuppi_cff')
task.add(process.puppiPhoton)
addToProcessAndTask('puppiForMET', process.puppiPhoton.clone(), process, task)
process.puppiForMET.candName = cms.InputTag('packedPFCandidates')
process.puppiForMET.photonName = cms.InputTag('slimmedPhotons')
process.puppiForMET.runOnMiniAOD = cms.bool(True)
setupPuppiPhotonMiniAOD(process)
task.add(process.egmPhotonIDTask)
#Line below replaces reference linking wiht delta R matching because the puppi references after merging are not consistent with those of the original packed candidate collection
process.puppiForMET.useRefs = False
#Line below points puppi MET to puppi no lepton which increases the response
process.puppiForMET.puppiCandName = 'puppiMerged'
#making a sequence for people running the MET tool in scheduled mode
if createScheduledSequence:
puppiMETSequence = cms.Sequence(process.puppi*process.pfLeptonsPUPPET*process.pfNoLepPUPPI*process.puppiNoLep*process.puppiMerged*process.puppiForMET)
setattr(process, "puppiMETSequence", puppiMETSequence)
def miniAOD_customizeMC(process):
#slimmed pileup information
process.load('PhysicsTools.PatAlgos.slimming.slimmedAddPileupInfo_cfi')
task = getPatAlgosToolsTask(process)
task.add(process.slimmedAddPileupInfo)
process.muonMatch.matched = "prunedGenParticles"
process.electronMatch.matched = "prunedGenParticles"
process.electronMatch.src = cms.InputTag("reducedEgamma",
"reducedGedGsfElectrons")
process.photonMatch.matched = "prunedGenParticles"
process.photonMatch.src = cms.InputTag("reducedEgamma",
"reducedGedPhotons")
process.ootPhotonMatch.matched = "prunedGenParticles"
process.ootPhotonMatch.src = cms.InputTag("reducedEgamma",
"reducedOOTPhotons")
process.tauMatch.matched = "prunedGenParticles"
process.tauGenJets.GenParticles = "prunedGenParticles"
#Boosted taus
process.tauMatchBoosted.matched = "prunedGenParticles"
process.tauGenJetsBoosted.GenParticles = "prunedGenParticles"
process.patJetPartons.particles = "prunedGenParticles"
process.patJetPartonMatch.matched = "prunedGenParticles"
process.patJetPartonMatch.mcStatus = [3, 23]
process.patJetGenJetMatch.matched = "slimmedGenJets"
process.patJetGenJetMatchAK8.matched = "slimmedGenJetsAK8"
process.patMuons.embedGenMatch = False
process.patElectrons.embedGenMatch = False
process.patPhotons.embedGenMatch = False
process.patOOTPhotons.embedGenMatch = False
process.patTaus.embedGenMatch = False
process.patTausBoosted.embedGenMatch = False
process.patJets.embedGenPartonMatch = False
#also jet flavour must be switched
process.patJetFlavourAssociation.rParam = 0.4
def makePuppies( process ):
task = getPatAlgosToolsTask(process)
process.load('CommonTools.PileupAlgos.Puppi_cff')
task.add(process.puppi)
process.pfNoLepPUPPI = cms.EDFilter("PdgIdCandViewSelector",
src = cms.InputTag("particleFlow"),
pdgId = cms.vint32( 1,2,22,111,130,310,2112,211,-211,321,-321,999211,2212,-2212 )
)
task.add(process.pfNoLepPUPPI)
process.pfLeptonsPUPPET = cms.EDFilter("PdgIdCandViewSelector",
src = cms.InputTag("particleFlow"),
pdgId = cms.vint32(-11,11,-13,13),
)
task.add(process.pfLeptonsPUPPET)
addToProcessAndTask('puppiNoLep', process.puppi.clone(), process, task)
process.puppiNoLep.candName = cms.InputTag('pfNoLepPUPPI')
process.puppiMerged = cms.EDProducer("CandViewMerger",src = cms.VInputTag( 'puppiNoLep','pfLeptonsPUPPET'))
task.add(process.puppiMerged)
process.load('CommonTools.PileupAlgos.PhotonPuppi_cff')
task.add(process.puppiPhoton)
addToProcessAndTask('puppiForMET', process.puppiPhoton.clone(), process, task)
#Line below replaces reference linking wiht delta R matching because the puppi references after merging are not consistent with those of the original PF collection
process.puppiForMET.useRefs = False
#Line below points puppi MET to puppi no lepton which increases the response
process.puppiForMET.puppiCandName = 'puppiMerged'
def makeRecoJetCollection(process,
pfCandCollection,
coneSize,
useCHSAlgo,
postfix):
task = getPatAlgosToolsTask(process)
jetColName="ak"+str(int(coneSize*10))+"PFJets"
internalPfCandColl=pfCandCollection
if useCHSAlgo:
addToProcessAndTask("tmpPFCandCollPtr"+postfix,
cms.EDProducer("PFCandidateFwdPtrProducer",
src = cms.InputTag(pfCandCollection) ),
process, task )
process.load("CommonTools.ParticleFlow.pfNoPileUpJME_cff")
task.add(process.pfNoPileUpJMETask)
cloneProcessingSnippet(process, getattr(process,"pfNoPileUpJMESequence"), postfix, addToTask = True )
getattr(process, "pfPileUpJME"+postfix).PFCandidates = cms.InputTag("tmpPFCandCollPtr"+postfix)
getattr(process, "pfNoPileUpJME"+postfix).bottomCollection = cms.InputTag("tmpPFCandCollPtr"+postfix)
internalPfCandColl = "pfNoPileUpJME"+postfix
jetColName+="CHS"
addToProcessAndTask(jetColName+postfix,
getattr(process,jetColName).clone(
src = cms.InputTag(internalPfCandColl),
rParam=cms.double(coneSize),
doAreaFastjet = True),
process, task )
def makeRecoJetCollection(process, pfCandCollection, coneSize, useCHSAlgo,
postfix):
task = getPatAlgosToolsTask(process)
jetColName = "ak" + str(int(coneSize * 10)) + "PFJets"
internalPfCandColl = pfCandCollection
if useCHSAlgo:
addToProcessAndTask(
"tmpPFCandCollPtr" + postfix,
cms.EDProducer("PFCandidateFwdPtrProducer",
src=cms.InputTag(pfCandCollection)), process, task)
process.load("CommonTools.ParticleFlow.pfNoPileUpJME_cff")
task.add(process.pfNoPileUpJMETask)
cloneProcessingSnippet(process,
getattr(process, "pfNoPileUpJMESequence"),
postfix,
addToTask=True)
getattr(process, "pfPileUpJME" +
postfix).PFCandidates = cms.InputTag("tmpPFCandCollPtr" +
postfix)
getattr(process, "pfNoPileUpJME" +
postfix).bottomCollection = cms.InputTag("tmpPFCandCollPtr" +
postfix)
internalPfCandColl = "pfNoPileUpJME" + postfix
jetColName += "CHS"
addToProcessAndTask(
jetColName + postfix,
getattr(process,
jetColName).clone(src=cms.InputTag(internalPfCandColl),
rParam=cms.double(coneSize),
doAreaFastjet=True), process, task)
def makePuppiesFromMiniAOD(process, createScheduledSequence=False):
task = getPatAlgosToolsTask(process)
process.load('CommonTools.PileupAlgos.Puppi_cff')
task.add(process.puppi)
process.puppi.candName = cms.InputTag('packedPFCandidates')
process.puppi.clonePackedCands = True
process.puppi.vertexName = cms.InputTag('offlineSlimmedPrimaryVertices')
process.puppi.useExistingWeights = True
process.pfNoLepPUPPI = cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string(
"abs(pdgId) != 13 && abs(pdgId) != 11 && abs(pdgId) != 15"))
task.add(process.pfNoLepPUPPI)
process.pfLeptonsPUPPET = cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string(
"abs(pdgId) == 13 || abs(pdgId) == 11 || abs(pdgId) == 15"))
task.add(process.pfLeptonsPUPPET)
addToProcessAndTask('puppiNoLep', process.puppi.clone(), process, task)
process.puppiNoLep.candName = cms.InputTag('pfNoLepPUPPI')
process.puppiNoLep.useWeightsNoLep = True
process.puppiNoLep.PtMaxPhotons = 20.
process.puppiForMET = cms.EDProducer("CandViewMerger",
src=cms.VInputTag(
'puppiNoLep', 'pfLeptonsPUPPET'))
task.add(process.puppiForMET)
#making a sequence for people running the MET tool in scheduled mode
if createScheduledSequence:
puppiMETSequence = cms.Sequence(
process.puppi * process.pfLeptonsPUPPET * process.pfNoLepPUPPI *
process.puppiNoLep * process.puppiForMET)
setattr(process, "puppiMETSequence", puppiMETSequence)
def miniAOD_customizeData(process):
from PhysicsTools.PatAlgos.tools.coreTools import runOnData
runOnData(process, outputModules=[])
process.load("RecoCTPPS.TotemRPLocal.ctppsLocalTrackLiteProducer_cff")
process.load("RecoCTPPS.ProtonReconstruction.ctppsProtons_cff")
task = getPatAlgosToolsTask(process)
task.add(process.ctppsLocalTrackLiteProducer)
task.add(process.ctppsProtons)
def miniAOD_customizeMC(process):
task = getPatAlgosToolsTask(process)
#GenJetFlavourInfos
process.load("PhysicsTools.JetMCAlgos.HadronAndPartonSelector_cfi")
task.add(process.selectedHadronsAndPartons)
task.add(process.selectedHadronsAndPartonsForGenJetsFlavourInfos)
process.load("PhysicsTools.JetMCAlgos.AK4GenJetFlavourInfos_cfi")
task.add(process.ak4GenJetFlavourInfos)
process.load(
'PhysicsTools.PatAlgos.slimming.slimmedGenJetsFlavourInfos_cfi')
task.add(process.slimmedGenJetsFlavourInfos)
#slimmed pileup information
process.load('PhysicsTools.PatAlgos.slimming.slimmedAddPileupInfo_cfi')
task.add(process.slimmedAddPileupInfo)
process.muonMatch.matched = "prunedGenParticles"
process.electronMatch.matched = "prunedGenParticles"
process.electronMatch.src = cms.InputTag("reducedEgamma",
"reducedGedGsfElectrons")
process.photonMatch.matched = "prunedGenParticles"
process.photonMatch.src = cms.InputTag("reducedEgamma",
"reducedGedPhotons")
process.ootPhotonMatch.matched = "prunedGenParticles"
process.ootPhotonMatch.src = cms.InputTag("reducedEgamma",
"reducedOOTPhotons")
process.tauMatch.matched = "prunedGenParticles"
process.tauGenJets.GenParticles = "prunedGenParticles"
#Boosted taus
process.tauMatchBoosted.matched = "prunedGenParticles"
process.tauGenJetsBoosted.GenParticles = "prunedGenParticles"
process.patJetPartons.particles = "genParticles"
process.patJetPartonMatch.matched = "prunedGenParticles"
pp_on_AA.toModify(process.patJetPartonMatch,
matched="hiSignalGenParticles")
from Configuration.ProcessModifiers.genJetSubEvent_cff import genJetSubEvent
genJetSubEvent.toModify(process.patJetPartonMatch,
matched="cleanedPartons")
process.patJetPartonMatch.mcStatus = [3, 23]
process.patJetGenJetMatch.matched = "slimmedGenJets"
(~pp_on_AA).toModify(
process, patJetGenJetMatchAK8Puppi=dict(matched="slimmedGenJetsAK8"))
process.patMuons.embedGenMatch = False
process.patElectrons.embedGenMatch = False
process.patPhotons.embedGenMatch = False
process.patOOTPhotons.embedGenMatch = False
process.patTaus.embedGenMatch = False
process.patTausBoosted.embedGenMatch = False
process.patJets.embedGenPartonMatch = False
#also jet flavour must be switched
process.patJetFlavourAssociation.rParam = 0.4
from PhysicsTools.PatAlgos.producersHeavyIons.heavyIonJetSetup import removeJECsForMC
pp_on_AA.toModify(process, removeJECsForMC)
pp_on_AA.toReplaceWith(
task, task.copyAndExclude([process.slimmedGenJetsFlavourInfos]))
def addLowPtTaus(process):
from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet
from PhysicsTools.PatAlgos.tools.helpers import massSearchReplaceAnyInputTag
process.load("RecoTauTag.Configuration.LowPtHPSPFTaus_cff")
patAlgosToolsTask = configtools.getPatAlgosToolsTask(process)
patAlgosToolsTask.add(process.LowPtHPSPFTausTask)
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
process.ptau = cms.Path(process.PFTau)
process.PATTauSequence = cms.Sequence(process.PFTau + process.makePatTaus +
process.selectedPatTaus)
process.PATTauSequenceLowPt = cloneProcessingSnippet(
process, process.PATTauSequence, "LowPt", addToTask=True)
process.recoTauAK4PFJets08RegionLowPt.src = cms.InputTag('LowPtTauSeeds')
process.recoTauAK4PFJets08RegionLowPt.pfCandSrc = cms.InputTag(
'particleFlow')
process.recoTauAK4PFJets08RegionLowPt.pfCandAssocMapSrc = cms.InputTag(
'LowPtTauSeeds', 'pfCandAssocMapForIsolation')
process.selectedPatTausLowPt.cut = cms.string(
"pt > 1. && tauID(\'decayModeFindingNewDMs\')> 0.5"
) #tau pt> 1 GeV of threshold output
process.ak4PFJetsLegacyHPSPiZerosLowPt.jetSrc = cms.InputTag(
'LowPtTauSeeds')
process.ak4PFJetsLegacyHPSPiZerosLowPt.minJetPt = cms.double(
1) #jet pt> 1 GeV of threshold in input
process.ak4PFJetsRecoTauChargedHadronsLowPt.jetSrc = cms.InputTag(
'LowPtTauSeeds')
process.ak4PFJetsRecoTauChargedHadronsLowPt.builders[
1].dRcone = cms.double(0.3)
process.ak4PFJetsRecoTauChargedHadronsLowPt.builders[
1].dRconeLimitedToJetArea = cms.bool(True)
process.combinatoricRecoTausLowPt.jetSrc = cms.InputTag('LowPtTauSeeds')
_allModifiers = cms.VPSet()
for modifier in process.combinatoricRecoTausLowPt.modifiers:
_allModifiers.append(modifier)
process.combinatoricRecoTausLowPt.modifiers.remove(
process.combinatoricRecoTausLowPt.modifiers[3])
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
for era in [run2_miniAOD_80XLegacy, run2_miniAOD_94XFall17]:
era.toModify(process.combinatoricRecoTausLowPt,
modifiers=_allModifiers)
process.combinatoricRecoTausLowPt.builders[0].pfCandSrc = cms.InputTag(
'particleFlow')
## Note JetArea is not defined for subjets (-> do not switch to True in hpsPFTauDiscriminationByLooseMuonRejection3LowPt, False is default)
## The restiction to jetArea is turned to dRMatch=0.1 (-> use explicitly this modified value)
#process.hpsPFTauDiscriminationByLooseMuonRejection3LowPt.dRmuonMatch = 0.1
#process.hpsPFTauDiscriminationByTightMuonRejection3LowPt.dRmuonMatch = 0.1
massSearchReplaceAnyInputTag(process.PATTauSequenceLowPt,
cms.InputTag("ak4PFJets"),
cms.InputTag("LowPtTauSeeds"))
process.slimmedTausLowPt = process.slimmedTaus.clone(
src=cms.InputTag("selectedPatTausLowPt"))
patAlgosToolsTask.add(process.slimmedTausLowPt)
return process
def miniAOD_customizeData(process):
from PhysicsTools.PatAlgos.tools.coreTools import runOnData
runOnData( process, outputModules = [] )
process.load("RecoCTPPS.TotemRPLocal.ctppsLocalTrackLiteProducer_cff")
process.load("RecoCTPPS.ProtonReconstruction.ctppsProtons_cff")
process.load("Geometry.VeryForwardGeometry.geometryRPFromDB_cfi")
task = getPatAlgosToolsTask(process)
from Configuration.Eras.Modifier_ctpps_2016_cff import ctpps_2016
ctpps_2016.toModify(task, func=lambda t: t.add(process.ctppsLocalTrackLiteProducer))
ctpps_2016.toModify(task, func=lambda t: t.add(process.ctppsProtons))
def miniAOD_customizeData(process):
from PhysicsTools.PatAlgos.tools.coreTools import runOnData
runOnData( process, outputModules = [] )
process.load("RecoCTPPS.TotemRPLocal.ctppsLocalTrackLiteProducer_cff")
process.load("RecoCTPPS.ProtonReconstruction.ctppsProtons_cff")
process.load("Geometry.VeryForwardGeometry.geometryRPFromDB_cfi")
task = getPatAlgosToolsTask(process)
from Configuration.Eras.Modifier_ctpps_2016_cff import ctpps_2016
ctpps_2016.toModify(task, func=lambda t: t.add(process.ctppsLocalTrackLiteProducer))
ctpps_2016.toModify(task, func=lambda t: t.add(process.ctppsProtons))
def makeInputForPUPPIIsolationMuon(process):
task = getPatAlgosToolsTask(process)
addToProcessAndTask('muonPUPPIIsolation', _muonIsolationMiniAODPUPPI.clone(), process, task)
process.muonPUPPIIsolation.srcToIsolate = cms.InputTag("muons")
process.muonPUPPIIsolation.srcForIsolationCone = cms.InputTag("packedPFCandidates")
addToProcessAndTask('muonPUPPINoLeptonsIsolation', _muonIsolationMiniAODPUPPINoLeptons.clone(), process, task)
process.muonPUPPINoLeptonsIsolation.srcToIsolate = cms.InputTag("muons")
process.muonPUPPINoLeptonsIsolation.srcForIsolationCone = cms.InputTag("packedPFCandidates")
def addBadMuonFilters(process):
task = getPatAlgosToolsTask(process)
process.load("RecoMET.METFilters.badGlobalMuonTaggersAOD_cff")
task.add(process.badGlobalMuonTagger)
task.add(process.cloneGlobalMuonTagger)
process.Flag_noBadMuons = cms.Path(process.noBadGlobalMuons)
process.Flag_badMuons = cms.Path(process.badGlobalMuonTagger)
process.Flag_duplicateMuons = cms.Path(process.cloneGlobalMuonTagger)
for P in process.Flag_noBadMuons, process.Flag_badMuons, process.Flag_duplicateMuons:
process.schedule.insert(0, P)
def addBadMuonFilters(process):
task = getPatAlgosToolsTask(process)
process.load("RecoMET.METFilters.badGlobalMuonTaggersAOD_cff")
task.add(process.badGlobalMuonTagger)
task.add(process.cloneGlobalMuonTagger)
process.Flag_noBadMuons = cms.Path(process.noBadGlobalMuons)
process.Flag_badMuons = cms.Path(process.badGlobalMuonTagger)
process.Flag_duplicateMuons = cms.Path(process.cloneGlobalMuonTagger)
for P in process.Flag_noBadMuons, process.Flag_badMuons, process.Flag_duplicateMuons:
process.schedule.insert(0, P)
def miniAOD_customizeData(process):
from PhysicsTools.PatAlgos.tools.coreTools import runOnData
runOnData( process, outputModules = [] )
process.load("RecoPPS.Local.ctppsLocalTrackLiteProducer_cff")
process.load("RecoPPS.ProtonReconstruction.ctppsProtons_cff")
process.load("Geometry.VeryForwardGeometry.geometryRPFromDB_cfi")
process.load('L1Trigger.L1TGlobal.simGtExtFakeProd_cfi')
task = getPatAlgosToolsTask(process)
from Configuration.Eras.Modifier_ctpps_cff import ctpps
ctpps.toModify(task, func=lambda t: t.add(process.ctppsLocalTrackLiteProducer))
ctpps.toModify(task, func=lambda t: t.add(process.ctppsProtons))
from Configuration.ProcessModifiers.run2_miniAOD_UL_cff import run2_miniAOD_UL
run2_miniAOD_UL.toModify(task, func=lambda t: t.add(process.simGtExtUnprefireable))
def reduceFinalJetCollection(process, jetCollection, badMuons):
task = getPatAlgosToolsTask(process)
label = jetCollection.label()
addToProcessAndTask(label+"AllEvents",
jetCollection.clone(),
process, task )
process.globalReplace(label,
cms.EDProducer("PATJetCollectionReducer",
writeEmptyCollection = cms.bool(False),
jetCollection = cms.InputTag(label+"AllEvents"),
triggeringCollections=badMuons,
)
)
def reduceFinalJetCollection(process, jetCollection, badMuons):
task = getPatAlgosToolsTask(process)
label = jetCollection.label()
addToProcessAndTask(label + "AllEvents", jetCollection.clone(), process,
task)
process.globalReplace(
label,
cms.EDProducer(
"PATJetCollectionReducer",
writeEmptyCollection=cms.bool(False),
jetCollection=cms.InputTag(label + "AllEvents"),
triggeringCollections=badMuons,
))
def loadJetMETBTag(process):
task = getPatAlgosToolsTask(process)
import RecoParticleFlow.PFProducer.pfLinker_cff
process.particleFlowPtrs = RecoParticleFlow.PFProducer.pfLinker_cff.particleFlowPtrs.clone(
)
task.add(process.particleFlowPtrs)
process.load("CommonTools.ParticleFlow.pfNoPileUpIso_cff")
task.add(process.pfNoPileUpIsoTask)
process.load("CommonTools.ParticleFlow.ParticleSelectors.pfSortByType_cff")
task.add(process.pfSortByTypeTask)
import RecoJets.Configuration.RecoPFJets_cff
process.ak4PFJetsCHS = RecoJets.Configuration.RecoPFJets_cff.ak4PFJetsCHS.clone(
)
task.add(process.ak4PFJetsCHS)
# need also the non-CHS ones as they are used to seed taus
process.ak4PFJets = RecoJets.Configuration.RecoPFJets_cff.ak4PFJets.clone()
task.add(process.ak4PFJets)
process.ak8PFJetsCHS = RecoJets.Configuration.RecoPFJets_cff.ak8PFJetsCHS.clone(
)
task.add(process.ak8PFJetsCHS)
process.fixedGridRhoAll = RecoJets.Configuration.RecoPFJets_cff.fixedGridRhoAll.clone(
)
process.fixedGridRhoFastjetAll = RecoJets.Configuration.RecoPFJets_cff.fixedGridRhoFastjetAll.clone(
)
process.fixedGridRhoFastjetCentral = RecoJets.Configuration.RecoPFJets_cff.fixedGridRhoFastjetCentral.clone(
)
process.fixedGridRhoFastjetCentralChargedPileUp = RecoJets.Configuration.RecoPFJets_cff.fixedGridRhoFastjetCentralChargedPileUp.clone(
)
process.fixedGridRhoFastjetCentralNeutral = RecoJets.Configuration.RecoPFJets_cff.fixedGridRhoFastjetCentralNeutral.clone(
)
task.add(process.fixedGridRhoAll, process.fixedGridRhoFastjetAll,
process.fixedGridRhoFastjetCentral,
process.fixedGridRhoFastjetCentralChargedPileUp,
process.fixedGridRhoFastjetCentralNeutral)
process.load("RecoJets.JetAssociationProducers.ak4JTA_cff")
task.add(process.ak4JTATask)
process.load('RecoBTag.Configuration.RecoBTag_cff')
task.add(process.btaggingTask)
process.load("RecoMET.METProducers.PFMET_cfi")
task.add(process.pfMet)
def toolCode(self, process):
"""
Tool code implementation
"""
## initialize parameters
labelName=self._parameters['labelName'].value
metSource=self._parameters['metSource'].value
## do necessary imports
from PhysicsTools.PatAlgos.producersLayer1.metProducer_cfi import patMETs
## add module to the process
task = getPatAlgosToolsTask(process)
addToProcessAndTask(labelName, patMETs.clone(metSource = metSource, addMuonCorrections=False), process, task)
## add module to output
if hasattr(process, "out"):
process.out.outputCommands+=["keep *_{LABEL_NAME}_*_*".format(LABEL_NAME=labelName)]
def makeInputForPUPPIIsolationEgm(process):
task = getPatAlgosToolsTask(process)
addToProcessAndTask('egmPhotonPUPPIIsolation', _egmPhotonPUPPIIsolationForPhotons.clone(), process, task)
process.egmPhotonPUPPIIsolation.srcToIsolate = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.egmPhotonPUPPIIsolation.srcForIsolationCone = cms.InputTag("particleFlow")
process.egmPhotonPUPPIIsolation.puppiValueMap = cms.InputTag('puppi')
addToProcessAndTask('egmElectronPUPPIIsolation', _egmElectronIsolationMiniAODPUPPI.clone(), process, task)
process.egmElectronPUPPIIsolation.srcToIsolate = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.egmElectronPUPPIIsolation.srcForIsolationCone = cms.InputTag("packedPFCandidates")
addToProcessAndTask('egmElectronPUPPINoLeptonsIsolation', _egmElectronIsolationMiniAODPUPPINoLeptons.clone(), process, task)
process.egmElectronPUPPINoLeptonsIsolation.srcToIsolate = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.egmElectronPUPPINoLeptonsIsolation.srcForIsolationCone = cms.InputTag("packedPFCandidates")
def makeInputForPUPPIIsolationMuon(process):
task = getPatAlgosToolsTask(process)
addToProcessAndTask('muonPUPPIIsolation',
_muonIsolationMiniAODPUPPI.clone(), process, task)
process.muonPUPPIIsolation.srcToIsolate = cms.InputTag("muons")
process.muonPUPPIIsolation.srcForIsolationCone = cms.InputTag(
"packedPFCandidates")
addToProcessAndTask('muonPUPPINoLeptonsIsolation',
_muonIsolationMiniAODPUPPINoLeptons.clone(), process,
task)
process.muonPUPPINoLeptonsIsolation.srcToIsolate = cms.InputTag("muons")
process.muonPUPPINoLeptonsIsolation.srcForIsolationCone = cms.InputTag(
"packedPFCandidates")
def backupJetsFirstStep(process):
task = getPatAlgosToolsTask(process)
"""Take snapshots of the sequences before we change the PFCandidates"""
process.originalAK4JetTask, process.originalAK4JetSequence = listDependencyChain(process, getattr(process,"slimmedJets"), ('particleFlow', 'muons'))
backupAK4JetSequence = cloneProcessingSnippet(process, getattr(process,"originalAK4JetSequence"), "Backup", addToTask = True )
process.originalAK4PuppiJetTask, process.originalAK4PuppiJetSequence = listDependencyChain(process,getattr(process,"slimmedJetsPuppi"), ('particleFlow', 'muons'))
backupAK4PuppiJetSequence = cloneProcessingSnippet(process, getattr(process,"originalAK4PuppiJetSequence"), "Backup", addToTask = True )
process.originalAK8JetTask,process.originalAK8JetSequence = listDependencyChain(process, getattr(process,"slimmedJetsAK8"), ('particleFlow', 'muons'))
backupAK8JetSequence = cloneProcessingSnippet(process, getattr(process,"originalAK8JetSequence"), "Backup", addToTask = True )
task.add(process.originalAK4JetTask)
task.add(process.originalAK4PuppiJetTask)
task.add(process.originalAK8JetTask)
return { 'AK4':backupAK4JetSequence, 'AK4Puppi':backupAK4PuppiJetSequence, 'AK8':backupAK8JetSequence }
def makePuppiesFromMiniAOD( process, createScheduledSequence=False ):
task = getPatAlgosToolsTask(process)
process.load('CommonTools.PileupAlgos.Puppi_cff')
task.add(process.puppi)
process.puppi.candName = 'packedPFCandidates'
process.puppi.clonePackedCands = True
process.puppi.vertexName = 'offlineSlimmedPrimaryVertices'
process.puppi.useExistingWeights = True
task.add(process.puppiNoLep)
process.puppiNoLep.candName = 'packedPFCandidates'
process.puppiNoLep.clonePackedCands = True
process.puppiNoLep.vertexName = 'offlineSlimmedPrimaryVertices'
process.puppiNoLep.useExistingWeights = True
#making a sequence for people running the MET tool in scheduled mode
if createScheduledSequence:
puppiMETSequence = cms.Sequence(process.puppi*process.puppiNoLep)
setattr(process, "puppiMETSequence", puppiMETSequence)
def addPFCandidates(process,src,patLabel='PFParticles',cut="",postfix=""):
from PhysicsTools.PatAlgos.producersLayer1.pfParticleProducer_cfi import patPFParticles
# make modules
producer = patPFParticles.clone(pfCandidateSource = src)
filter = cms.EDFilter("PATPFParticleSelector",
src = cms.InputTag("pat" + patLabel),
cut = cms.string(cut))
counter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(0),
maxNumber = cms.uint32(999999),
src = cms.InputTag("pat" + patLabel))
# add modules to process
task = getPatAlgosToolsTask(process)
addToProcessAndTask("pat" + patLabel, producer, process, task)
addToProcessAndTask("selectedPat" + patLabel, filter, process, task)
addToProcessAndTask("countPat" + patLabel, counter, process, task)
# summary tables
applyPostfix(process, "patCandidateSummary", postfix).candidates.append(cms.InputTag('pat' + patLabel))
applyPostfix(process, "selectedPatCandidateSummary", postfix).candidates.append(cms.InputTag('selectedPat' + patLabel))
def addPFCandidates(process,src,patLabel='PFParticles',cut="",postfix=""):
from PhysicsTools.PatAlgos.producersLayer1.pfParticleProducer_cfi import patPFParticles
# make modules
producer = patPFParticles.clone(pfCandidateSource = src)
filter = cms.EDFilter("PATPFParticleSelector",
src = cms.InputTag("pat" + patLabel),
cut = cms.string(cut))
counter = cms.EDFilter("PATCandViewCountFilter",
minNumber = cms.uint32(0),
maxNumber = cms.uint32(999999),
src = cms.InputTag("pat" + patLabel))
# add modules to process
task = getPatAlgosToolsTask(process)
addToProcessAndTask("pat" + patLabel, producer, process, task)
addToProcessAndTask("selectedPat" + patLabel, filter, process, task)
addToProcessAndTask("countPat" + patLabel, counter, process, task)
# summary tables
applyPostfix(process, "patCandidateSummary", postfix).candidates.append(cms.InputTag('pat' + patLabel))
applyPostfix(process, "selectedPatCandidateSummary", postfix).candidates.append(cms.InputTag('selectedPat' + patLabel))
def loadJetMETBTag(process):
task = getPatAlgosToolsTask(process)
import RecoParticleFlow.PFProducer.pfLinker_cff
process.particleFlowPtrs = RecoParticleFlow.PFProducer.pfLinker_cff.particleFlowPtrs.clone()
task.add(process.particleFlowPtrs)
process.load("CommonTools.ParticleFlow.pfNoPileUpIso_cff")
task.add(process.pfNoPileUpIsoTask)
process.load("CommonTools.ParticleFlow.ParticleSelectors.pfSortByType_cff")
task.add(process.pfSortByTypeTask)
import RecoJets.Configuration.RecoPFJets_cff
process.ak4PFJetsCHS = RecoJets.Configuration.RecoPFJets_cff.ak4PFJetsCHS.clone()
task.add(process.ak4PFJetsCHS)
# need also the non-CHS ones as they are used to seed taus
process.ak4PFJets = RecoJets.Configuration.RecoPFJets_cff.ak4PFJets.clone()
task.add(process.ak4PFJets)
process.ak8PFJetsCHS = RecoJets.Configuration.RecoPFJets_cff.ak8PFJetsCHS.clone()
task.add(process.ak8PFJetsCHS)
process.fixedGridRhoAll = RecoJets.Configuration.RecoPFJets_cff.fixedGridRhoAll.clone()
process.fixedGridRhoFastjetAll = RecoJets.Configuration.RecoPFJets_cff.fixedGridRhoFastjetAll.clone()
process.fixedGridRhoFastjetCentral = RecoJets.Configuration.RecoPFJets_cff.fixedGridRhoFastjetCentral.clone()
process.fixedGridRhoFastjetCentralChargedPileUp = RecoJets.Configuration.RecoPFJets_cff.fixedGridRhoFastjetCentralChargedPileUp.clone()
process.fixedGridRhoFastjetCentralNeutral = RecoJets.Configuration.RecoPFJets_cff.fixedGridRhoFastjetCentralNeutral.clone()
task.add( process.fixedGridRhoAll,
process.fixedGridRhoFastjetAll,
process.fixedGridRhoFastjetCentral,
process.fixedGridRhoFastjetCentralChargedPileUp,
process.fixedGridRhoFastjetCentralNeutral )
process.load("RecoJets.JetAssociationProducers.ak4JTA_cff")
task.add(process.ak4JTATask)
process.load('RecoBTag.Configuration.RecoBTag_cff')
task.add(process.btaggingTask)
process.load("RecoMET.METProducers.PFMET_cfi")
task.add(process.pfMet)
def toolCode(self, process):
"""
Tool code implementation
"""
## initialize parameters
labelName = self._parameters['labelName'].value
metSource = self._parameters['metSource'].value
## do necessary imports
from PhysicsTools.PatAlgos.producersLayer1.metProducer_cfi import patMETs
## add module to the process
task = getPatAlgosToolsTask(process)
addToProcessAndTask(
labelName,
patMETs.clone(metSource=metSource, addMuonCorrections=False),
process, task)
## add module to output
if hasattr(process, "out"):
process.out.outputCommands += [
"keep *_{LABEL_NAME}_*_*".format(LABEL_NAME=labelName)
]
def addDiscardedPFCandidates(process, inputCollection, verbose=False):
task = getPatAlgosToolsTask(process)
process.primaryVertexAssociationDiscardedCandidates = process.primaryVertexAssociation.clone(
particles = inputCollection,
)
task.add(process.primaryVertexAssociationDiscardedCandidates)
process.packedPFCandidatesDiscarded = process.packedPFCandidates.clone(
inputCollection = inputCollection,
PuppiNoLepSrc = cms.InputTag(""),
PuppiSrc = cms.InputTag(""),
secondaryVerticesForWhiteList = cms.VInputTag(),
vertexAssociator = cms.InputTag("primaryVertexAssociationDiscardedCandidates","original")
)
task.add(process.packedPFCandidatesDiscarded)
addKeepStatement(process, "keep patPackedCandidates_packedPFCandidates_*_*",
["keep patPackedCandidates_packedPFCandidatesDiscarded_*_*"],
verbose=verbose)
def toolCode(self, process):
label=self._parameters['label'].value
tracks=self._parameters['tracks'].value
particleType=self._parameters['particleType'].value
candSelection=self._parameters['candSelection'].value
process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi");
## add ChargedCandidateProducer from track
task = getPatAlgosToolsTask(process)
addToProcessAndTask('patAOD' + label + 'Unfiltered',
cms.EDProducer("ConcreteChargedCandidateProducer",
src = tracks,
particleType = cms.string(particleType)),
process, task)
## add CandViewSelector with preselection string
addToProcessAndTask('patAOD' + label,
cms.EDFilter("CandViewSelector",
src = cms.InputTag('patAOD' + label + 'Unfiltered'),
cut = cms.string(candSelection)),
process, task)
def nanoAOD_addDeepBTagFor80X(process):
print("Updating process to run DeepCSV btag on legacy 80X datasets")
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual']), 'None'),
btagDiscriminators = ['pfDeepCSVJetTags:probb','pfDeepCSVJetTags:probbb','pfDeepCSVJetTags:probc'], ## to add discriminators
btagPrefix = ''
)
process.load("Configuration.StandardSequences.MagneticField_cff")
process.looseJetId.src="selectedUpdatedPatJets"
process.tightJetId.src="selectedUpdatedPatJets"
process.tightJetIdLepVeto.src="selectedUpdatedPatJets"
process.bJetVars.src="selectedUpdatedPatJets"
process.slimmedJetsWithUserData.src="selectedUpdatedPatJets"
process.qgtagger80x.srcJets="selectedUpdatedPatJets"
patAlgosToolsTask = getPatAlgosToolsTask(process)
patAlgosToolsTask .add(process.updatedPatJets)
patAlgosToolsTask .add(process.patJetCorrFactors)
process.additionalendpath = cms.EndPath(patAlgosToolsTask)
return process
def cleanPfCandidates(process, verbose=False):
task = getPatAlgosToolsTask(process)
#add producer at the beginning of the schedule
process.load("CommonTools.ParticleFlow.pfCandidateRecalibrator_cfi")
task.add(process.pfCandidateRecalibrator)
replacePFCandidates = MassSearchReplaceAnyInputTagVisitor("particleFlow", "pfCandidateRecalibrator", verbose=verbose)
replacePFTmpPtrs = MassSearchReplaceAnyInputTagVisitor("particleFlowTmpPtrs", "particleFlowPtrs", verbose=verbose)
for everywhere in [ process.producers, process.filters, process.analyzers, process.psets, process.vpsets ]:
for name,obj in everywhere.iteritems():
if obj != process.pfCandidateRecalibrator:
replacePFCandidates.doIt(obj, name)
replacePFTmpPtrs.doIt(obj, name)
process.load("CommonTools.ParticleFlow.pfEGammaToCandidateRemapper_cfi")
task.add(process.pfEGammaToCandidateRemapper)
process.pfEGammaToCandidateRemapper.pf2pf = cms.InputTag("pfCandidateRecalibrator")
process.reducedEgamma.gsfElectronsPFValMap = cms.InputTag("pfEGammaToCandidateRemapper","electrons")
process.reducedEgamma.photonsPFValMap = cms.InputTag("pfEGammaToCandidateRemapper","photons")
def cleanPFCandidates(process, badMuons, verbose=False):
task = getPatAlgosToolsTask(process)
process.load("CommonTools.ParticleFlow.muonsCleaned_cfi")
task.add(process.muonsCleaned)
process.patMuons.userData.userInts.src = [ cms.InputTag("muonsCleaned:oldPF") ]
process.load("CommonTools.ParticleFlow.pfCandidatesBadMuonsCleaned_cfi")
task.add(process.pfCandidatesBadMuonsCleaned)
process.muonsCleaned.badmuons = badMuons
replaceMuons = MassSearchReplaceAnyInputTagVisitor("muons", "muonsCleaned", verbose=verbose)
needOriginalMuons = [ process.muonsCleaned ] + [ getattr(process,l.moduleLabel) for l in badMuons ]
replacePFCandidates = MassSearchReplaceAnyInputTagVisitor("particleFlow", "pfCandidatesBadMuonsCleaned", verbose=verbose)
for everywhere in [ process.producers, process.filters, process.analyzers, process.psets, process.vpsets ]:
for name,obj in everywhere.iteritems():
if obj not in needOriginalMuons:
replaceMuons.doIt(obj, name)
if obj != process.pfCandidatesBadMuonsCleaned:
replacePFCandidates.doIt(obj, name)
process.load("CommonTools.ParticleFlow.pfEGammaToCandidateRemapper_cfi")
task.add(process.pfEGammaToCandidateRemapper)
process.pfEGammaToCandidateRemapper.pf2pf = cms.InputTag("pfCandidatesBadMuonsCleaned")
process.reducedEgamma.gsfElectronsPFValMap = cms.InputTag("pfEGammaToCandidateRemapper","electrons")
process.reducedEgamma.photonsPFValMap = cms.InputTag("pfEGammaToCandidateRemapper","photons")
if hasattr(process,"gedGsfElectronsFixed"):
# also reconfigure pfEGammaToCandidateRemapper because of GS Fix
# first the old one
process.pfEGammaToCandidateRemapperBeforeGSFix = process.pfEGammaToCandidateRemapper.clone()
task.add(process.pfEGammaToCandidateRemapperBeforeGSFix)
process.reducedEgammaBeforeGSFix.gsfElectronsPFValMap = cms.InputTag("pfEGammaToCandidateRemapperBeforeGSFix","electrons")
process.reducedEgammaBeforeGSFix.photonsPFValMap = cms.InputTag("pfEGammaToCandidateRemapperBeforeGSFix","photons")
# then the new one
process.pfEGammaToCandidateRemapper.electrons = cms.InputTag("gedGsfElectronsFixed")
process.pfEGammaToCandidateRemapper.photons = cms.InputTag("gedPhotonsFixed")
process.pfEGammaToCandidateRemapper.electron2pf = cms.InputTag("particleBasedIsolationGSFixed","gedGsfElectrons")
process.pfEGammaToCandidateRemapper.photon2pf = cms.InputTag("particleBasedIsolationGSFixed","gedPhotons")
else:
sys.stderr.write("WARNING : attempt to use gain switch corrected electron/photon collection gedGsfElectronsFixed, but the current process does not contain such collection")
def nanoAOD_addDeepFlavourTagFor94X2016(process):
print("Updating process to run DeepCSV btag on 94X re-miniAOD of legacy 80X datasets")
updateJetCollection(
process,
jetSource = cms.InputTag('slimmedJets'),
jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual']), 'None'),
btagDiscriminators = ['pfDeepFlavourJetTags:probb','pfDeepFlavourJetTags:probbb','pfDeepFlavourJetTags:problepb'], ## to add discriminators
btagPrefix = ''
)
process.load("Configuration.StandardSequences.MagneticField_cff")
process.looseJetId.src="selectedUpdatedPatJets"
process.tightJetId.src="selectedUpdatedPatJets"
process.tightJetIdLepVeto.src="selectedUpdatedPatJets"
process.bJetVars.src="selectedUpdatedPatJets"
process.slimmedJetsWithUserData.src="selectedUpdatedPatJets"
process.qgtagger80x.srcJets="selectedUpdatedPatJets"
process.pfDeepFlavourJetTags.graph_path = 'RecoBTag/Combined/data/DeepFlavourV03_10X_training/constant_graph.pb'
process.pfDeepFlavourJetTags.lp_names = ["cpf_input_batchnorm/keras_learning_phase"]
patAlgosToolsTask = getPatAlgosToolsTask(process)
patAlgosToolsTask .add(process.updatedPatJets)
patAlgosToolsTask .add(process.patJetCorrFactors)
process.additionalendpath = cms.EndPath(patAlgosToolsTask)
return process
def applySubstructure( process, postfix="" ) :
task = getPatAlgosToolsTask(process)
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import _patJets as patJetsDefault
#add AK8
addJetCollection(process, postfix=postfix, labelName = 'AK8',
jetSource = cms.InputTag('ak8PFJetsCHS'+postfix),
algo= 'AK', rParam = 0.8,
jetCorrections = ('AK8PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
genJetCollection = cms.InputTag('slimmedGenJetsAK8')
)
getattr(process,"patJetsAK8"+postfix).userData.userFloats.src = [] # start with empty list of user floats
getattr(process,"selectedPatJetsAK8").cut = cms.string("pt > 170")
## AK8 groomed masses
from RecoJets.Configuration.RecoPFJets_cff import ak8PFJetsCHSPruned, ak8PFJetsCHSSoftDrop
addToProcessAndTask('ak8PFJetsCHSPruned'+postfix, ak8PFJetsCHSPruned.clone(), process, task)
addToProcessAndTask('ak8PFJetsCHSSoftDrop'+postfix, ak8PFJetsCHSSoftDrop.clone(), process, task)
from RecoJets.JetProducers.ak8PFJetsCHS_groomingValueMaps_cfi import ak8PFJetsCHSPrunedMass, ak8PFJetsCHSTrimmedMass, ak8PFJetsCHSFilteredMass, ak8PFJetsCHSSoftDropMass
addToProcessAndTask('ak8PFJetsCHSPrunedMass'+postfix, ak8PFJetsCHSPrunedMass.clone(), process, task)
addToProcessAndTask('ak8PFJetsCHSTrimmedMass'+postfix, ak8PFJetsCHSTrimmedMass.clone(), process, task)
addToProcessAndTask('ak8PFJetsCHSFilteredMass'+postfix, ak8PFJetsCHSFilteredMass.clone(), process, task)
addToProcessAndTask('ak8PFJetsCHSSoftDropMass'+postfix, ak8PFJetsCHSSoftDropMass.clone(), process, task)
getattr(process,"patJetsAK8").userData.userFloats.src += ['ak8PFJetsCHSPrunedMass'+postfix,'ak8PFJetsCHSSoftDropMass'+postfix]
getattr(process,"patJetsAK8").addTagInfos = cms.bool(False)
# add Njetiness
process.load('RecoJets.JetProducers.nJettinessAdder_cfi')
task.add(process.Njettiness)
addToProcessAndTask('NjettinessAK8'+postfix, process.Njettiness.clone(), process, task)
getattr(process,"NjettinessAK8").src = cms.InputTag("ak8PFJetsCHS"+postfix)
getattr(process,"NjettinessAK8").cone = cms.double(0.8)
getattr(process,"patJetsAK8").userData.userFloats.src += ['NjettinessAK8'+postfix+':tau1','NjettinessAK8'+postfix+':tau2','NjettinessAK8'+postfix+':tau3']
#add AK8 from PUPPI
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJetsPuppi
from RecoJets.JetProducers.ak8PFJets_cfi import ak8PFJetsPuppi
addToProcessAndTask('ak4PFJetsPuppi'+postfix,ak4PFJetsPuppi.clone(), process, task)
addToProcessAndTask('ak8PFJetsPuppi'+postfix,ak8PFJetsPuppi.clone(), process, task)
from RecoJets.Configuration.RecoPFJets_cff import ak8PFJetsPuppiSoftDrop
addToProcessAndTask('ak8PFJetsPuppiSoftDrop'+postfix, ak8PFJetsPuppiSoftDrop.clone(), process, task)
getattr(process,"ak8PFJetsPuppi").doAreaFastjet = True # even for standard ak8PFJets this is overwritten in RecoJets/Configuration/python/RecoPFJets_cff
#add AK8 from PUPPI
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJetsPuppi
from RecoJets.JetProducers.ak8PFJets_cfi import ak8PFJetsPuppi, ak8PFJetsPuppiSoftDrop, ak8PFJetsPuppiConstituents, ak8PFJetsCHSConstituents
#from RecoJets.Configuration.RecoPFJets_cff import ak8PFJetsPuppi, ak8PFJetsPuppiSoftDrop, ak8PFJetsPuppiConstituents, ak8PFJetsCHSConstituents
addToProcessAndTask('ak4PFJetsPuppi'+postfix,ak4PFJetsPuppi.clone(), process, task)
addToProcessAndTask('ak8PFJetsPuppiConstituents', ak8PFJetsPuppiConstituents.clone(), process, task )
addToProcessAndTask('ak8PFJetsCHSConstituents', ak8PFJetsCHSConstituents.clone(), process, task )
addToProcessAndTask('ak8PFJetsPuppi'+postfix,ak8PFJetsPuppi.clone(), process, task)
addToProcessAndTask('ak8PFJetsPuppiSoftDrop'+postfix, ak8PFJetsPuppiSoftDrop.clone(), process, task)
getattr(process,"ak8PFJetsPuppi").doAreaFastjet = True # even for standard ak8PFJets this is overwritten in RecoJets/Configuration/python/RecoPFJets_cff
addJetCollection(process, postfix=postfix, labelName = 'AK8Puppi',
jetSource = cms.InputTag('ak8PFJetsPuppi'+postfix),
algo= 'AK', rParam = 0.8,
jetCorrections = ('AK8PFPuppi', cms.vstring(['L2Relative', 'L3Absolute']), 'None'),
btagDiscriminators = ([x.value() for x in patJetsDefault.discriminatorSources] + ['pfBoostedDoubleSecondaryVertexAK8BJetTags']),
genJetCollection = cms.InputTag('slimmedGenJetsAK8')
)
getattr(process,"patJetsAK8Puppi"+postfix).userData.userFloats.src = [] # start with empty list of user floats
getattr(process,"selectedPatJetsAK8Puppi"+postfix).cut = cms.string("pt > 170")
from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX
addToProcessAndTask('ak8PFJetsPuppiTracksAssociatorAtVertex'+postfix, cms.EDProducer("JetTracksAssociatorAtVertex",
j2tParametersVX.clone( coneSize = cms.double(0.8) ),
jets = cms.InputTag("ak8PFJetsPuppi") ),
process, task)
addToProcessAndTask('patJetAK8PuppiCharge'+postfix, cms.EDProducer("JetChargeProducer",
src = cms.InputTag("ak8PFJetsPuppiTracksAssociatorAtVertex"),
var = cms.string('Pt'),
exp = cms.double(1.0) ),
process, task)
## AK8 groomed masses
from RecoJets.Configuration.RecoPFJets_cff import ak8PFJetsPuppiSoftDrop
addToProcessAndTask('ak8PFJetsPuppiSoftDrop'+postfix, ak8PFJetsPuppiSoftDrop.clone(), process, task)
from RecoJets.JetProducers.ak8PFJetsPuppi_groomingValueMaps_cfi import ak8PFJetsPuppiSoftDropMass
addToProcessAndTask('ak8PFJetsPuppiSoftDropMass'+postfix, ak8PFJetsPuppiSoftDropMass.clone(), process, task)
getattr(process,"patJetsAK8Puppi"+postfix).userData.userFloats.src += ['ak8PFJetsPuppiSoftDropMass'+postfix]
getattr(process,"patJetsAK8Puppi"+postfix).addTagInfos = cms.bool(False)
# add Njetiness
addToProcessAndTask('NjettinessAK8Puppi'+postfix, process.Njettiness.clone(), process, task)
getattr(process,"NjettinessAK8Puppi"+postfix).src = cms.InputTag("ak8PFJetsPuppi"+postfix)
getattr(process,"NjettinessAK8Puppi").cone = cms.double(0.8)
getattr(process,"patJetsAK8Puppi").userData.userFloats.src += ['NjettinessAK8Puppi'+postfix+':tau1','NjettinessAK8Puppi'+postfix+':tau2','NjettinessAK8Puppi'+postfix+':tau3']
addToProcessAndTask("ak8PFJetsCHSValueMap"+postfix, cms.EDProducer("RecoJetToPatJetDeltaRValueMapProducer",
src = cms.InputTag("ak8PFJetsPuppi"+postfix),
matched = cms.InputTag("patJetsAK8"+postfix),
distMax = cms.double(0.8),
values = cms.vstring([
'userFloat("ak8PFJetsCHSPrunedMass"'+postfix+')',
'userFloat("ak8PFJetsCHSSoftDropMass"'+postfix+')',
'userFloat("NjettinessAK8'+postfix+':tau1")',
'userFloat("NjettinessAK8'+postfix+':tau2")',
'userFloat("NjettinessAK8'+postfix+':tau3")',
'pt','eta','phi','mass'
]),
valueLabels = cms.vstring( [
'ak8PFJetsCHSPrunedMass',
'ak8PFJetsCHSSoftDropMass',
'NjettinessAK8CHSTau1',
'NjettinessAK8CHSTau2',
'NjettinessAK8CHSTau3',
'pt','eta','phi','mass'
]) ),
process, task)
getattr(process,"patJetsAK8Puppi"+postfix).userData.userFloats.src += [
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'ak8PFJetsCHSPrunedMass'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'ak8PFJetsCHSSoftDropMass'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'NjettinessAK8CHSTau1'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'NjettinessAK8CHSTau2'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'NjettinessAK8CHSTau3'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'pt'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'eta'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'phi'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'mass'),
]
# add Njetiness
process.load('RecoJets.JetProducers.nJettinessAdder_cfi')
task.add(process.Njettiness)
addToProcessAndTask('NjettinessAK8Subjets'+postfix, process.Njettiness.clone(), process, task)
getattr(process,"NjettinessAK8Subjets"+postfix).src = cms.InputTag("ak8PFJetsPuppiSoftDrop"+postfix, "SubJets")
getattr(process,"NjettinessAK8Subjets").cone = cms.double(0.8)
## PATify CHS soft drop fat jets
addJetCollection(
process,
postfix=postfix,
labelName = 'AK8PFCHSSoftDrop',
jetSource = cms.InputTag('ak8PFJetsCHSSoftDrop'+postfix),
btagDiscriminators = ['None'],
jetCorrections = ('AK8PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'),
getJetMCFlavour = False # jet flavor disabled
)
## PATify puppi soft drop fat jets
addJetCollection(
process,
postfix=postfix,
labelName = 'AK8PFPuppiSoftDrop',
jetSource = cms.InputTag('ak8PFJetsPuppiSoftDrop'+postfix),
btagDiscriminators = ['None'],
jetCorrections = ('AK8PFPuppi', ['L2Relative', 'L3Absolute'], 'None'),
getJetMCFlavour = False # jet flavor disabled
)
## PATify soft drop subjets
addJetCollection(
process,
postfix=postfix,
labelName = 'AK8PFPuppiSoftDropSubjets',
jetSource = cms.InputTag('ak8PFJetsPuppiSoftDrop'+postfix,'SubJets'),
algo = 'ak', # needed for subjet flavor clustering
rParam = 0.8, # needed for subjet flavor clustering
btagDiscriminators = ['pfDeepCSVJetTags:probb', 'pfDeepCSVJetTags:probbb', 'pfCombinedInclusiveSecondaryVertexV2BJetTags','pfCombinedMVAV2BJetTags'],
jetCorrections = ('AK4PFPuppi', ['L2Relative', 'L3Absolute'], 'None'),
explicitJTA = True, # needed for subjet b tagging
svClustering = True, # needed for subjet b tagging
genJetCollection = cms.InputTag('slimmedGenJets'),
fatJets=cms.InputTag('ak8PFJetsPuppi'), # needed for subjet flavor clustering
groomedFatJets=cms.InputTag('ak8PFJetsPuppiSoftDrop') # needed for subjet flavor clustering
)
getattr(process,"selectedPatJetsAK8PFPuppiSoftDrop"+postfix).cut = cms.string("pt > 170")
getattr(process,"patJetsAK8PFPuppiSoftDropSubjets"+postfix).userData.userFloats.src += ['NjettinessAK8Subjets'+postfix+':tau1','NjettinessAK8Subjets'+postfix+':tau2','NjettinessAK8Subjets'+postfix+':tau3']
addToProcessAndTask("slimmedJetsAK8PFPuppiSoftDropSubjets"+postfix,
cms.EDProducer("PATJetSlimmer",
src = cms.InputTag("selectedPatJetsAK8PFPuppiSoftDropSubjets"),
packedPFCandidates = cms.InputTag("packedPFCandidates"),
dropJetVars = cms.string("1"),
dropDaughters = cms.string("0"),
rekeyDaughters = cms.string("1"),
dropTrackRefs = cms.string("1"),
dropSpecific = cms.string("1"),
dropTagInfos = cms.string("1"),
modifyJets = cms.bool(True),
mixedDaughters = cms.bool(False),
modifierConfig = cms.PSet( modifications = cms.VPSet() )
),
process, task)
## Establish references between PATified fat jets and subjets using the BoostedJetMerger
addToProcessAndTask("slimmedJetsAK8PFPuppiSoftDropPacked"+postfix,
cms.EDProducer("BoostedJetMerger",
jetSrc=cms.InputTag("selectedPatJetsAK8PFPuppiSoftDrop"),
subjetSrc=cms.InputTag("slimmedJetsAK8PFPuppiSoftDropSubjets")
),
process, task )
addToProcessAndTask("packedPatJetsAK8"+postfix, cms.EDProducer("JetSubstructurePacker",
jetSrc = cms.InputTag("selectedPatJetsAK8Puppi"+postfix),
distMax = cms.double(0.8),
algoTags = cms.VInputTag(
cms.InputTag("slimmedJetsAK8PFPuppiSoftDropPacked"+postfix)
),
algoLabels = cms.vstring(
'SoftDropPuppi'
),
fixDaughters = cms.bool(True),
packedPFCandidates = cms.InputTag("packedPFCandidates"+postfix),
),
process, task)
# switch off daughter re-keying since it's done in the JetSubstructurePacker (and can't be done afterwards)
process.slimmedJetsAK8.rekeyDaughters = "0"
def applySubstructure( process, postfix="" ) :
task = getPatAlgosToolsTask(process)
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import _patJets as patJetsDefault
# Configure the RECO jets
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJetsPuppi
from RecoJets.JetProducers.ak8PFJets_cfi import ak8PFJetsPuppi, ak8PFJetsPuppiSoftDrop, ak8PFJetsPuppiConstituents, ak8PFJetsCHSConstituents
from RecoJets.JetProducers.ak8GenJets_cfi import ak8GenJets, ak8GenJetsSoftDrop, ak8GenJetsConstituents
addToProcessAndTask('ak4PFJetsPuppi'+postfix,ak4PFJetsPuppi.clone(), process, task)
addToProcessAndTask('ak8PFJetsPuppi'+postfix,ak8PFJetsPuppi.clone(), process, task)
addToProcessAndTask('ak8PFJetsPuppiConstituents', ak8PFJetsPuppiConstituents.clone(cut = cms.string('pt > 170.0 && abs(rapidity()) < 2.4') ), process, task )
addToProcessAndTask('ak8PFJetsCHSConstituents', ak8PFJetsCHSConstituents.clone(), process, task )
addToProcessAndTask('ak8PFJetsPuppiSoftDrop'+postfix, ak8PFJetsPuppiSoftDrop.clone( src = cms.InputTag('ak8PFJetsPuppiConstituents', 'constituents') ), process, task)
addToProcessAndTask('ak8GenJetsNoNuConstituents'+postfix, ak8GenJetsConstituents.clone(src='ak8GenJetsNoNu'), process, task )
addToProcessAndTask('ak8GenJetsNoNuSoftDrop'+postfix,ak8GenJetsSoftDrop.clone(src=cms.InputTag('ak8GenJetsNoNuConstituents'+postfix, 'constituents')),process,task)
addToProcessAndTask('slimmedGenJetsAK8SoftDropSubJets'+postfix,
cms.EDProducer("PATGenJetSlimmer",
src = cms.InputTag("ak8GenJetsNoNuSoftDrop"+postfix, "SubJets"),
packedGenParticles = cms.InputTag("packedGenParticles"),
cut = cms.string(""),
cutLoose = cms.string(""),
nLoose = cms.uint32(0),
clearDaughters = cms.bool(False), #False means rekeying
dropSpecific = cms.bool(True), # Save space
), process, task )
#add AK8 CHS
addJetCollection(process, postfix=postfix, labelName = 'AK8',
jetSource = cms.InputTag('ak8PFJetsCHS'+postfix),
algo= 'AK', rParam = 0.8,
btagDiscriminators = ['None'],
jetCorrections = ('AK8PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'),
genJetCollection = cms.InputTag('slimmedGenJetsAK8')
)
getattr(process,"patJetsAK8"+postfix).userData.userFloats.src = [] # start with empty list of user floats
getattr(process,"selectedPatJetsAK8").cut = cms.string("pt > 170")
## add AK8 groomed masses with CHS
from RecoJets.Configuration.RecoPFJets_cff import ak8PFJetsCHSPruned, ak8PFJetsCHSSoftDrop
addToProcessAndTask('ak8PFJetsCHSPruned'+postfix, ak8PFJetsCHSPruned.clone(), process, task)
addToProcessAndTask('ak8PFJetsCHSSoftDrop'+postfix, ak8PFJetsCHSSoftDrop.clone(), process, task)
from RecoJets.JetProducers.ak8PFJetsCHS_groomingValueMaps_cfi import ak8PFJetsCHSPrunedMass, ak8PFJetsCHSTrimmedMass, ak8PFJetsCHSFilteredMass, ak8PFJetsCHSSoftDropMass
addToProcessAndTask('ak8PFJetsCHSPrunedMass'+postfix, ak8PFJetsCHSPrunedMass.clone(), process, task)
addToProcessAndTask('ak8PFJetsCHSTrimmedMass'+postfix, ak8PFJetsCHSTrimmedMass.clone(), process, task)
addToProcessAndTask('ak8PFJetsCHSFilteredMass'+postfix, ak8PFJetsCHSFilteredMass.clone(), process, task)
addToProcessAndTask('ak8PFJetsCHSSoftDropMass'+postfix, ak8PFJetsCHSSoftDropMass.clone(), process, task)
getattr(process,"patJetsAK8").userData.userFloats.src += ['ak8PFJetsCHSPrunedMass'+postfix,'ak8PFJetsCHSSoftDropMass'+postfix]
getattr(process,"patJetsAK8").addTagInfos = cms.bool(False)
# add Njetiness for CHS
process.load('RecoJets.JetProducers.nJettinessAdder_cfi')
task.add(process.Njettiness)
addToProcessAndTask('NjettinessAK8'+postfix, process.Njettiness.clone(), process, task)
getattr(process,"NjettinessAK8").src = cms.InputTag("ak8PFJetsCHS"+postfix)
getattr(process,"NjettinessAK8").cone = cms.double(0.8)
getattr(process,"patJetsAK8").userData.userFloats.src += ['NjettinessAK8'+postfix+':tau1','NjettinessAK8'+postfix+':tau2','NjettinessAK8'+postfix+':tau3','NjettinessAK8'+postfix+':tau4']
# add Njetiness from CHS
addToProcessAndTask('NjettinessAK8Subjets'+postfix, process.Njettiness.clone(), process, task)
getattr(process,"NjettinessAK8Subjets"+postfix).src = cms.InputTag("ak8PFJetsPuppiSoftDrop"+postfix, "SubJets")
getattr(process,"NjettinessAK8Subjets").cone = cms.double(0.8)
## PATify CHS soft drop fat jets
addJetCollection(
process,
postfix=postfix,
labelName = 'AK8PFCHSSoftDrop',
jetSource = cms.InputTag('ak8PFJetsCHSSoftDrop'+postfix),
btagDiscriminators = ['None'],
jetCorrections = ('AK8PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute'], 'None'),
getJetMCFlavour = False # jet flavor disabled
)
#add RECO AK8 from PUPPI and RECO AK8 PUPPI with soft drop... will be needed by ungroomed AK8 jets later
## PATify puppi soft drop fat jets
addJetCollection(
process,
postfix=postfix,
labelName = 'AK8PFPuppiSoftDrop' + postfix,
jetSource = cms.InputTag('ak8PFJetsPuppiSoftDrop'+postfix),
btagDiscriminators = ['None'],
genJetCollection = cms.InputTag('slimmedGenJetsAK8'),
jetCorrections = ('AK8PFPuppi', ['L2Relative', 'L3Absolute'], 'None'),
getJetMCFlavour = False # jet flavor disabled
)
## PATify soft drop subjets
addJetCollection(
process,
postfix=postfix,
labelName = 'AK8PFPuppiSoftDropSubjets',
jetSource = cms.InputTag('ak8PFJetsPuppiSoftDrop'+postfix,'SubJets'),
algo = 'ak', # needed for subjet flavor clustering
rParam = 0.8, # needed for subjet flavor clustering
btagDiscriminators = ['pfDeepCSVJetTags:probb', 'pfDeepCSVJetTags:probbb', 'pfCombinedInclusiveSecondaryVertexV2BJetTags','pfCombinedMVAV2BJetTags'],
jetCorrections = ('AK4PFPuppi', ['L2Relative', 'L3Absolute'], 'None'),
explicitJTA = True, # needed for subjet b tagging
svClustering = True, # needed for subjet b tagging
genJetCollection = cms.InputTag('slimmedGenJetsAK8SoftDropSubJets'),
fatJets=cms.InputTag('ak8PFJetsPuppi'), # needed for subjet flavor clustering
groomedFatJets=cms.InputTag('ak8PFJetsPuppiSoftDrop') # needed for subjet flavor clustering
)
# add groomed ECFs and N-subjettiness to soft dropped pat::Jets for fat jets and subjets
process.load('RecoJets.JetProducers.ECF_cff')
addToProcessAndTask('nb1AK8PuppiSoftDrop'+postfix, process.ecfNbeta1.clone(src = cms.InputTag("ak8PFJetsPuppiSoftDrop"+postfix), cuts = cms.vstring('', '', 'pt > 250')), process, task)
addToProcessAndTask('nb2AK8PuppiSoftDrop'+postfix, process.ecfNbeta2.clone(src = cms.InputTag("ak8PFJetsPuppiSoftDrop"+postfix), cuts = cms.vstring('', '', 'pt > 250')), process, task)
#too slow now ==> disable
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
from Configuration.Eras.Modifier_pp_on_XeXe_2017_cff import pp_on_XeXe_2017
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
for e in [pp_on_XeXe_2017, pp_on_AA_2018, phase2_common]:
e.toModify(getattr(process,'nb1AK8PuppiSoftDrop'+postfix), cuts = ['pt > 999999', 'pt > 999999', 'pt > 999999'] )
e.toModify(getattr(process,'nb2AK8PuppiSoftDrop'+postfix), cuts = ['pt > 999999', 'pt > 999999', 'pt > 999999'] )
getattr(process,"patJetsAK8PFPuppiSoftDrop").userData.userFloats.src += ['nb1AK8PuppiSoftDrop'+postfix+':ecfN2','nb1AK8PuppiSoftDrop'+postfix+':ecfN3']
getattr(process,"patJetsAK8PFPuppiSoftDrop").userData.userFloats.src += ['nb2AK8PuppiSoftDrop'+postfix+':ecfN2','nb2AK8PuppiSoftDrop'+postfix+':ecfN3']
addToProcessAndTask('nb1AK8PuppiSoftDropSubjets'+postfix, process.ecfNbeta1.clone(src = cms.InputTag("ak8PFJetsPuppiSoftDrop"+postfix, "SubJets")), process, task)
addToProcessAndTask('nb2AK8PuppiSoftDropSubjets'+postfix, process.ecfNbeta2.clone(src = cms.InputTag("ak8PFJetsPuppiSoftDrop"+postfix, "SubJets")), process, task)
getattr(process,"patJetsAK8PFPuppiSoftDropSubjets"+postfix).userData.userFloats.src += ['nb1AK8PuppiSoftDropSubjets'+postfix+':ecfN2','nb1AK8PuppiSoftDropSubjets'+postfix+':ecfN3']
getattr(process,"patJetsAK8PFPuppiSoftDropSubjets"+postfix).userData.userFloats.src += ['nb2AK8PuppiSoftDropSubjets'+postfix+':ecfN2','nb2AK8PuppiSoftDropSubjets'+postfix+':ecfN3']
getattr(process,"patJetsAK8PFPuppiSoftDropSubjets"+postfix).userData.userFloats.src += ['NjettinessAK8Subjets'+postfix+':tau1','NjettinessAK8Subjets'+postfix+':tau2','NjettinessAK8Subjets'+postfix+':tau3','NjettinessAK8Subjets'+postfix+':tau4']
for e in [pp_on_XeXe_2017, pp_on_AA_2018, phase2_common]:
e.toModify(getattr(process,'nb1AK8PuppiSoftDropSubjets'+postfix), cuts = ['pt > 999999', 'pt > 999999', 'pt > 999999'] )
e.toModify(getattr(process,'nb2AK8PuppiSoftDropSubjets'+postfix), cuts = ['pt > 999999', 'pt > 999999', 'pt > 999999'] )
# rekey the groomed ECF value maps to the ungroomed reco jets, which will then be picked
# up by PAT in the user floats.
addToProcessAndTask("ak8PFJetsPuppiSoftDropValueMap"+postfix,
cms.EDProducer("RecoJetToPatJetDeltaRValueMapProducer",
src = cms.InputTag("ak8PFJetsPuppi"+postfix),
matched = cms.InputTag("patJetsAK8PFPuppiSoftDrop"+postfix),
distMax = cms.double(0.8),
values = cms.vstring([
'userFloat("nb1AK8PuppiSoftDrop'+postfix+':ecfN2")',
'userFloat("nb1AK8PuppiSoftDrop'+postfix+':ecfN3")',
'userFloat("nb2AK8PuppiSoftDrop'+postfix+':ecfN2")',
'userFloat("nb2AK8PuppiSoftDrop'+postfix+':ecfN3")',
]),
valueLabels = cms.vstring( [
'nb1AK8PuppiSoftDropN2',
'nb1AK8PuppiSoftDropN3',
'nb2AK8PuppiSoftDropN2',
'nb2AK8PuppiSoftDropN3',
]) ),
process, task)
# Patify AK8 PF PUPPI
addJetCollection(process, postfix=postfix, labelName = 'AK8Puppi',
jetSource = cms.InputTag('ak8PFJetsPuppi'+postfix),
algo= 'AK', rParam = 0.8,
jetCorrections = ('AK8PFPuppi', cms.vstring(['L2Relative', 'L3Absolute']), 'None'),
btagDiscriminators = ([
'pfCombinedSecondaryVertexV2BJetTags',
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfCombinedMVAV2BJetTags',
'pfDeepCSVJetTags:probb',
'pfDeepCSVJetTags:probc',
'pfDeepCSVJetTags:probudsg',
'pfDeepCSVJetTags:probbb',
'pfBoostedDoubleSecondaryVertexAK8BJetTags']),
genJetCollection = cms.InputTag('slimmedGenJetsAK8')
)
getattr(process,"patJetsAK8Puppi"+postfix).userData.userFloats.src = [] # start with empty list of user floats
getattr(process,"selectedPatJetsAK8Puppi"+postfix).cut = cms.string("pt > 100")
getattr(process,"selectedPatJetsAK8Puppi"+postfix).cutLoose = cms.string("pt > 30")
getattr(process,"selectedPatJetsAK8Puppi"+postfix).nLoose = cms.uint32(3)
from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX
addToProcessAndTask('ak8PFJetsPuppiTracksAssociatorAtVertex'+postfix, cms.EDProducer("JetTracksAssociatorAtVertex",
j2tParametersVX.clone( coneSize = cms.double(0.8) ),
jets = cms.InputTag("ak8PFJetsPuppi") ),
process, task)
addToProcessAndTask('patJetAK8PuppiCharge'+postfix, cms.EDProducer("JetChargeProducer",
src = cms.InputTag("ak8PFJetsPuppiTracksAssociatorAtVertex"),
var = cms.string('Pt'),
exp = cms.double(1.0) ),
process, task)
## now add AK8 groomed masses and ECF
from RecoJets.JetProducers.ak8PFJetsPuppi_groomingValueMaps_cfi import ak8PFJetsPuppiSoftDropMass
addToProcessAndTask('ak8PFJetsPuppiSoftDropMass'+postfix, ak8PFJetsPuppiSoftDropMass.clone(), process, task)
getattr(process,"patJetsAK8Puppi"+postfix).userData.userFloats.src += ['ak8PFJetsPuppiSoftDropMass'+postfix]
getattr(process,"patJetsAK8Puppi"+postfix).addTagInfos = cms.bool(False)
getattr(process,"patJetsAK8Puppi"+postfix).userData.userFloats.src += [
cms.InputTag('ak8PFJetsPuppiSoftDropValueMap'+postfix,'nb1AK8PuppiSoftDropN2'),
cms.InputTag('ak8PFJetsPuppiSoftDropValueMap'+postfix,'nb1AK8PuppiSoftDropN3'),
cms.InputTag('ak8PFJetsPuppiSoftDropValueMap'+postfix,'nb2AK8PuppiSoftDropN2'),
cms.InputTag('ak8PFJetsPuppiSoftDropValueMap'+postfix,'nb2AK8PuppiSoftDropN3'),
]
# add PUPPI Njetiness
addToProcessAndTask('NjettinessAK8Puppi'+postfix, process.Njettiness.clone(), process, task)
getattr(process,"NjettinessAK8Puppi"+postfix).src = cms.InputTag("ak8PFJetsPuppi"+postfix)
getattr(process,"NjettinessAK8Puppi").cone = cms.double(0.8)
getattr(process,"patJetsAK8Puppi").userData.userFloats.src += ['NjettinessAK8Puppi'+postfix+':tau1','NjettinessAK8Puppi'+postfix+':tau2','NjettinessAK8Puppi'+postfix+':tau3','NjettinessAK8Puppi'+postfix+':tau4']
# Now combine the CHS and PUPPI information into the PUPPI jets via delta R value maps
addToProcessAndTask("ak8PFJetsCHSValueMap"+postfix, cms.EDProducer("RecoJetToPatJetDeltaRValueMapProducer",
src = cms.InputTag("ak8PFJetsPuppi"+postfix),
matched = cms.InputTag("patJetsAK8"+postfix),
distMax = cms.double(0.8),
values = cms.vstring([
'userFloat("ak8PFJetsCHSPrunedMass"'+postfix+')',
'userFloat("ak8PFJetsCHSSoftDropMass"'+postfix+')',
'userFloat("NjettinessAK8'+postfix+':tau1")',
'userFloat("NjettinessAK8'+postfix+':tau2")',
'userFloat("NjettinessAK8'+postfix+':tau3")',
'userFloat("NjettinessAK8'+postfix+':tau4")',
'pt','eta','phi','mass', 'jetArea', 'jecFactor(0)'
]),
valueLabels = cms.vstring( [
'ak8PFJetsCHSPrunedMass',
'ak8PFJetsCHSSoftDropMass',
'NjettinessAK8CHSTau1',
'NjettinessAK8CHSTau2',
'NjettinessAK8CHSTau3',
'NjettinessAK8CHSTau4',
'pt','eta','phi','mass', 'jetArea', 'rawFactor'
]) ),
process, task)
# Now set up the user floats
getattr(process,"patJetsAK8Puppi"+postfix).userData.userFloats.src += [
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'ak8PFJetsCHSPrunedMass'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'ak8PFJetsCHSSoftDropMass'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'NjettinessAK8CHSTau1'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'NjettinessAK8CHSTau2'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'NjettinessAK8CHSTau3'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'NjettinessAK8CHSTau4'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'pt'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'eta'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'phi'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'mass'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'jetArea'),
cms.InputTag('ak8PFJetsCHSValueMap'+postfix,'rawFactor'),
]
addToProcessAndTask("slimmedJetsAK8PFPuppiSoftDropSubjets"+postfix,
cms.EDProducer("PATJetSlimmer",
src = cms.InputTag("selectedPatJetsAK8PFPuppiSoftDropSubjets"),
packedPFCandidates = cms.InputTag("packedPFCandidates"),
dropJetVars = cms.string("1"),
dropDaughters = cms.string("0"),
rekeyDaughters = cms.string("1"),
dropTrackRefs = cms.string("1"),
dropSpecific = cms.string("1"),
dropTagInfos = cms.string("1"),
modifyJets = cms.bool(True),
mixedDaughters = cms.bool(False),
modifierConfig = cms.PSet( modifications = cms.VPSet() )
),
process, task)
## Establish references between PATified fat jets and subjets using the BoostedJetMerger
addToProcessAndTask("slimmedJetsAK8PFPuppiSoftDropPacked"+postfix,
cms.EDProducer("BoostedJetMerger",
jetSrc=cms.InputTag("selectedPatJetsAK8PFPuppiSoftDrop"),
subjetSrc=cms.InputTag("slimmedJetsAK8PFPuppiSoftDropSubjets")
),
process, task )
addToProcessAndTask("packedPatJetsAK8"+postfix, cms.EDProducer("JetSubstructurePacker",
jetSrc = cms.InputTag("selectedPatJetsAK8Puppi"+postfix),
distMax = cms.double(0.8),
algoTags = cms.VInputTag(
cms.InputTag("slimmedJetsAK8PFPuppiSoftDropPacked"+postfix)
),
algoLabels = cms.vstring(
'SoftDropPuppi'
),
fixDaughters = cms.bool(True),
packedPFCandidates = cms.InputTag("packedPFCandidates"+postfix),
),
process, task)
# switch off daughter re-keying since it's done in the JetSubstructurePacker (and can't be done afterwards)
process.slimmedJetsAK8.rekeyDaughters = "0"
# Reconfigure the slimmedAK8 jet information to keep
process.slimmedJetsAK8.dropDaughters = cms.string("pt < 170")
process.slimmedJetsAK8.dropSpecific = cms.string("pt < 170")
process.slimmedJetsAK8.dropTagInfos = cms.string("pt < 170")
def miniAOD_customizeCommon(process):
process.patMuons.isoDeposits = cms.PSet()
process.patElectrons.isoDeposits = cms.PSet()
process.patTaus.isoDeposits = cms.PSet()
process.patPhotons.isoDeposits = cms.PSet()
#
process.patMuons.embedTrack = True # used for IDs
process.patMuons.embedCombinedMuon = True # used for IDs
process.patMuons.embedMuonBestTrack = True # used for IDs
process.patMuons.embedStandAloneMuon = True # maybe?
process.patMuons.embedPickyMuon = False # no, use best track
process.patMuons.embedTpfmsMuon = False # no, use best track
process.patMuons.embedDytMuon = False # no, use best track
process.patMuons.addPuppiIsolation = cms.bool(True)
process.patMuons.puppiIsolationChargedHadrons = cms.InputTag("muonPUPPIIsolation","h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiIsolationNeutralHadrons = cms.InputTag("muonPUPPIIsolation","h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiIsolationPhotons = cms.InputTag("muonPUPPIIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationPhotons = cms.InputTag("muonPUPPINoLeptonsIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.computeMiniIso = cms.bool(True)
process.patMuons.computeMuonMVA = cms.bool(True)
#
# disable embedding of electron and photon associated objects already stored by the ReducedEGProducer
process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core
process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster
process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters
process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters
process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters
process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters
process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer
process.patElectrons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.patElectrons.usePfCandidateMultiMap = True
process.patElectrons.pfCandidateMultiMap = cms.InputTag("reducedEgamma","reducedGsfElectronPfCandMap")
process.patElectrons.electronIDSources = cms.PSet(
# configure many IDs as InputTag <someName> = <someTag> you
# can comment out those you don't want to save some disk space
eidRobustLoose = cms.InputTag("reducedEgamma","eidRobustLoose"),
eidRobustTight = cms.InputTag("reducedEgamma","eidRobustTight"),
eidLoose = cms.InputTag("reducedEgamma","eidLoose"),
eidTight = cms.InputTag("reducedEgamma","eidTight"),
eidRobustHighEnergy = cms.InputTag("reducedEgamma","eidRobustHighEnergy"),
)
process.patElectrons.addPFClusterIso = cms.bool(True)
#add puppi isolation in miniAOD
process.patElectrons.addPuppiIsolation = cms.bool(True)
process.patElectrons.puppiIsolationChargedHadrons = cms.InputTag("egmElectronPUPPIIsolation","h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPIIsolation","h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiIsolationPhotons = cms.InputTag("egmElectronPUPPIIsolation","gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiNoLeptonsIsolationPhotons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.computeMiniIso = cms.bool(True)
process.patElectrons.ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleEcalPFClusIso")
process.patElectrons.hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleHcalPFClusIso")
process.elPFIsoDepositChargedPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositChargedAllPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositNeutralPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
#
process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster
process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster
process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters
process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters
process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer
process.patPhotons.addPFClusterIso = cms.bool(True)
#add puppi isolation in miniAOD
process.patPhotons.addPuppiIsolation = cms.bool(True)
process.patPhotons.puppiIsolationChargedHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h+-DR030-")
process.patPhotons.puppiIsolationNeutralHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h0-DR030-")
process.patPhotons.puppiIsolationPhotons = cms.InputTag("egmPhotonPUPPIIsolation","gamma-DR030-")
process.patPhotons.ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoEcalPFClusIso")
process.patPhotons.hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoHcalPFClusIso")
process.patPhotons.photonSource = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.patPhotons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.patPhotons.photonIDSources = cms.PSet(
PhotonCutBasedIDLoose = cms.InputTag('reducedEgamma',
'PhotonCutBasedIDLoose'),
PhotonCutBasedIDTight = cms.InputTag('reducedEgamma',
'PhotonCutBasedIDTight')
)
process.phPFIsoDepositChargedPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositChargedAllPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositNeutralPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
#
process.patOOTPhotons.photonSource = cms.InputTag("reducedEgamma","reducedOOTPhotons")
process.patOOTPhotons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
#
process.selectedPatJets.cut = cms.string("pt > 10")
process.selectedPatMuons.cut = cms.string("pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))")
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(process.selectedPatMuons, cut = "pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose') || muonID('ME0MuonArbitrated') || muonID('GEMMuonArbitrated')) )")
process.selectedPatElectrons.cut = cms.string("")
process.selectedPatTaus.cut = cms.string("pt > 18. && tauID('decayModeFindingNewDMs')> 0.5")
process.selectedPatPhotons.cut = cms.string("")
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
from PhysicsTools.PatAlgos.slimming.applySubstructure_cff import applySubstructure
applySubstructure( process )
#
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone
switchOnTriggerStandAlone( process, outputModule = '' )
process.patTrigger.packTriggerPathNames = cms.bool(True)
#
# apply type I + other PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncForMiniAODProduction
runMetCorAndUncForMiniAODProduction(process, metType="PF",
jetCollUnskimmed="patJets")
#caloMET computation
from PhysicsTools.PatAlgos.tools.metTools import addMETCollection
addMETCollection(process,
labelName = "patCaloMet",
metSource = "caloMetM"
)
#noHF pfMET =========
task = getPatAlgosToolsTask(process)
process.noHFCands = cms.EDFilter("GenericPFCandidateSelector",
src=cms.InputTag("particleFlow"),
cut=cms.string("abs(pdgId)!=1 && abs(pdgId)!=2 && abs(eta)<3.0")
)
task.add(process.noHFCands)
runMetCorAndUncForMiniAODProduction(process,
pfCandColl=cms.InputTag("noHFCands"),
recoMetFromPFCs=True, #needed for HF removal
jetSelection="pt>15 && abs(eta)<3.",
postfix="NoHF"
)
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsNoHF', process.slimmedMETs.clone(), process, task)
process.slimmedMETsNoHF.src = cms.InputTag("patMETsNoHF")
process.slimmedMETsNoHF.rawVariation = cms.InputTag("patPFMetNoHF")
process.slimmedMETsNoHF.t1Uncertainties = cms.InputTag("patPFMetT1%sNoHF")
process.slimmedMETsNoHF.t01Variation = cms.InputTag("patPFMetT0pcT1NoHF")
process.slimmedMETsNoHF.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sNoHF")
process.slimmedMETsNoHF.tXYUncForRaw = cms.InputTag("patPFMetTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1 = cms.InputTag("patPFMetT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyNoHF")
del process.slimmedMETsNoHF.caloMET
# ================== NoHF pfMET
# ================== CHSMET
process.CHSCands = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("fromPV(0) > 0")
)
task.add(process.CHSCands)
process.pfMetCHS = cms.EDProducer("PFMETProducer",
src = cms.InputTag("CHSCands"),
alias = cms.string('pfMet'),
globalThreshold = cms.double(0.0),
calculateSignificance = cms.bool(False),
)
task.add(process.pfMetCHS)
addMETCollection(process,
labelName = "patCHSMet",
metSource = "pfMetCHS"
)
process.patCHSMet.computeMETSignificance = cms.bool(False)
# ================== CHSMET
# ================== TrkMET
process.TrkCands = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("charge()!=0 && pvAssociationQuality()>=4 && vertexRef().key()==0")
)
task.add(process.TrkCands)
process.pfMetTrk = cms.EDProducer("PFMETProducer",
src = cms.InputTag("TrkCands"),
alias = cms.string('pfMet'),
globalThreshold = cms.double(0.0),
calculateSignificance = cms.bool(False),
)
task.add(process.pfMetTrk)
addMETCollection(process,
labelName = "patTrkMet",
metSource = "pfMetTrk"
)
process.patTrkMet.computeMETSignificance = cms.bool(False)
# ================== TrkMET
## PU JetID
process.load("RecoJets.JetProducers.PileupJetID_cfi")
task.add(process.pileUpJetIDTask)
process.patJets.userData.userFloats.src = [ cms.InputTag("pileupJetId:fullDiscriminant"), ]
process.patJets.userData.userInts.src = [ cms.InputTag("pileupJetId:fullId"), ]
## Quark Gluon Likelihood
process.load('RecoJets.JetProducers.QGTagger_cfi')
task.add(process.QGTaggerTask)
process.patJets.userData.userFloats.src += [ cms.InputTag('QGTagger:qgLikelihood'), ]
## CaloJets
process.caloJetMap = cms.EDProducer("RecoJetDeltaRValueMapProducer",
src = process.patJets.jetSource,
matched = cms.InputTag("ak4CaloJets"),
distMax = cms.double(0.4),
values = cms.vstring('pt','emEnergyFraction'),
valueLabels = cms.vstring('pt','emEnergyFraction'),
lazyParser = cms.bool(True) )
task.add(process.caloJetMap)
process.patJets.userData.userFloats.src += [ cms.InputTag("caloJetMap:pt"), cms.InputTag("caloJetMap:emEnergyFraction") ]
#Muon object modifications
from PhysicsTools.PatAlgos.slimming.muonIsolationsPUPPI_cfi import makeInputForPUPPIIsolationMuon
makeInputForPUPPIIsolationMuon(process)
#EGM object modifications
from PhysicsTools.PatAlgos.slimming.egmIsolationsPUPPI_cfi import makeInputForPUPPIIsolationEgm
makeInputForPUPPIIsolationEgm(process)
from RecoEgamma.EgammaTools.egammaObjectModificationsInMiniAOD_cff import egamma_modifications
process.slimmedElectrons.modifierConfig.modifications = egamma_modifications
process.slimmedPhotons.modifierConfig.modifications = egamma_modifications
#VID Electron IDs
electron_ids = ['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_PHYS14_PU20bx25_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_50ns_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_Trig_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_50ns_Trig_V1_cff']
switchOnVIDElectronIdProducer(process,DataFormat.MiniAOD, task)
process.egmGsfElectronIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.electronMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
process.electronRegressionValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
for idmod in electron_ids:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection,None,False,task)
#heepIDVarValueMaps only exists if HEEP V6.1 or HEEP 7.0 ID has already been loaded
if hasattr(process,'heepIDVarValueMaps'):
process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
#force HEEP to use miniAOD (otherwise it'll detect the AOD)
process.heepIDVarValueMaps.dataFormat = cms.int32(2)
#VID Photon IDs
photon_ids = ['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_25ns_V1_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_50ns_V1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring15_25ns_nonTrig_V2p1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring15_50ns_nonTrig_V2p1_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff']
switchOnVIDPhotonIdProducer(process,DataFormat.AOD, task)
process.egmPhotonIsolation.srcToIsolate = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
for iPSet in process.egmPhotonIsolation.isolationConeDefinitions:
iPSet.particleBasedIsolation = cms.InputTag("reducedEgamma","reducedPhotonPfCandMap")
process.egmPhotonIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonRegressionValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.particleBasedIsolation = \
cms.InputTag("reducedEgamma","reducedPhotonPfCandMap")
process.photonMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedPhotons')
for idmod in photon_ids:
setupAllVIDIdsInModule(process,idmod,setupVIDPhotonSelection,None,False,task)
#---------------------------------------------------------------------------
#Adding Boosted Subjets taus
from RecoTauTag.Configuration.boostedHPSPFTaus_cfi import addBoostedTaus
addBoostedTaus(process)
#---------------------------------------------------------------------------
#Adding tau reco for 80X legacy reMiniAOD
#make a copy of makePatTauTask to avoid labels and substitution problems
_makePatTausTaskWithTauReReco = process.makePatTausTask.copy()
#add PFTau reco modules to cloned makePatTauTask
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
_makePatTausTaskWithTauReReco.add(process.PFTauTask)
#replace original task by extended one for the miniAOD_80XLegacy era
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithTauReReco)
#---------------------------------------------------------------------------
# Adding puppi jets
if not hasattr(process, 'ak4PFJetsPuppi'): #MM: avoid confilct with substructure call
process.load('RecoJets.JetProducers.ak4PFJetsPuppi_cfi')
task.add(process.ak4PFJets)
task.add(process.ak4PFJetsPuppi)
process.ak4PFJetsPuppi.doAreaFastjet = True # even for standard ak4PFJets this is overwritten in RecoJets/Configuration/python/RecoPFJets_cff
from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX
process.ak4PFJetsPuppiTracksAssociatorAtVertex = cms.EDProducer("JetTracksAssociatorAtVertex",
j2tParametersVX,
jets = cms.InputTag("ak4PFJetsPuppi")
)
task.add(process.ak4PFJetsPuppiTracksAssociatorAtVertex)
process.patJetPuppiCharge = cms.EDProducer("JetChargeProducer",
src = cms.InputTag("ak4PFJetsPuppiTracksAssociatorAtVertex"),
var = cms.string('Pt'),
exp = cms.double(1.0)
)
task.add(process.patJetPuppiCharge)
addJetCollection(process, postfix = "", labelName = 'Puppi', jetSource = cms.InputTag('ak4PFJetsPuppi'),
jetCorrections = ('AK4PFPuppi', ['L2Relative', 'L3Absolute'], ''),
pfCandidates = cms.InputTag('puppi'), # using Puppi candidates as input for b tagging of Puppi jets
algo= 'AK', rParam = 0.4, btagDiscriminators = map(lambda x: x.value() ,process.patJets.discriminatorSources)
)
process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets'
process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge")
process.selectedPatJetsPuppi.cut = cms.string("pt > 15")
process.load('PhysicsTools.PatAlgos.slimming.slimmedJets_cfi')
task.add(process.slimmedJets)
task.add(process.slimmedJetsAK8)
addToProcessAndTask('slimmedJetsPuppi', process.slimmedJets.clone(), process, task)
process.slimmedJetsPuppi.src = cms.InputTag("selectedPatJetsPuppi")
process.slimmedJetsPuppi.packedPFCandidates = cms.InputTag("packedPFCandidates")
## puppi met
from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppies
makePuppies( process );
runMetCorAndUncForMiniAODProduction(process, metType="Puppi",
pfCandColl=cms.InputTag("puppiForMET"),
jetCollUnskimmed="slimmedJetsPuppi",
recoMetFromPFCs=True,
jetFlavor="AK4PFPuppi",
postfix="Puppi"
)
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsPuppi', process.slimmedMETs.clone(), process, task)
process.slimmedMETsPuppi.src = cms.InputTag("patMETsPuppi")
process.slimmedMETsPuppi.rawVariation = cms.InputTag("patPFMetPuppi")
process.slimmedMETsPuppi.t1Uncertainties = cms.InputTag("patPFMetT1%sPuppi")
process.slimmedMETsPuppi.t01Variation = cms.InputTag("patPFMetT0pcT1Puppi")
process.slimmedMETsPuppi.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sPuppi")
process.slimmedMETsPuppi.tXYUncForRaw = cms.InputTag("patPFMetTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1 = cms.InputTag("patPFMetT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyPuppi")
del process.slimmedMETsPuppi.caloMET
# add DetIdAssociatorRecords to EventSetup (for isolatedTracks)
process.load("TrackingTools.TrackAssociator.DetIdAssociatorESProducer_cff")
def miniAOD_customizeData(process):
from PhysicsTools.PatAlgos.tools.coreTools import runOnData
runOnData( process, outputModules = [] )
process.load("RecoCTPPS.TotemRPLocal.ctppsLocalTrackLiteProducer_cff")
task = getPatAlgosToolsTask(process)
task.add(process.ctppsLocalTrackLiteProducer)
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc')
process.load("Configuration.StandardSequences.MagneticField_cff")
## Output Module Configuration (expects a path 'p')
from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning
process.out = cms.OutputModule("PoolOutputModule",
fileName = cms.untracked.string('patTuple.root'),
## save only events passing the full path
#SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('p') ),
## save PAT output; you need a '*' to unpack the list of commands
## 'patEventContent'
outputCommands = cms.untracked.vstring('drop *', *patEventContentNoCleaning )
)
patAlgosToolsTask = getPatAlgosToolsTask(process)
process.outpath = cms.EndPath(process.out, patAlgosToolsTask)
## and add them to the event content
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection,addJetCollection
## Puppi
jetSeq = cms.Sequence()
process.load("CommonTools.PileupAlgos.Puppi_cff")
#process.puppi.candName = cms.InputTag( 'particleFlow' )
jetSeq += process.puppi
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJetsPuppi
process.ak8PFJetsPuppi = ak4PFJetsPuppi.clone( src = cms.InputTag( 'puppi' ),
doAreaFastjet = True,
rParam = 0.8,
def miniAOD_customizeCommon(process):
process.patMuons.isoDeposits = cms.PSet()
process.patElectrons.isoDeposits = cms.PSet()
process.patTaus.isoDeposits = cms.PSet()
process.patPhotons.isoDeposits = cms.PSet()
#
process.patMuons.embedTrack = True # used for IDs
process.patMuons.embedCombinedMuon = True # used for IDs
process.patMuons.embedMuonBestTrack = True # used for IDs
process.patMuons.embedStandAloneMuon = True # maybe?
process.patMuons.embedPickyMuon = False # no, use best track
process.patMuons.embedTpfmsMuon = False # no, use best track
process.patMuons.embedDytMuon = False # no, use best track
process.patMuons.addPuppiIsolation = cms.bool(True)
process.patMuons.puppiIsolationChargedHadrons = cms.InputTag("muonPUPPIIsolation","h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiIsolationNeutralHadrons = cms.InputTag("muonPUPPIIsolation","h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiIsolationPhotons = cms.InputTag("muonPUPPIIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationPhotons = cms.InputTag("muonPUPPINoLeptonsIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.computeMiniIso = cms.bool(True)
process.patMuons.computeMuonMVA = cms.bool(True)
process.patMuons.computeSoftMuonMVA = cms.bool(True)
#
# disable embedding of electron and photon associated objects already stored by the ReducedEGProducer
process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core
process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster
process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters
process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters
process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters
process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters
process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer
process.patElectrons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.patElectrons.usePfCandidateMultiMap = True
process.patElectrons.pfCandidateMultiMap = cms.InputTag("reducedEgamma","reducedGsfElectronPfCandMap")
process.patElectrons.electronIDSources = cms.PSet()
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(process.patElectrons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleHcalPFClusIso"))
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(process.patElectrons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleHcalPFClusIso"))
#add puppi isolation in miniAOD
process.patElectrons.addPuppiIsolation = cms.bool(True)
process.patElectrons.puppiIsolationChargedHadrons = cms.InputTag("egmElectronPUPPIIsolation","h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPIIsolation","h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiIsolationPhotons = cms.InputTag("egmElectronPUPPIIsolation","gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiNoLeptonsIsolationPhotons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.computeMiniIso = cms.bool(True)
process.elPFIsoDepositChargedPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositChargedAllPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositNeutralPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.elPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
#
process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster
process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster
process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters
process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters
process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer
#add puppi isolation in miniAOD
process.patPhotons.addPuppiIsolation = cms.bool(True)
process.patPhotons.puppiIsolationChargedHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h+-DR030-")
process.patPhotons.puppiIsolationNeutralHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h0-DR030-")
process.patPhotons.puppiIsolationPhotons = cms.InputTag("egmPhotonPUPPIIsolation","gamma-DR030-")
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(process.patPhotons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoHcalPFClusIso"))
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(process.patPhotons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoHcalPFClusIso"))
#the 80X legacy customsations are done in ootPhotonProducer for OOT photons
run2_miniAOD_94XFall17.toModify(process.patOOTPhotons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "ootPhoEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "ootPhoHcalPFClusIso"))
process.patPhotons.photonSource = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.patPhotons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.phPFIsoDepositChargedPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositChargedAllPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositNeutralPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
process.phPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma","reducedGedPhotons")
#
process.patOOTPhotons.photonSource = cms.InputTag("reducedEgamma","reducedOOTPhotons")
process.patOOTPhotons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
#
process.selectedPatJets.cut = cms.string("pt > 10")
process.selectedPatMuons.cut = cms.string("pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))")
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(process.selectedPatMuons, cut = "pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose') || muonID('ME0MuonArbitrated') || muonID('GEMMuonArbitrated')) )")
process.selectedPatElectrons.cut = cms.string("")
process.selectedPatTaus.cut = cms.string("pt > 18. && tauID('decayModeFindingNewDMs')> 0.5")
process.selectedPatPhotons.cut = cms.string("")
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
from PhysicsTools.PatAlgos.slimming.applySubstructure_cff import applySubstructure
applySubstructure( process )
#
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone
switchOnTriggerStandAlone( process, outputModule = '' )
process.patTrigger.packTriggerPathNames = cms.bool(True)
#
# apply type I + other PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncForMiniAODProduction
runMetCorAndUncForMiniAODProduction(process, metType="PF",
jetCollUnskimmed="patJets")
#caloMET computation
from PhysicsTools.PatAlgos.tools.metTools import addMETCollection
addMETCollection(process,
labelName = "patCaloMet",
metSource = "caloMetM"
)
#noHF pfMET =========
task = getPatAlgosToolsTask(process)
process.noHFCands = cms.EDFilter("GenericPFCandidateSelector",
src=cms.InputTag("particleFlow"),
cut=cms.string("abs(pdgId)!=1 && abs(pdgId)!=2 && abs(eta)<3.0")
)
task.add(process.noHFCands)
runMetCorAndUncForMiniAODProduction(process,
pfCandColl=cms.InputTag("noHFCands"),
recoMetFromPFCs=True, #needed for HF removal
jetSelection="pt>15 && abs(eta)<3.",
postfix="NoHF"
)
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsNoHF', process.slimmedMETs.clone(), process, task)
process.slimmedMETsNoHF.src = cms.InputTag("patMETsNoHF")
process.slimmedMETsNoHF.rawVariation = cms.InputTag("patPFMetNoHF")
process.slimmedMETsNoHF.t1Uncertainties = cms.InputTag("patPFMetT1%sNoHF")
process.slimmedMETsNoHF.t01Variation = cms.InputTag("patPFMetT0pcT1NoHF")
process.slimmedMETsNoHF.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sNoHF")
process.slimmedMETsNoHF.tXYUncForRaw = cms.InputTag("patPFMetTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1 = cms.InputTag("patPFMetT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyNoHF")
del process.slimmedMETsNoHF.caloMET
# ================== NoHF pfMET
# ================== CHSMET
process.CHSCands = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("fromPV(0) > 0")
)
task.add(process.CHSCands)
process.pfMetCHS = cms.EDProducer("PFMETProducer",
src = cms.InputTag("CHSCands"),
alias = cms.string('pfMet'),
globalThreshold = cms.double(0.0),
calculateSignificance = cms.bool(False),
)
task.add(process.pfMetCHS)
addMETCollection(process,
labelName = "patCHSMet",
metSource = "pfMetCHS"
)
process.patCHSMet.computeMETSignificance = cms.bool(False)
# ================== CHSMET
# ================== TrkMET
process.TrkCands = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("charge()!=0 && pvAssociationQuality()>=4 && vertexRef().key()==0")
)
task.add(process.TrkCands)
process.pfMetTrk = cms.EDProducer("PFMETProducer",
src = cms.InputTag("TrkCands"),
alias = cms.string('pfMet'),
globalThreshold = cms.double(0.0),
calculateSignificance = cms.bool(False),
)
task.add(process.pfMetTrk)
addMETCollection(process,
labelName = "patTrkMet",
metSource = "pfMetTrk"
)
process.patTrkMet.computeMETSignificance = cms.bool(False)
# ================== TrkMET
## PU JetID
process.load("RecoJets.JetProducers.PileupJetID_cfi")
task.add(process.pileUpJetIDTask)
process.patJets.userData.userFloats.src = [ cms.InputTag("pileupJetId:fullDiscriminant"), ]
process.patJets.userData.userInts.src = [ cms.InputTag("pileupJetId:fullId"), ]
## Quark Gluon Likelihood
process.load('RecoJets.JetProducers.QGTagger_cfi')
task.add(process.QGTaggerTask)
process.patJets.userData.userFloats.src += [ cms.InputTag('QGTagger:qgLikelihood'), ]
## DeepCSV meta discriminators (simple arithmethic on output probabilities)
process.load('RecoBTag.Combined.deepFlavour_cff')
task.add(process.pfDeepCSVDiscriminatorsJetTags)
process.patJets.discriminatorSources.extend([
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:BvsAll' ),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsB' ),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsL' ),
])
## CaloJets
process.caloJetMap = cms.EDProducer("RecoJetDeltaRValueMapProducer",
src = process.patJets.jetSource,
matched = cms.InputTag("ak4CaloJets"),
distMax = cms.double(0.4),
values = cms.vstring('pt','emEnergyFraction'),
valueLabels = cms.vstring('pt','emEnergyFraction'),
lazyParser = cms.bool(True) )
task.add(process.caloJetMap)
process.patJets.userData.userFloats.src += [ cms.InputTag("caloJetMap:pt"), cms.InputTag("caloJetMap:emEnergyFraction") ]
#Muon object modifications
from PhysicsTools.PatAlgos.slimming.muonIsolationsPUPPI_cfi import makeInputForPUPPIIsolationMuon
makeInputForPUPPIIsolationMuon(process)
#EGM object modifications
from PhysicsTools.PatAlgos.slimming.egmIsolationsPUPPI_cfi import makeInputForPUPPIIsolationEgm
makeInputForPUPPIIsolationEgm(process)
from RecoEgamma.EgammaTools.egammaObjectModificationsInMiniAOD_cff import egamma_modifications
process.slimmedElectrons.modifierConfig.modifications = egamma_modifications
process.slimmedPhotons.modifierConfig.modifications = egamma_modifications
#VID Electron IDs
process.patElectrons.addElectronID = cms.bool(True)
electron_ids = ['RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_HZZ_V1_cff',
]
switchOnVIDElectronIdProducer(process,DataFormat.MiniAOD, task)
process.egmGsfElectronIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedGsfElectrons")
process.electronMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
process.electronRegressionValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
for idmod in electron_ids:
setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection,None,False,task)
#heepIDVarValueMaps only exists if HEEP V6.1 or HEEP 7.0 ID has already been loaded
if hasattr(process,'heepIDVarValueMaps'):
process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag('reducedEgamma','reducedGedGsfElectrons')
#force HEEP to use miniAOD (otherwise it'll detect the AOD)
process.heepIDVarValueMaps.dataFormat = cms.int32(2)
#add the HEEP trk isol to the slimmed electron, add it to the first FromFloatValMap modifier
for pset in process.slimmedElectrons.modifierConfig.modifications:
if pset.hasParameter("modifierName") and pset.modifierName == cms.string('EGExtraInfoModifierFromFloatValueMaps'):
pset.electron_config.heepTrkPtIso = cms.InputTag("heepIDVarValueMaps","eleTrkPtIso")
break
#VID Photon IDs
process.patPhotons.addPhotonID = cms.bool(True)
photon_ids = ['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V1_TrueVtx_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1p1_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff']
switchOnVIDPhotonIdProducer(process,DataFormat.AOD, task)
process.egmPhotonIsolation.srcToIsolate = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
for iPSet in process.egmPhotonIsolation.isolationConeDefinitions:
iPSet.particleBasedIsolation = cms.InputTag("reducedEgamma","reducedPhotonPfCandMap")
process.egmPhotonIDs.physicsObjectSrc = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonRegressionValueMapProducer.src = \
cms.InputTag("reducedEgamma","reducedGedPhotons")
process.photonIDValueMapProducer.particleBasedIsolation = \
cms.InputTag("reducedEgamma","reducedPhotonPfCandMap")
process.photonMVAValueMapProducer.src = \
cms.InputTag('reducedEgamma','reducedGedPhotons')
for idmod in photon_ids:
setupAllVIDIdsInModule(process,idmod,setupVIDPhotonSelection,None,False,task)
#add the cut base IDs bitmaps of which cuts passed
from RecoEgamma.EgammaTools.egammaObjectModifications_tools import makeVIDBitsModifier
egamma_modifications.append(makeVIDBitsModifier(process,"egmGsfElectronIDs","egmPhotonIDs"))
#-- Adding boosted taus
from RecoTauTag.Configuration.boostedHPSPFTaus_cfi import addBoostedTaus
addBoostedTaus(process)
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
process.load("RecoTauTag.Configuration.HPSPFTaus_cff")
#-- Adding customization for 94X 2017 legacy reMniAOD
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
_makePatTausTaskWithRetrainedMVATauID = process.makePatTausTask.copy()
_makePatTausTaskWithRetrainedMVATauID.add(process.hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLTTask)
run2_miniAOD_94XFall17.toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithRetrainedMVATauID
)
#-- Adding customization for 80X 2016 legacy reMiniAOD
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
_makePatTausTaskWithTauReReco = process.makePatTausTask.copy()
_makePatTausTaskWithTauReReco.add(process.PFTauTask)
run2_miniAOD_80XLegacy.toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithTauReReco
)
# Adding puppi jets
if not hasattr(process, 'ak4PFJetsPuppi'): #MM: avoid confilct with substructure call
process.load('RecoJets.JetProducers.ak4PFJetsPuppi_cfi')
task.add(process.ak4PFJets)
task.add(process.ak4PFJetsPuppi)
process.ak4PFJetsPuppi.doAreaFastjet = True # even for standard ak4PFJets this is overwritten in RecoJets/Configuration/python/RecoPFJets_cff
from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX
process.ak4PFJetsPuppiTracksAssociatorAtVertex = cms.EDProducer("JetTracksAssociatorAtVertex",
j2tParametersVX,
jets = cms.InputTag("ak4PFJetsPuppi")
)
task.add(process.ak4PFJetsPuppiTracksAssociatorAtVertex)
process.patJetPuppiCharge = cms.EDProducer("JetChargeProducer",
src = cms.InputTag("ak4PFJetsPuppiTracksAssociatorAtVertex"),
var = cms.string('Pt'),
exp = cms.double(1.0)
)
task.add(process.patJetPuppiCharge)
noDeepFlavourDiscriminators = [x.value() for x in process.patJets.discriminatorSources if not "DeepFlavour" in x.value()]
addJetCollection(process, postfix = "", labelName = 'Puppi', jetSource = cms.InputTag('ak4PFJetsPuppi'),
jetCorrections = ('AK4PFPuppi', ['L2Relative', 'L3Absolute'], ''),
pfCandidates = cms.InputTag("particleFlow"),
algo= 'AK', rParam = 0.4, btagDiscriminators = noDeepFlavourDiscriminators
)
process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets'
process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge")
process.selectedPatJetsPuppi.cut = cms.string("pt > 15")
from PhysicsTools.PatAlgos.slimming.applyDeepBtagging_cff import applyDeepBtagging
applyDeepBtagging( process )
addToProcessAndTask('slimmedJetsPuppiNoMultiplicities', process.slimmedJetsNoDeepFlavour.clone(), process, task)
process.slimmedJetsPuppiNoMultiplicities.src = cms.InputTag("selectedPatJetsPuppi")
process.slimmedJetsPuppiNoMultiplicities.packedPFCandidates = cms.InputTag("packedPFCandidates")
from PhysicsTools.PatAlgos.patPuppiJetSpecificProducer_cfi import patPuppiJetSpecificProducer
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
process.patPuppiJetSpecificProducer = patPuppiJetSpecificProducer.clone(
src=cms.InputTag("slimmedJetsPuppiNoMultiplicities"),
)
task.add(process.patPuppiJetSpecificProducer)
updateJetCollection(
process,
labelName = 'PuppiJetSpecific',
jetSource = cms.InputTag('slimmedJetsPuppiNoMultiplicities'),
)
process.updatedPatJetsPuppiJetSpecific.userData.userFloats.src = ['patPuppiJetSpecificProducer:puppiMultiplicity', 'patPuppiJetSpecificProducer:neutralPuppiMultiplicity', 'patPuppiJetSpecificProducer:neutralHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:photonPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFEMPuppiMultiplicity' ]
process.slimmedJetsPuppi = process.selectedUpdatedPatJetsPuppiJetSpecific.clone()
delattr(process, 'selectedUpdatedPatJetsPuppiJetSpecific')
task.add(process.slimmedJetsPuppi)
## puppi met
from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppies
makePuppies( process );
runMetCorAndUncForMiniAODProduction(process, metType="Puppi",
pfCandColl=cms.InputTag("puppiForMET"),
jetCollUnskimmed="slimmedJetsPuppi",
recoMetFromPFCs=True,
jetFlavor="AK4PFPuppi",
postfix="Puppi"
)
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsPuppi', process.slimmedMETs.clone(), process, task)
process.slimmedMETsPuppi.src = cms.InputTag("patMETsPuppi")
process.slimmedMETsPuppi.rawVariation = cms.InputTag("patPFMetPuppi")
process.slimmedMETsPuppi.t1Uncertainties = cms.InputTag("patPFMetT1%sPuppi")
process.slimmedMETsPuppi.t01Variation = cms.InputTag("patPFMetT0pcT1Puppi")
process.slimmedMETsPuppi.t1SmearedVarsAndUncs = cms.InputTag("patPFMetT1Smear%sPuppi")
process.slimmedMETsPuppi.tXYUncForRaw = cms.InputTag("patPFMetTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1 = cms.InputTag("patPFMetT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01 = cms.InputTag("patPFMetT0pcT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1Smear = cms.InputTag("patPFMetT1SmearTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01Smear = cms.InputTag("patPFMetT0pcT1SmearTxyPuppi")
del process.slimmedMETsPuppi.caloMET
# add DetIdAssociatorRecords to EventSetup (for isolatedTracks)
process.load("TrackingTools.TrackAssociator.DetIdAssociatorESProducer_cff")
# EGamma objects from HGCal are not yet in GED
# so add companion collections for Phase-II MiniAOD production
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
process.load("RecoEgamma.EgammaTools.slimmedEgammaFromMultiCl_cff")
phase2_hgcal.toModify(task, func=lambda t: t.add(process.slimmedEgammaFromMultiClTask))
def CompactSkim(process,inFileNames,outFileName,Global_Tag='auto:run2_mc',MC=True,Filter=True):
patAlgosToolsTask = getPatAlgosToolsTask(process)
process.load('Configuration.StandardSequences.Services_cff')
process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi')
process.load('FWCore.MessageService.MessageLogger_cfi')
process.load('Configuration.EventContent.EventContent_cff')
process.load('Configuration.StandardSequences.GeometryRecoDB_cff')
process.load('Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff')
process.load('Configuration.StandardSequences.EndOfProcess_cff')
patAlgosToolsTask.add(process.MEtoEDMConverter)
process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff')
process.MessageLogger.cerr.FwkReport.reportEvery = 100
process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(False) )
process.source = cms.Source('PoolSource', fileNames = cms.untracked.vstring(inFileNames))
process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) )
from Configuration.AlCa.GlobalTag_condDBv2 import GlobalTag
process.GlobalTag = GlobalTag(process.GlobalTag, Global_Tag, '')
# make patCandidates, select and clean them
process.load('PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff')
patAlgosToolsTask.add(process.patCandidatesTask)
process.load('PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff')
patAlgosToolsTask.add(process.selectedPatCandidatesTask)
process.load('PhysicsTools.PatAlgos.cleaningLayer1.cleanPatCandidates_cff')
patAlgosToolsTask.add(process.cleanPatCandidatesTask)
process.patMuons.embedTrack = True
process.selectedPatMuons.cut = cms.string('muonID(\"TMOneStationTight\")'
' && abs(innerTrack.dxy) < 0.3'
' && abs(innerTrack.dz) < 20.'
' && innerTrack.hitPattern.trackerLayersWithMeasurement > 5'
' && innerTrack.hitPattern.pixelLayersWithMeasurement > 0'
' && innerTrack.quality(\"highPurity\")'
)
#make patTracks
from PhysicsTools.PatAlgos.tools.trackTools import makeTrackCandidates
makeTrackCandidates(process,
label = 'TrackCands', # output collection
tracks = cms.InputTag('generalTracks'), # input track collection
particleType = 'pi+', # particle type (for assigning a mass)
preselection = 'pt > 0.7', # preselection cut on candidates
selection = 'pt > 0.7', # selection on PAT Layer 1 objects
isolation = {}, # isolations to use (set to {} for None)
isoDeposits = [],
mcAs = None # replicate MC match as the one used for Muons
)
process.patTrackCands.embedTrack = True
# dimuon = Onia2MUMU
process.load('HeavyFlavorAnalysis.Onia2MuMu.onia2MuMuPAT_cfi')
patAlgosToolsTask.add(process.onia2MuMuPAT)
process.onia2MuMuPAT.muons=cms.InputTag('cleanPatMuons')
process.onia2MuMuPAT.primaryVertexTag=cms.InputTag('offlinePrimaryVertices')
process.onia2MuMuPAT.beamSpotTag=cms.InputTag('offlineBeamSpot')
process.onia2MuMuPATCounter = cms.EDFilter('CandViewCountFilter',
src = cms.InputTag('onia2MuMuPAT'),
minNumber = cms.uint32(1),
filter = cms.bool(True)
)
# reduce MC genParticles a la miniAOD
process.load('PhysicsTools.PatAlgos.slimming.genParticles_cff')
patAlgosToolsTask.add(process.genParticlesTask)
process.packedGenParticles.inputVertices = cms.InputTag('offlinePrimaryVertices')
# make photon candidate conversions for P-wave studies
process.load('HeavyFlavorAnalysis.Onia2MuMu.OniaPhotonConversionProducer_cfi')
patAlgosToolsTask.add(process.PhotonCandidates)
# add v0 with tracks embed
process.load('HeavyFlavorAnalysis.Onia2MuMu.OniaAddV0TracksProducer_cfi')
patAlgosToolsTask.add(process.oniaV0Tracks)
# Pick branches you want to keep
SlimmedEventContent = [
'keep recoVertexs_offlinePrimaryVertices_*_*',
'keep *_inclusiveSecondaryVertices_*_*',
'keep *_offlineBeamSpot_*_*',
'keep *_TriggerResults_*_HLT',
'keep *_gtDigis_*_RECO',
'keep *_cleanPatTrackCands_*_*',
'keep *_PhotonCandidates_*_*',
'keep *_onia2MuMuPAT_*_*',
'keep *_generalV0Candidates_*_*',
'keep *_oniaV0Tracks_*_*',
'keep PileupSummaryInfos_*_*_*'
]
if not MC:
from PhysicsTools.PatAlgos.tools.coreTools import runOnData
runOnData( process, outputModules = [] )
else :
SlimmedEventContent += [
'keep patPackedGenParticles_packedGenParticles_*_*',
'keep recoGenParticles_prunedGenParticles_*_*',
'keep GenFilterInfo_*_*_*',
'keep GenEventInfoProduct_generator_*_*',
'keep GenRunInfoProduct_*_*_*'
]
process.FilterOutput = cms.Path(process.onia2MuMuPATCounter)
process.out = cms.OutputModule('PoolOutputModule',
fileName = cms.untracked.string(outFileName),
outputCommands = cms.untracked.vstring('drop *', *SlimmedEventContent),
SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring('FilterOutput')) if Filter else cms.untracked.PSet()
)
process.outpath = cms.EndPath(process.out, patAlgosToolsTask)
import FWCore.ParameterSet.Config as cms
process = cms.Process("PAT")
import PhysicsTools.PatAlgos.tools.helpers as configtools
patAlgosToolsTask = configtools.getPatAlgosToolsTask(process)
## Options
process.options = cms.untracked.PSet(
wantSummary = cms.untracked.bool( True )
)
## Messaging
process.load("FWCore.MessageLogger.MessageLogger_cfi")
#process.Tracer = cms.Service("Tracer")
## Conditions
process.load( "Configuration.Geometry.GeometryRecoDB_cff" )
process.load( "Configuration.StandardSequences.MagneticField_AutoFromDBCurrent_cff" )
process.load( "Configuration.StandardSequences.FrontierConditions_GlobalTag_cff" )
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag( process.GlobalTag, 'auto:com10_8E33v2' )
## Input
from PhysicsTools.PatAlgos.patInputFiles_cff import filesSingleMuRECO
process.source = cms.Source(
"PoolSource"
, fileNames = filesSingleMuRECO
)
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32( 100 )
