diff --git a/Configuration/PyReleaseValidation/python/relval_2017.py b/Configuration/PyReleaseValidation/python/relval_2017.py index 3f19c035eabfc..8956994237dd5 100644 --- a/Configuration/PyReleaseValidation/python/relval_2017.py +++ b/Configuration/PyReleaseValidation/python/relval_2017.py @@ -16,14 +16,14 @@ # 2017 (ele guns 10, 35, 1000; pho guns 10, 35; mu guns 1, 10, 100, 1000, QCD 3TeV, QCD Flat) # (ZMM, TTbar, ZEE, MinBias, TTbar PU, ZEE PU, TTbar design) # (TTbar trackingOnly, trackingRun2, trackingOnlyRun2, trackingLowPU, pixelTrackingOnly) -# (TTbar PU with JME NanoAOD, disable for now due to Run-3 Nano-Prompt preparation) +# (TTbar PU with JME NanoAOD) # 2018 (ele guns 10, 35, 1000; pho guns 10, 35; mu guns 1, 10, 100, 1000, QCD 3TeV, QCD Flat) # (pho guns 10, 35 with photonDRN enabled) # 2018 (ZMM, TTbar, ZEE, MinBias, TTbar PU, ZEE PU, TTbar design) # (TTbar trackingOnly, pixelTrackingOnly) # (HE collapse: TTbar, TTbar PU, TTbar design) # (ParkingBPH: TTbar) -# (TTbar PU with JME NanoAOD, disable for now due to Run-3 Nano-Prompt preparation) +# (TTbar PU with JME NanoAOD) # (Patatrack pixel-only: ZMM - on CPU: quadruplets, triplets) # (Patatrack pixel-only: TTbar - on CPU: quadruplets, triplets) # (Patatrack ECAL-only: TTbar - on CPU) @@ -33,6 +33,7 @@ # (ele guns 10, 35, 1000; pho guns 10, 35; mu guns 1, 10, 100, 1000, QCD 3TeV, QCD Flat) # (ZMM, TTbar, ZEE, MinBias, TTbar PU, TTbar PU premix, ZEE PU, TTbar design, GluGluTo2Jets, GluGluTo2Jets PU) # (TTbar trackingOnly, pixelTrackingOnly, trackingMkFit, trackdnn) +# (TTbar with JME NanoAOD) # (Patatrack pixel-only: ZMM - on CPU: quadruplets, triplets) # (Patatrack pixel-only: TTbar - on CPU: quadruplets, triplets) # (Patatrack ECAL-only: TTbar - on CPU) @@ -49,14 +50,14 @@ numWFIB = [10001.0,10002.0,10003.0,10004.0,10005.0,10006.0,10007.0,10008.0,10009.0,10059.0,10071.0, 10042.0,10024.0,10025.0,10026.0,10023.0,10224.0,10225.0,10424.0, 10024.1,10024.2,10024.3,10024.4,10024.5, - #10224.15, + 10224.15, 10801.0,10802.0,10803.0,10804.0,10805.0,10806.0,10807.0,10808.0,10809.0,10859.0,10871.0, 10804.31, 10805.31, 10842.0,10824.0,10825.0,10826.0,10823.0,11024.0,11025.0,11224.0, 10824.1,10824.5, 10824.6,11024.6,11224.6, 10824.8, - #11024.15, + 11024.15, 10842.501,10842.505, 10824.501,10824.505, 10824.511, @@ -66,6 +67,7 @@ 11601.0,11602.0,11603.0,11604.0,11605.0,11606.0,11607.0,11608.0,11609.0,11630.0,11643.0, 11650.0,11634.0,11646.0,11640.0,11834.0,11834.99,11846.0,12034.0,11725.0,11925.0, 11634.1,11634.5,11634.7,11634.71,11634.72,11634.91, + 11634.15, 11650.501,11650.505, 11634.501,11634.505, 11634.511, diff --git a/Configuration/PyReleaseValidation/python/relval_pileup.py b/Configuration/PyReleaseValidation/python/relval_pileup.py index 55b30ebadced3..8f2fd8794c9d9 100644 --- a/Configuration/PyReleaseValidation/python/relval_pileup.py +++ b/Configuration/PyReleaseValidation/python/relval_pileup.py @@ -39,7 +39,7 @@ workflows[25202]=['',['TTbar_13','DIGIUP15_PU25','RECOUP15_PU25','HARVESTUP15_PU25','NANOUP15_PU25']] workflows[25202.1]=['',['TTbar_13','DIGIUP15APVSimu_PU25','RECOUP15_PU25','HARVESTUP15_PU25']] workflows[25202.2]=['',['TTbar_13','DIGIUP15APVSimu_PU25','RECOUP15_PU25_HIPM','HARVESTUP15_PU25']] -#workflows[25202.15]=['',['TTbar_13','DIGIUP15_PU25','RECOUP15_PU25','HARVESTUP15_PU25','NANOUP15MC_PU25_JME']] #JME NanoAOD, disable until Nano-Run3 prompt dev is done +workflows[25202.15]=['',['TTbar_13','DIGIUP15_PU25','RECOUP15_PU25','HARVESTUP15_PU25','NANOUP15MC_PU25_JME']] workflows[25203]=['',['H125GGgluonfusion_13','DIGIUP15_PU25','RECOUP15_PU25','HARVESTUP15_PU25','NANOUP15_PU25']] workflows[25204]=['',['QQH1352T_13','DIGIUP15_PU25','RECOUP15_PU25','HARVESTUP15_PU25']] workflows[25205]=['',['ZTT_13','DIGIUP15_PU25','RECOUP15_PU25','HARVESTUP15_PU25','NANOUP15_PU25']] diff --git a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py index 6d1e641ca683c..a7c964bf7cdad 100644 --- a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py +++ b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py @@ -1504,10 +1504,11 @@ def setup_(self, step, stepName, stepDict, k, properties): if 'Nano' in step: stepDict[stepName][k] = merge([{'--customise': 'PhysicsTools/NanoAOD/custom_jme_cff.PrepJMECustomNanoAOD_MC'}, stepDict[step][k]]) def condition(self, fragment, stepList, key, hasHarvest): - return fragment=="TTbar_13" and ('2017' in key or '2018' in key) + return (fragment=="TTbar_13" or fragment=="TTbar_14TeV") and ('2017' in key or '2018' in key or '2021' in key) and ('FS' not in key) upgradeWFs['JMENano'] = UpgradeWorkflow_JMENano( steps = [ 'Nano', + 'RecoNano', ], PU = [], suffix = '_JMENano', diff --git a/PhysicsTools/NanoAOD/python/custom_jme_cff.py b/PhysicsTools/NanoAOD/python/custom_jme_cff.py index 96ac4e5187f66..44123012ddc1c 100644 --- a/PhysicsTools/NanoAOD/python/custom_jme_cff.py +++ b/PhysicsTools/NanoAOD/python/custom_jme_cff.py @@ -8,8 +8,9 @@ from RecoJets.JetProducers.PileupJetID_cfi import _chsalgos_81x, _chsalgos_94x, _chsalgos_102x from PhysicsTools.NanoAOD.common_cff import Var, P4Vars -from PhysicsTools.NanoAOD.jets_cff import jetTable, jetCorrFactorsNano, updatedJets, finalJets, qgtagger, hfJetShowerShapeforNanoAOD -from PhysicsTools.NanoAOD.jets_cff import genJetTable, genJetFlavourAssociation, genJetFlavourTable +from PhysicsTools.NanoAOD.jetsAK4_CHS_cff import jetTable, jetCorrFactorsNano, updatedJets, finalJets, qgtagger, hfJetShowerShapeforNanoAOD +from PhysicsTools.NanoAOD.jetsAK4_Puppi_cff import jetPuppiTable, jetPuppiCorrFactorsNano, updatedJetsPuppi, updatedJetsPuppiWithUserData +from PhysicsTools.NanoAOD.jetMC_cff import genJetTable, genJetFlavourAssociation, genJetFlavourTable from PhysicsTools.PatAlgos.tools.jetCollectionTools import GenJetAdder, RecoJetAdder from PhysicsTools.PatAlgos.tools.jetTools import supportedJetAlgos @@ -68,7 +69,7 @@ } # # By default, these collections are saved in the main NanoAODs: -# - ak4pfchs (Jet in NanoAOD), slimmedJets in MiniAOD +# - ak4pfpuppi (Jet in NanoAOD), slimmedJetsPuppi in MiniAOD # - ak8pfpuppi (FatJet in NanoAOD), slimmedJetsAK8 in MiniAOD # Below is a list of recojets that we can save in NanoAOD. Set # "enabled" to true if you want to store the recojet collection. @@ -87,14 +88,6 @@ "genJetsCollection": "AK4GenJetsNoNu", "minPtFastjet" : 0., }, - { - "jet" : "ak4pfpuppi", - "enabled" : True, - "inputCollection" : "", - "genJetsCollection": "AK4GenJetsNoNu", - "bTagDiscriminators": bTagDiscriminatorsForAK4, - "minPtFastjet" : 0., - }, { "jet" : "ak8pf", "enabled" : False, @@ -117,14 +110,6 @@ "doc" : "AK4 PF jets", "ptcut" : "", }, - "ak4pfpuppi" : { - "name" : "JetPuppi", - "doc" : "AK4 PF Puppi", - "ptcut" : "", - "doQGL" : True, - "doPUIDVar": True, - "doBTag": True, - }, "ak8pf" : { "name" : "FatJetPF", "doc" : "AK8 PF jets", @@ -157,46 +142,46 @@ nConstPhotons = Var("photonMultiplicity()",int,doc="number of photons in the jet"), ) PUIDVARS = cms.PSet( - puId_dR2Mean = Var("?(pt>10)?userFloat('puId_dR2Mean'):-1",float,doc="pT^2-weighted average square distance of jet constituents from the jet axis (PileUp ID BDT input variable)", precision= 6), - puId_majW = Var("?(pt>10)?userFloat('puId_majW'):-1",float,doc="major axis of jet ellipsoid in eta-phi plane (PileUp ID BDT input variable)", precision= 6), - puId_minW = Var("?(pt>10)?userFloat('puId_minW'):-1",float,doc="minor axis of jet ellipsoid in eta-phi plane (PileUp ID BDT input variable)", precision= 6), - puId_frac01 = Var("?(pt>10)?userFloat('puId_frac01'):-1",float,doc="fraction of constituents' pT contained within dR <0.1 (PileUp ID BDT input variable)", precision= 6), - puId_frac02 = Var("?(pt>10)?userFloat('puId_frac02'):-1",float,doc="fraction of constituents' pT contained within 0.1< dR <0.2 (PileUp ID BDT input variable)", precision= 6), - puId_frac03 = Var("?(pt>10)?userFloat('puId_frac03'):-1",float,doc="fraction of constituents' pT contained within 0.2< dR <0.3 (PileUp ID BDT input variable)", precision= 6), - puId_frac04 = Var("?(pt>10)?userFloat('puId_frac04'):-1",float,doc="fraction of constituents' pT contained within 0.3< dR <0.4 (PileUp ID BDT input variable)", precision= 6), - puId_ptD = Var("?(pt>10)?userFloat('puId_ptD'):-1",float,doc="pT-weighted average pT of constituents (PileUp ID BDT input variable)", precision= 6), - puId_beta = Var("?(pt>10)?userFloat('puId_beta'):-1",float,doc="fraction of pT of charged constituents associated to PV (PileUp ID BDT input variable)", precision= 6), - puId_pull = Var("?(pt>10)?userFloat('puId_pull'):-1",float,doc="magnitude of pull vector (PileUp ID BDT input variable)", precision= 6), - puId_jetR = Var("?(pt>10)?userFloat('puId_jetR'):-1",float,doc="fraction of jet pT carried by the leading constituent (PileUp ID BDT input variable)", precision= 6), - puId_jetRchg = Var("?(pt>10)?userFloat('puId_jetRchg'):-1",float,doc="fraction of jet pT carried by the leading charged constituent (PileUp ID BDT input variable)", precision= 6), - puId_nCharged = Var("?(pt>10)?userInt('puId_nCharged'):-1",int,doc="number of charged constituents (PileUp ID BDT input variable)"), + puId_dR2Mean = Var("?(pt>=10)?userFloat('puId_dR2Mean'):-1",float,doc="pT^2-weighted average square distance of jet constituents from the jet axis (PileUp ID BDT input variable)", precision=6), + puId_majW = Var("?(pt>=10)?userFloat('puId_majW'):-1",float,doc="major axis of jet ellipsoid in eta-phi plane (PileUp ID BDT input variable)", precision=6), + puId_minW = Var("?(pt>=10)?userFloat('puId_minW'):-1",float,doc="minor axis of jet ellipsoid in eta-phi plane (PileUp ID BDT input variable)", precision=6), + puId_frac01 = Var("?(pt>=10)?userFloat('puId_frac01'):-1",float,doc="fraction of constituents' pT contained within dR <0.1 (PileUp ID BDT input variable)", precision=6), + puId_frac02 = Var("?(pt>=10)?userFloat('puId_frac02'):-1",float,doc="fraction of constituents' pT contained within 0.1< dR <0.2 (PileUp ID BDT input variable)", precision=6), + puId_frac03 = Var("?(pt>=10)?userFloat('puId_frac03'):-1",float,doc="fraction of constituents' pT contained within 0.2< dR <0.3 (PileUp ID BDT input variable)", precision=6), + puId_frac04 = Var("?(pt>=10)?userFloat('puId_frac04'):-1",float,doc="fraction of constituents' pT contained within 0.3< dR <0.4 (PileUp ID BDT input variable)", precision=6), + puId_ptD = Var("?(pt>=10)?userFloat('puId_ptD'):-1",float,doc="pT-weighted average pT of constituents (PileUp ID BDT input variable)", precision=6), + puId_beta = Var("?(pt>=10)?userFloat('puId_beta'):-1",float,doc="fraction of pT of charged constituents associated to PV (PileUp ID BDT input variable)", precision=6), + puId_pull = Var("?(pt>=10)?userFloat('puId_pull'):-1",float,doc="magnitude of pull vector (PileUp ID BDT input variable)", precision=6), + puId_jetR = Var("?(pt>=10)?userFloat('puId_jetR'):-1",float,doc="fraction of jet pT carried by the leading constituent (PileUp ID BDT input variable)", precision=6), + puId_jetRchg = Var("?(pt>=10)?userFloat('puId_jetRchg'):-1",float,doc="fraction of jet pT carried by the leading charged constituent (PileUp ID BDT input variable)", precision=6), + puId_nCharged = Var("?(pt>=10)?userInt('puId_nCharged'):-1",int,doc="number of charged constituents (PileUp ID BDT input variable)"), ) QGLVARS = cms.PSet( - qgl_axis2 = Var("?(pt>10)?userFloat('qgl_axis2'):-1",float,doc="ellipse minor jet axis (Quark vs Gluon likelihood input variable)", precision= 6), - qgl_ptD = Var("?(pt>10)?userFloat('qgl_ptD'):-1",float,doc="pT-weighted average pT of constituents (Quark vs Gluon likelihood input variable)", precision= 6), - qgl_mult = Var("?(pt>10)?userInt('qgl_mult'):-1", int,doc="PF candidates multiplicity (Quark vs Gluon likelihood input variable)"), + qgl_axis2 = Var("?(pt>=10)?userFloat('qgl_axis2'):-1",float,doc="ellipse minor jet axis (Quark vs Gluon likelihood input variable)", precision=10), + qgl_ptD = Var("?(pt>=10)?userFloat('qgl_ptD'):-1",float,doc="pT-weighted average pT of constituents (Quark vs Gluon likelihood input variable)", precision=10), + qgl_mult = Var("?(pt>=10)?userInt('qgl_mult'):-1", int,doc="PF candidates multiplicity (Quark vs Gluon likelihood input variable)"), ) BTAGVARS = cms.PSet( - btagDeepB = Var("?(pt>15)&&((bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'))>=0)?bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'):-1",float,doc="DeepCSV b+bb tag discriminator",precision=10), - btagCSVV2 = Var("?pt>15?bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags'):-1",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10), - btagDeepCvL = Var("?(pt>15)&&(bDiscriminator('pfDeepCSVJetTags:probc')>=0)?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probudsg')):-1", float,doc="DeepCSV c vs udsg discriminator",precision=10), - btagDeepCvB = Var("?(pt>15)&&bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')):-1",float,doc="DeepCSV c vs b+bb discriminator",precision=10), + btagDeepB = Var("?(pt>=15)&&((bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'))>=0)?bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'):-1",float,doc="DeepCSV b+bb tag discriminator",precision=10), + btagCSVV2 = Var("?(pt>=15)?bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags'):-1",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10), + btagDeepCvL = Var("?(pt>=15)&&(bDiscriminator('pfDeepCSVJetTags:probc')>=0)?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probudsg')):-1", float,doc="DeepCSV c vs udsg discriminator",precision=10), + btagDeepCvB = Var("?(pt>=15)&&bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')):-1",float,doc="DeepCSV c vs b+bb discriminator",precision=10), ) DEEPJETVARS = cms.PSet( - btagDeepFlavB = Var("?pt>15?bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'):-1",float,doc="DeepJet b+bb+lepb tag discriminator",precision=10), - btagDeepFlavC = Var("?pt>15?bDiscriminator('pfDeepFlavourJetTags:probc'):-1",float,doc="DeepFlavour charm tag raw score",precision=10), - btagDeepFlavG = Var("?pt>15?bDiscriminator('pfDeepFlavourJetTags:probg'):-1",float,doc="DeepFlavour gluon tag raw score",precision=10), - btagDeepFlavUDS = Var("?pt>15?bDiscriminator('pfDeepFlavourJetTags:probuds'):-1",float,doc="DeepFlavour uds tag raw score",precision=10), - btagDeepFlavCvL = Var("?(pt>15)&&(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg')):-1",float,doc="DeepJet c vs uds+g discriminator",precision=10), - btagDeepFlavCvB = Var("?(pt>15)&&(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')):-1",float,doc="DeepJet c vs b+bb+lepb discriminator",precision=10), - btagDeepFlavQG = Var("?(pt>15)&&(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds'))>0?bDiscriminator('pfDeepFlavourJetTags:probg')/(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds')):-1",float,doc="DeepJet g vs uds discriminator",precision=10), + btagDeepFlavB = Var("?(pt>=15)?bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'):-1",float,doc="DeepJet b+bb+lepb tag discriminator",precision=10), + btagDeepFlavC = Var("?(pt>=15)?bDiscriminator('pfDeepFlavourJetTags:probc'):-1",float,doc="DeepFlavour charm tag raw score",precision=10), + btagDeepFlavG = Var("?(pt>=15)?bDiscriminator('pfDeepFlavourJetTags:probg'):-1",float,doc="DeepFlavour gluon tag raw score",precision=10), + btagDeepFlavUDS = Var("?(pt>=15)?bDiscriminator('pfDeepFlavourJetTags:probuds'):-1",float,doc="DeepFlavour uds tag raw score",precision=10), + btagDeepFlavCvL = Var("?(pt>=15)&&(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg')):-1",float,doc="DeepJet c vs uds+g discriminator",precision=10), + btagDeepFlavCvB = Var("?(pt>=15)&&(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')):-1",float,doc="DeepJet c vs b+bb+lepb discriminator",precision=10), + btagDeepFlavQG = Var("?(pt>=15)&&(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds'))>0?bDiscriminator('pfDeepFlavourJetTags:probg')/(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds')):-1",float,doc="DeepJet g vs uds discriminator",precision=10), ) PARTICLENETAK4VARS = cms.PSet( - particleNetAK4_B = Var("?pt>15?bDiscriminator('pfParticleNetAK4DiscriminatorsJetTags:BvsAll'):-1",float,doc="ParticleNetAK4 tagger b vs all (udsg, c) discriminator",precision=10), - particleNetAK4_CvsL = Var("?pt>15?bDiscriminator('pfParticleNetAK4DiscriminatorsJetTags:CvsL'):-1",float,doc="ParticleNetAK4 tagger c vs udsg discriminator",precision=10), - particleNetAK4_CvsB = Var("?pt>15?bDiscriminator('pfParticleNetAK4DiscriminatorsJetTags:CvsB'):-1",float,doc="ParticleNetAK4 tagger c vs b discriminator",precision=10), - particleNetAK4_QvsG = Var("?pt>15?bDiscriminator('pfParticleNetAK4DiscriminatorsJetTags:QvsG'):-1",float,doc="ParticleNetAK4 tagger uds vs g discriminator",precision=10), - particleNetAK4_puIdDisc = Var("?pt>15?1-bDiscriminator('pfParticleNetAK4JetTags:probpu'):-1",float,doc="ParticleNetAK4 tagger pileup jet discriminator",precision=10), + particleNetAK4_B = Var("?(pt>=15)?bDiscriminator('pfParticleNetAK4DiscriminatorsJetTags:BvsAll'):-1",float,doc="ParticleNetAK4 tagger b vs all (udsg, c) discriminator",precision=10), + particleNetAK4_CvsL = Var("?(pt>=15)?bDiscriminator('pfParticleNetAK4DiscriminatorsJetTags:CvsL'):-1",float,doc="ParticleNetAK4 tagger c vs udsg discriminator",precision=10), + particleNetAK4_CvsB = Var("?(pt>=15)?bDiscriminator('pfParticleNetAK4DiscriminatorsJetTags:CvsB'):-1",float,doc="ParticleNetAK4 tagger c vs b discriminator",precision=10), + particleNetAK4_QvsG = Var("?(pt>=15)?bDiscriminator('pfParticleNetAK4DiscriminatorsJetTags:QvsG'):-1",float,doc="ParticleNetAK4 tagger uds vs g discriminator",precision=10), + particleNetAK4_puIdDisc = Var("?(pt>=15)?1-bDiscriminator('pfParticleNetAK4JetTags:probpu'):-1",float,doc="ParticleNetAK4 tagger pileup jet discriminator",precision=10), ) CALOJETVARS = cms.PSet(P4Vars, @@ -213,7 +198,7 @@ # # #****************************************** -def AddJetID(proc, jetName="", jetSrc="", jetTableName="", jetSequenceName=""): +def AddJetID(proc, jetName="", jetSrc="", jetTableName="", jetTaskName=""): """ Setup modules to calculate PF jet ID """ @@ -273,17 +258,17 @@ def AddJetID(proc, jetName="", jetSrc="", jetTableName="", jetSequenceName=""): modifier.toModify(getattr(proc, jetTableName).variables, jetId = Var("userInt('tightIdLepVeto')*4+userInt('tightId')*2+userInt('looseId')",int, doc="Jet ID flags bit1 is loose, bit2 is tight, bit3 is tightLepVeto")) - getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, jetSrc))+1, getattr(proc, tightJetId)) - getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, tightJetId))+1, getattr(proc, tightJetIdLepVeto)) + getattr(proc,jetTaskName).add(getattr(proc, tightJetId)) + getattr(proc,jetTaskName).add(getattr(proc, tightJetIdLepVeto)) - setattr(proc,"_"+jetSequenceName+"_2016", getattr(proc,jetSequenceName).copy()) - getattr(proc,"_"+jetSequenceName+"_2016").insert(getattr(proc, "_"+jetSequenceName+"_2016").index(getattr(proc, tightJetId)), getattr(proc, looseJetId)) + setattr(proc,"_"+jetTaskName+"_2016", getattr(proc,jetTaskName).copy()) + getattr(proc,"_"+jetTaskName+"_2016").add(getattr(proc, looseJetId)) for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016: - modifier.toReplaceWith(getattr(proc,jetSequenceName), getattr(proc, "_"+jetSequenceName+"_2016")) + modifier.toReplaceWith(getattr(proc,jetTaskName), getattr(proc, "_"+jetTaskName+"_2016")) return proc -def AddPileUpJetIDVars(proc, jetName="", jetSrc="", jetTableName="", jetSequenceName=""): +def AddPileUpJetIDVars(proc, jetName="", jetSrc="", jetTableName="", jetTaskName=""): """ Setup modules to calculate pileup jet ID input variables for PF jet """ @@ -300,7 +285,7 @@ def AddPileUpJetIDVars(proc, jetName="", jetSrc="", jetTableName="", jetSequence usePuppi = True if "Puppi" in jetName else False ) ) - getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, jetSrc))+1, getattr(proc, puJetIdVarsCalculator)) + getattr(proc,jetTaskName).add(getattr(proc, puJetIdVarsCalculator)) # # Get the variables @@ -311,7 +296,7 @@ def AddPileUpJetIDVars(proc, jetName="", jetSrc="", jetTableName="", jetSequence srcPileupJetId = cms.InputTag(puJetIdVarsCalculator) ) ) - getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, puJetIdVarsCalculator))+1, getattr(proc, puJetIDVar)) + getattr(proc,jetTaskName).add(getattr(proc, puJetIDVar)) # # Save variables as userFloats and userInts for each jet @@ -350,7 +335,7 @@ def AddPileUpJetIDVars(proc, jetName="", jetSrc="", jetTableName="", jetSequence return proc -def AddQGLTaggerVars(proc, jetName="", jetSrc="", jetTableName="", jetSequenceName="", calculateQGLVars=False): +def AddQGLTaggerVars(proc, jetName="", jetSrc="", jetTableName="", jetTaskName="", calculateQGLVars=False): """ Schedule the QGTagger module to calculate input variables to the QG likelihood """ @@ -379,7 +364,7 @@ def AddQGLTaggerVars(proc, jetName="", jetSrc="", jetTableName="", jetSequenceNa getattr(proc,jetTableName).variables.qgl_mult = QGLVARS.qgl_mult if calculateQGLVars: - getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, jetSrc))+1, getattr(proc, QGLTagger)) + getattr(proc,jetTaskName).add(getattr(proc, QGLTagger)) return proc @@ -436,7 +421,7 @@ def AddNewPatJets(proc, recoJetInfo, runOnMC): nanoInfoForJet = nanoInfo_recojets[recoJetInfo.jet] jetTablePrefix = nanoInfoForJet["name"] jetTableDoc = nanoInfoForJet["doc"] - ptcut = nanoInfoForJet["ptcut"] if "ptcut" in nanoInfoForJet else "" + ptcut = nanoInfoForJet["ptcut"] if "ptcut" in nanoInfoForJet else 8 doPUIDVar = nanoInfoForJet["doPUIDVar"] if "doPUIDVar" in nanoInfoForJet else False doQGL = nanoInfoForJet["doQGL"] if "doQGL" in nanoInfoForJet else False doBTag = nanoInfoForJet["doBTag"] if "doBTag" in nanoInfoForJet else False @@ -449,7 +434,7 @@ def AddNewPatJets(proc, recoJetInfo, runOnMC): return proc def SavePatJets(proc, jetName, payload, patJetFinalColl, jetTablePrefix, jetTableDoc, - doPF, doCalo, ptcut="", doPUIDVar=False, doQGL=False, doBTag=False, runOnMC=False): + doPF, doCalo, ptcut, doPUIDVar=False, doQGL=False, doBTag=False, runOnMC=False): """ Schedule modules for a given patJet collection and save its variables into custom NanoAOD """ @@ -488,14 +473,14 @@ def SavePatJets(proc, jetName, payload, patJetFinalColl, jetTablePrefix, jetTabl # # Filter jets with pt cut # - finalJetsCutDefault = "(pt >= 8)" + finalJetsCut = "(pt >= {ptcut:.0f})".format(ptcut=ptcut) if runOnMC: - finalJetsCutDefault = "(pt >= 8) || ((pt < 8) && (genJetFwdRef().backRef().isNonnull()))" + finalJetsCut = "(pt >= {ptcut:.0f}) || ((pt < {ptcut:.0f}) && (genJetFwdRef().backRef().isNonnull()))".format(ptcut=ptcut) finalJetsForTable = "finalJets{}".format(jetName) setattr(proc, finalJetsForTable, finalJets.clone( src = srcJetsWithUserData, - cut = ptcut if ptcut != "" else finalJetsCutDefault + cut = finalJetsCut ) ) @@ -508,12 +493,12 @@ def SavePatJets(proc, jetName, payload, patJetFinalColl, jetTablePrefix, jetTabl jetTableCutDefault = "" #Don't apply any cuts for the table. - jetTableDocDefault = jetTableDoc + " with JECs applied. Jets with pt > 8 GeV are stored." + jetTableDocDefault = jetTableDoc + " with JECs applied. Jets with pt >= {ptcut:.0f} GeV are stored.".format(ptcut=ptcut) if runOnMC: - jetTableDocDefault += "For jets with pt < 8 GeV, only those matched to gen jets are stored." + jetTableDocDefault += "For jets with pt < {ptcut:.0f} GeV, only those matched to gen jets are stored.".format(ptcut=ptcut) - jetTable = "jet{}Table".format(jetName) - setattr(proc,jetTable, cms.EDProducer("SimpleCandidateFlatTableProducer", + jetTableName = "jet{}Table".format(jetName) + setattr(proc,jetTableName, cms.EDProducer("SimpleCandidateFlatTableProducer", src = cms.InputTag(finalJetsForTable), cut = cms.string(jetTableCutDefault), name = cms.string(jetTablePrefix), @@ -523,15 +508,16 @@ def SavePatJets(proc, jetName, payload, patJetFinalColl, jetTablePrefix, jetTabl variables = cms.PSet(tableContent) ) ) - getattr(proc,jetTable).variables.pt.precision=10 + getattr(proc,jetTableName).variables.pt.precision=10 + getattr(proc,jetTableName).variables.rawFactor.precision=10 # # Save MC-only jet variables in table # - jetMCTable = "jet{}MCTable".format(jetName) - setattr(proc, jetMCTable, cms.EDProducer("SimpleCandidateFlatTableProducer", + jetMCTableName = "jet{}MCTable".format(jetName) + setattr(proc, jetMCTableName, cms.EDProducer("SimpleCandidateFlatTableProducer", src = cms.InputTag(finalJetsForTable), - cut = getattr(proc,jetTable).cut, + cut = getattr(proc,jetTableName).cut, name = cms.string(jetTablePrefix), singleton = cms.bool(False), extension = cms.bool(True), # this is an extension table @@ -544,60 +530,209 @@ def SavePatJets(proc, jetName, payload, patJetFinalColl, jetTablePrefix, jetTabl ) # - # Define the jet modules sequence first + # Define the jet modules Task first # - jetSequenceName = "jet{}Sequence".format(jetName) - setattr(proc, jetSequenceName, cms.Sequence( - getattr(proc,jetCorrFactors)+ - getattr(proc,srcJets)+ - getattr(proc,srcJetsWithUserData)+ - getattr(proc,finalJetsForTable) - ) + jetTaskName = "jet{}Task".format(jetName) + setattr(proc, jetTaskName, cms.Task( + getattr(proc,jetCorrFactors), + getattr(proc,srcJets), + getattr(proc,srcJetsWithUserData), + getattr(proc,finalJetsForTable) + ) ) + proc.nanoTableTaskCommon.add(getattr(proc,jetTaskName)) # - # Define the jet table sequences + # Define the jet tables Task # - jetTableSequenceName = "jet{}TablesSequence".format(jetName) - setattr(proc, jetTableSequenceName, cms.Sequence(getattr(proc,jetTable))) - - jetTableSequenceMCName = "jet{}MCTablesSequence".format(jetName) - setattr(proc, jetTableSequenceMCName, cms.Sequence(getattr(proc,jetMCTable))) + jetTableTaskName = "jet{}TablesTask".format(jetName) + setattr(proc, jetTableTaskName, cms.Task(getattr(proc,jetTableName))) + proc.nanoTableTaskCommon.add(getattr(proc,jetTableTaskName)) + jetMCTableTaskName = "jet{}MCTablesTask".format(jetName) + setattr(proc, jetMCTableTaskName, cms.Task(getattr(proc,jetMCTableName))) if runOnMC: - proc.nanoSequenceMC += getattr(proc,jetSequenceName) - proc.nanoSequenceMC += getattr(proc,jetTableSequenceName) - proc.nanoSequenceMC += getattr(proc,jetTableSequenceMCName) - else: - proc.nanoSequence += getattr(proc,jetSequenceName) - proc.nanoSequence += getattr(proc,jetTableSequenceName) + proc.nanoTableTaskFS.add(getattr(proc,jetMCTableTaskName)) # # Schedule plugins to calculate Jet ID, PileUp Jet ID input variables, and Quark-Gluon Likehood input variables. # if doPF: - proc = AddJetID(proc, jetName=jetName, jetSrc=srcJets, jetTableName=jetTable, jetSequenceName=jetSequenceName) + proc = AddJetID(proc, jetName=jetName, jetSrc=srcJets, jetTableName=jetTableName, jetTaskName=jetTaskName) if doPUIDVar: - proc = AddPileUpJetIDVars(proc, jetName=jetName, jetSrc=srcJets, jetTableName=jetTable, jetSequenceName=jetSequenceName) + proc = AddPileUpJetIDVars(proc, jetName=jetName, jetSrc=srcJets, jetTableName=jetTableName, jetTaskName=jetTaskName) if doQGL: - proc = AddQGLTaggerVars(proc,jetName=jetName, jetSrc=srcJets, jetTableName=jetTable, jetSequenceName=jetSequenceName, calculateQGLVars=True) + proc = AddQGLTaggerVars(proc,jetName=jetName, jetSrc=srcJets, jetTableName=jetTableName, jetTaskName=jetTaskName, calculateQGLVars=True) # # Save b-tagging algorithm scores. Should only be done for jet collection with b-tagging # calculated when reclustered or collection saved with b-tagging info in MiniAOD # if doBTag: - AddBTaggingScores(proc,jetTableName=jetTable) - AddDeepJetGluonLQuarkScores(proc,jetTableName=jetTable) - AddParticleNetAK4Scores(proc,jetTableName=jetTable) + AddBTaggingScores(proc,jetTableName=jetTableName) + AddDeepJetGluonLQuarkScores(proc,jetTableName=jetTableName) + AddParticleNetAK4Scores(proc,jetTableName=jetTableName) + + return proc + + +def ReclusterAK4PuppiJets(proc, recoJA, runOnMC): + """ + Recluster AK4 Puppi jets and replace slimmedJetsPuppi + that is used as default to save AK4 Puppi jets in NanoAODs. + """ + print("custom_jme_cff::ReclusterAK4PuppiJets: Recluster AK4 PF Puppi jets") + + # + # Recluster AK4 Puppi jets + # + cfg = { + "jet" : "ak4pfpuppi", + "inputCollection" : "", + "genJetsCollection": "AK4GenJetsNoNu", + "bTagDiscriminators": bTagDiscriminatorsForAK4, + "minPtFastjet" : 0., + } + recoJetInfo = recoJA.addRecoJetCollection(proc, **cfg) + + jetName = recoJetInfo.jetUpper + patJetFinalColl = recoJetInfo.patJetFinalCollection + + # + # Change the input jet source for jetCorrFactorsNano + # and updatedJets + # + proc.jetPuppiCorrFactorsNano.src=patJetFinalColl + proc.updatedJetsPuppi.jetSource=patJetFinalColl + + # + # Change pt cut + # + finalJetsPuppiCut = "" + if runOnMC: + finalJetsPuppiCut = "(pt >= 8) || ((pt < 8) && (genJetFwdRef().backRef().isNonnull()))" + else: + finalJetsPuppiCut = "(pt >= 8)" + + proc.finalJetsPuppi.cut = finalJetsPuppiCut + # + # Add a minimum pt cut for corrT1METJets. + # + proc.corrT1METJetPuppiTable.cut = "pt>=8 && pt<15 && abs(eta)<9.9" + + # + # Jet table + # + # For Run-2 eras, the main AK4 jet collection in NanoAOD is the CHS collection + run2_nanoAOD_ANY.toModify(proc.jetTable, name = "Jet") + # So need to change the table name for AK4 puppi here + run2_nanoAOD_ANY.toModify(proc.jetPuppiTable, + name = "JetPuppi", + src = cms.InputTag("finalJetsPuppi") + ) + + # + # Jet table documentation + # + jetPuppiTableDoc = "AK4 PF Puppi jets with JECs applied. Jets with pt >= 8 GeV are stored." + if runOnMC: + jetPuppiTableDoc += "For jets with pt < 8 GeV, only those matched to AK4 Gen jets are stored." + proc.jetPuppiTable.doc = jetPuppiTableDoc + + proc.jetPuppiTable.variables.rawFactor.precision = 10 + + # + # Add variables + # + proc.jetPuppiTable.variables.hfHEF = PFJETVARS.hfHEF + proc.jetPuppiTable.variables.hfEmEF = PFJETVARS.hfEmEF + proc.jetPuppiTable.variables.nConstChHads = PFJETVARS.nConstChHads + proc.jetPuppiTable.variables.nConstNeuHads = PFJETVARS.nConstNeuHads + proc.jetPuppiTable.variables.nConstHFHads = PFJETVARS.nConstHFHads + proc.jetPuppiTable.variables.nConstHFEMs = PFJETVARS.nConstHFEMs + proc.jetPuppiTable.variables.nConstMuons = PFJETVARS.nConstMuons + proc.jetPuppiTable.variables.nConstElecs = PFJETVARS.nConstElecs + proc.jetPuppiTable.variables.nConstPhotons = PFJETVARS.nConstPhotons + + # + # Add variables for pileup jet ID studies. + # + + proc = AddPileUpJetIDVars(proc, + jetName = jetName, + jetSrc = "updatedJetsPuppi", + jetTableName = "jetPuppiTable", + jetTaskName = "jetPuppiTask" + ) + # + # Add variables for quark guon likelihood tagger studies. + # Save variables as userFloats and userInts in each jet + # + proc = AddQGLTaggerVars(proc, + jetName = jetName, + jetSrc = "updatedJetsPuppi", + jetTableName = "jetPuppiTable", + jetTaskName = "jetPuppiTask", + calculateQGLVars=True + ) + # + # Save standard b-tagging and c-tagging variables + # + proc.jetPuppiTable.variables.btagDeepB = BTAGVARS.btagDeepB + proc.jetPuppiTable.variables.btagCSVV2 = BTAGVARS.btagCSVV2 + proc.jetPuppiTable.variables.btagDeepCvL = BTAGVARS.btagDeepCvL + proc.jetPuppiTable.variables.btagDeepCvB = BTAGVARS.btagDeepCvB + # + # Save DeepJet b-tagging and c-tagging variables + # + proc.jetPuppiTable.variables.btagDeepFlavB = DEEPJETVARS.btagDeepFlavB + proc.jetPuppiTable.variables.btagDeepFlavCvL = DEEPJETVARS.btagDeepFlavCvL + proc.jetPuppiTable.variables.btagDeepFlavCvB = DEEPJETVARS.btagDeepFlavCvB + # + # Save DeepJet raw score for gluon and light quarks + # + proc.jetPuppiTable.variables.btagDeepFlavG = DEEPJETVARS.btagDeepFlavG + proc.jetPuppiTable.variables.btagDeepFlavUDS = DEEPJETVARS.btagDeepFlavUDS + proc.jetPuppiTable.variables.btagDeepFlavQG = DEEPJETVARS.btagDeepFlavQG + # + # Add ParticleNetAK4 scores + # + proc.jetPuppiTable.variables.particleNetAK4_B = PARTICLENETAK4VARS.particleNetAK4_B + proc.jetPuppiTable.variables.particleNetAK4_CvsL = PARTICLENETAK4VARS.particleNetAK4_CvsL + proc.jetPuppiTable.variables.particleNetAK4_CvsB = PARTICLENETAK4VARS.particleNetAK4_CvsB + proc.jetPuppiTable.variables.particleNetAK4_QvsG = PARTICLENETAK4VARS.particleNetAK4_QvsG + proc.jetPuppiTable.variables.particleNetAK4_puIdDisc = PARTICLENETAK4VARS.particleNetAK4_puIdDisc + + # + # For Run-2 eras, don't need to save the low pt AK4 Puppi jet table for MET + # + _jetPuppiForMETTask = proc.jetPuppiForMETTask.copyAndExclude([proc.corrT1METJetPuppiTable]) + run2_nanoAOD_ANY.toReplaceWith(proc.jetPuppiForMETTask, _jetPuppiForMETTask) + + # + # Save MC-only jet variables in jet table + # + if runOnMC: + + jetMCTableName = "jet{}MCTable".format(jetName) + setattr(proc, jetMCTableName, proc.jetMCTable.clone( + src = proc.jetPuppiTable.src, + name = proc.jetPuppiTable.name + ) + ) + jetMCTableTaskName = "jet{}MCTablesTask".format(jetName) + setattr(proc, jetMCTableTaskName, cms.Task(getattr(proc,jetMCTableName))) + + _nanoTableTaskFS = proc.nanoTableTaskFS.copy() + _nanoTableTaskFS.add(getattr(proc,jetMCTableTaskName)) + run2_nanoAOD_ANY.toReplaceWith(proc.nanoTableTaskFS, _nanoTableTaskFS) return proc def ReclusterAK4CHSJets(proc, recoJA, runOnMC): """ - Recluster AK4 CHS jets and replace slimmedJets - that is used as default to save AK4 CHS jets - in NanoAODs. + Recluster AK4 CHS jets and replace slimmedJets that is used as default to + save AK4 CHS jets in NanoAODs (for Run-2). """ print("custom_jme_cff::ReclusterAK4CHSJets: Recluster AK4 PF CHS jets") @@ -642,17 +777,29 @@ def ReclusterAK4CHSJets(proc, recoJA, runOnMC): # Jet table cut # jetTableCut = "" # must not have any cut at the jetTable for AK4 CHS as it has been cross-cleaned + proc.jetTable.src = cms.InputTag("finalJets") proc.jetTable.cut = jetTableCut - proc.jetMCTable.cut = jetTableCut + proc.jetMCTable.cut = jetTableCut + proc.jetTable.name = "JetCHS" + + # + # For Run-2 eras, the main AK4 jet collection in NanoAOD is the CHS collection + # + run2_nanoAOD_ANY.toModify(proc.jetTable, + src = cms.InputTag("linkedObjects","jets"), + name = "Jet" + ) # # Jet table documentation # - jetTableDoc = "AK4 PF CHS jets with JECs applied. Jets with pt > 8 GeV are stored." + jetTableDoc = "AK4 PF CHS jets with JECs applied. Jets with pt >= 8 GeV are stored." if runOnMC: jetTableDoc += "For jets with pt < 8 GeV, only those matched to AK4 Gen jets are stored." proc.jetTable.doc = jetTableDoc + proc.jetTable.variables.rawFactor.precision = 10 + # # Add variables # @@ -678,15 +825,14 @@ def ReclusterAK4CHSJets(proc, recoJA, runOnMC): vertexes = "offlineSlimmedPrimaryVertices" ) ) - proc.jetSequence.insert(proc.jetSequence.index(proc.pileupJetId94X), getattr(proc, pileupJetId80X)) - - proc.updatedJetsWithUserData.userInts.puId80XfullId = cms.InputTag('pileupJetId80X:fullId') - proc.updatedJetsWithUserData.userFloats.puId80XDisc = cms.InputTag("pileupJetId80X:fullDiscriminant") - - run2_nanoAOD_94X2016.toModify(proc.jetTable.variables, puIdDisc = Var("userFloat('puId80XDisc')",float,doc="Pilup ID discriminant with 80X (2016) training",precision=10)) - + _jetUserDataTask = proc.jetUserDataTask.copy() + _jetUserDataTask.add(getattr(proc,pileupJetId80X)) for modifier in run2_nanoAOD_94X2016, run2_nanoAOD_94XMiniAODv1, run2_nanoAOD_94XMiniAODv2, run2_nanoAOD_102Xv1: + modifier.toReplaceWith(proc.jetUserDataTask, _jetUserDataTask) + modifier.toModify(proc.updatedJetsWithUserData.userInts, puId80XfullId = cms.InputTag('pileupJetId80X:fullId')) modifier.toModify(proc.jetTable.variables, puId = Var("userInt('puId80XfullId')", int, doc="Pileup ID flags with 80X (2016) training")) + run2_nanoAOD_94X2016.toModify(proc.updatedJetsWithUserData.userFloats, puId80XDisc = cms.InputTag("pileupJetId80X:fullDiscriminant")) + run2_nanoAOD_94X2016.toModify(proc.jetTable.variables, puIdDisc = Var("userFloat('puId80XDisc')",float,doc="Pilup ID discriminant with 80X (2016) training",precision=10)) # # Add charged energy fraction from other primary vertices @@ -702,10 +848,10 @@ def ReclusterAK4CHSJets(proc, recoJA, runOnMC): # Add variables for pileup jet ID studies. # proc = AddPileUpJetIDVars(proc, - jetName = "", + jetName = jetName, jetSrc = "updatedJets", jetTableName = "jetTable", - jetSequenceName = "jetSequence" + jetTaskName = "jetTask" ) # # Add variables for quark guon likelihood tagger studies. @@ -752,7 +898,7 @@ def ReclusterAK4CHSJets(proc, recoJA, runOnMC): #The following lines make sure it is. hfJetShowerShapeforCustomNanoAOD = "hfJetShowerShapeforCustomNanoAOD" setattr(proc, hfJetShowerShapeforCustomNanoAOD, hfJetShowerShapeforNanoAOD.clone(jets="updatedJets",vertices="offlineSlimmedPrimaryVertices") ) - proc.jetSequence.insert(proc.jetSequence.index(proc.updatedJetsWithUserData), getattr(proc, hfJetShowerShapeforCustomNanoAOD)) + proc.jetUserDataTask.add(getattr(proc, hfJetShowerShapeforCustomNanoAOD)) proc.updatedJetsWithUserData.userFloats.hfsigmaEtaEta = cms.InputTag('hfJetShowerShapeforCustomNanoAOD:sigmaEtaEta') proc.updatedJetsWithUserData.userFloats.hfsigmaPhiPhi = cms.InputTag('hfJetShowerShapeforCustomNanoAOD:sigmaPhiPhi') proc.updatedJetsWithUserData.userInts.hfcentralEtaStripSize = cms.InputTag('hfJetShowerShapeforCustomNanoAOD:centralEtaStripSize') @@ -762,6 +908,64 @@ def ReclusterAK4CHSJets(proc, recoJA, runOnMC): proc.jetTable.variables.hfcentralEtaStripSize = Var("userInt('hfcentralEtaStripSize')", int, doc="eta size of the central tower strip in HF (noise discriminating variable) ") proc.jetTable.variables.hfadjacentEtaStripsSize = Var("userInt('hfadjacentEtaStripsSize')", int, doc="eta size of the strips next to the central tower strip in HF (noise discriminating variable) ") + # + # Since AK4 Puppi jet is the main AK4 jet collection for Run-3, disable + # b-jets/c-jets NN-based mass regression for AK4 CHS. + # + _jetUserDataTask = proc.jetUserDataTask.copyAndExclude([proc.bJetVars]) + (~run2_nanoAOD_ANY).toReplaceWith(proc.jetUserDataTask, _jetUserDataTask) + + _jetTablesTask = proc.jetTablesTask.copyAndExclude([proc.bjetNN, proc.cjetNN]) + (~run2_nanoAOD_ANY).toReplaceWith(proc.jetTablesTask, _jetTablesTask) + + (~run2_nanoAOD_ANY).toModify(proc.updatedJetsWithUserData.userFloats, + leadTrackPt = None, + leptonPtRel = None, + leptonPtRatio = None, + leptonPtRelInv = None, + leptonPtRelv0 = None, + leptonPtRatiov0 = None, + leptonPtRelInvv0 = None, + leptonDeltaR = None, + leptonPt = None, + vtxPt = None, + vtxMass = None, + vtx3dL = None, + vtx3deL = None, + ptD = None, + genPtwNu = None + ) + + (~run2_nanoAOD_ANY).toModify(proc.updatedJetsWithUserData.userInts, + vtxNtrk = None, + leptonPdgId = None + ) + + (~run2_nanoAOD_ANY).toModify(proc.jetTable, externalVariables = cms.PSet()) + + # + # For Run-3, don't need to save the low pt AK4 CHS jet table for MET + # + _jetForMETTask = proc.jetForMETTask.copyAndExclude([proc.corrT1METJetTable]) + (~run2_nanoAOD_ANY).toReplaceWith(proc.jetForMETTask, _jetForMETTask) + + # + # Save MC-only jet variables in jet table + # + if runOnMC: + jetMCTableName = "jet{}MCTable".format(jetName) + setattr(proc, jetMCTableName, proc.jetMCTable.clone( + src = proc.jetTable.src, + name = proc.jetTable.name + ) + ) + jetMCTableTaskName = "jet{}MCTablesTask".format(jetName) + setattr(proc, jetMCTableTaskName, cms.Task(getattr(proc,jetMCTableName))) + + _nanoTableTaskFS = proc.nanoTableTaskFS.copy() + _nanoTableTaskFS.add(getattr(proc,jetMCTableTaskName)) + (~run2_nanoAOD_ANY).toReplaceWith(proc.nanoTableTaskFS, _nanoTableTaskFS) + return proc def AddNewAK8PuppiJetsForJEC(proc, recoJA, runOnMC): @@ -788,7 +992,7 @@ def AddNewAK8PuppiJetsForJEC(proc, recoJA, runOnMC): patJetFinalColl = recoJetInfo.patJetFinalCollection jetTablePrefix = "FatJetForJEC" jetTableDoc = "AK8 PF Puppi jets with JECs applied. Reclustered for JEC studies so only minimal info stored." - ptcut = ""# No need to specify ptcut. Use default in SavePatJets function + ptcut = 15 SavePatJets(proc, jetName, payload, patJetFinalColl, jetTablePrefix, jetTableDoc, doPF=True, @@ -820,7 +1024,7 @@ def AddNewAK8CHSJets(proc, recoJA, runOnMC): patJetFinalColl = recoJetInfo.patJetFinalCollection jetTablePrefix = "FatJetCHS" jetTableDoc = "AK8 PF CHS jets with JECs applied. Reclustered for JEC studies so only minimal info stored." - ptcut = ""# No need to specify ptcut. Use default in SavePatJets function + ptcut = 15 SavePatJets(proc, jetName, payload, patJetFinalColl, jetTablePrefix, jetTableDoc, doPF=True, @@ -834,6 +1038,8 @@ def AddVariablesForAK8PuppiJets(proc): Add more variables for AK8 PFPUPPI jets """ + proc.fatJetTable.variables.rawFactor.precision = 10 + # # These variables are not stored for AK8PFPUPPI (slimmedJetsAK8) # in MiniAOD if their pt < 170 GeV. Hence the conditional fill. @@ -883,8 +1089,8 @@ def SaveGenJets(proc, genJetName, genJetAlgo, genJetSizeNr, genJetFinalColl, gen Schedule modules for a given genJet collection and save its variables into custom NanoAOD """ - genJetTableThisJet = "jet{}Table".format(genJetName) - setattr(proc, genJetTableThisJet, genJetTable.clone( + genJetTableName = "jet{}Table".format(genJetName) + setattr(proc, genJetTableName, genJetTable.clone( src = genJetFinalColl, cut = "", # No cut specified here. Save all gen jets after clustering name = genJetTablePrefix, @@ -893,31 +1099,31 @@ def SaveGenJets(proc, genJetName, genJetAlgo, genJetSizeNr, genJetFinalColl, gen ) ) - genJetFlavourAssociationThisJet = "genJet{}FlavourAssociation".format(genJetName) - setattr(proc, genJetFlavourAssociationThisJet, genJetFlavourAssociation.clone( - jets = getattr(proc,genJetTableThisJet).src, + genJetFlavourAssociationName = "genJet{}FlavourAssociation".format(genJetName) + setattr(proc, genJetFlavourAssociationName, genJetFlavourAssociation.clone( + jets = getattr(proc,genJetTableName).src, jetAlgorithm = supportedJetAlgos[genJetAlgo], rParam = genJetSizeNr, ) ) - genJetFlavourTableThisJet = "genJet{}FlavourTable".format(genJetName) - setattr(proc, genJetFlavourTableThisJet, genJetFlavourTable.clone( - name = getattr(proc,genJetTableThisJet).name, - src = getattr(proc,genJetTableThisJet).src, - cut = getattr(proc,genJetTableThisJet).cut, - jetFlavourInfos = genJetFlavourAssociationThisJet, + genJetFlavourTableName = "genJet{}FlavourTable".format(genJetName) + setattr(proc, genJetFlavourTableName, genJetFlavourTable.clone( + name = getattr(proc,genJetTableName).name, + src = getattr(proc,genJetTableName).src, + cut = getattr(proc,genJetTableName).cut, + jetFlavourInfos = genJetFlavourAssociationName, ) ) - genJetSequenceName = "genJet{}Sequence".format(genJetName) - setattr(proc, genJetSequenceName, cms.Sequence( - getattr(proc,genJetTableThisJet)+ - getattr(proc,genJetFlavourAssociationThisJet)+ - getattr(proc,genJetFlavourTableThisJet) + genJetTaskName = "genJet{}Task".format(genJetName) + setattr(proc, genJetTaskName, cms.Task( + getattr(proc,genJetTableName), + getattr(proc,genJetFlavourAssociationName), + getattr(proc,genJetFlavourTableName) ) ) - proc.nanoSequenceMC.insert(proc.nanoSequenceMC.index(proc.jetMC)+1, getattr(proc,genJetSequenceName)) + proc.jetMCTask.add(getattr(proc,genJetTaskName)) return proc @@ -951,14 +1157,14 @@ def ReclusterAK4GenJets(proc, genJA): proc.genJetTable.cut = "" # No cut specified here. Save all gen jets after clustering proc.genJetTable.doc = "AK4 Gen jets (made with visible genparticles) with pt > 3 GeV" # default pt cut after clustering is 3 GeV - genJetFlavourAssociationThisJet = "genJet{}FlavourAssociation".format(genJetName) - setattr(proc, genJetFlavourAssociationThisJet, genJetFlavourAssociation.clone( + genJetFlavourAssociationName = "genJet{}FlavourAssociation".format(genJetName) + setattr(proc, genJetFlavourAssociationName, genJetFlavourAssociation.clone( jets = proc.genJetTable.src, jetAlgorithm = supportedJetAlgos[genJetAlgo], rParam = genJetSizeNr, ) ) - proc.jetMC.insert(proc.jetMC.index(proc.genJetFlavourTable), getattr(proc, genJetFlavourAssociationThisJet)) + proc.jetMCTask.add(getattr(proc, genJetFlavourAssociationName)) return proc def AddNewAK8GenJetsForJEC(proc, genJA): @@ -1006,6 +1212,7 @@ def RemoveAllJetPtCuts(proc): """ proc.finalJets.cut = "" # 15 -> 10 + proc.finalJetsPuppi.cut = "" # 15 -> 10 proc.finalJetsAK8.cut = "" # 170 -> 170 proc.genJetTable.cut = "" # 10 -> 8 proc.genJetFlavourTable.cut = "" # 10 -> 8 @@ -1077,6 +1284,10 @@ def PrepJMECustomNanoAOD(process,runOnMC): ########################################################################### process = ReclusterAK4CHSJets(process, recoJA, runOnMC) ########################################################################### + # Recluster AK4 Puppi jets and replace "slimmedJets" + ########################################################################### + process = ReclusterAK4PuppiJets(process, recoJA, runOnMC) + ########################################################################### # Add additional Reco jets to NanoAOD ########################################################################### for jetConfig in config_recojets: @@ -1084,6 +1295,35 @@ def PrepJMECustomNanoAOD(process,runOnMC): recoJetInfo = recoJA.addRecoJetCollection(process, **cfg) AddNewPatJets(process, recoJetInfo, runOnMC) + ########################################################################### + # Add jet tasks + # By default for Run-3, add AK4 CHS jet tasks. + # For Run-2 eras, add AK4 Puppi jet tasks + ########################################################################### + def addAK4JetTasks(proc, addAK4CHSJetTasks, addAK4PuppiJetTasks): + if addAK4CHSJetTasks: + proc.nanoTableTaskCommon.add(proc.jetTask) + proc.nanoTableTaskCommon.add(proc.jetTablesTask) + proc.nanoTableTaskCommon.add(proc.jetForMETTask) + if addAK4PuppiJetTasks: + proc.nanoTableTaskCommon.add(proc.jetPuppiTask) + proc.nanoTableTaskCommon.add(proc.jetPuppiTablesTask) + proc.nanoTableTaskCommon.add(proc.jetPuppiForMETTask) + return proc + + jmeNano_addAK4JetTasks_switch = cms.PSet( + jmeNano_addAK4CHS_switch = cms.untracked.bool(True), + jmeNano_addAK4Puppi_switch = cms.untracked.bool(False) + ) + run2_nanoAOD_ANY.toModify(jmeNano_addAK4JetTasks_switch, + jmeNano_addAK4CHS_switch = False, + jmeNano_addAK4Puppi_switch = True + ) + process = addAK4JetTasks(process, + addAK4CHSJetTasks = jmeNano_addAK4JetTasks_switch.jmeNano_addAK4CHS_switch, + addAK4PuppiJetTasks = jmeNano_addAK4JetTasks_switch.jmeNano_addAK4Puppi_switch, + ) + ########################################################################### # Save Maximum of Pt Hat Max ########################################################################### @@ -1098,10 +1338,15 @@ def PrepJMECustomNanoAOD(process,runOnMC): return process +from PhysicsTools.NanoAOD.V10.nano_cff import nanoAOD_customizeV10 + def PrepJMECustomNanoAOD_MC(process): - PrepJMECustomNanoAOD(process,runOnMC=True) + process = nanoAOD_customizeV10(process) + process = PrepJMECustomNanoAOD(process,runOnMC=True) + return process def PrepJMECustomNanoAOD_Data(process): - PrepJMECustomNanoAOD(process,runOnMC=False) + process = nanoAOD_customizeV10(process) + process = PrepJMECustomNanoAOD(process,runOnMC=False) return process diff --git a/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py b/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py index 066c0ef798575..b20f3dd24d730 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetCollectionTools.py @@ -2,6 +2,8 @@ from PhysicsTools.PatAlgos.tools.ConfigToolBase import * +from CommonTools.ParticleFlow.pfCHS_cff import pfCHS + from CommonTools.PileupAlgos.Puppi_cff import puppi from CommonTools.PileupAlgos.softKiller_cfi import softKiller @@ -283,7 +285,9 @@ def addRecoJetCollection(self, # elif recoJetInfo.jetPUMethod == "chs": self.addProcessAndTask(proc, pfCand, pfCHS.clone( - src = self.pfLabel)) + src = self.pfLabel + ) + ) self.prerequisites.append(pfCand) # # PUPPI @@ -292,6 +296,8 @@ def addRecoJetCollection(self, self.addProcessAndTask(proc, pfCand, puppi.clone( candName = self.pfLabel, vertexName = self.pvLabel, + clonePackedCands = True, + useExistingWeights = True, ) ) self.prerequisites.append(pfCand)