CMS 3D CMS Logo
custom_jme_cff.py
Go to the documentation of this file.
1 import FWCore.ParameterSet.Config as cms
2 
3 from Configuration.Eras.Modifier_run2_jme_2016_cff import run2_jme_2016
4 from Configuration.Eras.Modifier_run2_jme_2017_cff import run2_jme_2017
5 
6 from PhysicsTools.NanoAOD.common_cff import Var, P4Vars
7 from PhysicsTools.NanoAOD.jets_cff import jetTable
8 
9 from PhysicsTools.PatAlgos.tools.jetCollectionTools import GenJetAdder, RecoJetAdder
10 
11 import copy
12 
13 #
14 # By default, these collections are saved in NanoAODs:
15 # - ak4gen (GenJet in NanoAOD)
16 # - ak8gen (GenJetAK8 in NanoAOD)
17 # Below is a list of genjets that we can save in NanoAOD. Set
18 # "enabled" to true if you want to store the jet collection
19 config_genjets = [
20  {
21  "jet" : "ak5gen",
22  "enabled" : False,
23  },
24  {
25  "jet" : "ak6gen",
26  "enabled" : False,
27  },
28  {
29  "jet" : "ak7gen",
30  "enabled" : False,
31  },
32  {
33  "jet" : "ak9gen",
34  "enabled" : False,
35  },
36  {
37  "jet" : "ak10gen",
38  "enabled" : False,
39  },
40 ]
41 config_genjets = list(filter(lambda k: k['enabled'], config_genjets))
42 #
43 # GenJets info in NanoAOD
44 #
45 nanoInfo_genjets = {
46  "ak5gen" : {
47  "name" : "GenJetAK5",
48  "doc" : "AK5 jets",
49  },
50  "ak6gen" : {
51  "name" : "GenJetAK6",
52  "doc" : "AK6 jets",
53  },
54  "ak7gen" : {
55  "name" : "GenJetAK7",
56  "doc" : "AK9 jets",
57  },
58  "ak9gen" : {
59  "name" : "GenJetAK9",
60  "doc" : "AK9 jets",
61  },
62  "ak10gen" : {
63  "name" : "GenJetAK10",
64  "doc" : "AK10 jets",
65  },
66 }
67 #
68 # By default, these collections are saved in NanoAODs:
69 # - ak4pfchs (Jet in NanoAOD)
70 # - ak8pfpuppi (FatJet in NanoAOD)
71 # By default, the ak4pfchs (Jet) and ak8pfpuppi (FatJet) collections
72 # are saved in NanoAODs.
73 # Below is a list of recojets that we can save in NanoAOD. Set "enabled"
74 # to true if you want to store the recojet collection.
75 #
76 config_recojets = [
77  {
78  "jet" : "ak4pfpuppi",
79  "enabled" : True,
80  "inputCollection" : "slimmedJetsPuppi", #Exist in MiniAOD
81  "genJetsCollection": "slimmedGenJets",
82  },
83  {
84  "jet" : "ak4calo",
85  "enabled" : True,
86  "inputCollection" : "slimmedCaloJets", #Exist in MiniAOD
87  "genJetsCollection": "slimmedGenJets",
88  },
89  {
90  "jet" : "ak4pf",
91  "enabled" : True,
92  "inputCollection" : "",
93  "genJetsCollection": "slimmedGenJets",
94  },
95  {
96  "jet" : "ak8pf",
97  "enabled" : True,
98  "inputCollection" : "",
99  "genJetsCollection": "slimmedGenJetsAK8",
100  },
101  {
102  "jet" : "ak8pfchs",
103  "enabled" : True,
104  "inputCollection" : "",
105  "genJetsCollection": "slimmedGenJetsAK8",
106  },
107  {
108  "jet" : "ak6pf",
109  "enabled" : False,
110  "inputCollection" : "",
111  "genJetsCollection": "AK6GenJetsNoNu",
112  },
113  {
114  "jet" : "ak10pf",
115  "enabled" : False,
116  "inputCollection" : "",
117  "genJetsCollection": "AK10GenJetsNoNu",
118  },
119 ]
120 config_recojets = list(filter(lambda k: k['enabled'], config_recojets))
121 #
122 # RecoJets info in NanoAOD
123 #
124 nanoInfo_recojets = {
125  "ak4pfpuppi" : {
126  "name" : "JetPUPPI",
127  "doc" : "AK4PFPUPPI jets",
128  },
129  "ak4calo" : {
130  "name": "JetCalo",
131  "doc" : "AK4Calo jets",
132  },
133  "ak4pf" : {
134  "name": "JetPF",
135  "doc" : "AK4PF jets",
136  },
137  "ak8pf" : {
138  "name": "FatJetPF",
139  "doc" : "AK8PF jets",
140  },
141  "ak8pfchs" : {
142  "name" : "FatJetCHS",
143  "doc" : "AK8PFCHS jets",
144  },
145  "ak6pf" : {
146  "name": "JetAK6PF",
147  "doc" : "AK6PF jets",
148  },
149  "ak10pf" : {
150  "name" : "FatJetAK10PF",
151  "doc" : "AK10PF jets",
152  },
153 }
154 
155 #
156 # The reco jet names already exists
157 # in NanoAOD.
158 #
159 recojetNameInNano = [ "Jet", "FatJet" ]
160 #
161 # The gen jet names already exists
162 # in NanoAOD.
163 #
164 genjetNameInNano = [ "GenJet", "GenJetAK8" ]
165 
166 JETVARS = cms.PSet(P4Vars,
167  HFHEF = Var("HFHadronEnergyFraction()", float, doc = "energy fraction in forward hadronic calorimeter", precision = 6),
168  HFEMEF = Var("HFEMEnergyFraction()", float, doc = "energy fraction in forward EM calorimeter", precision = 6),
169  area = jetTable.variables.area,
170  chHEF = jetTable.variables.chHEF,
171  neHEF = jetTable.variables.neHEF,
172  chEmEF = jetTable.variables.chEmEF,
173  neEmEF = jetTable.variables.neEmEF,
174  muEF = jetTable.variables.muEF,
175  rawFactor = jetTable.variables.rawFactor,
176  jetId = jetTable.variables.jetId,
177  chFPV0EF = jetTable.variables.chFPV0EF,
178  chFPV1EF = jetTable.variables.chFPV1EF,
179  chFPV2EF = jetTable.variables.chFPV2EF,
180  chFPV3EF = jetTable.variables.chFPV3EF,
181 )
182 
183 #============================================
184 #
185 # TableGenJetAdder
186 #
187 #============================================
188 class TableGenJetAdder(object):
189  """
190  Tool to store gen jet variables in NanoAOD for customized
191  gen jet collections.
192  """
193  def __init__(self):
194  self.main = []
195 
196  def getSequence(self, proc):
197  """
198  Tool to add
199  """
200  tasks = self.main
201 
202  resultSequence = cms.Sequence()
203  for idx, task in enumerate(tasks):
204  if idx == 0:
205  resultSequence = cms.Sequence(getattr(proc, task))
206  else:
207  resultSequence.insert(idx, getattr(proc, task))
208  return resultSequence
209 
210  def addTable(self, proc, genJetInfo):
211  currentTasks = []
212 
213  print("custom_jme_cff::TableGenJetAdder::addTable: Adding Table for GenJet Collection: {}".format(genJetInfo.jet))
214 
215  name = nanoInfo_genjets[genJetInfo.jet]["name"]
216  doc = nanoInfo_genjets[genJetInfo.jet]["doc"]
217 
218  if name in genjetNameInNano:
219  raise RuntimeError('GenJet collection name (%s) taken in NanoAOD for %s' %(name, genJetInfo.jet))
220 
221  #
222  # GenJet Table
223  #
224  table = "{}Table".format(genJetInfo.jetTagName)
225  genJetsCollection = "{}{}{}".format(genJetInfo.jetAlgo.upper(), genJetInfo.jetSize, 'GenJetsNoNu')
226  setattr(proc, table, cms.EDProducer("SimpleCandidateFlatTableProducer",
227  src = cms.InputTag(genJetsCollection),
228  cut = cms.string(""),
229  name = cms.string(name),
230  doc = cms.string('{} (generator level)'.format(doc)),
231  singleton = cms.bool(False),
232  extension = cms.bool(False),
233  variables = cms.PSet(P4Vars,
234  area = jetTable.variables.area,
235  ),
236  )
237  )
238  currentTasks.append(table)
239 
240  #
241  # GenJet Flavour Table
242  #
243  genFlavour = "{}Flavour".format(genJetInfo.jetTagName)
244  genFlavourTable = "{}Table".format(genFlavour)
245  if genFlavourTable in self.main:
246  raise ValueError("Step '%s' already implemented" % genFlavourTable)
247  setattr(proc, genFlavourTable, cms.EDProducer("GenJetFlavourTableProducer",
248  name = cms.string(name),
249  src = cms.InputTag(genJetsCollection),
250  cut = cms.string(""),
251  deltaR = cms.double(0.1),
252  jetFlavourInfos = cms.InputTag(genFlavour),
253  )
254  )
255  currentTasks.append(genFlavourTable)
256  self.main.extend(currentTasks)
257 
258 #============================================
259 #
260 # TableRecoJetAdder
261 #
262 #============================================
263 class TableRecoJetAdder(object):
264  """
265  Tool to store reco jet variables in NanoAOD for customized
266  reco jet collections.
267  """
268  def __init__(self):
269  self.main = []
270 
271  def getSequence(self, proc):
272  tasks = self.main
273 
274  resultSequence = cms.Sequence()
275  for idx, task in enumerate(tasks):
276  if idx == 0:
277  resultSequence = cms.Sequence(getattr(proc, task))
278  else:
279  resultSequence.insert(idx, getattr(proc, task))
280  return resultSequence
281 
282  def addTable(self, proc, recoJetInfo):
283 
284  currentTasks = []
285 
286  print("custom_jme_cff::TableRecoJetAdder::addTable: Adding Table for Reco Jet Collection: {}".format(recoJetInfo.jet))
287 
288  name = nanoInfo_recojets[recoJetInfo.jet]["name"]
289  doc = nanoInfo_recojets[recoJetInfo.jet]["doc"]
290 
291  if name in recojetNameInNano:
292  raise RuntimeError('RecoJet collection name (%s) taken in NanoAOD for %s' %(name, recoJetInfo.jet))
293 
294  table = "{}Table".format(recoJetInfo.jetTagName)
295  if recoJetInfo.skipUserData:
296  if recoJetInfo.doCalo:
297  tableContents = cms.PSet(
298  P4Vars,
299  area = jetTable.variables.area,
300  rawFactor = jetTable.variables.rawFactor,
301  emf = Var("emEnergyFraction()", float, doc = "electromagnetic energy fraction", precision = 10),
302  )
303  else:
304  tableContents = cms.PSet(
305  P4Vars,
306  area = jetTable.variables.area,
307  rawFactor = jetTable.variables.rawFactor,
308  )
309  else:
310  tableContents = JETVARS.clone()
311 
312  updatedJets = "updatedJets{}".format(recoJetInfo.jetTagName)
313  setattr(proc, table, cms.EDProducer("SimpleCandidateFlatTableProducer",
314  src = cms.InputTag(updatedJets),
315  cut = cms.string(""),
316  name = cms.string(name),
317  doc = cms.string(doc),
318  singleton = cms.bool(False),
319  extension = cms.bool(False),
320  variables = tableContents,
321  )
322  )
323  currentTasks.append(table)
324 
325  self.main.extend(currentTasks)
326 
327 def AddPileUpJetIDVars(proc):
328 
329  print("custom_jme_cff::AddPileUpJetIDVars: Recalculate pile-up jet ID variables and save them")
330 
331  #
332  # Recalculate PUJet ID variables
333  #
334  from RecoJets.JetProducers.PileupJetID_cfi import pileupJetIdCalculator
335  proc.pileupJetIdCalculatorAK4PFCHS = pileupJetIdCalculator.clone(
336  jets = "updatedJets",
337  vertexes = "offlineSlimmedPrimaryVertices",
338  inputIsCorrected = True,
339  applyJec = False
340  )
341  proc.jetSequence.insert(proc.jetSequence.index(proc.updatedJets)+1, proc.pileupJetIdCalculatorAK4PFCHS)
342 
343  #
344  # Get the variables
345  #
346  proc.puJetVarAK4PFCHS = cms.EDProducer("PileupJetIDVarProducer",
347  srcJet = cms.InputTag("updatedJets"),
348  srcPileupJetId = cms.InputTag("pileupJetIdCalculatorAK4PFCHS")
349  )
350  proc.jetSequence.insert(proc.jetSequence.index(proc.jercVars)+1, proc.puJetVarAK4PFCHS)
351 
352  #
353  # Save variables as userFloats and userInts in each jet
354  #
355  proc.updatedJetsWithUserData.userFloats.dR2Mean = cms.InputTag("puJetVarAK4PFCHS:dR2Mean")
356  proc.updatedJetsWithUserData.userFloats.majW = cms.InputTag("puJetVarAK4PFCHS:majW")
357  proc.updatedJetsWithUserData.userFloats.minW = cms.InputTag("puJetVarAK4PFCHS:minW")
358  proc.updatedJetsWithUserData.userFloats.frac01 = cms.InputTag("puJetVarAK4PFCHS:frac01")
359  proc.updatedJetsWithUserData.userFloats.frac02 = cms.InputTag("puJetVarAK4PFCHS:frac02")
360  proc.updatedJetsWithUserData.userFloats.frac03 = cms.InputTag("puJetVarAK4PFCHS:frac03")
361  proc.updatedJetsWithUserData.userFloats.frac04 = cms.InputTag("puJetVarAK4PFCHS:frac04")
362  proc.updatedJetsWithUserData.userFloats.ptD = cms.InputTag("puJetVarAK4PFCHS:ptD")
363  proc.updatedJetsWithUserData.userFloats.beta = cms.InputTag("puJetVarAK4PFCHS:beta")
364  proc.updatedJetsWithUserData.userFloats.pull = cms.InputTag("puJetVarAK4PFCHS:pull")
365  proc.updatedJetsWithUserData.userFloats.jetR = cms.InputTag("puJetVarAK4PFCHS:jetR")
366  proc.updatedJetsWithUserData.userFloats.jetRchg = cms.InputTag("puJetVarAK4PFCHS:jetRchg")
367  proc.updatedJetsWithUserData.userInts.nCharged = cms.InputTag("puJetVarAK4PFCHS:nCharged")
368 
369  #
370  # Specfiy variables in the jetTable to save in NanoAOD
371  #
372  proc.jetTable.variables.dR2Mean = Var("userFloat('dR2Mean')", float, doc="pT^2-weighted average square distance of jet constituents from the jet axis", precision= 6)
373  proc.jetTable.variables.majW = Var("userFloat('majW')", float, doc="major axis of jet ellipsoid in eta-phi plane", precision= 6)
374  proc.jetTable.variables.minW = Var("userFloat('minW')", float, doc="minor axis of jet ellipsoid in eta-phi plane", precision= 6)
375  proc.jetTable.variables.frac01 = Var("userFloat('frac01')", float, doc="frac of constituents' pT contained within dR<0.1", precision= 6)
376  proc.jetTable.variables.frac02 = Var("userFloat('frac02')", float, doc="frac of constituents' pT contained within 0.1<dR<0.2", precision= 6)
377  proc.jetTable.variables.frac03 = Var("userFloat('frac03')", float, doc="frac of constituents' pT contained within 0.2<dR<0.3", precision= 6)
378  proc.jetTable.variables.frac04 = Var("userFloat('frac04')", float, doc="frac of constituents' pT contained within 0.3<dR<0.4", precision= 6)
379  proc.jetTable.variables.ptD = Var("userFloat('ptD')", float, doc="pT-weighted average pT of constituents", precision= 6)
380  proc.jetTable.variables.beta = Var("userFloat('beta')", float, doc="fraction of pT of charged constituents associated to PV", precision= 6)
381  proc.jetTable.variables.pull = Var("userFloat('pull')", float, doc="magnitude of pull vector", precision= 6)
382  proc.jetTable.variables.jetR = Var("userFloat('jetR')", float, doc="fraction of jet pT carried by the leading constituent", precision= 6)
383  proc.jetTable.variables.jetRchg = Var("userFloat('jetRchg')", float, doc="fraction of jet pT carried by the leading charged constituent", precision= 6)
384  proc.jetTable.variables.nCharged = Var("userInt('nCharged')", int, doc="number of charged constituents")
385 
386 def AddQGLTaggerVars(proc):
387  #
388  # Save variables as userFloats and userInts
389  #
390  proc.updatedJetsWithUserData.userFloats.qgl_axis2 = cms.InputTag("qgtagger:axis2")
391  proc.updatedJetsWithUserData.userFloats.qgl_ptD = cms.InputTag("qgtagger:ptD")
392  proc.updatedJetsWithUserData.userInts.qgl_mult = cms.InputTag("qgtagger:mult")
393  #
394  # Specfiy variables in the jetTable to save in NanoAOD
395  #
396  proc.jetTable.variables.qgl_axis2 = Var("userFloat('qgl_axis2')", float, doc="ellipse minor jet axis (Quark vs Gluon likelihood input variable)", precision= 6)
397  proc.jetTable.variables.qgl_ptD = Var("userFloat('qgl_ptD')", float, doc="pT-weighted average pT of constituents (Quark vs Gluon likelihood input variable)", precision= 6)
398  proc.jetTable.variables.qgl_mult = Var("userInt('qgl_mult')", int, doc="PF candidates multiplicity (Quark vs Gluon likelihood input variable)")
399 
400 def AddDeepJetGluonLQuarkScores(proc):
401  #
402  # Save DeepJet raw score for gluon and light quark
403  #
404  proc.jetTable.variables.btagDeepFlavG = Var("bDiscriminator('pfDeepFlavourJetTags:probg')",float,doc="DeepFlavour gluon tag raw score",precision=10)
405  proc.jetTable.variables.btagDeepFlavUDS = Var("bDiscriminator('pfDeepFlavourJetTags:probuds')",float,doc="DeepFlavour uds tag raw score",precision=10)
406 
407 def PrepJMECustomNanoAOD(process,runOnMC):
408  #
409  # Additional variables to AK4GenJets
410  #
411  process.genJetTable.variables.area = JETVARS.area
412  #
413  # Additional variables to AK8GenJets
414  #
415  process.genJetAK8Table.variables.area = JETVARS.area
416  #
417  # Additional variables for AK4PFCHS
418  #
419  process.jetTable.variables.HFHEF = JETVARS.HFHEF
420  process.jetTable.variables.HFEMEF = JETVARS.HFEMEF
421  #
422  # Additional variables to AK8PFPUPPI
423  #
424  # These variables are not stored for AK8PFCHS (slimmedJetsAK8)
425  # in MiniAOD if their pt < 170 GeV. Hence the conditional fill.
426  #
427  process.fatJetTable.variables.chHEF = Var("?isPFJet()?chargedHadronEnergyFraction():-1", float, doc="charged Hadron Energy Fraction", precision = 6)
428  process.fatJetTable.variables.neHEF = Var("?isPFJet()?neutralHadronEnergyFraction():-1", float, doc="neutral Hadron Energy Fraction", precision = 6)
429  process.fatJetTable.variables.chEmEF = Var("?isPFJet()?chargedEmEnergyFraction():-1", float, doc="charged Electromagnetic Energy Fraction", precision = 6)
430  process.fatJetTable.variables.neEmEF = Var("?isPFJet()?neutralEmEnergyFraction():-1", float, doc="neutral Electromagnetic Energy Fraction", precision = 6)
431  process.fatJetTable.variables.muEF = Var("?isPFJet()?muonEnergyFraction():-1", float, doc="muon Energy Fraction", precision = 6)
432  process.fatJetTable.variables.HFHEF = Var("?isPFJet()?HFHadronEnergyFraction():-1", float, doc="energy fraction in forward hadronic calorimeter", precision = 6)
433  process.fatJetTable.variables.HFEMEF = Var("?isPFJet()?HFEMEnergyFraction():-1", float, doc="energy fraction in forward EM calorimeter", precision = 6)
434  #
435  #
436  #
437  process.jercVarsFatJet = process.jercVars.clone(
438  srcJet = "updatedJetsAK8",
439  maxDR = 0.8,
440  )
441  process.jetSequence.insert(process.jetSequence.index(process.updatedJetsAK8WithUserData), process.jercVarsFatJet)
442 
443  process.updatedJetsAK8WithUserData.userFloats = cms.PSet(
444  chFPV0EF = cms.InputTag("%s:chargedFromPV0EnergyFraction" %process.jercVarsFatJet.label()),
445  chFPV1EF = cms.InputTag("%s:chargedFromPV1EnergyFraction" %process.jercVarsFatJet.label()),
446  chFPV2EF = cms.InputTag("%s:chargedFromPV2EnergyFraction" %process.jercVarsFatJet.label()),
447  chFPV3EF = cms.InputTag("%s:chargedFromPV3EnergyFraction" %process.jercVarsFatJet.label()),
448  )
449 
450  process.fatJetTable.variables.chFPV0EF = JETVARS.chFPV0EF
451  process.fatJetTable.variables.chFPV1EF = JETVARS.chFPV1EF
452  process.fatJetTable.variables.chFPV2EF = JETVARS.chFPV2EF
453  process.fatJetTable.variables.chFPV3EF = JETVARS.chFPV3EF
454 
455  #
456  #
457  #
458  process.finalJets.cut = "" # 15 -> 10
459  process.finalJetsAK8.cut = "" # 170 -> 170
460  process.genJetTable.cut = "" # 10 -> 8
461  process.genJetFlavourTable.cut = "" # 10 -> 8
462  process.genJetAK8Table.cut = "" # 100 -> 80
463  process.genJetAK8FlavourTable.cut = "" # 100 -> 80
464  #
465  # Add variables for pileup jet ID studies.
466  #
467  AddPileUpJetIDVars(process)
468  #
469  # Add variables for quark guon likelihood tagger studies.
470  #
471  AddQGLTaggerVars(process)
472  #
473  # Add DeepJet scores for gluon and light quarks tagging
474  #
475  AddDeepJetGluonLQuarkScores(process)
476 
477 
478 
479  #
480  # Add GenJets to NanoAOD
481  #
482  genJA = GenJetAdder()
483  tableGenJA = TableGenJetAdder()
484 
485  for jetConfig in config_genjets:
486  cfg = { k : v for k, v in jetConfig.items() if k != "enabled" }
487  genJetInfo = genJA.addGenJetCollection(process, **cfg)
488  tableGenJA.addTable(process, genJetInfo)
489 
490  #
491  # Add RecoJets to NanoAOD
492  #
493  recoJA = RecoJetAdder(runOnMC=runOnMC)
494  tableRecoJA = TableRecoJetAdder()
495 
496  for jetConfig in config_recojets:
497  cfg = { k : v for k, v in jetConfig.items() if k != "enabled" }
498  recoJetInfo = recoJA.addRecoJetCollection(process, **cfg)
499  tableRecoJA.addTable(process, recoJetInfo)
500 
501  if runOnMC:
502  process.nanoSequenceMC += genJA.getSequence(process)
503  process.nanoSequenceMC += recoJA.getSequence(process)
504  process.nanoSequenceMC += tableGenJA.getSequence(process)
505  process.nanoSequenceMC += tableRecoJA.getSequence(process)
506  else:
507  process.nanoSequence += recoJA.getSequence(process)
508  process.nanoSequence += tableRecoJA.getSequence(process)
509 
510  return process
511 
512 def PrepJMECustomNanoAOD_MC(process):
513  PrepJMECustomNanoAOD(process,runOnMC=True)
514  return process
515 
516 def PrepJMECustomNanoAOD_Data(process):
517  PrepJMECustomNanoAOD(process,runOnMC=False)
518  return process
resolutioncreator_cfi.object
object
Definition: resolutioncreator_cfi.py:4
custom_jme_cff.TableRecoJetAdder.__init__
def __init__(self)
Definition: custom_jme_cff.py:268
custom_jme_cff.AddPileUpJetIDVars
def AddPileUpJetIDVars(proc)
Definition: custom_jme_cff.py:327
custom_jme_cff.TableGenJetAdder.__init__
def __init__(self)
Definition: custom_jme_cff.py:193
common_cff
custom_jme_cff.TableGenJetAdder.main
main
Definition: custom_jme_cff.py:194
custom_jme_cff.PrepJMECustomNanoAOD_MC
def PrepJMECustomNanoAOD_MC(process)
Definition: custom_jme_cff.py:512
common_cff.Var
def Var(expr, valtype, compression=None, doc=None, mcOnly=False, precision=-1)
Definition: common_cff.py:20
ALCARECOTkAlBeamHalo_cff.filter
filter
Definition: ALCARECOTkAlBeamHalo_cff.py:27
custom_jme_cff.TableGenJetAdder.getSequence
def getSequence(self, proc)
Definition: custom_jme_cff.py:196
custom_jme_cff.AddQGLTaggerVars
def AddQGLTaggerVars(proc)
Definition: custom_jme_cff.py:386
custom_jme_cff.PrepJMECustomNanoAOD
def PrepJMECustomNanoAOD(process, runOnMC)
Definition: custom_jme_cff.py:407
custom_jme_cff.TableRecoJetAdder.getSequence
def getSequence(self, proc)
Definition: custom_jme_cff.py:271
custom_jme_cff.PrepJMECustomNanoAOD_Data
def PrepJMECustomNanoAOD_Data(process)
Definition: custom_jme_cff.py:516
jets_cff
custom_jme_cff.TableRecoJetAdder.main
main
Definition: custom_jme_cff.py:269
edm::print
S & print(S &os, JobReport::InputFile const &f)
Definition: JobReport.cc:66
custom_jme_cff.TableRecoJetAdder.addTable
def addTable(self, proc, recoJetInfo)
Definition: custom_jme_cff.py:282
custom_jme_cff.TableGenJetAdder
Definition: custom_jme_cff.py:188
format
PileupJetID_cfi
list
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger list("!*", "!HLTx*" if it matches 2 triggers or more) will accept the event if all the matching triggers are FAIL. It will reject the event if any of the triggers are PASS or EXCEPTION(this matches the behavior of "!*" before the partial wildcard feature was incorporated). Triggers which are in the READY state are completely ignored.(READY should never be returned since the trigger paths have been run
custom_jme_cff.TableRecoJetAdder
Definition: custom_jme_cff.py:263
custom_jme_cff.TableGenJetAdder.addTable
def addTable(self, proc, genJetInfo)
Definition: custom_jme_cff.py:210
custom_jme_cff.AddDeepJetGluonLQuarkScores
def AddDeepJetGluonLQuarkScores(proc)
Definition: custom_jme_cff.py:400
Generated for CMSSW Reference Manual by doxygen 1.8.16