def nanoAOD_customizeCommon(process):
# makePuppiesFromMiniAOD(process,True) # call this here as it calls switchOnVIDPhotonIdProducer
process = nanoAOD_activateVID(process)
nanoAOD_addDeepInfo_switch = cms.PSet(
nanoAOD_addDeepBTag_switch = cms.untracked.bool(False),
nanoAOD_addDeepFlavourTag_switch = cms.untracked.bool(False),
)
run2_miniAOD_80XLegacy.toModify(nanoAOD_addDeepInfo_switch, nanoAOD_addDeepBTag_switch = cms.untracked.bool(True))
for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016, run2_nanoAOD_94XMiniAODv1, run2_nanoAOD_94XMiniAODv2:
modifier.toModify(nanoAOD_addDeepInfo_switch, nanoAOD_addDeepFlavourTag_switch = cms.untracked.bool(True))
process = nanoAOD_addDeepInfo(process,
addDeepBTag=nanoAOD_addDeepInfo_switch.nanoAOD_addDeepBTag_switch,
addDeepFlavour=nanoAOD_addDeepInfo_switch.nanoAOD_addDeepFlavourTag_switch)
nanoAOD_addDeepInfoAK8_switch = cms.PSet(
nanoAOD_addDeepBTag_switch = cms.untracked.bool(False),
nanoAOD_addDeepBoostedJet_switch = cms.untracked.bool(True), # will deactivate this in future miniAOD releases
jecPayload = cms.untracked.string('AK8PFPuppi')
)
# deepAK8 should not run on 80X, that contains ak8PFJetsCHS jets
run2_miniAOD_80XLegacy.toModify(nanoAOD_addDeepInfoAK8_switch,
nanoAOD_addDeepBTag_switch = cms.untracked.bool(True),
nanoAOD_addDeepBoostedJet_switch = cms.untracked.bool(False),
jecPayload = cms.untracked.string('AK8PFchs'))
process = nanoAOD_addDeepInfoAK8(process,
addDeepBTag=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepBTag_switch,
addDeepBoostedJet=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepBoostedJet_switch,
jecPayload=nanoAOD_addDeepInfoAK8_switch.jecPayload)
return process
def nanoAOD_customizeCommon(process):
# makePuppiesFromMiniAOD(process,True) # call this here as it calls switchOnVIDPhotonIdProducer
process = nanoAOD_activateVID(process)
nanoAOD_addDeepInfo_switch = cms.PSet(
nanoAOD_addDeepBTag_switch = cms.untracked.bool(False),
nanoAOD_addDeepFlavourTag_switch = cms.untracked.bool(False),
)
run2_miniAOD_80XLegacy.toModify(nanoAOD_addDeepInfo_switch, nanoAOD_addDeepBTag_switch = cms.untracked.bool(True))
for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016, run2_nanoAOD_94XMiniAODv1, run2_nanoAOD_94XMiniAODv2:
modifier.toModify(nanoAOD_addDeepInfo_switch, nanoAOD_addDeepFlavourTag_switch = cms.untracked.bool(True))
process = nanoAOD_addDeepInfo(process,
addDeepBTag=nanoAOD_addDeepInfo_switch.nanoAOD_addDeepBTag_switch,
addDeepFlavour=nanoAOD_addDeepInfo_switch.nanoAOD_addDeepFlavourTag_switch)
nanoAOD_addDeepInfoAK8_switch = cms.PSet(
nanoAOD_addDeepBTag_switch = cms.untracked.bool(False),
nanoAOD_addDeepBoostedJet_switch = cms.untracked.bool(True), # will deactivate this in future miniAOD releases
nanoAOD_addDeepDoubleX_switch = cms.untracked.bool(True),
jecPayload = cms.untracked.string('AK8PFPuppi')
)
# deepAK8 should not run on 80X, that contains ak8PFJetsCHS jets
run2_miniAOD_80XLegacy.toModify(nanoAOD_addDeepInfoAK8_switch,
nanoAOD_addDeepBTag_switch = cms.untracked.bool(True),
nanoAOD_addDeepBoostedJet_switch = cms.untracked.bool(False),
nanoAOD_addDeepDoubleX_switch = cms.untracked.bool(False),
jecPayload = cms.untracked.string('AK8PFchs'))
process = nanoAOD_addDeepInfoAK8(process,
addDeepBTag=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepBTag_switch,
addDeepBoostedJet=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepBoostedJet_switch,
addDeepDoubleX=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepDoubleX_switch,
jecPayload=nanoAOD_addDeepInfoAK8_switch.jecPayload)
(run2_nanoAOD_94XMiniAODv1 | run2_nanoAOD_94X2016 | run2_nanoAOD_94XMiniAODv2 | run2_nanoAOD_102Xv1 | run2_nanoAOD_106Xv1).toModify(process, lambda p : nanoAOD_addTauIds(p))
return process
import FWCore.ParameterSet.Config as cms
from RecoParticleFlow.PFClusterProducer.particleFlowClusterECAL_cfi import *
particleFlowClusterOOTECAL = particleFlowClusterECAL.clone()
particleFlowClusterOOTECAL.inputECAL = cms.InputTag(
"particleFlowClusterOOTECALUncorrected")
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(particleFlowClusterOOTECAL.energyCorrector,
recHitsEBLabel="reducedEcalRecHitsEB",
recHitsEELabel="reducedEcalRecHitsEE")
),
ootPhotonPFClusterIsoSources = cms.VInputTag(
cms.InputTag("ootPhotonEcalPFClusterIsolationProducer"),
cms.InputTag("ootPhotonHcalPFClusterIsolationProducer"),
),
ootPhotonPFClusterIsoOutput = cms.vstring(
"ootPhoEcalPFClusIso",
"ootPhoHcalPFClusIso",
),
gsfElectronPFClusterIsoSources = cms.VInputTag(
cms.InputTag("electronEcalPFClusterIsolationProducer"),
cms.InputTag("electronHcalPFClusterIsolationProducer"),
),
gsfElectronPFClusterIsoOutput = cms.vstring(
"eleEcalPFClusIso",
"eleHcalPFClusIso",
),
)
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
phase2_common.toModify(reducedEgamma,
preshowerEcalHits = cms.InputTag(""),
)
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(
reducedEgamma,
ootPhotonPFClusterIsoSources = [ "ootPhotonEcalPFClusterIsolationProducer" ],
ootPhotonPFClusterIsoOutput = [ "ootPhoEcalPFClusIso" ]
)
import PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi
from math import ceil, log
# this below is used only in some eras
slimmedElectronsUpdated = cms.EDProducer(
"PATElectronUpdater",
src=cms.InputTag("slimmedElectrons"),
vertices=cms.InputTag("offlineSlimmedPrimaryVertices"),
computeMiniIso=cms.bool(False),
pfCandsForMiniIso=cms.InputTag("packedPFCandidates"),
miniIsoParamsB=PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.
patElectrons.miniIsoParamsB, # so they're in sync
miniIsoParamsE=PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.
patElectrons.miniIsoParamsE, # so they're in sync
)
run2_miniAOD_80XLegacy.toModify(slimmedElectronsUpdated, computeMiniIso=True)
electron_id_modules_WorkingPoints_nanoAOD = cms.PSet(
modules=cms.vstring(
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V2_cff',
),
WorkingPoints=cms.vstring(
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-veto",
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-loose",
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-medium",
def setupCustomizedAK4(process, runOnMC=False, path=None):
# Mu subtraction
process.MuSubProducer = cms.EDProducer('MuSubProducer',
src=cms.InputTag('slimmedMuons'),
pfcs=cms.InputTag('packedPFCandidates'),
vtxs=cms.InputTag('offlineSlimmedPrimaryVertices'),
ptmin=cms.double(55.0)
)
bTagDiscriminators = [
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfDeepCSVJetTags:probb',
'pfDeepCSVJetTags:probbb'
]
JETCorrLevels = ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']
from PhysicsTools.NanoHRT.jetToolbox_cff import jetToolbox
jetToolbox(process, 'ak4', 'dummySeq', 'out', associateTask=False,
PUMethod='CHS', JETCorrPayload='AK4PFchs', JETCorrLevels=JETCorrLevels,
postFix='MuSub',
newPFCollection=True, nameNewPFCollection="MuSubProducer",
Cut='pt > 20.0 && abs(rapidity()) < 2.4',
bTagDiscriminators=bTagDiscriminators)
srcJets = cms.InputTag('selectedPatJetsAK4PFCHSMuSub')
# jetID
process.looseJetIdCustomAK4 = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('WINTER16'),
quality = cms.string('LOOSE'),
),
src=srcJets
)
process.tightJetIdCustomAK4 = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER17'),
quality = cms.string('TIGHT'),
),
src=srcJets
)
run2_miniAOD_80XLegacy.toModify(process.tightJetIdCustomAK4.filterParams, version="WINTER16")
process.tightJetIdLepVetoCustomAK4 = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('WINTER17'),
quality = cms.string('TIGHTLEPVETO'),
),
src=srcJets
)
process.customAK4WithUserData = cms.EDProducer("PATJetUserDataEmbedder",
src=srcJets,
userFloats=cms.PSet(),
userInts=cms.PSet(
tightId=cms.InputTag("tightJetIdCustomAK4"),
tightIdLepVeto=cms.InputTag("tightJetIdLepVetoCustomAK4"),
),
)
run2_miniAOD_80XLegacy.toModify(process.customAK4WithUserData.userInts,
looseId=cms.InputTag("looseJetIdCustomAK4"),
tightIdLepVeto=None,
)
process.customAK4Table = cms.EDProducer("SimpleCandidateFlatTableProducer",
src=cms.InputTag("customAK4WithUserData"),
name=cms.string("CustomAK4CHS"),
cut=cms.string(""),
doc=cms.string("muon subtracted AK4"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(False), # this is the main table for the jets
variables=cms.PSet(P4Vars,
jetId=Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')", int, doc="Jet ID flags bit1 is loose (always false in 2017 since it does not exist), bit2 is tight, bit3 is tightLepVeto"),
area=Var("jetArea()", float, doc="jet catchment area, for JECs", precision=10),
rawFactor=Var("1.-jecFactor('Uncorrected')", float, doc="1 - Factor to get back to raw pT", precision=6),
btagCSVV2=Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')", float, doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)", precision=10),
btagDeepB=Var("bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')", float, doc="DeepCSV b+bb tag discriminator", precision=10)
)
)
run2_miniAOD_80XLegacy.toModify(process.customAK4Table.variables, jetId=Var("userInt('tightId')*2+userInt('looseId')", int, doc="Jet ID flags bit1 is loose, bit2 is tight"))
process.customAK4Table.variables.pt.precision = 10
process.customizedAK4Task = cms.Task(
process.MuSubProducer,
process.tightJetIdCustomAK4,
process.tightJetIdLepVetoCustomAK4,
process.customAK4WithUserData,
process.customAK4Table
)
_customizedAK4Task_80X = process.customizedAK4Task.copy()
_customizedAK4Task_80X.replace(process.tightJetIdLepVetoCustomAK4, process.looseJetIdCustomAK4)
run2_miniAOD_80XLegacy.toReplaceWith(process.customizedAK4Task, _customizedAK4Task_80X)
if path is None:
process.schedule.associate(process.customizedAK4Task)
else:
getattr(process, path).associate(process.customizedAK4Task)
),
operatingPoints=cms.vstring(
"3", "3", "3"), #loose = 0, medium = 1, tight = 2, reshaping = 3
measurementTypesB=cms.vstring(
"iterativefit", "iterativefit",
"iterativefit"), #e.g. "comb", "incl", "ttbar", "iterativefit"
measurementTypesC=cms.vstring("iterativefit", "iterativefit",
"iterativefit"),
measurementTypesUDSG=cms.vstring("iterativefit", "iterativefit",
"iterativefit"),
sysTypes=cms.vstring("central", "central", "central"))
run2_miniAOD_80XLegacy.toModify(
btagWeightTable,
cut=cms.string(
"pt > 25. && abs(eta) < 2.4"), #80X corresponds to 2016, |eta| < 2.4
weightFiles=cms.vstring( #80X corresponds to 2016 SFs
btagSFdir + "CSVv2_Moriond17_B_H.csv", "unavailable",
btagSFdir + "cMVAv2_Moriond17_B_H.csv"))
run2_nanoAOD_92X.toModify(
btagWeightTable, #92X corresponds to MCv1, for which SFs are unavailable
weightFiles=cms.vstring("unavailable", "unavailable", "unavailable"))
genWeightsTable = cms.EDProducer(
"GenWeightsTableProducer",
genEvent=cms.InputTag("generator"),
lheInfo=cms.InputTag("externalLHEProducer"),
preferredPDFs=cms.VPSet( # see https://lhapdf.hepforge.org/pdfsets.html
cms.PSet(name=cms.string("PDF4LHC15_nnlo_30_pdfas"),
lhaid=cms.uint32(91400)),
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()
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.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(
'puppi'
), # using Puppi candidates as input for b tagging of Puppi jets
algo='AK',
rParam=0.4,
btagDiscriminators=noDeepFlavourDiscriminators)
process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets'
process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge")
process.selectedPatJetsPuppi.cut = cms.string("pt > 15")
process.load('PhysicsTools.PatAlgos.slimming.slimmedJets_cfi')
# update slimmed jets to include DeepFlavour (keep same name)
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
# make clone for DeepFlavour-less slimmed jets, so output name is preserved
process.slimmedJetsNoDeepFlavour = process.slimmedJets.clone()
task.add(process.slimmedJetsNoDeepFlavour)
updateJetCollection(
process,
jetSource=cms.InputTag('slimmedJetsNoDeepFlavour'),
# updateJetCollection defaults to MiniAOD inputs but
# here it is made explicit (as in training or MINIAOD redoing)
pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'),
pfCandidates=cms.InputTag('packedPFCandidates'),
svSource=cms.InputTag('slimmedSecondaryVertices'),
muSource=cms.InputTag('slimmedMuons'),
elSource=cms.InputTag('slimmedElectrons'),
jetCorrections=('AK4PFchs',
cms.vstring(['L1FastJet', 'L2Relative',
'L3Absolute']), 'None'),
btagDiscriminators=[
'pfDeepFlavourJetTags:probb',
'pfDeepFlavourJetTags:probbb',
'pfDeepFlavourJetTags:problepb',
'pfDeepFlavourJetTags:probc',
'pfDeepFlavourJetTags:probuds',
'pfDeepFlavourJetTags:probg',
],
postfix='SlimmedDeepFlavour',
printWarning=False)
# slimmedJets with DeepFlavour (remove DeepFlavour-less)
delattr(process, 'slimmedJets')
process.slimmedJets = process.selectedUpdatedPatJetsSlimmedDeepFlavour.clone(
)
# delete module not used anymore (slimmedJets substitutes)
delattr(process, 'selectedUpdatedPatJetsSlimmedDeepFlavour')
task.add(process.slimmedJets)
task.add(process.slimmedJetsAK8)
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
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 setupAK15(process, runOnMC=False, path=None):
# recluster Puppi jets
bTagDiscriminators = [
'pfJetProbabilityBJetTags',
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
]
subjetBTagDiscriminators = [
'pfJetProbabilityBJetTags',
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
]
JETCorrLevels = ['L2Relative', 'L3Absolute', 'L2L3Residual']
from PhysicsTools.NanoTuples.jetToolbox_cff import jetToolbox
jetToolbox(process,
'ak15',
'dummySeqAK15',
'out',
associateTask=False,
PUMethod='Puppi',
JETCorrPayload='AK8PFPuppi',
JETCorrLevels=JETCorrLevels,
Cut='pt > 160.0 && abs(rapidity()) < 2.4',
miniAOD=True,
runOnMC=runOnMC,
addNsub=True,
maxTau=3,
addSoftDrop=True,
addSoftDropSubjets=True,
subJETCorrPayload='AK4PFPuppi',
subJETCorrLevels=JETCorrLevels,
bTagDiscriminators=bTagDiscriminators,
subjetBTagDiscriminators=subjetBTagDiscriminators)
if runOnMC:
process.ak15GenJetsNoNu.jetPtMin = 100
process.ak15GenJetsNoNuSoftDrop.jetPtMin = 100
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
from RecoBTag.MXNet.pfDeepBoostedJet_cff import _pfMassDecorrelatedDeepBoostedJetTagsProbs as pfMassDecorrelatedDeepBoostedJetTagsProbs
updateJetCollection(
process,
jetSource=cms.InputTag('packedPatJetsAK15PFPuppiSoftDrop'),
rParam=1.5,
jetCorrections=('AK8PFPuppi', cms.vstring(['L2Relative',
'L3Absolute']), 'None'),
btagDiscriminators=bTagDiscriminators +
pfMassDecorrelatedDeepBoostedJetTagsProbs,
postfix='AK15WithPuppiDaughters',
)
# configure DeepAK15
from PhysicsTools.NanoTuples.pfDeepBoostedJetPreprocessParamsAK15_cfi import pfDeepBoostedJetPreprocessParams as params
process.pfDeepBoostedJetTagInfosAK15WithPuppiDaughters.jet_radius = 1.5
process.pfMassDecorrelatedDeepBoostedJetTagsAK15WithPuppiDaughters.preprocessParams = params
process.pfMassDecorrelatedDeepBoostedJetTagsAK15WithPuppiDaughters.model_path = 'PhysicsTools/NanoTuples/data/DeepBoostedJet/ak15/decorrelated/resnet-symbol.json'
process.pfMassDecorrelatedDeepBoostedJetTagsAK15WithPuppiDaughters.param_path = 'PhysicsTools/NanoTuples/data/DeepBoostedJet/ak15/decorrelated/resnet.params'
# src
srcJets = cms.InputTag('selectedUpdatedPatJetsAK15WithPuppiDaughters')
# jetID
process.looseJetIdAK15Puppi = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER16'),
quality=cms.string('LOOSE'),
),
src=srcJets)
process.tightJetIdAK15Puppi = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER17'),
quality=cms.string('TIGHT'),
),
src=srcJets)
run2_miniAOD_80XLegacy.toModify(process.tightJetIdAK15Puppi.filterParams,
version="WINTER16")
process.tightJetIdLepVetoAK15Puppi = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER17'),
quality=cms.string('TIGHTLEPVETO'),
),
src=srcJets)
process.ak15WithUserData = cms.EDProducer(
"PATJetUserDataEmbedder",
src=srcJets,
userFloats=cms.PSet(),
userInts=cms.PSet(
tightId=cms.InputTag("tightJetIdAK15Puppi"),
tightIdLepVeto=cms.InputTag("tightJetIdLepVetoAK15Puppi"),
),
)
run2_miniAOD_80XLegacy.toModify(
process.ak15WithUserData.userInts,
looseId=cms.InputTag("looseJetIdAK15Puppi"),
tightIdLepVeto=None,
)
process.ak15Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("ak15WithUserData"),
name=cms.string("AK15Puppi"),
cut=cms.string(""),
doc=cms.string("ak15 puppi jets"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(False), # this is the main table for the jets
variables=cms.PSet(
P4Vars,
jetId=Var(
"userInt('tightId')*2+4*userInt('tightIdLepVeto')",
int,
doc=
"Jet ID flags bit1 is loose (always false in 2017 since it does not exist), bit2 is tight, bit3 is tightLepVeto"
),
area=Var("jetArea()",
float,
doc="jet catchment area, for JECs",
precision=10),
rawFactor=Var("1.-jecFactor('Uncorrected')",
float,
doc="1 - Factor to get back to raw pT",
precision=6),
tau1=Var("userFloat('NjettinessAK15Puppi:tau1')",
float,
doc="Nsubjettiness (1 axis)",
precision=10),
tau2=Var("userFloat('NjettinessAK15Puppi:tau2')",
float,
doc="Nsubjettiness (2 axis)",
precision=10),
tau3=Var("userFloat('NjettinessAK15Puppi:tau3')",
float,
doc="Nsubjettiness (3 axis)",
precision=10),
msoftdrop=Var("groomedMass()",
float,
doc="Corrected soft drop mass with PUPPI",
precision=10),
btagCSVV2=Var(
"bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",
float,
doc=
"pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",
precision=10),
btagJP=Var(
"bDiscriminator('pfJetProbabilityBJetTags')",
float,
doc="pfJetProbabilityBJetTags b-tag discriminator (aka JP)",
precision=10),
nBHadrons=Var("jetFlavourInfo().getbHadrons().size()",
int,
doc="number of b-hadrons"),
nCHadrons=Var("jetFlavourInfo().getcHadrons().size()",
int,
doc="number of c-hadrons"),
subJetIdx1=Var(
"?nSubjetCollections()>0 && subjets().size()>0?subjets()[0].key():-1",
int,
doc="index of first subjet"),
subJetIdx2=Var(
"?nSubjetCollections()>0 && subjets().size()>1?subjets()[1].key():-1",
int,
doc="index of second subjet"),
))
run2_miniAOD_80XLegacy.toModify(
process.ak15Table.variables,
jetId=Var("userInt('tightId')*2+userInt('looseId')",
int,
doc="Jet ID flags bit1 is loose, bit2 is tight"))
process.ak15Table.variables.pt.precision = 10
# add Mass Decorrelated taggers
for prob in pfMassDecorrelatedDeepBoostedJetTagsProbs:
name = prob.split(':')[1]
setattr(
process.ak15Table.variables, name,
Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
process.ak15SubJetTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("selectedPatJetsAK15PFPuppiSoftDropPacked",
"SubJets"),
cut=cms.string(""),
name=cms.string("AK15PuppiSubJet"),
doc=cms.string("ak15 puppi subjets"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(False), # this is the main table for the jets
variables=cms.PSet(
P4Vars,
area=Var("jetArea()",
float,
doc="jet catchment area, for JECs",
precision=10),
rawFactor=Var("1.-jecFactor('Uncorrected')",
float,
doc="1 - Factor to get back to raw pT",
precision=6),
btagCSVV2=Var(
"bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",
float,
doc=
" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",
precision=10),
btagJP=Var(
"bDiscriminator('pfJetProbabilityBJetTags')",
float,
doc="pfJetProbabilityBJetTags b-tag discriminator (aka JP)",
precision=10),
nBHadrons=Var("jetFlavourInfo().getbHadrons().size()",
int,
doc="number of b-hadrons"),
nCHadrons=Var("jetFlavourInfo().getcHadrons().size()",
int,
doc="number of c-hadrons"),
))
process.ak15SubJetTable.variables.pt.precision = 10
process.ak15Task = cms.Task(
process.tightJetIdAK15Puppi,
process.tightJetIdLepVetoAK15Puppi,
process.ak15WithUserData,
process.ak15Table,
process.ak15SubJetTable,
)
if runOnMC:
process.genJetAK15Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("ak15GenJetsNoNu"),
cut=cms.string("pt > 100."),
name=cms.string("GenJetAK15"),
doc=cms.string("AK15 GenJets made with visible genparticles"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(
False), # this is the main table for the genjets
variables=cms.PSet(P4Vars, ))
process.genJetAK15Table.variables.pt.precision = 10
process.genSubJetAK15Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("ak15GenJetsNoNuSoftDrop", "SubJets"),
cut=cms.string(""),
name=cms.string("GenSubJetAK15"),
doc=cms.string("AK15 Gen-SubJets made with visible genparticles"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(
False), # this is the main table for the genjets
variables=cms.PSet(P4Vars, ))
process.genSubJetAK15Table.variables.pt.precision = 10
process.ak15Task.add(process.genJetAK15Table)
process.ak15Task.add(process.genSubJetAK15Table)
_ak15Task_80X = process.ak15Task.copy()
_ak15Task_80X.replace(process.tightJetIdLepVetoAK15Puppi,
process.looseJetIdAK15Puppi)
run2_miniAOD_80XLegacy.toReplaceWith(process.ak15Task, _ak15Task_80X)
if path is None:
process.schedule.associate(process.ak15Task)
else:
getattr(process, path).associate(process.ak15Task)
cms.InputTag("generalV0Candidates","Lambda"),
),
minPtForTrackProperties = cms.double(0.95),
covarianceVersion = cms.int32(0), #so far: 0 is Phase0, 1 is Phase1
# covariancePackingSchemas = cms.vint32(1,257,513,769,0), # a cheaper schema in kb/ev
covariancePackingSchemas = cms.vint32(8,264,520,776,0), # more accurate schema +0.6kb/ev
pfCandidateTypesForHcalDepth = cms.vint32(),
storeHcalDepthEndcapOnly = cms.bool(False), # switch to store info only for endcap
storeTiming = cms.bool(False)
)
from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel
phase1Pixel.toModify(packedPFCandidates, covarianceVersion =1 )
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(packedPFCandidates, chargedHadronIsolation = "" )
from Configuration.Eras.Modifier_run2_HCAL_2018_cff import run2_HCAL_2018
run2_HCAL_2018.toModify(packedPFCandidates,
pfCandidateTypesForHcalDepth = [130,11,22,211,13], # PF cand types for adding Hcal depth energy frac information
# (130: neutral h, 11: ele, 22: photon, 211: charged h, 13: mu) # excluding e.g. 1:h_HF, 2:egamma_HF
storeHcalDepthEndcapOnly = True
)
from Configuration.Eras.Modifier_run3_common_cff import run3_common
run3_common.toModify(packedPFCandidates,
pfCandidateTypesForHcalDepth = [], # For now, no PF cand type is considered for addition of Hcal depth energy frac
storeHcalDepthEndcapOnly = False
)
from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing
import FWCore.ParameterSet.Config as cms
from RecoCTPPS.TotemRPLocal.ctppsLocalTrackLiteDefaultProducer_cfi import ctppsLocalTrackLiteDefaultProducer
ctppsLocalTrackLiteProducer = ctppsLocalTrackLiteDefaultProducer.clone()
# enable the module for CTPPS era(s)
from Configuration.Eras.Modifier_ctpps_2016_cff import ctpps_2016
ctpps_2016.toModify(ctppsLocalTrackLiteProducer,
includeStrips=True,
includeDiamonds=True,
includePixels=True)
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(ctppsLocalTrackLiteProducer, tagPixelTrack="")
# PFClusterIso
patOOTPhotons.addPFClusterIso = cms.bool(True)
patOOTPhotons.ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "ootPhoEcalPFClusIso")
patOOTPhotons.hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "ootPhoHcalPFClusIso")
# MC Match
patOOTPhotons.genParticleMatch = cms.InputTag("ootPhotonMatch") ## particles source to be used for the matching
## for scheduled mode
makePatOOTPhotonsTask = cms.Task(
ootPhotonMatch,
patOOTPhotons
)
makePatOOTPhotons = cms.Sequence(makePatOOTPhotonsTask)
## For legacy reprocessing
from RecoEgamma.EgammaPhotonProducers.ootPhotonSequence_cff import *
from RecoEgamma.EgammaIsolationAlgos.pfClusterIsolation_cfi import ootPhotonEcalPFClusterIsolationProducer
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toReplaceWith(makePatOOTPhotonsTask, cms.Task(
ootPhotonTask,
ootPhotonEcalPFClusterIsolationProducer,
makePatOOTPhotonsTask.copy()
))
run2_miniAOD_80XLegacy.toModify(patOOTPhotons, hcalPFClusterIsoMap = "")
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1p1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V2_cff',
),
WorkingPoints = cms.vstring(
"egmPhotonIDs:cutBasedPhotonID-Fall17-94X-V2-loose",
"egmPhotonIDs:cutBasedPhotonID-Fall17-94X-V2-medium",
"egmPhotonIDs:cutBasedPhotonID-Fall17-94X-V2-tight",
)
)
run2_miniAOD_80XLegacy.toModify(photon_id_modules_WorkingPoints_nanoAOD,
modules = cms.vstring(
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff',
),
WorkingPoints = cms.vstring(
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-loose",
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-medium",
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-tight",
)
)
run2_nanoAOD_94X2016.toModify(photon_id_modules_WorkingPoints_nanoAOD,
modules = cms.vstring(
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
),
WorkingPoints = cms.vstring(
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-loose",
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-medium",
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-tight",
)
)
## Modify plots accordingly to era
_vplots80X = nanoDQM.vplots.clone()
# Tau plots
_tauPlots80X = cms.VPSet()
for plot in _vplots80X.Tau.plots:
if (plot.name.value().find("MVA")>-1 and plot.name.value().find("2017")>-1) or (plot.name.value().find("AntiEle")>-1 and plot.name.value().find("2018")>-1):
continue
_tauPlots80X.append(plot)
_tauPlots80X.append(Plot1D('idMVAnewDM', 'idMVAnewDM', 64, -0.5, 63.5, 'IsolationMVArun2v1DBnewDMwLT ID working point: bitmask 1 = VLoose, 2 = Loose, 4 = Medium, 8 = Tight, 16 = VTight, 32 = VVTight'))
_tauPlots80X.append(Plot1D('idMVAoldDMdR03', 'idMVAoldDMdR03', 64, -0.5, 63.5, 'IsolationMVArun2v1DBdR03oldDMwLT ID working point: bitmask 1 = VLoose, 2 = Loose, 4 = Medium, 8 = Tight, 16 = VTight, 32 = VVTight'))
_tauPlots80X.append(Plot1D('rawMVAnewDM', 'rawMVAnewDM', 20, -1, 1, 'byIsolationMVArun2v1DBnewDMwLT raw output discriminator'))
_tauPlots80X.append(Plot1D('rawMVAoldDMdR03', 'rawMVAoldDMdR03', 20, -1, 1, 'byIsolationMVArun2v1DBdR03oldDMwLT raw output discriminator'))
_vplots80X.Tau.plots = _tauPlots80X
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(nanoDQM,
vplots = _vplots80X
)
_METFixEE2017_DQMentry = nanoDQM.vplots.MET.clone()
_METFixEE2017_plots = cms.VPSet()
for plot in _METFixEE2017_DQMentry.plots:
if plot.name.value().find("fiducial")>-1: continue
_METFixEE2017_plots.append(plot)
_METFixEE2017_DQMentry.plots = _METFixEE2017_plots
from Configuration.Eras.Modifier_run2_nanoAOD_94XMiniAODv1_cff import run2_nanoAOD_94XMiniAODv1
from Configuration.Eras.Modifier_run2_nanoAOD_94XMiniAODv2_cff import run2_nanoAOD_94XMiniAODv2
for modifier in run2_nanoAOD_94XMiniAODv1, run2_nanoAOD_94XMiniAODv2:
modifier.toModify(nanoDQM.vplots, METFixEE2017 = _METFixEE2017_DQMentry)
_Electron_plots_2016 = copy.deepcopy(nanoDQM.vplots.Electron.plots)
_Electron_plots_2016.append(Plot1D('cutBased_HLTPreSel', 'cutBased_HLTPreSel', 2, -0.5, 1.5, 'cut-based HLT pre-selection ID'))
##################### User floats producers, selectors ##########################
finalTaus = cms.EDFilter("PATTauRefSelector",
src = cms.InputTag("slimmedTausUpdated"),
cut = cms.string("pt > 18 && tauID('decayModeFindingNewDMs') && (tauID('byLooseCombinedIsolationDeltaBetaCorr3Hits') || tauID('byVLooseIsolationMVArun2v1DBoldDMwLT2015') || tauID('byVLooseIsolationMVArun2v1DBnewDMwLT') || tauID('byVLooseIsolationMVArun2v1DBdR03oldDMwLT') || tauID('byVVLooseIsolationMVArun2v1DBoldDMwLT') || tauID('byVVLooseIsolationMVArun2v1DBoldDMwLT2017v2') || tauID('byVVLooseIsolationMVArun2v1DBnewDMwLT2017v2') || tauID('byVVLooseIsolationMVArun2v1DBdR03oldDMwLT2017v2'))")
)
from Configuration.Eras.Modifier_run2_nanoAOD_94XMiniAODv1_cff import run2_nanoAOD_94XMiniAODv1
for era in [run2_nanoAOD_94XMiniAODv1,]:
era.toModify(finalTaus,
cut = cms.string("pt > 18 && tauID('decayModeFindingNewDMs') && (tauID('byLooseCombinedIsolationDeltaBetaCorr3Hits') || tauID('byVLooseIsolationMVArun2v1DBoldDMwLT') || tauID('byVLooseIsolationMVArun2v1DBnewDMwLT') || tauID('byVLooseIsolationMVArun2v1DBdR03oldDMwLT') || tauID('byVVLooseIsolationMVArun2v1DBoldDMwLT2017v1') || tauID('byVVLooseIsolationMVArun2v1DBoldDMwLT2017v2') || tauID('byVVLooseIsolationMVArun2v1DBnewDMwLT2017v2') || tauID('byVVLooseIsolationMVArun2v1DBdR03oldDMwLT2017v2'))")
)
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(finalTaus,
src = cms.InputTag("slimmedTaus"),
cut = cms.string("pt > 18 && tauID('decayModeFindingNewDMs') && (tauID('byLooseCombinedIsolationDeltaBetaCorr3Hits') || tauID('byVLooseIsolationMVArun2v1DBoldDMwLT') || tauID('byVLooseIsolationMVArun2v1DBnewDMwLT') || tauID('byVLooseIsolationMVArun2v1DBdR03oldDMwLT'))")
)
##################### Tables for final output and docs ##########################
def _tauIdWPMask(pattern, choices, doc=""):
return Var(" + ".join(["%d * tauID('%s')" % (pow(2,i), pattern % c) for (i,c) in enumerate(choices)]), "uint8",
doc=doc+": bitmask "+", ".join(["%d = %s" % (pow(2,i),c) for (i,c) in enumerate(choices)]))
def _tauId2WPMask(pattern,doc):
return _tauIdWPMask(pattern,choices=("Loose","Tight"),doc=doc)
def _tauId3WPMask(pattern,doc):
return _tauIdWPMask(pattern,choices=("Loose","Medium","Tight"),doc=doc)
def _tauId5WPMask(pattern,doc):
return _tauIdWPMask(pattern,choices=("VLoose","Loose","Medium","Tight","VTight"),doc=doc)
def _tauId6WPMask(pattern,doc):
return _tauIdWPMask(pattern,choices=("VLoose","Loose","Medium","Tight","VTight","VVTight"),doc=doc)
def _tauId7WPMask(pattern,doc):
def nanoAOD_customizeCommon(process):
run2_miniAOD_80XLegacy.toModify(process, nanoAOD_addDeepBTagFor80X)
run2_nanoAOD_94X2016.toModify(process, nanoAOD_addDeepFlavourTagFor94X2016)
return process
weightFiles = cms.vstring( #default settings are for 2017 94X. toModify function is called later for other eras.
btagSFdir+"CSVv2_94XSF_V2_B_F.csv",
btagSFdir+"DeepCSV_94XSF_V2_B_F.csv",
"unavailable" #if SFs for an algorithm in an era is unavailable, the corresponding branch will not be stored
),
operatingPoints = cms.vstring("3","3","3"), #loose = 0, medium = 1, tight = 2, reshaping = 3
measurementTypesB = cms.vstring("iterativefit","iterativefit","iterativefit"), #e.g. "comb", "incl", "ttbar", "iterativefit"
measurementTypesC = cms.vstring("iterativefit","iterativefit","iterativefit"),
measurementTypesUDSG = cms.vstring("iterativefit","iterativefit","iterativefit"),
sysTypes = cms.vstring("central","central","central")
)
run2_miniAOD_80XLegacy.toModify(btagWeightTable,
cut = cms.string("pt > 25. && abs(eta) < 2.4"), #80X corresponds to 2016, |eta| < 2.4
weightFiles = cms.vstring( #80X corresponds to 2016 SFs
btagSFdir+"CSVv2_Moriond17_B_H.csv",
"unavailable",
btagSFdir+"cMVAv2_Moriond17_B_H.csv"
)
)
run2_nanoAOD_92X.toModify(btagWeightTable, #92X corresponds to MCv1, for which SFs are unavailable
weightFiles = cms.vstring(
"unavailable",
"unavailable",
"unavailable"
)
)
genWeightsTable = cms.EDProducer("GenWeightsTableProducer",
genEvent = cms.InputTag("generator"),
lheInfo = cms.InputTag("externalLHEProducer"),
from Configuration.Eras.Modifier_run2_nanoAOD_94XMiniAODv2_cff import run2_nanoAOD_94XMiniAODv2
from Configuration.Eras.Modifier_run2_nanoAOD_94X2016_cff import run2_nanoAOD_94X2016
from PhysicsTools.NanoAOD.common_cff import *
import PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi
from math import ceil,log
# this below is used only in some eras
slimmedElectronsUpdated = cms.EDProducer("PATElectronUpdater",
src = cms.InputTag("slimmedElectrons"),
vertices = cms.InputTag("offlineSlimmedPrimaryVertices"),
computeMiniIso = cms.bool(False),
pfCandsForMiniIso = cms.InputTag("packedPFCandidates"),
miniIsoParamsB = PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.patElectrons.miniIsoParamsB, # so they're in sync
miniIsoParamsE = PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.patElectrons.miniIsoParamsE, # so they're in sync
)
run2_miniAOD_80XLegacy.toModify( slimmedElectronsUpdated, computeMiniIso = True )
electron_id_modules_WorkingPoints_nanoAOD = cms.PSet(
modules = cms.vstring(
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V2_cff',
),
WorkingPoints = cms.vstring(
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-veto",
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-loose",
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-medium",
src=cms.InputTag("softActivityJets"),
cut=cms.string('pt>2'))
looseJetId = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER16'),
quality=cms.string('LOOSE'),
),
src=cms.InputTag("slimmedJets"))
tightJetId = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER17'),
quality=cms.string('TIGHT'),
),
src=cms.InputTag("slimmedJets"))
run2_miniAOD_80XLegacy.toModify(tightJetId.filterParams, version="WINTER16")
tightJetIdLepVeto = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER17'),
quality=cms.string('TIGHTLEPVETO'),
),
src=cms.InputTag("slimmedJets"))
looseJetIdAK8 = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER16'),
quality=cms.string('LOOSE'),
),
src=cms.InputTag("slimmedJetsAK8"))
tightJetIdAK8 = cms.EDProducer("PatJetIDValueMapProducer",
from RecoEcal.EgammaClusterProducers.particleFlowSuperClusterECAL_cfi import *
particleFlowSuperClusterOOTECAL = particleFlowSuperClusterECAL.clone()
particleFlowSuperClusterOOTECAL.PFClusters = cms.InputTag("particleFlowClusterOOTECAL")
particleFlowSuperClusterOOTECAL.ESAssociation = cms.InputTag("particleFlowClusterOOTECAL")
particleFlowSuperClusterOOTECAL.PFBasicClusterCollectionBarrel = cms.string("particleFlowBasicClusterOOTECALBarrel")
particleFlowSuperClusterOOTECAL.PFSuperClusterCollectionBarrel = cms.string("particleFlowSuperClusterOOTECALBarrel")
particleFlowSuperClusterOOTECAL.PFBasicClusterCollectionEndcap = cms.string("particleFlowBasicClusterOOTECALEndcap")
particleFlowSuperClusterOOTECAL.PFSuperClusterCollectionEndcap = cms.string("particleFlowSuperClusterOOTECALEndcap")
particleFlowSuperClusterOOTECAL.PFBasicClusterCollectionPreshower = cms.string("particleFlowBasicClusterOOTECALPreshower")
particleFlowSuperClusterOOTECAL.PFSuperClusterCollectionEndcapWithPreshower = cms.string("particleFlowSuperClusterOOTECALEndcapWithPreshower")
## modification for Algo
particleFlowSuperClusterOOTECAL.isOOTCollection = cms.bool(True)
particleFlowSuperClusterOOTECAL.barrelRecHits = cms.InputTag("ecalRecHit","EcalRecHitsEB")
particleFlowSuperClusterOOTECAL.endcapRecHits = cms.InputTag("ecalRecHit","EcalRecHitsEE")
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(
particleFlowSuperClusterOOTECAL,
barrelRecHits = "reducedEcalRecHitsEB",
endcapRecHits = "reducedEcalRecHitsEE"
)
run2_miniAOD_80XLegacy.toModify(
particleFlowSuperClusterOOTECAL.regressionConfig,
ecalRecHitsEB = "reducedEcalRecHitsEB",
ecalRecHitsEE = "reducedEcalRecHitsEE"
)
)
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(
reducedEgamma,
photonPFClusterIsoSources = cms.VInputTag(
cms.InputTag("photonEcalPFClusterIsolationProducer"),
cms.InputTag("photonHcalPFClusterIsolationProducer"),
),
photonPFClusterIsoOutput = cms.vstring(
"phoEcalPFClusIso",
"phoHcalPFClusIso",
),
ootPhotonPFClusterIsoSources = cms.VInputTag(
cms.InputTag("ootPhotonEcalPFClusterIsolationProducer"),
),
ootPhotonPFClusterIsoOutput = cms.vstring(
"ootPhoEcalPFClusIso",
),
gsfElectronPFClusterIsoSources = cms.VInputTag(
cms.InputTag("electronEcalPFClusterIsolationProducer"),
cms.InputTag("electronHcalPFClusterIsolationProducer"),
),
gsfElectronPFClusterIsoOutput = cms.vstring(
"eleEcalPFClusIso",
"eleHcalPFClusIso",
)
)
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(
patOOTPhotons.genParticleMatch = cms.InputTag("ootPhotonMatch") ## particles source to be used for the matching
## for scheduled mode
makePatOOTPhotonsTask = cms.Task(
ootPhotonMatch,
patOOTPhotons
)
makePatOOTPhotons = cms.Sequence(makePatOOTPhotonsTask)
## For legacy reprocessing
from RecoEgamma.EgammaPhotonProducers.ootPhotonSequence_cff import *
from RecoEgamma.EgammaIsolationAlgos.pfClusterIsolation_cfi import ootPhotonEcalPFClusterIsolationProducer
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toReplaceWith(makePatOOTPhotonsTask, cms.Task(
ootPhotonTask,
ootPhotonEcalPFClusterIsolationProducer,
makePatOOTPhotonsTask.copy()
))
#the OOT are made from scratch in re-miniAOD
#we could put the PFCluster isolation in there when we initially make them
#but decided to emulate what is done in 80X where the the isolation is only put
#into the pat object and value maps are saved
#hence we need to have the source to be ootPhotons not ootPhotonsTmp
run2_miniAOD_80XLegacy.toModify(ootPhotonEcalPFClusterIsolationProducer,candidateProducer = cms.InputTag('ootPhotons') )
run2_miniAOD_80XLegacy.toModify(patOOTPhotons, addPFClusterIso = cms.bool(True),ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "ootPhoEcalPFClusIso"),hcalPFClusterIsoMap = cms.InputTag("") )
),
ootPhotonPFClusterIsoSources=cms.VInputTag(
cms.InputTag("ootPhotonEcalPFClusterIsolationProducer"),
cms.InputTag("ootPhotonHcalPFClusterIsolationProducer"),
),
ootPhotonPFClusterIsoOutput=cms.vstring(
"ootPhoEcalPFClusIso",
"ootPhoHcalPFClusIso",
),
gsfElectronPFClusterIsoSources=cms.VInputTag(
cms.InputTag("electronEcalPFClusterIsolationProducer"),
cms.InputTag("electronHcalPFClusterIsolationProducer"),
),
gsfElectronPFClusterIsoOutput=cms.vstring(
"eleEcalPFClusIso",
"eleHcalPFClusIso",
),
)
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
phase2_common.toModify(
reducedEgamma,
preshowerEcalHits=cms.InputTag(""),
)
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(
reducedEgamma,
ootPhotonPFClusterIsoSources=["ootPhotonEcalPFClusterIsolationProducer"],
ootPhotonPFClusterIsoOutput=["ootPhoEcalPFClusIso"])
#############################################################
from RecoEgamma.EgammaTools.calibratedEgammas_cff import ecalTrkCombinationRegression
egamma8XLegacyEtScaleSysModifier = cms.PSet(
modifierName = cms.string('EGEtScaleSysModifier'),
epCombConfig = ecalTrkCombinationRegression,
uncertFunc = cms.PSet(
name = cms.string("UncertFuncV1"),
lowEt = cms.double(43.5),
highEt = cms.double(46.5),
lowEtUncert = cms.double(0.002),
highEtUncert = cms.double(-0.002)
)
)
def appendReducedEgammaEnergyScaleAndSmearingModifier(modifiers):
modifiers.append(reducedEgammaEnergyScaleAndSmearingModifier)
def prependEgamma8XObjectUpdateModifier(modifiers):
modifiers.insert(0,egamma8XObjectUpdateModifier)
def appendEgamma8XLegacyAppendableModifiers (modifiers):
modifiers.append(reducedEgammaEnergyScaleAndSmearingModifier)
modifiers.append(egamma8XLegacyEtScaleSysModifier)
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(egamma_modifications,appendReducedEgammaEnergyScaleAndSmearingModifier)
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(egamma_modifications,appendEgamma8XLegacyAppendableModifiers)
run2_miniAOD_80XLegacy.toModify(egamma_modifications,prependEgamma8XObjectUpdateModifier)
photon_config = cms.PSet(
photonIsolationHI = cms.InputTag("reducedEgamma:photonIsolationHIProducerppGED")
)
)
def appendReducedEgammaEnergyScaleAndSmearingModifier(modifiers):
modifiers.append(reducedEgammaEnergyScaleAndSmearingModifier)
def prependEgamma8XObjectUpdateModifier(modifiers):
modifiers.insert(0,egamma8XObjectUpdateModifier)
def appendEgamma8XLegacyAppendableModifiers (modifiers):
modifiers.append(reducedEgammaEnergyScaleAndSmearingModifier)
modifiers.append(egamma8XLegacyEtScaleSysModifier)
def appendEgammaHIPhotonIsolationModifier(modifiers):
modifiers.append(egammaHIPhotonIsolationModifier)
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
from Configuration.ProcessModifiers.run2_miniAOD_UL_cff import run2_miniAOD_UL
(run2_miniAOD_94XFall17 | run2_miniAOD_UL).toModify(egamma_modifications,appendReducedEgammaEnergyScaleAndSmearingModifier)
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
#80X doesnt have the bug which prevents GsfTracks used to match conversions so set true
run2_miniAOD_80XLegacy.toModify(egamma9X105XUpdateModifier,allowGsfTrackForConvs = True)
run2_miniAOD_80XLegacy.toModify(egamma_modifications,appendEgamma8XLegacyAppendableModifiers)
run2_miniAOD_80XLegacy.toModify(egamma_modifications,prependEgamma8XObjectUpdateModifier)
from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA
pp_on_AA.toModify(egamma_modifications, appendEgammaHIPhotonIsolationModifier)
),
userCands = cms.PSet(
jetForLepJetVar = cms.InputTag("ptRatioRelForMu:jetForLepJetVar") # warning: Ptr is null if no match is found
),
)
# this below is used only in some eras
slimmedMuonsWithDZ = cms.EDProducer("PATMuonUpdater",
src = cms.InputTag("slimmedMuonsWithUserData"),
vertices = cms.InputTag("offlineSlimmedPrimaryVertices")
)
finalMuons = cms.EDFilter("PATMuonRefSelector",
src = cms.InputTag("slimmedMuonsWithUserData"),
cut = cms.string("pt > 3 && track.isNonnull && isLooseMuon")
)
run2_miniAOD_80XLegacy.toModify(finalMuons, src = "slimmedMuonsWithDZ")
run2_nanoAOD_92X.toModify(finalMuons, src = "slimmedMuonsWithDZ")
muonMVATTH= cms.EDProducer("MuonBaseMVAValueMapProducer",
src = cms.InputTag("linkedObjects","muons"),
weightFile = cms.FileInPath("PhysicsTools/NanoAOD/data/mu_BDTG.weights.xml"),
name = cms.string("muonMVATTH"),
isClassifier = cms.bool(True),
variablesOrder = cms.vstring(["LepGood_pt","LepGood_eta","LepGood_jetNDauChargedMVASel","LepGood_miniRelIsoCharged","LepGood_miniRelIsoNeutral","LepGood_jetPtRelv2","LepGood_jetPtRatio","LepGood_jetBTagCSV","LepGood_sip3d","LepGood_dxy","LepGood_dz","LepGood_segmentCompatibility"]),
variables = cms.PSet(
LepGood_pt = cms.string("pt"),
LepGood_eta = cms.string("eta"),
LepGood_jetNDauChargedMVASel = cms.string("userFloat('jetNDauChargedMVASel')"),
LepGood_miniRelIsoCharged = cms.string("userFloat('miniIsoChg')/pt"),
LepGood_miniRelIsoNeutral = cms.string("(userFloat('miniIsoAll')-userFloat('miniIsoChg'))/pt"),
LepGood_jetPtRelv2 = cms.string("userFloat('ptRel')"),
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 = True
process.patMuons.computeMuonMVA = True
process.patMuons.computeSoftMuonMVA = True
process.patMuons.addTriggerMatching = True
from Configuration.Eras.Modifier_run2_muon_2016_cff import run2_muon_2016
from Configuration.Eras.Modifier_run2_muon_2017_cff import run2_muon_2017
from Configuration.Eras.Modifier_run2_muon_2018_cff import run2_muon_2018
run2_muon_2016.toModify(
process.patMuons,
effectiveAreaVec=[0.0735, 0.0619, 0.0465, 0.0433, 0.0577])
run2_muon_2017.toModify(
process.patMuons,
effectiveAreaVec=[0.0566, 0.0562, 0.0363, 0.0119, 0.0064])
run2_muon_2018.toModify(
process.patMuons,
effectiveAreaVec=[0.0566, 0.0562, 0.0363, 0.0119, 0.0064])
run2_muon_2016.toModify(
process.patMuons,
mvaTrainingFile=
"RecoMuon/MuonIdentification/data/mu_2016_BDTG.weights.xml")
process.patMuons.computePuppiCombinedIso = 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
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
(run2_miniAOD_80XLegacy | run2_miniAOD_94XFall17).toModify(
process.patElectrons,
addPFClusterIso=True,
ecalPFClusterIsoMap="reducedEgamma:eleEcalPFClusIso",
hcalPFClusterIsoMap="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-")
(run2_miniAOD_80XLegacy | run2_miniAOD_94XFall17).toModify(
process.patPhotons,
addPFClusterIso=True,
ecalPFClusterIsoMap="reducedEgamma:phoEcalPFClusIso",
hcalPFClusterIsoMap="reducedEgamma:phoHcalPFClusIso")
#the 80X legacy customsations are done in ootPhotonProducer for OOT photons
run2_miniAOD_94XFall17.toModify(
process.patOOTPhotons,
addPFClusterIso=True,
ecalPFClusterIsoMap="reducedEgamma:ootPhoEcalPFClusIso",
hcalPFClusterIsoMap="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')) )"
)
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
from Configuration.Eras.Modifier_pp_on_PbPb_run3_cff import pp_on_PbPb_run3
(pp_on_AA_2018 | pp_on_PbPb_run3).toModify(
process.selectedPatMuons,
cut=
"pt > 5 || isPFMuon || (pt > 1.2 && (isGlobalMuon || isStandAloneMuon) )"
)
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)
process.slimmedMETs.addDeepMETs = True
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)
from RecoMET.METProducers.pfMet_cfi import pfMet
process.pfMetCHS = pfMet.clone(src='CHSCands')
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 = pfMet.clone(src='TrkCands')
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.heepElectronID_HEEPV71_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.mvaElectronID_Fall17_noIso_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V2_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')
# To use older DataFormats, the electronMVAValueMapProducer MUST take a updated electron collection
# such that the conversion variables are filled correctly.
process.load("RecoEgamma.EgammaTools.gedGsfElectronsTo106X_cff")
run2_miniAOD_80XLegacy.toModify(
task, func=lambda t: t.add(process.gedGsfElectronsFrom80XTo106XTask))
run2_miniAOD_80XLegacy.toModify(
process.electronMVAValueMapProducer,
keysForValueMaps=cms.InputTag('reducedEgamma',
'reducedGedGsfElectrons'),
src=cms.InputTag("gedGsfElectronsFrom80XTo106X"))
run2_miniAOD_94XFall17.toModify(
task, func=lambda t: t.add(process.gedGsfElectronsFrom94XTo106XTask))
run2_miniAOD_94XFall17.toModify(
process.electronMVAValueMapProducer,
keysForValueMaps=cms.InputTag('reducedEgamma',
'reducedGedGsfElectrons'),
src=cms.InputTag("gedGsfElectronsFrom94XTo106X"))
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toModify(
task, func=lambda t: t.add(process.gedGsfElectronsFrom94XTo106XTask))
pp_on_AA_2018.toModify(process.electronMVAValueMapProducer,
keysForValueMaps=cms.InputTag(
'reducedEgamma', 'reducedGedGsfElectrons'),
src="gedGsfElectronsFrom94XTo106X")
for idmod in electron_ids:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection, None,
False, task)
#VID Photon IDs
process.patPhotons.addPhotonID = cms.bool(True)
photon_ids = [
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V1_TrueVtx_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1p1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V2_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff'
]
switchOnVIDPhotonIdProducer(process, DataFormat.AOD, task)
process.egmPhotonIDs.physicsObjectSrc = cms.InputTag(
"reducedEgamma", "reducedGedPhotons")
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
_makePatTausTaskWithRetrainedMVATauID = process.makePatTausTask.copy()
_makePatTausTaskWithRetrainedMVATauID.add(
process.hpsPFTauBasicDiscriminatorsTask,
process.hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLTTask,
process.hpsPFTauDiscriminationByIsolationMVArun2v1DBnewDMwLTTask,
process.hpsPFTauBasicDiscriminatorsdR03Task,
process.hpsPFTauDiscriminationByIsolationMVArun2v1DBdR03oldDMwLTTask,
process.hpsPFTauDiscriminationByMVA6rawElectronRejection,
process.hpsPFTauDiscriminationByMVA6ElectronRejection,
process.hpsPFTauDiscriminationByMuonRejection3)
from Configuration.ProcessModifiers.run2_miniAOD_UL_cff import run2_miniAOD_UL
(run2_miniAOD_94XFall17 | run2_miniAOD_UL).toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithRetrainedMVATauID)
#-- Adding DeepTauID
# deepTau v2p1
_updatedTauName = 'slimmedTausDeepIDsv2p1'
_noUpdatedTauName = 'slimmedTausNoDeepIDs'
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(process,
debug=False,
updatedTauName=_updatedTauName,
toKeep=['deepTau2017v2p1'])
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common #Phase2 Tau MVA
phase2_common.toModify(
tauIdEmbedder.toKeep,
func=lambda t: t.append('newDMPhase2v1')) #Phase2 Tau MVA
tauIdEmbedder.runTauID()
addToProcessAndTask(_noUpdatedTauName, process.slimmedTaus.clone(),
process, task)
delattr(process, 'slimmedTaus')
process.deepTau2017v2p1.taus = _noUpdatedTauName
process.slimmedTaus = getattr(process,
_updatedTauName).clone(src=_noUpdatedTauName)
process.deepTauIDTask = cms.Task(process.deepTau2017v2p1,
process.slimmedTaus)
task.add(process.deepTauIDTask)
if 'newDMPhase2v1' in tauIdEmbedder.toKeep:
process.rerunDiscriminationByIsolationMVADBnewDMwLTPhase2raw.PATTauProducer = _noUpdatedTauName
process.rerunDiscriminationByIsolationMVADBnewDMwLTPhase2.PATTauProducer = _noUpdatedTauName
task.add(process.rerunIsolationMVADBnewDMwLTPhase2Task)
#-- Rerun tauID against dead ECal towers to taus for the various re-MiniAOD eras
# to enable default behoviour with leading track extrapolation to ECAL
_makePatTausTaskWithDeadECalVeto = process.makePatTausTask.copy()
_makePatTausTaskWithDeadECalVeto.add(
process.hpsPFTauDiscriminationByDeadECALElectronRejection)
_run2_miniAOD_ANY = (run2_miniAOD_80XLegacy | run2_miniAOD_94XFall17
| run2_miniAOD_UL)
_run2_miniAOD_ANY.toReplaceWith(process.makePatTausTask,
_makePatTausTaskWithDeadECalVeto)
#-- Adding customization for 80X 2016 legacy reMiniAOD and 2018 heavy ions
_makePatTausTaskWithTauReReco = process.makePatTausTask.copy()
_makePatTausTaskWithTauReReco.add(process.PFTauTask)
(run2_miniAOD_80XLegacy | pp_on_AA_2018).toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithTauReReco)
# Adding puppi jets
process.load('CommonTools.PileupAlgos.Puppi_cff')
process.load('RecoJets.JetProducers.ak4PFJets_cfi')
from Configuration.Eras.Modifier_pA_2016_cff import pA_2016
_rerun_puppijets_task = task.copy()
_rerun_puppijets_task.add(process.puppi, process.ak4PFJetsPuppi)
(_run2_miniAOD_ANY | pA_2016 | pp_on_AA_2018).toReplaceWith(
task, _rerun_puppijets_task)
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(
'slimmedJetsPuppi',
process.slimmedJetsNoDeepFlavour.clone(
src="selectedPatJetsPuppi",
packedPFCandidates="packedPFCandidates"), process, task)
task.add(process.slimmedJetsPuppi)
# Embed pixelClusterTagInfos in slimmedJets
process.patJets.addTagInfos = True
process.patJets.tagInfoSources = ["pixelClusterTagInfos"]
process.slimmedJetsNoDeepFlavour.dropTagInfos = '0'
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour.addTagInfos = True
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour.tagInfoSources = [
"pixelClusterTagInfos"
]
_run2_miniAOD_ANY.toModify(process.patJets, addTagInfos=False)
_run2_miniAOD_ANY.toModify(
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour,
addTagInfos=False)
## puppi met
process.load('RecoMET.METProducers.pfMetPuppi_cfi')
_rerun_puppimet_task = task.copy()
_rerun_puppimet_task.add(process.puppiNoLep, process.pfMetPuppi)
(_run2_miniAOD_ANY | pA_2016 | pp_on_AA_2018).toReplaceWith(
task, _rerun_puppimet_task)
runMetCorAndUncForMiniAODProduction(process,
metType="Puppi",
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
process.load('RecoMET.METPUSubtraction.deepMETProducer_cfi')
addToProcessAndTask('deepMETsResolutionTune',
process.deepMETProducer.clone(), process, task)
addToProcessAndTask('deepMETsResponseTune',
process.deepMETProducer.clone(), process, task)
process.deepMETsResponseTune.graph_path = 'RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2018.pb'
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
phase2_common.toModify(
process.deepMETsResolutionTune,
max_n_pf=12500,
graph_path="RecoMET/METPUSubtraction/data/deepmet/deepmet_v1_phase2.pb"
)
phase2_common.toModify(
process.deepMETsResponseTune,
max_n_pf=12500,
graph_path=
"RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_phase2.pb")
from Configuration.Eras.Modifier_run2_jme_2016_cff import run2_jme_2016
run2_jme_2016.toModify(
process.deepMETsResponseTune,
graph_path=
"RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2016.pb")
# 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))
# L1 pre-firing weights for 2016 and 2017
from Configuration.Eras.Modifier_run2_L1prefiring_cff import run2_L1prefiring
from Configuration.Eras.Modifier_stage1L1Trigger_cff import stage1L1Trigger
from Configuration.Eras.Modifier_stage2L1Trigger_2017_cff import stage2L1Trigger_2017
process.load("PhysicsTools.PatUtils.L1ECALPrefiringWeightProducer_cff")
stage1L1Trigger.toModify(process.prefiringweight, DataEra="2016BtoH")
stage2L1Trigger_2017.toModify(process.prefiringweight, DataEra="2017BtoF")
run2_L1prefiring.toModify(task,
func=lambda t: t.add(process.prefiringweight))
from Configuration.Eras.Modifier_run2_nanoAOD_94XMiniAODv2_cff import run2_nanoAOD_94XMiniAODv2
from Configuration.Eras.Modifier_run2_nanoAOD_94X2016_cff import run2_nanoAOD_94X2016
from PhysicsTools.NanoAOD.common_cff import *
import PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi
from math import ceil,log
# this below is used only in some eras
slimmedElectronsUpdated = cms.EDProducer("PATElectronUpdater",
src = cms.InputTag("slimmedElectrons"),
vertices = cms.InputTag("offlineSlimmedPrimaryVertices"),
computeMiniIso = cms.bool(False),
pfCandsForMiniIso = cms.InputTag("packedPFCandidates"),
miniIsoParamsB = PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.patElectrons.miniIsoParamsB, # so they're in sync
miniIsoParamsE = PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.patElectrons.miniIsoParamsE, # so they're in sync
)
run2_miniAOD_80XLegacy.toModify( slimmedElectronsUpdated, computeMiniIso = True )
from PhysicsTools.SelectorUtils.tools.vid_id_tools import setupVIDSelection
from RecoEgamma.ElectronIdentification.egmGsfElectronIDs_cff import *
from RecoEgamma.ElectronIdentification.heepIdVarValueMapProducer_cfi import *
electronMVAValueMapProducer.srcMiniAOD = cms.InputTag("slimmedElectrons")
run2_miniAOD_80XLegacy.toModify(electronMVAValueMapProducer, srcMiniAOD = "slimmedElectronsUpdated")
run2_nanoAOD_92X.toModify(electronMVAValueMapProducer, srcMiniAOD = "slimmedElectronsUpdated")
electronMVAVariableHelper.srcMiniAOD = cms.InputTag("slimmedElectrons")
run2_miniAOD_80XLegacy.toModify(electronMVAVariableHelper, srcMiniAOD = "slimmedElectronsUpdated")
run2_nanoAOD_92X.toModify(electronMVAVariableHelper, srcMiniAOD = "slimmedElectronsUpdated")
egmGsfElectronIDs.physicsObjectIDs = cms.VPSet()
egmGsfElectronIDs.physicsObjectSrc = cms.InputTag('slimmedElectrons')
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
from Configuration.Eras.Modifier_run2_nanoAOD_92X_cff import run2_nanoAOD_92X
from PhysicsTools.NanoAOD.common_cff import *
import PhysicsTools.PatAlgos.producersLayer1.muonProducer_cfi
# this below is used only in some eras
slimmedMuonsUpdated = cms.EDProducer("PATMuonUpdater",
src = cms.InputTag("slimmedMuons"),
vertices = cms.InputTag("offlineSlimmedPrimaryVertices"),
computeMiniIso = cms.bool(False),
pfCandsForMiniIso = cms.InputTag("packedPFCandidates"),
miniIsoParams = PhysicsTools.PatAlgos.producersLayer1.muonProducer_cfi.patMuons.miniIsoParams, # so they're in sync
recomputeMuonBasicSelectors = cms.bool(False),
)
run2_nanoAOD_92X.toModify( slimmedMuonsUpdated, recomputeMuonBasicSelectors = True )
run2_miniAOD_80XLegacy.toModify( slimmedMuonsUpdated, computeMiniIso = True, recomputeMuonBasicSelectors = True )
isoForMu = cms.EDProducer("MuonIsoValueMapProducer",
src = cms.InputTag("slimmedMuons"),
relative = cms.bool(False),
rho_MiniIso = cms.InputTag("fixedGridRhoFastjetAll"),
EAFile_MiniIso = cms.FileInPath("PhysicsTools/NanoAOD/data/effAreaMuons_cone03_pfNeuHadronsAndPhotons_80X.txt"),
)
run2_miniAOD_80XLegacy.toModify(isoForMu, src = "slimmedMuonsUpdated")
run2_nanoAOD_92X.toModify(isoForMu, src = "slimmedMuonsUpdated")
ptRatioRelForMu = cms.EDProducer("MuonJetVarProducer",
srcJet = cms.InputTag("slimmedJets"),
srcLep = cms.InputTag("slimmedMuons"),
srcVtx = cms.InputTag("offlineSlimmedPrimaryVertices"),
)
from Configuration.Eras.Modifier_run2_nanoAOD_92X_cff import run2_nanoAOD_92X
from Configuration.Eras.Modifier_run2_nanoAOD_94XMiniAODv1_cff import run2_nanoAOD_94XMiniAODv1
from PhysicsTools.NanoAOD.common_cff import *
import PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi
from math import ceil,log
# this below is used only in some eras
slimmedElectronsUpdated = cms.EDProducer("PATElectronUpdater",
src = cms.InputTag("slimmedElectrons"),
vertices = cms.InputTag("offlineSlimmedPrimaryVertices"),
computeMiniIso = cms.bool(False),
pfCandsForMiniIso = cms.InputTag("packedPFCandidates"),
miniIsoParamsB = PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.patElectrons.miniIsoParamsB, # so they're in sync
miniIsoParamsE = PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.patElectrons.miniIsoParamsE, # so they're in sync
)
run2_miniAOD_80XLegacy.toModify( slimmedElectronsUpdated, computeMiniIso = True )
from PhysicsTools.SelectorUtils.tools.vid_id_tools import setupVIDSelection
from RecoEgamma.ElectronIdentification.egmGsfElectronIDs_cff import *
from RecoEgamma.ElectronIdentification.heepIdVarValueMapProducer_cfi import *
electronMVAValueMapProducer.srcMiniAOD = cms.InputTag("slimmedElectrons")
run2_miniAOD_80XLegacy.toModify(electronMVAValueMapProducer, srcMiniAOD = "slimmedElectronsUpdated")
run2_nanoAOD_92X.toModify(electronMVAValueMapProducer, srcMiniAOD = "slimmedElectronsUpdated")
egmGsfElectronIDs.physicsObjectIDs = cms.VPSet()
egmGsfElectronIDs.physicsObjectSrc = cms.InputTag('slimmedElectrons')
run2_miniAOD_80XLegacy.toModify(egmGsfElectronIDs, physicsObjectSrc = "slimmedElectronsUpdated")
run2_nanoAOD_92X.toModify(egmGsfElectronIDs, physicsObjectSrc = "slimmedElectronsUpdated")
heepIDVarValueMaps.elesMiniAOD = cms.InputTag('slimmedElectrons')
def setupCustomizedAK8(process, runOnMC=False, path=None):
# recluster Puppi jets, add N-Subjettiness and ECF
bTagDiscriminators = [
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfBoostedDoubleSecondaryVertexAK8BJetTags',
'pfMassIndependentDeepDoubleBvLJetTags:probHbb',
'pfMassIndependentDeepDoubleCvLJetTags:probHcc',
'pfMassIndependentDeepDoubleCvBJetTags:probHcc',
]
subjetBTagDiscriminators = [
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfDeepCSVJetTags:probb',
'pfDeepCSVJetTags:probbb',
]
JETCorrLevels = ['L2Relative', 'L3Absolute', 'L2L3Residual']
from PhysicsTools.NanoHRT.jetToolbox_cff import jetToolbox
jetToolbox(process,
'ak8',
'dummySeq',
'out',
associateTask=False,
PUMethod='Puppi',
JETCorrPayload='AK8PFPuppi',
JETCorrLevels=JETCorrLevels,
Cut='pt > 170.0 && abs(rapidity()) < 2.4',
miniAOD=True,
runOnMC=runOnMC,
addNsub=True,
maxTau=4,
addEnergyCorrFunc=True,
GetSubjetMCFlavour=False,
GetJetMCFlavour=False,
addSoftDrop=True,
addSoftDropSubjets=True,
subJETCorrPayload='AK4PFPuppi',
subJETCorrLevels=JETCorrLevels,
bTagDiscriminators=bTagDiscriminators,
subjetBTagDiscriminators=subjetBTagDiscriminators)
if runOnMC:
process.ak8GenJetsNoNu.jetPtMin = 100
process.ak8GenJetsNoNuSoftDrop.jetPtMin = 100
# DeepAK8
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
from RecoBTag.MXNet.pfDeepBoostedJet_cff import _pfDeepBoostedJetTagsProbs, _pfMassDecorrelatedDeepBoostedJetTagsProbs
Bdiscs = [
'pfDeepFlavourJetTags:probb', 'pfDeepFlavourJetTags:probbb',
'pfDeepFlavourJetTags:probuds', 'pfDeepFlavourJetTags:probg',
'pfDeepFlavourJetTags:problepb', 'pfDeepFlavourJetTags:probc',
'pfCombinedInclusiveSecondaryVertexV2BJetTags'
]
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
jetToolbox(process,
'ak8',
'ak8JetSubs',
'out',
associateTask=False,
updateCollection='packedPatJetsAK8PFPuppiSoftDrop',
JETCorrPayload='AK8PFPuppi',
JETCorrLevels=JETCorrLevels,
Cut='pt > 170.0 && abs(rapidity()) < 2.4',
miniAOD=True,
runOnMC=runOnMC,
bTagDiscriminators=bTagDiscriminators +
_pfDeepBoostedJetTagsProbs +
_pfMassDecorrelatedDeepBoostedJetTagsProbs,
updateCollectionSubjets=
'selectedPatJetsAK8PFPuppiSoftDropPacked:SubJets',
subjetBTagDiscriminators=Bdiscs,
subJETCorrPayload='AK4PFPuppi',
subJETCorrLevels=JETCorrLevels,
postFix='AK8WithPuppiDaughters')
process.imageJetsAK8Puppi = cms.EDProducer(
'ImageProducer',
src=cms.InputTag(
'selectedUpdatedPatJetsAK8PFPuppiAK8WithPuppiDaughters'),
sj=cms.InputTag(
'selectedUpdatedPatJetsAK8PFPuppiAK8WithPuppiDaughtersSoftDropPacked'
),
sdmcoll=cms.string('ak8PFJetsPuppiSoftDropMass'),
pb_path=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/top_MC_output.pb'),
pb_pathMD=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/top_MD_output.pb'),
pb_pathPhoflessMD=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/pho_MD_flavorless_output.pb'),
pb_pathPhoMD=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/pho_nolep_MD_doubleB_output.pb'),
pb_pathW=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/w_MC_output.pb'),
pb_pathWMD=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/w_MD_output.pb'),
pb_pathH=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/hbb_nolep_MC_doubleB_output.pb'),
pb_pathHMD=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/hbb_nolep_MD_doubleB_output.pb'),
pb_pathHflessMD=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/hbb_MD_flavorless_output.pb'),
pb_pathZ=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/z_nolep_MC_doubleB_output.pb'),
pb_pathZflessMD=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/z_MD_flavorless_output.pb'),
pb_pathZMD=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/z_nolep_MD_doubleB_output.pb'),
pb_pathWWMD=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/ww_MD_output.pb'),
pb_pathWWlepMD=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/wwlep_MD_output.pb'),
pb_pathHWWMD=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/hww_MD_output.pb'),
pb_pathHWWlepMD=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/hwwlep_MD_output.pb'),
pb_pathMDHOT=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/top_MD_HOT_output.pb'),
pb_pathWWlepMDHOT=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/wwlep_MD_HOT_output.pb'),
pb_pathWWMDHOT=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/ww_MD_HOT_output.pb'),
pb_pathHWWlepMDHOT=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/hwwlep_MD_HOT_output.pb'),
pb_pathHWWMDHOT=cms.untracked.FileInPath(
'PhysicsTools/NanoHRT/data/Image/hww_MD_HOT_output.pb'),
extex=cms.string(''),
isHotVR=cms.bool(False),
)
# src
srcJets = cms.InputTag('imageJetsAK8Puppi')
# jetID
process.looseJetIdCustomAK8 = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER16'),
quality=cms.string('LOOSE'),
),
src=srcJets)
process.tightJetIdCustomAK8 = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER17PUPPI'),
quality=cms.string('TIGHT'),
),
src=srcJets)
run2_miniAOD_80XLegacy.toModify(process.tightJetIdCustomAK8.filterParams,
version="WINTER16")
process.tightJetIdLepVetoCustomAK8 = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER17PUPPI'),
quality=cms.string('TIGHTLEPVETO'),
),
src=srcJets)
for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016:
modifier.toModify(process.tightJetIdCustomAK8.filterParams,
version="WINTER16")
modifier.toModify(process.tightJetIdLepVetoCustomAK8.filterParams,
version="WINTER16")
run2_nanoAOD_102Xv1.toModify(process.tightJetIdCustomAK8.filterParams,
version="SUMMER18PUPPI")
run2_nanoAOD_102Xv1.toModify(
process.tightJetIdLepVetoCustomAK8.filterParams,
version="SUMMER18PUPPI")
process.customAK8WithUserData = cms.EDProducer(
"PATJetUserDataEmbedder",
src=srcJets,
userFloats=cms.PSet(),
userInts=cms.PSet(
tightId=cms.InputTag("tightJetIdCustomAK8"),
tightIdLepVeto=cms.InputTag("tightJetIdLepVetoCustomAK8"),
),
)
run2_miniAOD_80XLegacy.toModify(
process.customAK8WithUserData.userInts,
looseId=cms.InputTag("looseJetIdCustomAK8"),
tightIdLepVeto=None,
)
process.customAK8Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("customAK8WithUserData"),
name=cms.string("CustomAK8Puppi"),
cut=cms.string(""),
doc=cms.string("customized ak8 puppi jets for HRT"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(False), # this is the main table for the jets
variables=cms.PSet(
P4Vars,
jetId=Var(
"userInt('tightId')*2+4*userInt('tightIdLepVeto')",
int,
doc=
"Jet ID flags bit1 is loose (always false in 2017 since it does not exist), bit2 is tight, bit3 is tightLepVeto"
),
area=Var("jetArea()",
float,
doc="jet catchment area, for JECs",
precision=10),
rawFactor=Var("1.-jecFactor('Uncorrected')",
float,
doc="1 - Factor to get back to raw pT",
precision=6),
tau1=Var("userFloat('NjettinessAK8Puppi:tau1')",
float,
doc="Nsubjettiness (1 axis)",
precision=10),
tau2=Var("userFloat('NjettinessAK8Puppi:tau2')",
float,
doc="Nsubjettiness (2 axis)",
precision=10),
tau3=Var("userFloat('NjettinessAK8Puppi:tau3')",
float,
doc="Nsubjettiness (3 axis)",
precision=10),
tau4=Var("userFloat('NjettinessAK8Puppi:tau4')",
float,
doc="Nsubjettiness (4 axis)",
precision=10),
n2b1=Var(
"userFloat('ak8PFJetsPuppiSoftDropValueMap:nb1AK8PuppiSoftDropN2')",
float,
doc="N2 with beta=1",
precision=10),
n3b1=Var(
"userFloat('ak8PFJetsPuppiSoftDropValueMap:nb1AK8PuppiSoftDropN3')",
float,
doc="N3 with beta=1",
precision=10),
msoftdrop=Var("groomedMass()",
float,
doc="Corrected soft drop mass with PUPPI",
precision=10),
#btagDeepB = Var("bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')",float,doc="DeepCSV b+bb tag discriminator",precision=10),
#btagCSVV2=Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')", float, doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)", precision=10),
btagHbb=Var(
"bDiscriminator('pfBoostedDoubleSecondaryVertexAK8BJetTags')",
float,
doc="old Higgs to BB tagger discriminator",
precision=10),
btagDDBvL=Var(
"bDiscriminator('pfMassIndependentDeepDoubleBvLJetTags:probHbb')",
float,
doc=
"DeepDoubleX (mass-decorrelated) discriminator for H(Z)->bb vs QCD",
precision=10),
btagDDCvL=Var(
"bDiscriminator('pfMassIndependentDeepDoubleCvLJetTags:probHcc')",
float,
doc=
"DeepDoubleX (mass-decorrelated) discriminator for H(Z)->cc vs QCD",
precision=10),
btagDDCvB=Var(
"bDiscriminator('pfMassIndependentDeepDoubleCvBJetTags:probHcc')",
float,
doc=
"DeepDoubleX (mass-decorrelated) discriminator for H(Z)->cc vs H(Z)->bb",
precision=10),
subJetIdx1=Var(
"?nSubjetCollections()>0 && subjets().size()>0?subjets()[0].key():-1",
int,
doc="index of first subjet"),
subJetIdx2=Var(
"?nSubjetCollections()>0 && subjets().size()>1?subjets()[1].key():-1",
int,
doc="index of second subjet"),
nBHadrons=Var("jetFlavourInfo().getbHadrons().size()",
int,
doc="number of b-hadrons"),
nCHadrons=Var("jetFlavourInfo().getcHadrons().size()",
int,
doc="number of c-hadrons"),
iW=Var("userFloat('Image:w')",
float,
doc="Image w tagger score",
precision=-1),
iMDW=Var("userFloat('ImageMD:w')",
float,
doc="Image MD w tagger score",
precision=-1),
iMDH=Var("userFloat('ImageMD:h')",
float,
doc="Image MD h tagger score",
precision=-1),
iMDHfless=Var("userFloat('ImageMD:hfless')",
float,
doc="Image MD h tagger score (without b tagging)",
precision=-1),
iMDHWW=Var("userFloat('ImageMD:hww')",
float,
doc="Image MD h->ww->qqqq tagger score",
precision=-1),
iMDHWWlep=Var("userFloat('ImageMD:hwwlep')",
float,
doc="Image MD h->ww->lnuqq tagger score",
precision=-1),
itopmass=Var("userFloat('Image:mass')",
float,
doc="Image tagger groomed mass",
precision=-1),
))
#run2_miniAOD_80XLegacy.toModify( fatJetTable.variables, n2b1 = None)
#run2_miniAOD_80XLegacy.toModify( fatJetTable.variables, n3b1 = None)
run2_miniAOD_80XLegacy.toModify(
process.customAK8Table.variables,
jetId=Var("userInt('tightId')*2+userInt('looseId')",
int,
doc="Jet ID flags bit1 is loose, bit2 is tight"))
process.customAK8Table.variables.pt.precision = 10
_pfDeepBoostedJetTagsProbs_new = [
'pfDeepBoostedJetTags:probWcq', 'pfDeepBoostedJetTags:probWqq',
'pfDeepBoostedJetTags:probZbb', 'pfDeepBoostedJetTags:probZcc',
'pfDeepBoostedJetTags:probZqq', 'pfDeepBoostedJetTags:probHbb',
'pfDeepBoostedJetTags:probHcc', 'pfDeepBoostedJetTags:probHqqqq',
'pfDeepBoostedJetTags:probQCDbb', 'pfDeepBoostedJetTags:probQCDcc'
]
_pfMassDecorrelatedDeepBoostedJetTagsProbs_new = [
'pfMassDecorrelatedDeepBoostedJetTags:probWcq',
'pfMassDecorrelatedDeepBoostedJetTags:probWqq',
'pfMassDecorrelatedDeepBoostedJetTags:probZbb',
'pfMassDecorrelatedDeepBoostedJetTags:probZcc',
'pfMassDecorrelatedDeepBoostedJetTags:probZqq',
'pfMassDecorrelatedDeepBoostedJetTags:probHbb',
'pfMassDecorrelatedDeepBoostedJetTags:probHcc',
'pfMassDecorrelatedDeepBoostedJetTags:probHqqqq',
'pfMassDecorrelatedDeepBoostedJetTags:probQCDbb',
'pfMassDecorrelatedDeepBoostedJetTags:probQCDcc'
]
# add DeepAK8 scores: nominal
for prob in _pfDeepBoostedJetTagsProbs_new:
name = prob.split(':')[1].replace('prob', 'deepTag')
setattr(
process.customAK8Table.variables, name,
Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
# add DeepAK8 scores: mass decorrelated
for prob in _pfMassDecorrelatedDeepBoostedJetTagsProbs_new:
name = prob.split(':')[1].replace('prob', 'deepTagMD')
setattr(
process.customAK8Table.variables, name,
Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
process.customAK8SubJetTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("selectedPatJetsAK8PFPuppiSoftDropPacked", "SubJets"),
cut=cms.string(""),
name=cms.string("CustomAK8PuppiSubJet"),
doc=cms.string("customized ak8 puppi subjets for HRT"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(False), # this is the main table for the jets
variables=cms.PSet(
P4Vars,
btagDeepB=Var(
"bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')",
float,
doc="DeepCSV b+bb tag discriminator",
precision=10),
btagCSVV2=Var(
"bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",
float,
doc=
" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",
precision=10),
rawFactor=Var("1.-jecFactor('Uncorrected')",
float,
doc="1 - Factor to get back to raw pT",
precision=6),
area=Var("jetArea()",
float,
doc="jet catchment area, for JECs",
precision=10),
nBHadrons=Var("jetFlavourInfo().getbHadrons().size()",
int,
doc="number of b-hadrons"),
nCHadrons=Var("jetFlavourInfo().getcHadrons().size()",
int,
doc="number of c-hadrons"),
))
process.customAK8SubJetTable.variables.pt.precision = 10
process.customAK8Constituents = cms.EDProducer(
"PatJetConstituentPtrSelector",
#src = cms.InputTag("updatedJetsAK8"),
src=cms.InputTag("customAK8WithUserData"),
cut=cms.string("pt > 170.0"))
process.customAK8ConstituentsTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("customAK8Constituents", "constituents"),
cut=cms.string(""), #we should not filter after pruning
name=cms.string("PFCandsAK8"),
doc=cms.string("interesting particles from AK8 jets"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(
False), # this is the main table for the AK8 constituents
variables=cms.PSet(
CandVars,
puppiWeight=Var("puppiWeight()",
float,
doc="Puppi weight",
precision=10),
puppiWeightNoLep=Var("puppiWeightNoLep()",
float,
doc="Puppi weight removing leptons",
precision=10),
vtxChi2=Var("?hasTrackDetails()?vertexChi2():-1",
float,
doc="vertex chi2",
precision=10),
trkChi2=Var("?hasTrackDetails()?pseudoTrack().normalizedChi2():-1",
float,
doc="normalized trk chi2",
precision=10),
dz=Var("?hasTrackDetails()?dz():-1",
float,
doc="pf dz",
precision=10),
d0=Var("?hasTrackDetails()?dxy():-1",
float,
doc="pf d0",
precision=10),
d0Err=Var("?hasTrackDetails()?dxyError():-1",
float,
doc="pf d0 err",
precision=10),
))
process.customizedAK8Task = cms.Task(
process.imageJetsAK8Puppi,
process.tightJetIdCustomAK8,
process.tightJetIdLepVetoCustomAK8,
process.customAK8WithUserData,
process.customAK8Table,
process.customAK8SubJetTable,
process.customAK8Constituents,
process.customAK8ConstituentsTable,
)
if runOnMC:
process.customGenJetAK8Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("ak8GenJetsNoNu"),
cut=cms.string("pt > 100."),
name=cms.string("CustomGenJetAK8"),
doc=cms.string("AK8 GenJets made with visible genparticles"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(
False), # this is the main table for the genjets
variables=cms.PSet(
P4Vars,
#msoftdrop = Var("groomedMass('SoftDropPuppi')",float, doc="Corrected soft drop mass with PUPPI",precision=10), #wishlist
))
process.customGenJetAK8Table.variables.pt.precision = 10
process.customGenSubJetAK8Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("ak8GenJetsNoNuSoftDrop", "SubJets"),
cut=cms.string(""),
name=cms.string("CustomGenSubJetAK8"),
doc=cms.string("AK8 Gen-SubJets made with visible genparticles"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(
False), # this is the main table for the genjets
variables=cms.PSet(P4Vars, ))
process.customGenSubJetAK8Table.variables.pt.precision = 10
process.customGenJetAK8Constituents = cms.EDProducer(
"GenJetPackedConstituentPtrSelector",
#src = cms.InputTag("slimmedGenJetsAK8"),
src=cms.InputTag("ak8GenJetsNoNu"),
cut=cms.string("pt > 100.0"))
process.customGenJetAK8ParticleTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("customGenJetAK8Constituents", "constituents"),
cut=cms.string(""), #we should not filter after pruning
name=cms.string("GenPartAK8"),
doc=cms.string("interesting gen particles from AK8 jets"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(
False), # this is the main table for the AK8 constituents
variables=cms.PSet(CandVars, ))
#process.customizedAK8Task.add(process.customGenJetAK8Table)
#process.customizedAK8Task.add(process.customGenSubJetAK8Table)
#process.customizedAK8Task.add(process.customGenJetAK8Constituents)
#process.customizedAK8Task.add(process.customGenJetAK8ParticleTable)
_customizedAK8Task_80X = process.customizedAK8Task.copy()
_customizedAK8Task_80X.replace(process.tightJetIdLepVetoCustomAK8,
process.looseJetIdCustomAK8)
run2_miniAOD_80XLegacy.toReplaceWith(process.customizedAK8Task,
_customizedAK8Task_80X)
if path is None:
process.schedule.associate(process.customizedAK8Task)
else:
getattr(process, path).associate(process.customizedAK8Task)
import FWCore.ParameterSet.Config as cms
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
unpackedPatTrigger = cms.EDProducer("PATTriggerObjectStandAloneUnpacker",
patTriggerObjectsStandAlone = cms.InputTag('slimmedPatTrigger'),
triggerResults = cms.InputTag('TriggerResults::HLT'),
unpackFilterLabels = cms.bool(True)
)
# ERA-dependent configuration
run2_miniAOD_80XLegacy.toModify(
unpackedPatTrigger,
patTriggerObjectsStandAlone = "selectedPatTrigger",
unpackFilterLabels = False
)
triggerObjectTable = cms.EDProducer("TriggerObjectTableProducer",
name= cms.string("TrigObj"),
src = cms.InputTag("unpackedPatTrigger"),
l1EG = cms.InputTag("caloStage2Digis","EGamma"),
l1Sum = cms.InputTag("caloStage2Digis","EtSum"),
l1Jet = cms.InputTag("caloStage2Digis","Jet"),
l1Muon = cms.InputTag("gmtStage2Digis","Muon"),
l1Tau = cms.InputTag("caloStage2Digis","Tau"),
selections = cms.VPSet(
cms.PSet(
name = cms.string("Electron (PixelMatched e/gamma)"), # this selects also photons for the moment!
id = cms.int32(11),
sel = cms.string("type(92) && pt > 7 && coll('hltEgammaCandidates') && filter('*PixelMatchFilter')"),
l1seed = cms.string("type(-98)"), l1deltaR = cms.double(0.3),
#l2seed = cms.string("type(92) && coll('')"), l2deltaR = cms.double(0.5),
qualityBits = cms.string("filter('*CaloIdLTrackIdLIsoVL*TrackIso*Filter') + 2*filter('hltEle*WPTight*TrackIsoFilter*') + 4*filter('hltEle*WPLoose*TrackIsoFilter') + 8*filter('*OverlapFilterIsoEle*PFTau*')"),
# MUST use the same particle collection as in selectedHadronsAndPartons
from PhysicsTools.JetMCAlgos.GenHFHadronMatcher_cff import matchGenCHadron
matchGenCHadron = matchGenCHadron.clone(
genParticles = cms.InputTag("prunedGenParticles"),
jetFlavourInfos = cms.InputTag("slimmedGenJetsFlavourInfos"),
)
## Producer for ttbar categorisation ID
from TopQuarkAnalysis.TopTools.GenTtbarCategorizer_cfi import categorizeGenTtbar
categorizeGenTtbar = categorizeGenTtbar.clone(
genJetPtMin = 20.,
genJetAbsEtaMax = 2.4,
genJets = cms.InputTag("slimmedGenJets"),
)
### Era dependent customization
run2_miniAOD_80XLegacy.toModify( matchGenBHadron, jetFlavourInfos = cms.InputTag("genJetFlavourAssociation"),)
run2_miniAOD_80XLegacy.toModify( matchGenCHadron, jetFlavourInfos = cms.InputTag("genJetFlavourAssociation"),)
##################### Tables for final output and docs ##########################
ttbarCategoryTable = cms.EDProducer("GlobalVariablesTableProducer",
variables = cms.PSet(
genTtbarId = ExtVar( cms.InputTag("categorizeGenTtbar:genTtbarId"), "int", doc = "ttbar categorization")
)
)
ttbarCatMCProducers = cms.Sequence(matchGenBHadron + matchGenCHadron + categorizeGenTtbar)
from Configuration.Eras.Modifier_run2_nanoAOD_94XMiniAODv2_cff import run2_nanoAOD_94XMiniAODv2
from Configuration.Eras.Modifier_run2_nanoAOD_94X2016_cff import run2_nanoAOD_94X2016
from PhysicsTools.NanoAOD.common_cff import *
import PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi
from math import ceil,log
# this below is used only in some eras
slimmedElectronsUpdated = cms.EDProducer("PATElectronUpdater",
src = cms.InputTag("slimmedElectrons"),
vertices = cms.InputTag("offlineSlimmedPrimaryVertices"),
computeMiniIso = cms.bool(False),
pfCandsForMiniIso = cms.InputTag("packedPFCandidates"),
miniIsoParamsB = PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.patElectrons.miniIsoParamsB, # so they're in sync
miniIsoParamsE = PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.patElectrons.miniIsoParamsE, # so they're in sync
)
run2_miniAOD_80XLegacy.toModify( slimmedElectronsUpdated, computeMiniIso = True )
electron_id_modules_WorkingPoints_nanoAOD = cms.PSet(
modules = cms.vstring(
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V2_cff',
),
WorkingPoints = cms.vstring(
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-veto",
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-loose",
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-medium",
import PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi
from math import ceil, log
# this below is used only in some eras
slimmedElectronsUpdated = cms.EDProducer(
"PATElectronUpdater",
src=cms.InputTag("slimmedElectrons"),
vertices=cms.InputTag("offlineSlimmedPrimaryVertices"),
computeMiniIso=cms.bool(False),
pfCandsForMiniIso=cms.InputTag("packedPFCandidates"),
miniIsoParamsB=PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.
patElectrons.miniIsoParamsB, # so they're in sync
miniIsoParamsE=PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.
patElectrons.miniIsoParamsE, # so they're in sync
)
run2_miniAOD_80XLegacy.toModify(slimmedElectronsUpdated, computeMiniIso=True)
electron_id_modules_WorkingPoints_nanoAOD = cms.PSet(
modules=cms.vstring(
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V2_cff',
),
WorkingPoints=cms.vstring(
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-veto",
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-loose",
"egmGsfElectronIDs:cutBasedElectronID-Fall17-94X-V2-medium",
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))
userCands = cms.PSet(
jetForLepJetVar = cms.InputTag("ptRatioRelForEle:jetForLepJetVar") # warning: Ptr is null if no match is found
),
)
# this below is used only in some eras
slimmedElectronsWithDZ = cms.EDProducer("PATElectronUpdater",
src = cms.InputTag("slimmedElectronsWithUserData"),
vertices = cms.InputTag("offlineSlimmedPrimaryVertices")
)
finalElectrons = cms.EDFilter("PATElectronRefSelector",
src = cms.InputTag("slimmedElectronsWithUserData"),
cut = cms.string("pt > 5 ")
)
run2_miniAOD_80XLegacy.toModify(finalElectrons, src = "slimmedElectronsWithDZ")
run2_nanoAOD_92X.toModify(finalElectrons, src = "slimmedElectronsWithDZ")
electronMVATTH= cms.EDProducer("EleBaseMVAValueMapProducer",
src = cms.InputTag("linkedObjects","electrons"),
weightFile = cms.FileInPath("PhysicsTools/NanoAOD/data/el_BDTG.weights.xml"),
name = cms.string("electronMVATTH"),
isClassifier = cms.bool(True),
variablesOrder = cms.vstring(["LepGood_pt","LepGood_eta","LepGood_jetNDauChargedMVASel","LepGood_miniRelIsoCharged","LepGood_miniRelIsoNeutral","LepGood_jetPtRelv2","LepGood_jetPtRatio","LepGood_jetBTagCSV","LepGood_sip3d","LepGood_dxy","LepGood_dz","LepGood_mvaIdSpring16HZZ"]),
variables = cms.PSet(
LepGood_pt = cms.string("pt"),
LepGood_eta = cms.string("eta"),
LepGood_jetNDauChargedMVASel = cms.string("userFloat('jetNDauChargedMVASel')"),
LepGood_miniRelIsoCharged = cms.string("userFloat('miniIsoChg')/pt"),
LepGood_miniRelIsoNeutral = cms.string("(userFloat('miniIsoAll')-userFloat('miniIsoChg'))/pt"),
LepGood_jetPtRelv2 = cms.string("userFloat('ptRel')"),
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
from Configuration.Eras.Modifier_run2_nanoAOD_92X_cff import run2_nanoAOD_92X
from PhysicsTools.NanoAOD.common_cff import *
import PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi
from math import ceil,log
# this below is used only in some eras
slimmedElectronsUpdated = cms.EDProducer("PATElectronUpdater",
src = cms.InputTag("slimmedElectrons"),
vertices = cms.InputTag("offlineSlimmedPrimaryVertices"),
computeMiniIso = cms.bool(False),
pfCandsForMiniIso = cms.InputTag("packedPFCandidates"),
miniIsoParamsB = PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.patElectrons.miniIsoParamsB, # so they're in sync
miniIsoParamsE = PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.patElectrons.miniIsoParamsE, # so they're in sync
)
run2_miniAOD_80XLegacy.toModify( slimmedElectronsUpdated, computeMiniIso = True )
from PhysicsTools.SelectorUtils.tools.vid_id_tools import setupVIDSelection
from RecoEgamma.ElectronIdentification.egmGsfElectronIDs_cff import *
from RecoEgamma.ElectronIdentification.heepIdVarValueMapProducer_cfi import *
electronMVAValueMapProducer.srcMiniAOD = cms.InputTag("slimmedElectrons")
run2_miniAOD_80XLegacy.toModify(electronMVAValueMapProducer, srcMiniAOD = "slimmedElectronsUpdated")
run2_nanoAOD_92X.toModify(electronMVAValueMapProducer, srcMiniAOD = "slimmedElectronsUpdated")
egmGsfElectronIDs.physicsObjectIDs = cms.VPSet()
egmGsfElectronIDs.physicsObjectSrc = cms.InputTag('slimmedElectrons')
run2_miniAOD_80XLegacy.toModify(egmGsfElectronIDs, physicsObjectSrc = "slimmedElectronsUpdated")
run2_nanoAOD_92X.toModify(egmGsfElectronIDs, physicsObjectSrc = "slimmedElectronsUpdated")
heepIDVarValueMaps.elesMiniAOD = cms.InputTag('slimmedElectrons')
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V1_TrueVtx_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1p1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V2_cff',
),
WorkingPoints=cms.vstring(
"egmPhotonIDs:cutBasedPhotonID-Fall17-94X-V2-loose",
"egmPhotonIDs:cutBasedPhotonID-Fall17-94X-V2-medium",
"egmPhotonIDs:cutBasedPhotonID-Fall17-94X-V2-tight",
))
run2_miniAOD_80XLegacy.toModify(
photon_id_modules_WorkingPoints_nanoAOD,
modules=cms.vstring(
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff',
),
WorkingPoints=cms.vstring(
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-loose",
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-medium",
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-tight",
))
run2_nanoAOD_94X2016.toModify(
photon_id_modules_WorkingPoints_nanoAOD,
modules=cms.vstring(
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
),
WorkingPoints=cms.vstring(
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-loose",
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-medium",
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-tight",
))
looseJetId = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('WINTER16'),
quality = cms.string('LOOSE'),
),
src = cms.InputTag("slimmedJets")
)
tightJetId = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('WINTER17'),
quality = cms.string('TIGHT'),
),
src = cms.InputTag("slimmedJets")
)
run2_miniAOD_80XLegacy.toModify( tightJetId.filterParams, version = "WINTER16" )
tightJetIdLepVeto = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('WINTER17'),
quality = cms.string('TIGHTLEPVETO'),
),
src = cms.InputTag("slimmedJets")
)
looseJetIdAK8 = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('WINTER16'),
quality = cms.string('LOOSE'),
),
src = cms.InputTag("slimmedJetsAK8")
import FWCore.ParameterSet.Config as cms
from Configuration.Eras.Modifier_run2_HLTconditions_2016_cff import run2_HLTconditions_2016
from Configuration.Eras.Modifier_run2_HLTconditions_2017_cff import run2_HLTconditions_2017
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
from PhysicsTools.NanoAOD.common_cff import ExtVar
import copy
unpackedPatTrigger = cms.EDProducer(
"PATTriggerObjectStandAloneUnpacker",
patTriggerObjectsStandAlone=cms.InputTag('slimmedPatTrigger'),
triggerResults=cms.InputTag('TriggerResults::HLT'),
unpackFilterLabels=cms.bool(True))
# ERA-dependent configuration
run2_miniAOD_80XLegacy.toModify(
unpackedPatTrigger,
patTriggerObjectsStandAlone="selectedPatTrigger",
unpackFilterLabels=False)
triggerObjectTable = cms.EDProducer("TriggerObjectTableProducer",
name= cms.string("TrigObj"),
src = cms.InputTag("unpackedPatTrigger"),
l1EG = cms.InputTag("caloStage2Digis","EGamma"),
l1Sum = cms.InputTag("caloStage2Digis","EtSum"),
l1Jet = cms.InputTag("caloStage2Digis","Jet"),
l1Muon = cms.InputTag("gmtStage2Digis","Muon"),
l1Tau = cms.InputTag("caloStage2Digis","Tau"),
selections = cms.VPSet(
cms.PSet(
name = cms.string("Electron (PixelMatched e/gamma)"), # this selects also photons for the moment!
id = cms.int32(11),
sel = cms.string("type(92) && pt > 7 && coll('hltEgammaCandidates') && filter('*PixelMatchFilter')"),
from PhysicsTools.NanoAOD.common_cff import *
import PhysicsTools.PatAlgos.producersLayer1.muonProducer_cfi
# this below is used only in some eras
slimmedMuonsUpdated = cms.EDProducer(
"PATMuonUpdater",
src=cms.InputTag("slimmedMuons"),
vertices=cms.InputTag("offlineSlimmedPrimaryVertices"),
computeMiniIso=cms.bool(False),
pfCandsForMiniIso=cms.InputTag("packedPFCandidates"),
miniIsoParams=PhysicsTools.PatAlgos.producersLayer1.muonProducer_cfi.
patMuons.miniIsoParams, # so they're in sync
recomputeMuonBasicSelectors=cms.bool(False),
)
run2_miniAOD_80XLegacy.toModify(slimmedMuonsUpdated,
computeMiniIso=True,
recomputeMuonBasicSelectors=True)
isoForMu = cms.EDProducer(
"MuonIsoValueMapProducer",
src=cms.InputTag("slimmedMuons"),
relative=cms.bool(False),
rho_MiniIso=cms.InputTag("fixedGridRhoFastjetAll"),
EAFile_MiniIso=cms.FileInPath(
"PhysicsTools/NanoAOD/data/effAreaMuons_cone03_pfNeuHadronsAndPhotons_94X.txt"
),
)
run2_miniAOD_80XLegacy.toModify(
isoForMu,
src="slimmedMuonsUpdated",
EAFile_MiniIso=
import PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi
from math import ceil, log
# this below is used only in some eras
slimmedElectronsUpdated = cms.EDProducer(
"PATElectronUpdater",
src=cms.InputTag("slimmedElectrons"),
vertices=cms.InputTag("offlineSlimmedPrimaryVertices"),
computeMiniIso=cms.bool(False),
pfCandsForMiniIso=cms.InputTag("packedPFCandidates"),
miniIsoParamsB=PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.
patElectrons.miniIsoParamsB, # so they're in sync
miniIsoParamsE=PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi.
patElectrons.miniIsoParamsE, # so they're in sync
)
run2_miniAOD_80XLegacy.toModify(slimmedElectronsUpdated, computeMiniIso=True)
from PhysicsTools.SelectorUtils.tools.vid_id_tools import setupVIDSelection
from RecoEgamma.ElectronIdentification.egmGsfElectronIDs_cff import *
from RecoEgamma.ElectronIdentification.heepIdVarValueMapProducer_cfi import *
electronMVAValueMapProducer.srcMiniAOD = cms.InputTag("slimmedElectrons")
run2_miniAOD_80XLegacy.toModify(electronMVAValueMapProducer,
srcMiniAOD="slimmedElectronsUpdated")
run2_nanoAOD_92X.toModify(electronMVAValueMapProducer,
srcMiniAOD="slimmedElectronsUpdated")
egmGsfElectronIDs.physicsObjectIDs = cms.VPSet()
egmGsfElectronIDs.physicsObjectSrc = cms.InputTag('slimmedElectrons')
run2_miniAOD_80XLegacy.toModify(egmGsfElectronIDs,
physicsObjectSrc="slimmedElectronsUpdated")
import FWCore.ParameterSet.Config as cms
from RecoEcal.EgammaClusterProducers.particleFlowSuperClusterECAL_cfi import *
particleFlowSuperClusterOOTECAL = particleFlowSuperClusterECAL.clone(
PFClusters = "particleFlowClusterOOTECAL",
ESAssociation = "particleFlowClusterOOTECAL",
PFBasicClusterCollectionBarrel = "particleFlowBasicClusterOOTECALBarrel",
PFSuperClusterCollectionBarrel = "particleFlowSuperClusterOOTECALBarrel",
PFBasicClusterCollectionEndcap = "particleFlowBasicClusterOOTECALEndcap",
PFSuperClusterCollectionEndcap = "particleFlowSuperClusterOOTECALEndcap",
PFBasicClusterCollectionPreshower = "particleFlowBasicClusterOOTECALPreshower",
PFSuperClusterCollectionEndcapWithPreshower = "particleFlowSuperClusterOOTECALEndcapWithPreshower",
## modification for Algo
isOOTCollection = True,
barrelRecHits = "ecalRecHit:EcalRecHitsEB",
endcapRecHits = "ecalRecHit:EcalRecHitsEE"
)
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(
particleFlowSuperClusterOOTECAL,
barrelRecHits = "reducedEcalRecHitsEB",
endcapRecHits = "reducedEcalRecHitsEE"
)
run2_miniAOD_80XLegacy.toModify(
particleFlowSuperClusterOOTECAL.regressionConfig,
ecalRecHitsEB = "reducedEcalRecHitsEB",
ecalRecHitsEE = "reducedEcalRecHitsEE"
)
import FWCore.ParameterSet.Config as cms
_correctionFile2016Legacy = "EgammaAnalysis/ElectronTools/data/ScalesSmearings/Legacy2016_07Aug2017_FineEtaR9_v3_ele_unc"
_correctionFile2017Nov17 = "EgammaAnalysis/ElectronTools/data/ScalesSmearings/Run2017_17Nov2017_v1_ele_unc"
_correctionFile2017UL = "EgammaAnalysis/ElectronTools/data/ScalesSmearings/Run2017_24Feb2020_runEtaR9Gain_v2"
calibratedEgammaSettings = cms.PSet(
minEtToCalibrate=cms.double(5.0),
semiDeterministic=cms.bool(True),
correctionFile=cms.string(_correctionFile2017UL),
recHitCollectionEB=cms.InputTag('reducedEcalRecHitsEB'),
recHitCollectionEE=cms.InputTag('reducedEcalRecHitsEE'),
produceCalibratedObjs=cms.bool(True))
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(calibratedEgammaSettings,
correctionFile=_correctionFile2016Legacy)
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(calibratedEgammaSettings,
correctionFile=_correctionFile2017Nov17)
calibratedEgammaPatSettings = calibratedEgammaSettings.clone(
recHitCollectionEB=cms.InputTag('reducedEgamma', 'reducedEBRecHits'),
recHitCollectionEE=cms.InputTag('reducedEgamma', 'reducedEERecHits'))
ecalTrkCombinationRegression = cms.PSet(
ecalTrkRegressionConfig=cms.PSet(
rangeMinLowEt=cms.double(-1.),
rangeMaxLowEt=cms.double(3.0),
rangeMinHighEt=cms.double(-1.),
jetId = Var("userInt('tightId')*2+userInt('looseId')",int,doc="Jet ID flags bit1 is loose, bit2 is tight"),
qgl = Var("userFloat('QGTagger:qgLikelihood')",float,doc="Quark vs Gluon likelihood discriminator",precision=10),
nConstituents = Var("numberOfDaughters()",int,doc="Number of particles in the jet"),
rawFactor = Var("1.-jecFactor('Uncorrected')",float,doc="1 - Factor to get back to raw pT",precision=6),
chHEF = Var("chargedHadronEnergy()/energy()", float, doc="charged Hadron Energy Fraction", precision= 6),
neHEF = Var("neutralHadronEnergy()/energy()", float, doc="neutral Hadron Energy Fraction", precision= 6),
chEmEF = Var("chargedEmEnergy()/energy()", float, doc="charged Electromagnetic Energy Fraction", precision= 6),
neEmEF = Var("neutralEmEnergy()/energy()", float, doc="charged Electromagnetic EnergyFraction", precision= 6),
)
)
#jets are not as precise as muons
jetTable.variables.pt.precision=10
### Era dependent customization
run2_miniAOD_80XLegacy.toModify( slimmedJetsWithUserData, userFloats=cms.PSet(qgl=cms.InputTag('qgtagger80x:qgLikelihood')))
run2_miniAOD_80XLegacy.toModify( jetTable.variables.qgl, expr="userFloat('qgl')" )
bjetMVA= cms.EDProducer("BJetEnergyRegressionMVA",
src = cms.InputTag("linkedObjects","jets"),
pvsrc = cms.InputTag("offlineSlimmedPrimaryVertices"),
svsrc = cms.InputTag("slimmedSecondaryVertices"),
weightFile = cms.FileInPath("PhysicsTools/NanoAOD/data/bjet-regression.xml"),
name = cms.string("JetReg"),
isClassifier = cms.bool(False),
variablesOrder = cms.vstring(["Jet_pt","nPVs","Jet_eta","Jet_mt","Jet_leadTrackPt","Jet_leptonPtRel","Jet_leptonPt","Jet_leptonDeltaR","Jet_neHEF","Jet_neEmEF","Jet_vtxPt","Jet_vtxMass","Jet_vtx3dL","Jet_vtxNtrk","Jet_vtx3deL"]),
variables = cms.PSet(
Jet_pt = cms.string("pt"),
Jet_eta = cms.string("eta"),
Jet_mt = cms.string("mt"),
Jet_leptonPt = cms.string("?overlaps('muons').size()>0?overlaps('muons')[0].pt():(?overlaps('electrons').size()>0?overlaps('electrons')[0].pt():0)"),
modules=cms.vstring(
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V1_TrueVtx_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1_cff',
),
WorkingPoints=cms.vstring(
# can run only for one working point for the moment, as the working points are not nested
# "egmPhotonIDs:cutBasedPhotonID-Fall17-94X-V1-loose",
"egmPhotonIDs:cutBasedPhotonID-Fall17-94X-V1-medium",
# "egmPhotonIDs:cutBasedPhotonID-Fall17-94X-V1-tight",
))
run2_miniAOD_80XLegacy.toModify(
_photon_id_vid_modules_WorkingPoints,
modules=cms.vstring(
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff',
),
WorkingPoints=cms.vstring(
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-loose",
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-medium",
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-tight",
))
_bitmapVIDForPho_docstring = ''
for modname in _photon_id_vid_modules_WorkingPoints.modules:
ids = __import__(modname, globals(), locals(), ['idName', 'cutFlow'])
for name in dir(ids):
_id = getattr(ids, name)
if hasattr(_id, 'idName') and hasattr(_id, 'cutFlow'):
setupVIDSelection(egmPhotonIDs, _id)
if (len(_photon_id_vid_modules_WorkingPoints.WorkingPoints) > 0
and _id.idName == _photon_id_vid_modules_WorkingPoints.
cutID_Spring16_loose = cms.InputTag("egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-loose"),
cutID_Spring16_medium = cms.InputTag("egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-medium"),
cutID_Spring16_tight = cms.InputTag("egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-tight"),
mvaID_Spring16nonTrigV1_WP90 = cms.InputTag("egmPhotonIDs:mvaPhoID-Spring16-nonTrig-V1-wp90"),
mvaID_Spring16nonTrigV1_WP80 = cms.InputTag("egmPhotonIDs:mvaPhoID-Spring16-nonTrig-V1-wp80"),
),
userInts = cms.PSet(
VIDNestedWPBitmap = cms.InputTag("bitmapVIDForPho"),
VIDNestedWPBitmap_Spring16V2p2 = cms.InputTag("bitmapVIDForPhoSpring16V2p2"),
seedGain = cms.InputTag("seedGainPho"),
),
)
run2_miniAOD_80XLegacy.toModify(slimmedPhotonsWithUserData.userFloats,
ecalEnergyErrPostCorrNew = cms.InputTag("calibratedPatPhotons80XLegacy","ecalEnergyErrPostCorr"),
ecalEnergyPreCorrNew = cms.InputTag("calibratedPatPhotons80XLegacy","ecalEnergyPreCorr"),
ecalEnergyPostCorrNew = cms.InputTag("calibratedPatPhotons80XLegacy","ecalEnergyPostCorr"),
)
run2_nanoAOD_94XMiniAODv1.toModify(slimmedPhotonsWithUserData.userFloats,
ecalEnergyErrPostCorrNew = cms.InputTag("calibratedPatPhotons94Xv1","ecalEnergyErrPostCorr"),
ecalEnergyPreCorrNew = cms.InputTag("calibratedPatPhotons94Xv1","ecalEnergyPreCorr"),
ecalEnergyPostCorrNew = cms.InputTag("calibratedPatPhotons94Xv1","ecalEnergyPostCorr"),
)
(~(run2_miniAOD_80XLegacy | run2_nanoAOD_94X2016 | run2_nanoAOD_94XMiniAODv1 | run2_nanoAOD_94XMiniAODv2)).toModify(slimmedPhotonsWithUserData.userFloats,
ecalEnergyErrPostCorrNew = cms.InputTag("calibratedPatPhotons102Xv1","ecalEnergyErrPostCorr"),
ecalEnergyPreCorrNew = cms.InputTag("calibratedPatPhotons102Xv1","ecalEnergyPreCorr"),
ecalEnergyPostCorrNew = cms.InputTag("calibratedPatPhotons102Xv1","ecalEnergyPostCorr"),
)
finalPhotons = cms.EDFilter("PATPhotonRefSelector",
src = cms.InputTag("slimmedPhotonsWithUserData"),
import FWCore.ParameterSet.Config as cms
from RecoParticleFlow.PFClusterProducer.particleFlowRecHitECAL_cfi import *
particleFlowRecHitOOTECAL = particleFlowRecHitECAL.clone()
particleFlowRecHitOOTECAL.producers[0].qualityTests[1].timingCleaning = False
particleFlowRecHitOOTECAL.producers[1].qualityTests[1].timingCleaning = False
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
## EB
run2_miniAOD_80XLegacy.toModify(
particleFlowRecHitOOTECAL.producers[0],
src = "reducedEcalRecHitsEB",
srFlags = ""
)
## EE
run2_miniAOD_80XLegacy.toModify(
particleFlowRecHitOOTECAL.producers[1],
src = "reducedEcalRecHitsEE",
srFlags = ""
)
import FWCore.ParameterSet.Config as cms
particleFlowRecHitPS = cms.EDProducer("PFRecHitProducer",
navigator = cms.PSet(
name = cms.string("PFRecHitPreshowerNavigator")
),
producers = cms.VPSet(
cms.PSet(
name = cms.string("PFPSRecHitCreator"),
src = cms.InputTag("ecalPreshowerRecHit","EcalRecHitsES"),
qualityTests = cms.VPSet(
cms.PSet(
name = cms.string("PFRecHitQTestThreshold"),
threshold = cms.double(0.)
),
cms.PSet(
name = cms.string("PFRecHitQTestES"),
cleaningThreshold = cms.double(0.),
topologicalCleaning = cms.bool(True)
)
)
)
)
)
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(
particleFlowRecHitPS.producers[0],
src = "reducedEcalRecHitsES"
)
def nanoAOD_customizeCommon(process):
makePuppiesFromMiniAOD(process, True)
process.puppiNoLep.useExistingWeights = True
process.puppi.useExistingWeights = True
run2_nanoAOD_106Xv1.toModify(process.puppiNoLep, useExistingWeights=False)
run2_nanoAOD_106Xv1.toModify(process.puppi, useExistingWeights=False)
process = nanoAOD_activateVID(process)
nanoAOD_addDeepInfo_switch = cms.PSet(
nanoAOD_addDeepBTag_switch=cms.untracked.bool(False),
nanoAOD_addDeepFlavourTag_switch=cms.untracked.bool(False),
)
run2_miniAOD_80XLegacy.toModify(
nanoAOD_addDeepInfo_switch,
nanoAOD_addDeepBTag_switch=cms.untracked.bool(True))
for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016, run2_nanoAOD_94XMiniAODv1, run2_nanoAOD_94XMiniAODv2:
modifier.toModify(
nanoAOD_addDeepInfo_switch,
nanoAOD_addDeepFlavourTag_switch=cms.untracked.bool(True))
process = nanoAOD_addDeepInfo(
process,
addDeepBTag=nanoAOD_addDeepInfo_switch.nanoAOD_addDeepBTag_switch,
addDeepFlavour=nanoAOD_addDeepInfo_switch.
nanoAOD_addDeepFlavourTag_switch)
nanoAOD_addDeepInfoAK8_switch = cms.PSet(
nanoAOD_addDeepBTag_switch=cms.untracked.bool(False),
nanoAOD_addDeepBoostedJet_switch=cms.untracked.bool(False),
nanoAOD_addDeepDoubleX_switch=cms.untracked.bool(False),
nanoAOD_addDeepDoubleXV2_switch=cms.untracked.bool(False),
nanoAOD_addParticleNet_switch=cms.untracked.bool(False),
jecPayload=cms.untracked.string('AK8PFPuppi'))
# deepAK8 should not run on 80X, that contains ak8PFJetsCHS jets
run2_miniAOD_80XLegacy.toModify(nanoAOD_addDeepInfoAK8_switch,
nanoAOD_addDeepBTag_switch=True,
jecPayload='AK8PFchs')
# for 94X and 102X samples: needs to run DeepAK8, DeepDoubleX and ParticleNet
(run2_nanoAOD_94X2016 | run2_nanoAOD_94XMiniAODv1
| run2_nanoAOD_94XMiniAODv2 | run2_nanoAOD_102Xv1).toModify(
nanoAOD_addDeepInfoAK8_switch,
nanoAOD_addDeepBoostedJet_switch=True,
nanoAOD_addDeepDoubleX_switch=True,
nanoAOD_addDeepDoubleXV2_switch=True,
nanoAOD_addParticleNet_switch=True,
)
# for 106Xv1: only needs to run ParticleNet and DDXV2; DeepAK8, DeepDoubleX are already in MiniAOD
run2_nanoAOD_106Xv1.toModify(
nanoAOD_addDeepInfoAK8_switch,
nanoAOD_addDeepDoubleXV2_switch=True,
nanoAOD_addParticleNet_switch=True,
)
process = nanoAOD_addDeepInfoAK8(
process,
addDeepBTag=nanoAOD_addDeepInfoAK8_switch.nanoAOD_addDeepBTag_switch,
addDeepBoostedJet=nanoAOD_addDeepInfoAK8_switch.
nanoAOD_addDeepBoostedJet_switch,
addDeepDoubleX=nanoAOD_addDeepInfoAK8_switch.
nanoAOD_addDeepDoubleX_switch,
addDeepDoubleXV2=nanoAOD_addDeepInfoAK8_switch.
nanoAOD_addDeepDoubleXV2_switch,
addParticleNet=nanoAOD_addDeepInfoAK8_switch.
nanoAOD_addParticleNet_switch,
jecPayload=nanoAOD_addDeepInfoAK8_switch.jecPayload)
(run2_nanoAOD_94XMiniAODv1 | run2_nanoAOD_94X2016
| run2_nanoAOD_94XMiniAODv2 | run2_nanoAOD_102Xv1
| run2_nanoAOD_106Xv1).toModify(process, lambda p: nanoAOD_addTauIds(p))
return process
))
_tauPlots80X.append(
Plot1D(
'idMVAoldDMdR03', 'idMVAoldDMdR03', 64, -0.5, 63.5,
'IsolationMVArun2v1DBdR03oldDMwLT ID working point: bitmask 1 = VLoose, 2 = Loose, 4 = Medium, 8 = Tight, 16 = VTight, 32 = VVTight'
))
_tauPlots80X.append(
Plot1D('rawMVAnewDM', 'rawMVAnewDM', 20, -1, 1,
'byIsolationMVArun2v1DBnewDMwLT raw output discriminator'))
_tauPlots80X.append(
Plot1D('rawMVAoldDMdR03', 'rawMVAoldDMdR03', 20, -1, 1,
'byIsolationMVArun2v1DBdR03oldDMwLT raw output discriminator'))
_vplots80X.Tau.plots = _tauPlots80X
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(nanoDQM, vplots=_vplots80X)
_METFixEE2017_DQMentry = nanoDQM.vplots.MET.clone()
_METFixEE2017_plots = cms.VPSet()
for plot in _METFixEE2017_DQMentry.plots:
if plot.name.value().find("fiducial") > -1: continue
_METFixEE2017_plots.append(plot)
_METFixEE2017_DQMentry.plots = _METFixEE2017_plots
from Configuration.Eras.Modifier_run2_nanoAOD_94XMiniAODv1_cff import run2_nanoAOD_94XMiniAODv1
from Configuration.Eras.Modifier_run2_nanoAOD_94XMiniAODv2_cff import run2_nanoAOD_94XMiniAODv2
for modifier in run2_nanoAOD_94XMiniAODv1, run2_nanoAOD_94XMiniAODv2:
modifier.toModify(nanoDQM.vplots, METFixEE2017=_METFixEE2017_DQMentry)
_Electron_plots_2016 = copy.deepcopy(nanoDQM.vplots.Electron.plots)
_Electron_plots_2016.append(
Plot1D('cutBased_HLTPreSel', 'cutBased_HLTPreSel', 2, -0.5, 1.5,
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V1_TrueVtx_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1_cff',
),
WorkingPoints = cms.vstring(
# can run only for one working point for the moment, as the working points are not nested
# "egmPhotonIDs:cutBasedPhotonID-Fall17-94X-V1-loose",
"egmPhotonIDs:cutBasedPhotonID-Fall17-94X-V1-medium",
# "egmPhotonIDs:cutBasedPhotonID-Fall17-94X-V1-tight",
)
)
run2_miniAOD_80XLegacy.toModify(_photon_id_vid_modules_WorkingPoints,
modules = cms.vstring(
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff',
),
WorkingPoints = cms.vstring(
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-loose",
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-medium",
"egmPhotonIDs:cutBasedPhotonID-Spring16-V2p2-tight",
)
)
_bitmapVIDForPho_docstring = ''
for modname in _photon_id_vid_modules_WorkingPoints.modules:
ids= __import__(modname, globals(), locals(), ['idName','cutFlow'])
for name in dir(ids):
_id = getattr(ids,name)
if hasattr(_id,'idName') and hasattr(_id,'cutFlow'):
setupVIDSelection(egmPhotonIDs,_id)
if (len(_photon_id_vid_modules_WorkingPoints.WorkingPoints)>0 and _id.idName==_photon_id_vid_modules_WorkingPoints.WorkingPoints[0].split(':')[-1]):
_bitmapVIDForPho_docstring = 'VID compressed bitmap (%s), %d bits per cut'%(','.join([cut.cutName.value() for cut in _id.cutFlow]),int(ceil(log(len(_photon_id_vid_modules_WorkingPoints.WorkingPoints)+1,2))))
epCombConfig=ecalTrkCombinationRegression,
uncertFunc=cms.PSet(name=cms.string("UncertFuncV1"),
lowEt=cms.double(43.5),
highEt=cms.double(46.5),
lowEtUncert=cms.double(0.002),
highEtUncert=cms.double(-0.002)))
def appendReducedEgammaEnergyScaleAndSmearingModifier(modifiers):
modifiers.append(reducedEgammaEnergyScaleAndSmearingModifier)
def prependEgamma8XObjectUpdateModifier(modifiers):
modifiers.insert(0, egamma8XObjectUpdateModifier)
def appendEgamma8XLegacyAppendableModifiers(modifiers):
modifiers.append(reducedEgammaEnergyScaleAndSmearingModifier)
modifiers.append(egamma8XLegacyEtScaleSysModifier)
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(
egamma_modifications, appendReducedEgammaEnergyScaleAndSmearingModifier)
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(egamma_modifications,
appendEgamma8XLegacyAppendableModifiers)
run2_miniAOD_80XLegacy.toModify(egamma_modifications,
prependEgamma8XObjectUpdateModifier)
# this below is used only in some eras
slimmedMuonsUpdated = cms.EDProducer(
"PATMuonUpdater",
src=cms.InputTag("slimmedMuons"),
vertices=cms.InputTag("offlineSlimmedPrimaryVertices"),
computeMiniIso=cms.bool(False),
pfCandsForMiniIso=cms.InputTag("packedPFCandidates"),
miniIsoParams=PhysicsTools.PatAlgos.producersLayer1.muonProducer_cfi.
patMuons.miniIsoParams, # so they're in sync
recomputeMuonBasicSelectors=cms.bool(False),
)
run2_nanoAOD_92X.toModify(slimmedMuonsUpdated,
recomputeMuonBasicSelectors=True)
run2_miniAOD_80XLegacy.toModify(slimmedMuonsUpdated,
computeMiniIso=True,
recomputeMuonBasicSelectors=True)
isoForMu = cms.EDProducer(
"MuonIsoValueMapProducer",
src=cms.InputTag("slimmedMuons"),
relative=cms.bool(False),
rho_MiniIso=cms.InputTag("fixedGridRhoFastjetAll"),
EAFile_MiniIso=cms.FileInPath(
"PhysicsTools/NanoAOD/data/effAreaMuons_cone03_pfNeuHadronsAndPhotons_94X.txt"
),
)
run2_miniAOD_80XLegacy.toModify(
isoForMu,
src="slimmedMuonsUpdated",
EAFile_MiniIso=
pfEgammaCandidates="",
chargedHadronIsolation=cms.InputTag(""),
neutralHadronIsolation=cms.InputTag(""),
photonIsolation=cms.InputTag(""),
pfECALClusIsolation=cms.InputTag(
"ootPhotonEcalPFClusterIsolationProducer"),
pfHCALClusIsolation=cms.InputTag(
"ootPhotonHcalPFClusterIsolationProducer"),
valueMapPhotons="")
del ootPhotons.regressionConfig
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(ootPhotonsTmp,
barrelEcalHits="reducedEcalRecHitsEB",
endcapEcalHits="reducedEcalRecHitsEE",
preshowerHits="reducedEcalRecHitsES",
hcalTowers="")
run2_miniAOD_80XLegacy.toModify(ootPhotons,
barrelEcalHits="reducedEcalRecHitsEB",
endcapEcalHits="reducedEcalRecHitsEE",
preshowerHits="reducedEcalRecHitsES",
hcalTowers="",
pfECALClusIsolation=None,
pfHCALClusIsolation=None)
run2_miniAOD_80XLegacy.toModify(
ootPhotonsTmp.isolationSumsCalculatorSet,
barrelEcalRecHitCollection="reducedEcalRecHitsEB",
endcapEcalRecHitCollection="reducedEcalRecHitsEE",
HcalRecHitCollection="")
run2_miniAOD_80XLegacy.toModify(
def nanoAOD_customizeCommon(process):
run2_miniAOD_80XLegacy.toModify(process, nanoAOD_addDeepBTagFor80X)
return process
from Configuration.Eras.Modifier_run2_nanoAOD_94XMiniAODv1_cff import run2_nanoAOD_94XMiniAODv1
from Configuration.Eras.Modifier_run2_nanoAOD_94XMiniAODv2_cff import run2_nanoAOD_94XMiniAODv2
from Configuration.Eras.Modifier_run2_nanoAOD_102Xv1_cff import run2_nanoAOD_102Xv1
from PhysicsTools.NanoAOD.common_cff import *
import PhysicsTools.PatAlgos.producersLayer1.muonProducer_cfi
# this below is used only in some eras
slimmedMuonsUpdated = cms.EDProducer("PATMuonUpdater",
src = cms.InputTag("slimmedMuons"),
vertices = cms.InputTag("offlineSlimmedPrimaryVertices"),
computeMiniIso = cms.bool(False),
pfCandsForMiniIso = cms.InputTag("packedPFCandidates"),
miniIsoParams = PhysicsTools.PatAlgos.producersLayer1.muonProducer_cfi.patMuons.miniIsoParams, # so they're in sync
recomputeMuonBasicSelectors = cms.bool(False),
)
run2_miniAOD_80XLegacy.toModify( slimmedMuonsUpdated, computeMiniIso = True, recomputeMuonBasicSelectors = True )
isoForMu = cms.EDProducer("MuonIsoValueMapProducer",
src = cms.InputTag("slimmedMuons"),
relative = cms.bool(False),
rho_MiniIso = cms.InputTag("fixedGridRhoFastjetAll"),
EAFile_MiniIso = cms.FileInPath("PhysicsTools/NanoAOD/data/effAreaMuons_cone03_pfNeuHadronsAndPhotons_94X.txt"),
)
run2_miniAOD_80XLegacy.toModify(isoForMu, src = "slimmedMuonsUpdated", EAFile_MiniIso = "PhysicsTools/NanoAOD/data/effAreaMuons_cone03_pfNeuHadronsAndPhotons_80X.txt")
run2_nanoAOD_94X2016.toModify(isoForMu, EAFile_MiniIso = "PhysicsTools/NanoAOD/data/effAreaMuons_cone03_pfNeuHadronsAndPhotons_80X.txt")
ptRatioRelForMu = cms.EDProducer("MuonJetVarProducer",
srcJet = cms.InputTag("updatedJets"),
srcLep = cms.InputTag("slimmedMuons"),
srcVtx = cms.InputTag("offlineSlimmedPrimaryVertices"),
)
