CMS 3D CMS Logo
runTauIdMVA.py
Go to the documentation of this file.
1 from __future__ import print_function
2 import FWCore.ParameterSet.Config as cms
3 from RecoTauTag.RecoTau.TauDiscriminatorTools import noPrediscriminants
4 from RecoTauTag.RecoTau.PATTauDiscriminationByMVAIsolationRun2_cff import patDiscriminationByIsolationMVArun2v1raw, patDiscriminationByIsolationMVArun2v1
5 import os
6 import re
7 import six
8 
9 class TauIDEmbedder(object):
10  """class to rerun the tau seq and acces trainings from the database"""
11  availableDiscriminators = [
12  "2017v1", "2017v2", "newDM2017v2", "dR0p32017v2", "2016v1", "newDM2016v1",
13  "deepTau2017v1", "deepTau2017v2", "deepTau2017v2p1",
14  "DPFTau_2016_v0", "DPFTau_2016_v1",
15  "againstEle2018"
16  ]
17 
18  def __init__(self, process, debug = False,
19  updatedTauName = "slimmedTausNewID",
20  toKeep = ["deepTau2017v2p1"],
21  tauIdDiscrMVA_trainings_run2_2017 = { 'tauIdMVAIsoDBoldDMwLT2017' : "tauIdMVAIsoDBoldDMwLT2017", },
22  tauIdDiscrMVA_WPs_run2_2017 = {
23  'tauIdMVAIsoDBoldDMwLT2017' : {
24  'Eff95' : "DBoldDMwLTEff95",
25  'Eff90' : "DBoldDMwLTEff90",
26  'Eff80' : "DBoldDMwLTEff80",
27  'Eff70' : "DBoldDMwLTEff70",
28  'Eff60' : "DBoldDMwLTEff60",
29  'Eff50' : "DBoldDMwLTEff50",
30  'Eff40' : "DBoldDMwLTEff40"
31  }
32  },
33  tauIdDiscrMVA_2017_version = "v1",
34  conditionDB = "" # preparational DB: 'frontier://FrontierPrep/CMS_CONDITIONS'
35  ):
36  super(TauIDEmbedder, self).__init__()
37  self.process = process
38  self.debug = debug
39  self.updatedTauName = updatedTauName
40  self.process.load('RecoTauTag.Configuration.loadRecoTauTagMVAsFromPrepDB_cfi')
41  if len(conditionDB) != 0:
42  self.process.CondDBTauConnection.connect = cms.string(conditionDB)
43  self.process.loadRecoTauTagMVAsFromPrepDB.connect = cms.string(conditionDB)
44  # if debug:
45  # print self.process.CondDBTauConnection.connect
46  # print dir(self.process.loadRecoTauTagMVAsFromPrepDB)
47  # print self.process.loadRecoTauTagMVAsFromPrepDB.parameterNames_
48 
49  self.tauIdDiscrMVA_trainings_run2_2017 = tauIdDiscrMVA_trainings_run2_2017
50  self.tauIdDiscrMVA_WPs_run2_2017 = tauIdDiscrMVA_WPs_run2_2017
51  self.tauIdDiscrMVA_2017_version = tauIdDiscrMVA_2017_version
52  for discr in toKeep:
53  if discr not in TauIDEmbedder.availableDiscriminators:
54  raise RuntimeError('TauIDEmbedder: discriminator "{}" is not supported'.format(discr))
55  self.toKeep = toKeep
56 
57 
58  @staticmethod
59  def get_cmssw_version(debug = False):
60  """returns 'CMSSW_X_Y_Z'"""
61  cmssw_version = os.environ["CMSSW_VERSION"]
62  if debug: print ("get_cmssw_version:", cmssw_version)
63  return cmssw_version
64 
65  @classmethod
66  def get_cmssw_version_number(klass, debug = False):
67  """returns '(release, subversion, patch)' (without 'CMSSW_')"""
68  v = klass.get_cmssw_version().split("CMSSW_")[1].split("_")[0:3]
69  if debug: print ("get_cmssw_version_number:", v)
70  if v[2] == "X":
71  patch = -1
72  else:
73  patch = int(v[2])
74  return int(v[0]), int(v[1]), patch
75 
76  @staticmethod
77  def versionToInt(release=9, subversion=4, patch=0, debug = False):
78  version = release * 10000 + subversion * 100 + patch + 1 # shifted by one to account for pre-releases.
79  if debug: print ("versionToInt:", version)
80  return version
81 
82 
83  @classmethod
84  def is_above_cmssw_version(klass, release=9, subversion=4, patch=0, debug = False):
85  split_cmssw_version = klass.get_cmssw_version_number()
86  if klass.versionToInt(release, subversion, patch) > klass.versionToInt(split_cmssw_version[0], split_cmssw_version[1], split_cmssw_version[2]):
87  if debug: print ("is_above_cmssw_version:", False)
88  return False
89  else:
90  if debug: print ("is_above_cmssw_version:", True)
91  return True
92 
93  def tauIDMVAinputs(self, module, wp):
94  return cms.PSet(inputTag = cms.InputTag(module), workingPointIndex = cms.int32(-1 if wp=="raw" else -2 if wp=="category" else getattr(self.process, module).workingPoints.index(wp)))
95 
96  def loadMVA_WPs_run2_2017(self):
97  if self.debug: print ("loadMVA_WPs_run2_2017: performed")
98  global cms
99  for training, gbrForestName in self.tauIdDiscrMVA_trainings_run2_2017.items():
100 
101  self.process.loadRecoTauTagMVAsFromPrepDB.toGet.append(
102  cms.PSet(
103  record = cms.string('GBRWrapperRcd'),
104  tag = cms.string("RecoTauTag_%s%s" % (gbrForestName, self.tauIdDiscrMVA_2017_version)),
105  label = cms.untracked.string("RecoTauTag_%s%s" % (gbrForestName, self.tauIdDiscrMVA_2017_version))
106  )
107  )
108 
109  for WP in self.tauIdDiscrMVA_WPs_run2_2017[training].keys():
110  self.process.loadRecoTauTagMVAsFromPrepDB.toGet.append(
111  cms.PSet(
112  record = cms.string('PhysicsTGraphPayloadRcd'),
113  tag = cms.string("RecoTauTag_%s%s_WP%s" % (gbrForestName, self.tauIdDiscrMVA_2017_version, WP)),
114  label = cms.untracked.string("RecoTauTag_%s%s_WP%s" % (gbrForestName, self.tauIdDiscrMVA_2017_version, WP))
115  )
116  )
117 
118  self.process.loadRecoTauTagMVAsFromPrepDB.toGet.append(
119  cms.PSet(
120  record = cms.string('PhysicsTFormulaPayloadRcd'),
121  tag = cms.string("RecoTauTag_%s%s_mvaOutput_normalization" % (gbrForestName, self.tauIdDiscrMVA_2017_version)),
122  label = cms.untracked.string("RecoTauTag_%s%s_mvaOutput_normalization" % (gbrForestName, self.tauIdDiscrMVA_2017_version))
123  )
124  )
125 
126  def runTauID(self):
127  self.process.rerunMvaIsolationTask = cms.Task()
128  self.process.rerunMvaIsolationSequence = cms.Sequence()
129  tauIDSources = cms.PSet()
130 
131  # rerun the seq to obtain the 2017 nom training with 0.5 iso cone, old DM, ptph>1, trained on 2017MCv1
132  if "2017v1" in self.toKeep:
133  self.tauIdDiscrMVA_2017_version = "v1"
134  self.tauIdDiscrMVA_trainings_run2_2017 = {
135  'tauIdMVAIsoDBoldDMwLT2017' : "tauIdMVAIsoDBoldDMwLT2017",
136  }
137  self.tauIdDiscrMVA_WPs_run2_2017 = {
138  'tauIdMVAIsoDBoldDMwLT2017' : {
139  'Eff95' : "DBoldDMwLTEff95",
140  'Eff90' : "DBoldDMwLTEff90",
141  'Eff80' : "DBoldDMwLTEff80",
142  'Eff70' : "DBoldDMwLTEff70",
143  'Eff60' : "DBoldDMwLTEff60",
144  'Eff50' : "DBoldDMwLTEff50",
145  'Eff40' : "DBoldDMwLTEff40"
146  }
147  }
148  # update the list of available in DB samples
149  if not self.is_above_cmssw_version(9, 4, 4, self.debug):
150  if self.debug: print ("runTauID: not is_above_cmssw_version(9, 4, 4). Will update the list of available in DB samples to access 2017v1")
151  self.loadMVA_WPs_run2_2017()
152 
153  self.process.rerunDiscriminationByIsolationOldDMMVArun2017v1raw = patDiscriminationByIsolationMVArun2v1raw.clone(
154  PATTauProducer = cms.InputTag('slimmedTaus'),
155  Prediscriminants = noPrediscriminants,
156  loadMVAfromDB = cms.bool(True),
157  mvaName = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v1"),#RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v1 writeTauIdDiscrMVAs
158  mvaOpt = cms.string("DBoldDMwLTwGJ"),
159  verbosity = cms.int32(0)
160  )
161 
162  self.process.rerunDiscriminationByIsolationOldDMMVArun2017v1 = patDiscriminationByIsolationMVArun2v1.clone(
163  PATTauProducer = cms.InputTag('slimmedTaus'),
164  Prediscriminants = noPrediscriminants,
165  toMultiplex = cms.InputTag('rerunDiscriminationByIsolationOldDMMVArun2017v1raw'),
166  loadMVAfromDB = cms.bool(True),
167  mvaOutput_normalization = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v1_mvaOutput_normalization"), #writeTauIdDiscrMVAoutputNormalizations
168  mapping = cms.VPSet(
169  cms.PSet(
170  category = cms.uint32(0),
171  cut = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v1"), #writeTauIdDiscrWPs
172  variable = cms.string("pt"),
173  )
174  ),
175  workingPoints = cms.vstring(
176  "_WPEff95",
177  "_WPEff90",
178  "_WPEff80",
179  "_WPEff70",
180  "_WPEff60",
181  "_WPEff50",
182  "_WPEff40"
183  )
184  )
185 
186  self.rerunIsolationOldDMMVArun2017v1Task = cms.Task(
187  self.process.rerunDiscriminationByIsolationOldDMMVArun2017v1raw,
188  self.process.rerunDiscriminationByIsolationOldDMMVArun2017v1
189  )
190  self.process.rerunMvaIsolationTask.add(self.rerunIsolationOldDMMVArun2017v1Task)
191  self.process.rerunMvaIsolationSequence += cms.Sequence(self.rerunIsolationOldDMMVArun2017v1Task)
192 
193  tauIDSources.byIsolationMVArun2017v1DBoldDMwLTraw2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v1", "raw")
194  tauIDSources.byVVLooseIsolationMVArun2017v1DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v1", "_WPEff95")
195  tauIDSources.byVLooseIsolationMVArun2017v1DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v1", "_WPEff90")
196  tauIDSources.byLooseIsolationMVArun2017v1DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v1", "_WPEff80")
197  tauIDSources.byMediumIsolationMVArun2017v1DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v1", "_WPEff70")
198  tauIDSources.byTightIsolationMVArun2017v1DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v1", "_WPEff60")
199  tauIDSources.byVTightIsolationMVArun2017v1DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v1", "_WPEff50")
200  tauIDSources.byVVTightIsolationMVArun2017v1DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v1", "_WPEff40")
201 
202 
203  if "2017v2" in self.toKeep:
204  self.tauIdDiscrMVA_2017_version = "v2"
205  self.tauIdDiscrMVA_trainings_run2_2017 = {
206  'tauIdMVAIsoDBoldDMwLT2017' : "tauIdMVAIsoDBoldDMwLT2017",
207  }
208  self.tauIdDiscrMVA_WPs_run2_2017 = {
209  'tauIdMVAIsoDBoldDMwLT2017' : {
210  'Eff95' : "DBoldDMwLTEff95",
211  'Eff90' : "DBoldDMwLTEff90",
212  'Eff80' : "DBoldDMwLTEff80",
213  'Eff70' : "DBoldDMwLTEff70",
214  'Eff60' : "DBoldDMwLTEff60",
215  'Eff50' : "DBoldDMwLTEff50",
216  'Eff40' : "DBoldDMwLTEff40"
217  }
218  }
219 
220  if not self.is_above_cmssw_version(9, 4, 5, self.debug):
221  if self.debug: print ("runTauID: not is_above_cmssw_version(9, 4, 5). Will update the list of available in DB samples to access 2017v2")
222  self.loadMVA_WPs_run2_2017()
223 
224  self.process.rerunDiscriminationByIsolationOldDMMVArun2017v2raw = patDiscriminationByIsolationMVArun2v1raw.clone(
225  PATTauProducer = cms.InputTag('slimmedTaus'),
226  Prediscriminants = noPrediscriminants,
227  loadMVAfromDB = cms.bool(True),
228  mvaName = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v2"),#RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v1 writeTauIdDiscrMVAs
229  mvaOpt = cms.string("DBoldDMwLTwGJ"),
230  verbosity = cms.int32(0)
231  )
232 
233  self.process.rerunDiscriminationByIsolationOldDMMVArun2017v2 = patDiscriminationByIsolationMVArun2v1.clone(
234  PATTauProducer = cms.InputTag('slimmedTaus'),
235  Prediscriminants = noPrediscriminants,
236  toMultiplex = cms.InputTag('rerunDiscriminationByIsolationOldDMMVArun2017v2raw'),
237  loadMVAfromDB = cms.bool(True),
238  mvaOutput_normalization = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v2_mvaOutput_normalization"), #writeTauIdDiscrMVAoutputNormalizations
239  mapping = cms.VPSet(
240  cms.PSet(
241  category = cms.uint32(0),
242  cut = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v2"), #writeTauIdDiscrWPs
243  variable = cms.string("pt"),
244  )
245  ),
246  workingPoints = cms.vstring(
247  "_WPEff95",
248  "_WPEff90",
249  "_WPEff80",
250  "_WPEff70",
251  "_WPEff60",
252  "_WPEff50",
253  "_WPEff40"
254  ),
255  verbosity = cms.int32(0)
256  )
257 
258  self.rerunIsolationOldDMMVArun2017v2Task = cms.Task(
259  self.process.rerunDiscriminationByIsolationOldDMMVArun2017v2raw,
260  self.process.rerunDiscriminationByIsolationOldDMMVArun2017v2
261  )
262  self.process.rerunMvaIsolationTask.add(self.rerunIsolationOldDMMVArun2017v2Task)
263  self.process.rerunMvaIsolationSequence += cms.Sequence(self.rerunIsolationOldDMMVArun2017v2Task)
264 
265  tauIDSources.byIsolationMVArun2017v2DBoldDMwLTraw2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v2", "raw")
266  tauIDSources.byVVLooseIsolationMVArun2017v2DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v2", "_WPEff95")
267  tauIDSources.byVLooseIsolationMVArun2017v2DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v2", "_WPEff90")
268  tauIDSources.byLooseIsolationMVArun2017v2DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v2", "_WPEff80")
269  tauIDSources.byMediumIsolationMVArun2017v2DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v2", "_WPEff70")
270  tauIDSources.byTightIsolationMVArun2017v2DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v2", "_WPEff60")
271  tauIDSources.byVTightIsolationMVArun2017v2DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v2", "_WPEff50")
272  tauIDSources.byVVTightIsolationMVArun2017v2DBoldDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2017v2", "_WPEff40")
273 
274  if "newDM2017v2" in self.toKeep:
275  self.tauIdDiscrMVA_2017_version = "v2"
276  self.tauIdDiscrMVA_trainings_run2_2017 = {
277  'tauIdMVAIsoDBnewDMwLT2017' : "tauIdMVAIsoDBnewDMwLT2017",
278  }
279  self.tauIdDiscrMVA_WPs_run2_2017 = {
280  'tauIdMVAIsoDBnewDMwLT2017' : {
281  'Eff95' : "DBnewDMwLTEff95",
282  'Eff90' : "DBnewDMwLTEff90",
283  'Eff80' : "DBnewDMwLTEff80",
284  'Eff70' : "DBnewDMwLTEff70",
285  'Eff60' : "DBnewDMwLTEff60",
286  'Eff50' : "DBnewDMwLTEff50",
287  'Eff40' : "DBnewDMwLTEff40"
288  }
289  }
290 
291  if not self.is_above_cmssw_version(9, 4, 5, self.debug):
292  if self.debug: print ("runTauID: not is_above_cmssw_version(9, 4, 5). Will update the list of available in DB samples to access newDM2017v2")
293  self.loadMVA_WPs_run2_2017()
294 
295  self.process.rerunDiscriminationByIsolationNewDMMVArun2017v2raw = patDiscriminationByIsolationMVArun2v1raw.clone(
296  PATTauProducer = cms.InputTag('slimmedTaus'),
297  Prediscriminants = noPrediscriminants,
298  loadMVAfromDB = cms.bool(True),
299  mvaName = cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2017v2"),#RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v1 writeTauIdDiscrMVAs
300  mvaOpt = cms.string("DBnewDMwLTwGJ"),
301  verbosity = cms.int32(0)
302  )
303 
304  self.process.rerunDiscriminationByIsolationNewDMMVArun2017v2 = patDiscriminationByIsolationMVArun2v1.clone(
305  PATTauProducer = cms.InputTag('slimmedTaus'),
306  Prediscriminants = noPrediscriminants,
307  toMultiplex = cms.InputTag('rerunDiscriminationByIsolationNewDMMVArun2017v2raw'),
308  loadMVAfromDB = cms.bool(True),
309  mvaOutput_normalization = cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2017v2_mvaOutput_normalization"), #writeTauIdDiscrMVAoutputNormalizations
310  mapping = cms.VPSet(
311  cms.PSet(
312  category = cms.uint32(0),
313  cut = cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2017v2"), #writeTauIdDiscrWPs
314  variable = cms.string("pt"),
315  )
316  ),
317  workingPoints = cms.vstring(
318  "_WPEff95",
319  "_WPEff90",
320  "_WPEff80",
321  "_WPEff70",
322  "_WPEff60",
323  "_WPEff50",
324  "_WPEff40"
325  ),
326  verbosity = cms.int32(0)
327  )
328 
329  self.rerunIsolationNewDMMVArun2017v2Task = cms.Task(
330  self.process.rerunDiscriminationByIsolationNewDMMVArun2017v2raw,
331  self.process.rerunDiscriminationByIsolationNewDMMVArun2017v2
332  )
333  self.process.rerunMvaIsolationTask.add(self.rerunIsolationNewDMMVArun2017v2Task)
334  self.process.rerunMvaIsolationSequence += cms.Sequence(self.rerunIsolationNewDMMVArun2017v2Task)
335 
336  tauIDSources.byIsolationMVArun2017v2DBnewDMwLTraw2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2017v2", "raw")
337  tauIDSources.byVVLooseIsolationMVArun2017v2DBnewDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2017v2", "_WPEff95")
338  tauIDSources.byVLooseIsolationMVArun2017v2DBnewDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2017v2", "_WPEff90")
339  tauIDSources.byLooseIsolationMVArun2017v2DBnewDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2017v2", "_WPEff80")
340  tauIDSources.byMediumIsolationMVArun2017v2DBnewDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2017v2", "_WPEff70")
341  tauIDSources.byTightIsolationMVArun2017v2DBnewDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2017v2", "_WPEff60")
342  tauIDSources.byVTightIsolationMVArun2017v2DBnewDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2017v2", "_WPEff50")
343  tauIDSources.byVVTightIsolationMVArun2017v2DBnewDMwLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2017v2", "_WPEff40")
344 
345  if "dR0p32017v2" in self.toKeep:
346  self.tauIdDiscrMVA_2017_version = "v2"
347  self.tauIdDiscrMVA_trainings_run2_2017 = {
348  'tauIdMVAIsoDBoldDMdR0p3wLT2017' : "tauIdMVAIsoDBoldDMdR0p3wLT2017",
349  }
350  self.tauIdDiscrMVA_WPs_run2_2017 = {
351  'tauIdMVAIsoDBoldDMdR0p3wLT2017' : {
352  'Eff95' : "DBoldDMdR0p3wLTEff95",
353  'Eff90' : "DBoldDMdR0p3wLTEff90",
354  'Eff80' : "DBoldDMdR0p3wLTEff80",
355  'Eff70' : "DBoldDMdR0p3wLTEff70",
356  'Eff60' : "DBoldDMdR0p3wLTEff60",
357  'Eff50' : "DBoldDMdR0p3wLTEff50",
358  'Eff40' : "DBoldDMdR0p3wLTEff40"
359  }
360  }
361 
362  if not self.is_above_cmssw_version(9, 4, 5, self.debug):
363  if self.debug: print ("runTauID: not is_above_cmssw_version(9, 4, 5). Will update the list of available in DB samples to access dR0p32017v2")
364  self.loadMVA_WPs_run2_2017()
365 
366  self.process.rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2raw = patDiscriminationByIsolationMVArun2v1raw.clone(
367  PATTauProducer = cms.InputTag('slimmedTaus'),
368  Prediscriminants = noPrediscriminants,
369  loadMVAfromDB = cms.bool(True),
370  mvaName = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMdR0p3wLT2017v2"),
371  mvaOpt = cms.string("DBoldDMwLTwGJ"),
372  srcChargedIsoPtSum = cms.string('chargedIsoPtSumdR03'),
373  srcFootprintCorrection = cms.string('footprintCorrectiondR03'),
374  srcNeutralIsoPtSum = cms.string('neutralIsoPtSumdR03'),
375  srcPhotonPtSumOutsideSignalCone = cms.string('photonPtSumOutsideSignalConedR03'),
376  verbosity = cms.int32(0)
377  )
378 
379  self.process.rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2= patDiscriminationByIsolationMVArun2v1.clone(
380  PATTauProducer = cms.InputTag('slimmedTaus'),
381  Prediscriminants = noPrediscriminants,
382  toMultiplex = cms.InputTag('rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2raw'),
383  loadMVAfromDB = cms.bool(True),
384  mvaOutput_normalization = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMdR0p3wLT2017v2_mvaOutput_normalization"), #writeTauIdDiscrMVAoutputNormalizations
385  mapping = cms.VPSet(
386  cms.PSet(
387  category = cms.uint32(0),
388  cut = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMdR0p3wLT2017v2"), #writeTauIdDiscrWPs
389  variable = cms.string("pt"),
390  )
391  ),
392  workingPoints = cms.vstring(
393  "_WPEff95",
394  "_WPEff90",
395  "_WPEff80",
396  "_WPEff70",
397  "_WPEff60",
398  "_WPEff50",
399  "_WPEff40"
400  ),
401  verbosity = cms.int32(0)
402  )
403 
404  self.rerunIsolationOldDMdR0p3MVArun2017v2Task = cms.Task(
405  self.process.rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2raw,
406  self.process.rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2
407  )
408  self.process.rerunMvaIsolationTask.add(self.rerunIsolationOldDMdR0p3MVArun2017v2Task)
409  self.process.rerunMvaIsolationSequence += cms.Sequence(self.rerunIsolationOldDMdR0p3MVArun2017v2Task)
410 
411  tauIDSources.byIsolationMVArun2017v2DBoldDMdR0p3wLTraw2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2", "raw")
412  tauIDSources.byVVLooseIsolationMVArun2017v2DBoldDMdR0p3wLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2", "_WPEff95")
413  tauIDSources.byVLooseIsolationMVArun2017v2DBoldDMdR0p3wLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2", "_WPEff90")
414  tauIDSources.byLooseIsolationMVArun2017v2DBoldDMdR0p3wLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2", "_WPEff80")
415  tauIDSources.byMediumIsolationMVArun2017v2DBoldDMdR0p3wLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2", "_WPEff70")
416  tauIDSources.byTightIsolationMVArun2017v2DBoldDMdR0p3wLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2", "_WPEff60")
417  tauIDSources.byVTightIsolationMVArun2017v2DBoldDMdR0p3wLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2", "_WPEff50")
418  tauIDSources.byVVTightIsolationMVArun2017v2DBoldDMdR0p3wLT2017 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2", "_WPEff40")
419 
420  # 2016 training strategy(v2) - essentially the same as 2017 training strategy (v1), trained on 2016MC, old DM - currently not implemented in the tau sequence of any release
421  # self.process.rerunDiscriminationByIsolationOldDMMVArun2v2raw = patDiscriminationByIsolationMVArun2v1raw.clone(
422  # PATTauProducer = cms.InputTag('slimmedTaus'),
423  # Prediscriminants = noPrediscriminants,
424  # loadMVAfromDB = cms.bool(True),
425  # mvaName = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v2"),#RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v1 writeTauIdDiscrMVAs
426  # mvaOpt = cms.string("DBoldDMwLTwGJ"),
427  # verbosity = cms.int32(0)
428  # )
429  # #
430  # self.process.rerunDiscriminationByIsolationOldDMMVArun2v2VLoose = patDiscriminationByIsolationMVArun2v1VLoose.clone(
431  # PATTauProducer = cms.InputTag('slimmedTaus'),
432  # Prediscriminants = noPrediscriminants,
433  # toMultiplex = cms.InputTag('rerunDiscriminationByIsolationOldDMMVArun2v2raw'),
434  # key = cms.InputTag('rerunDiscriminationByIsolationOldDMMVArun2v2raw:category'),#?
435  # loadMVAfromDB = cms.bool(True),
436  # mvaOutput_normalization = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v2_mvaOutput_normalization"), #writeTauIdDiscrMVAoutputNormalizations
437  # mapping = cms.VPSet(
438  # cms.PSet(
439  # category = cms.uint32(0),
440  # cut = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v2_WPEff90"), #writeTauIdDiscrWPs
441  # variable = cms.string("pt"),
442  # )
443  # )
444  # )
445 
446  # 2016 training strategy(v1), trained on 2016MC, old DM
447  if "2016v1" in self.toKeep:
448  self.process.rerunDiscriminationByIsolationOldDMMVArun2v1raw = patDiscriminationByIsolationMVArun2v1raw.clone(
449  PATTauProducer = cms.InputTag('slimmedTaus'),
450  Prediscriminants = noPrediscriminants,
451  loadMVAfromDB = cms.bool(True),
452  mvaName = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v1"),
453  mvaOpt = cms.string("DBoldDMwLT"),
454  verbosity = cms.int32(0)
455  )
456 
457  self.process.rerunDiscriminationByIsolationOldDMMVArun2v1 = patDiscriminationByIsolationMVArun2v1.clone(
458  PATTauProducer = cms.InputTag('slimmedTaus'),
459  Prediscriminants = noPrediscriminants,
460  toMultiplex = cms.InputTag('rerunDiscriminationByIsolationOldDMMVArun2v1raw'),
461  loadMVAfromDB = cms.bool(True),
462  mvaOutput_normalization = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v1_mvaOutput_normalization"),
463  mapping = cms.VPSet(
464  cms.PSet(
465  category = cms.uint32(0),
466  cut = cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v1"),
467  variable = cms.string("pt"),
468  )
469  ),
470  workingPoints = cms.vstring(
471  "_WPEff90",
472  "_WPEff80",
473  "_WPEff70",
474  "_WPEff60",
475  "_WPEff50",
476  "_WPEff40"
477  )
478  )
479 
480  self.rerunIsolationOldDMMVArun2016v1Task = cms.Task(
481  self.process.rerunDiscriminationByIsolationOldDMMVArun2v1raw,
482  self.process.rerunDiscriminationByIsolationOldDMMVArun2v1
483  )
484  self.process.rerunMvaIsolationTask.add(self.rerunIsolationOldDMMVArun2016v1Task)
485  self.process.rerunMvaIsolationSequence += cms.Sequence(self.rerunIsolationOldDMMVArun2016v1Task)
486 
487  tauIDSources.byIsolationMVArun2v1DBoldDMwLTraw2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2v1", "raw")
488  tauIDSources.byVLooseIsolationMVArun2v1DBoldDMwLT2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2v1", "_WPEff90")
489  tauIDSources.byLooseIsolationMVArun2v1DBoldDMwLT2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2v1", "_WPEff80")
490  tauIDSources.byMediumIsolationMVArun2v1DBoldDMwLT2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2v1", "_WPEff70")
491  tauIDSources.byTightIsolationMVArun2v1DBoldDMwLT2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2v1", "_WPEff60")
492  tauIDSources.byVTightIsolationMVArun2v1DBoldDMwLT2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2v1", "_WPEff50")
493  tauIDSources.byVVTightIsolationMVArun2v1DBoldDMwLT2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationOldDMMVArun2v1", "_WPEff40")
494 
495  # 2016 training strategy(v1), trained on 2016MC, new DM
496  if "newDM2016v1" in self.toKeep:
497  self.process.rerunDiscriminationByIsolationNewDMMVArun2v1raw = patDiscriminationByIsolationMVArun2v1raw.clone(
498  PATTauProducer = cms.InputTag('slimmedTaus'),
499  Prediscriminants = noPrediscriminants,
500  loadMVAfromDB = cms.bool(True),
501  mvaName = cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2016v1"),
502  mvaOpt = cms.string("DBnewDMwLT"),
503  verbosity = cms.int32(0)
504  )
505 
506  self.process.rerunDiscriminationByIsolationNewDMMVArun2v1 = patDiscriminationByIsolationMVArun2v1.clone(
507  PATTauProducer = cms.InputTag('slimmedTaus'),
508  Prediscriminants = noPrediscriminants,
509  toMultiplex = cms.InputTag('rerunDiscriminationByIsolationNewDMMVArun2v1raw'),
510  loadMVAfromDB = cms.bool(True),
511  mvaOutput_normalization = cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2016v1_mvaOutput_normalization"),
512  mapping = cms.VPSet(
513  cms.PSet(
514  category = cms.uint32(0),
515  cut = cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2016v1_WPEff90"),
516  variable = cms.string("pt"),
517  )
518  ),
519  workingPoints = cms.vstring(
520  "_WPEff90",
521  "_WPEff80",
522  "_WPEff70",
523  "_WPEff60",
524  "_WPEff50",
525  "_WPEff40"
526  )
527  )
528 
529  self.rerunIsolationNewDMMVArun2016v1Task = cms.Task(
530  self.process.rerunDiscriminationByIsolationNewDMMVArun2v1raw,
531  self.process.rerunDiscriminationByIsolationNewDMMVArun2v1
532  )
533  self.process.rerunMvaIsolationTask.add(self.rerunIsolationNewDMMVArun2016v1Task)
534  self.process.rerunMvaIsolationSequence += cms.Sequence(self.rerunIsolationNewDMMVArun2016v1Task)
535 
536  tauIDSources.byIsolationMVArun2v1DBnewDMwLTraw2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2v1", "raw")
537  tauIDSources.byVLooseIsolationMVArun2v1DBnewDMwLT2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2v1", "_WPEff90")
538  tauIDSources.byLooseIsolationMVArun2v1DBnewDMwLT2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2v1", "_WPEff80")
539  tauIDSources.byMediumIsolationMVArun2v1DBnewDMwLT2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2v1", "_WPEff70")
540  tauIDSources.byTightIsolationMVArun2v1DBnewDMwLT2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2v1", "_WPEff60")
541  tauIDSources.byVTightIsolationMVArun2v1DBnewDMwLT2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2v1", "_WPEff50")
542  tauIDSources.byVVTightIsolationMVArun2v1DBnewDMwLT2016 = self.tauIDMVAinputs("rerunDiscriminationByIsolationNewDMMVArun2v1", "_WPEff40")
543 
544  if "deepTau2017v1" in self.toKeep:
545  if self.debug: print ("Adding DeepTau IDs")
546 
547  workingPoints_ = {
548  "e": {
549  "VVVLoose" : 0.96424,
550  "VVLoose" : 0.98992,
551  "VLoose" : 0.99574,
552  "Loose": 0.99831,
553  "Medium": 0.99868,
554  "Tight": 0.99898,
555  "VTight": 0.99911,
556  "VVTight": 0.99918
557  },
558  "mu": {
559  "VVVLoose" : 0.959619,
560  "VVLoose" : 0.997687,
561  "VLoose" : 0.999392,
562  "Loose": 0.999755,
563  "Medium": 0.999854,
564  "Tight": 0.999886,
565  "VTight": 0.999944,
566  "VVTight": 0.9999971
567  },
568 
569  "jet": {
570  "VVVLoose" : 0.5329,
571  "VVLoose" : 0.7645,
572  "VLoose" : 0.8623,
573  "Loose": 0.9140,
574  "Medium": 0.9464,
575  "Tight": 0.9635,
576  "VTight": 0.9760,
577  "VVTight": 0.9859
578  }
579  }
580  file_names = ['RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v1_20L1024N_quantized.pb']
581  self.process.deepTau2017v1 = cms.EDProducer("DeepTauId",
582  electrons = cms.InputTag('slimmedElectrons'),
583  muons = cms.InputTag('slimmedMuons'),
584  taus = cms.InputTag('slimmedTaus'),
585  pfcands = cms.InputTag('packedPFCandidates'),
586  vertices = cms.InputTag('offlineSlimmedPrimaryVertices'),
587  rho = cms.InputTag('fixedGridRhoAll'),
588  graph_file = cms.vstring(file_names),
589  mem_mapped = cms.bool(False),
590  version = cms.uint32(self.getDeepTauVersion(file_names[0])[1]),
591  debug_level = cms.int32(0),
592  disable_dxy_pca = cms.bool(False)
593  )
594 
595  self.processDeepProducer('deepTau2017v1', tauIDSources, workingPoints_)
596 
597  self.process.rerunMvaIsolationTask.add(self.process.deepTau2017v1)
598  self.process.rerunMvaIsolationSequence += self.process.deepTau2017v1
599 
600  if "deepTau2017v2" in self.toKeep:
601  if self.debug: print ("Adding DeepTau IDs")
602 
603  workingPoints_ = {
604  "e": {
605  "VVVLoose": 0.0630386,
606  "VVLoose": 0.1686942,
607  "VLoose": 0.3628130,
608  "Loose": 0.6815435,
609  "Medium": 0.8847544,
610  "Tight": 0.9675541,
611  "VTight": 0.9859251,
612  "VVTight": 0.9928449,
613  },
614  "mu": {
615  "VLoose": 0.1058354,
616  "Loose": 0.2158633,
617  "Medium": 0.5551894,
618  "Tight": 0.8754835,
619  },
620  "jet": {
621  "VVVLoose": 0.2599605,
622  "VVLoose": 0.4249705,
623  "VLoose": 0.5983682,
624  "Loose": 0.7848675,
625  "Medium": 0.8834768,
626  "Tight": 0.9308689,
627  "VTight": 0.9573137,
628  "VVTight": 0.9733927,
629  },
630  }
631 
632  file_names = [
633  'core:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_core.pb',
634  'inner:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_inner.pb',
635  'outer:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_outer.pb',
636  ]
637  self.process.deepTau2017v2 = cms.EDProducer("DeepTauId",
638  electrons = cms.InputTag('slimmedElectrons'),
639  muons = cms.InputTag('slimmedMuons'),
640  taus = cms.InputTag('slimmedTaus'),
641  pfcands = cms.InputTag('packedPFCandidates'),
642  vertices = cms.InputTag('offlineSlimmedPrimaryVertices'),
643  rho = cms.InputTag('fixedGridRhoAll'),
644  graph_file = cms.vstring(file_names),
645  mem_mapped = cms.bool(False),
646  version = cms.uint32(self.getDeepTauVersion(file_names[0])[1]),
647  debug_level = cms.int32(0),
648  disable_dxy_pca = cms.bool(False)
649  )
650 
651  self.processDeepProducer('deepTau2017v2', tauIDSources, workingPoints_)
652 
653  self.process.rerunMvaIsolationTask.add(self.process.deepTau2017v2)
654  self.process.rerunMvaIsolationSequence += self.process.deepTau2017v2
655 
656  if "deepTau2017v2p1" in self.toKeep:
657  if self.debug: print ("Adding DeepTau IDs")
658 
659  workingPoints_ = {
660  "e": {
661  "VVVLoose": 0.0630386,
662  "VVLoose": 0.1686942,
663  "VLoose": 0.3628130,
664  "Loose": 0.6815435,
665  "Medium": 0.8847544,
666  "Tight": 0.9675541,
667  "VTight": 0.9859251,
668  "VVTight": 0.9928449,
669  },
670  "mu": {
671  "VLoose": 0.1058354,
672  "Loose": 0.2158633,
673  "Medium": 0.5551894,
674  "Tight": 0.8754835,
675  },
676  "jet": {
677  "VVVLoose": 0.2599605,
678  "VVLoose": 0.4249705,
679  "VLoose": 0.5983682,
680  "Loose": 0.7848675,
681  "Medium": 0.8834768,
682  "Tight": 0.9308689,
683  "VTight": 0.9573137,
684  "VVTight": 0.9733927,
685  },
686  }
687 
688  file_names = [
689  'core:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_core.pb',
690  'inner:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_inner.pb',
691  'outer:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_outer.pb',
692  ]
693  self.process.deepTau2017v2p1 = cms.EDProducer("DeepTauId",
694  electrons = cms.InputTag('slimmedElectrons'),
695  muons = cms.InputTag('slimmedMuons'),
696  taus = cms.InputTag('slimmedTaus'),
697  pfcands = cms.InputTag('packedPFCandidates'),
698  vertices = cms.InputTag('offlineSlimmedPrimaryVertices'),
699  rho = cms.InputTag('fixedGridRhoAll'),
700  graph_file = cms.vstring(file_names),
701  mem_mapped = cms.bool(False),
702  version = cms.uint32(self.getDeepTauVersion(file_names[0])[1]),
703  debug_level = cms.int32(0),
704  disable_dxy_pca = cms.bool(True),
705  is_online = cms.bool(False)
706  )
707 
708  self.processDeepProducer('deepTau2017v2p1', tauIDSources, workingPoints_)
709 
710  self.process.rerunMvaIsolationTask.add(self.process.deepTau2017v2p1)
711  self.process.rerunMvaIsolationSequence += self.process.deepTau2017v2p1
712 
713  if "DPFTau_2016_v0" in self.toKeep:
714  if self.debug: print ("Adding DPFTau isolation (v0)")
715 
716  workingPoints_ = {
717  "all": {
718  "Tight" : "if(decayMode == 0) return (0.898328 - 0.000160992 * pt);" + \
719  "if(decayMode == 1) return (0.910138 - 0.000229923 * pt);" + \
720  "if(decayMode == 10) return (0.873958 - 0.0002328 * pt);" + \
721  "return 99.0;"
722  #"Tight" : "? decayMode == 0 ? (0.898328 - 0.000160992 * pt) : " +
723  # "(? decayMode == 1 ? 0.910138 - 0.000229923 * pt : " +
724  # "(? decayMode == 10 ? (0.873958 - 0.0002328 * pt) : 1))"
725  # "Tight" : "(decayMode == 0) * (0.898328 - 0.000160992 * pt) + \
726  # (decayMode == 1) * (0.910138 - 0.000229923 * pt) + \
727  # (decayMode == 10) * (0.873958 - 0.0002328 * pt) "
728  }
729  }
730  file_names = [ 'RecoTauTag/TrainingFiles/data/DPFTauId/DPFIsolation_2017v0_quantized.pb' ]
731  self.process.dpfTau2016v0 = cms.EDProducer("DPFIsolation",
732  pfcands = cms.InputTag('packedPFCandidates'),
733  taus = cms.InputTag('slimmedTaus'),
734  vertices = cms.InputTag('offlineSlimmedPrimaryVertices'),
735  graph_file = cms.vstring(file_names),
736  version = cms.uint32(self.getDpfTauVersion(file_names[0])),
737  mem_mapped = cms.bool(False)
738  )
739 
740  self.processDeepProducer('dpfTau2016v0', tauIDSources, workingPoints_)
741 
742  self.process.rerunMvaIsolationTask.add(self.process.dpfTau2016v0)
743  self.process.rerunMvaIsolationSequence += self.process.dpfTau2016v0
744 
745 
746  if "DPFTau_2016_v1" in self.toKeep:
747  print ("Adding DPFTau isolation (v1)")
748  print ("WARNING: WPs are not defined for DPFTau_2016_v1")
749  print ("WARNING: The score of DPFTau_2016_v1 is inverted: i.e. for Sig->0, for Bkg->1 with -1 for undefined input (preselection not passed).")
750 
751  workingPoints_ = {
752  "all": {"Tight" : 0.123} #FIXME: define WP
753  }
754 
755  file_names = [ 'RecoTauTag/TrainingFiles/data/DPFTauId/DPFIsolation_2017v1_quantized.pb' ]
756  self.process.dpfTau2016v1 = cms.EDProducer("DPFIsolation",
757  pfcands = cms.InputTag('packedPFCandidates'),
758  taus = cms.InputTag('slimmedTaus'),
759  vertices = cms.InputTag('offlineSlimmedPrimaryVertices'),
760  graph_file = cms.vstring(file_names),
761  version = cms.uint32(self.getDpfTauVersion(file_names[0])),
762  mem_mapped = cms.bool(False)
763  )
764 
765  self.processDeepProducer('dpfTau2016v1', tauIDSources, workingPoints_)
766 
767  self.process.rerunMvaIsolationTask.add(self.process.dpfTau2016v1)
768  self.process.rerunMvaIsolationSequence += self.process.dpfTau2016v1
769 
770  if "againstEle2018" in self.toKeep:
771  antiElectronDiscrMVA6_version = "MVA6v3_noeveto"
772 
774  from RecoTauTag.RecoTau.PATTauDiscriminationAgainstElectronMVA6_cfi import patTauDiscriminationAgainstElectronMVA6
775  self.process.patTauDiscriminationByElectronRejectionMVA62018Raw = patTauDiscriminationAgainstElectronMVA6.clone(
776  Prediscriminants = noPrediscriminants, #already selected for MiniAOD
777  vetoEcalCracks = cms.bool(False), #keep taus in EB-EE cracks
778  mvaName_NoEleMatch_wGwoGSF_BL = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_BL',
779  mvaName_NoEleMatch_wGwoGSF_EC = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_EC',
780  mvaName_NoEleMatch_woGwoGSF_BL = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_BL',
781  mvaName_NoEleMatch_woGwoGSF_EC = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_EC',
782  mvaName_wGwGSF_BL = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_BL',
783  mvaName_wGwGSF_EC = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_EC',
784  mvaName_woGwGSF_BL = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_BL',
785  mvaName_woGwGSF_EC = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_EC'
786  )
787 
788  from RecoTauTag.RecoTau.PATTauDiscriminantCutMultiplexer_cfi import patTauDiscriminantCutMultiplexer
789  self.process.patTauDiscriminationByElectronRejectionMVA62018 = patTauDiscriminantCutMultiplexer.clone(
790  PATTauProducer = self.process.patTauDiscriminationByElectronRejectionMVA62018Raw.PATTauProducer,
791  Prediscriminants = self.process.patTauDiscriminationByElectronRejectionMVA62018Raw.Prediscriminants,
792  toMultiplex = cms.InputTag("patTauDiscriminationByElectronRejectionMVA62018Raw"),
793  mapping = cms.VPSet(
794  cms.PSet(
795  category = cms.uint32(0),
796  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_BL'),
797  variable = cms.string('pt')
798  ),
799  cms.PSet(
800  category = cms.uint32(2),
801  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_BL'),
802  variable = cms.string('pt')
803  ),
804  cms.PSet(
805  category = cms.uint32(5),
806  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_BL'),
807  variable = cms.string('pt')
808  ),
809  cms.PSet(
810  category = cms.uint32(7),
811  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_BL'),
812  variable = cms.string('pt')
813  ),
814  cms.PSet(
815  category = cms.uint32(8),
816  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_EC'),
817  variable = cms.string('pt')
818  ),
819  cms.PSet(
820  category = cms.uint32(10),
821  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_EC'),
822  variable = cms.string('pt')
823  ),
824  cms.PSet(
825  category = cms.uint32(13),
826  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_EC'),
827  variable = cms.string('pt')
828  ),
829  cms.PSet(
830  category = cms.uint32(15),
831  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_EC'),
832  variable = cms.string('pt')
833  )
834  ),
835  workingPoints = cms.vstring(
836  "_WPeff98",
837  "_WPeff90",
838  "_WPeff80",
839  "_WPeff70",
840  "_WPeff60"
841  )
842  )
843 
844  self.process.patTauDiscriminationByElectronRejectionMVA62018Task = cms.Task(
845  self.process.patTauDiscriminationByElectronRejectionMVA62018Raw,
846  self.process.patTauDiscriminationByElectronRejectionMVA62018
847  )
848  self.process.patTauDiscriminationByElectronRejectionMVA62018Seq = cms.Sequence(self.process.patTauDiscriminationByElectronRejectionMVA62018Task)
849  self.process.rerunMvaIsolationTask.add(self.process.patTauDiscriminationByElectronRejectionMVA62018Task)
850  self.process.rerunMvaIsolationSequence += self.process.patTauDiscriminationByElectronRejectionMVA62018Seq
851 
852  _againstElectronTauIDSources = cms.PSet(
853  againstElectronMVA6Raw2018 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA62018", "raw"),
854  againstElectronMVA6category2018 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA62018", "category"),
855  againstElectronVLooseMVA62018 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA62018", "_WPeff98"),
856  againstElectronLooseMVA62018 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA62018", "_WPeff90"),
857  againstElectronMediumMVA62018 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA62018", "_WPeff80"),
858  againstElectronTightMVA62018 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA62018", "_WPeff70"),
859  againstElectronVTightMVA62018 = self.tauIDMVAinputs("patTauDiscriminationByElectronRejectionMVA62018", "_WPeff60")
860  )
861  _tauIDSourcesWithAgainistEle = cms.PSet(
862  tauIDSources.clone(),
863  _againstElectronTauIDSources
864  )
865  tauIDSources =_tauIDSourcesWithAgainistEle.clone()
866 
867 
868  if self.debug: print('Embedding new TauIDs into \"'+self.updatedTauName+'\"')
869  if not hasattr(self.process, self.updatedTauName):
870  embedID = cms.EDProducer("PATTauIDEmbedder",
871  src = cms.InputTag('slimmedTaus'),
872  tauIDSources = tauIDSources
873  )
874  setattr(self.process, self.updatedTauName, embedID)
875  else: #assume same type
876  tauIDSources = cms.PSet(
877  getattr(self.process, self.updatedTauName).tauIDSources,
878  tauIDSources)
879  getattr(self.process, self.updatedTauName).tauIDSources = tauIDSources
880 
881 
882  def processDeepProducer(self, producer_name, tauIDSources, workingPoints_):
883  for target,points in six.iteritems(workingPoints_):
884  setattr(tauIDSources, 'by{}VS{}raw'.format(producer_name[0].upper()+producer_name[1:], target),
885  cms.PSet(inputTag = cms.InputTag(producer_name, 'VS{}'.format(target)), workingPointIndex = cms.int32(-1)))
886 
887  cut_expressions = []
888  for index, (point,cut) in enumerate(six.iteritems(points)):
889  cut_expressions.append(str(cut))
890 
891  setattr(tauIDSources, 'by{}{}VS{}'.format(point, producer_name[0].upper()+producer_name[1:], target),
892  cms.PSet(inputTag = cms.InputTag(producer_name, 'VS{}'.format(target)), workingPointIndex = cms.int32(index)))
893 
894  setattr(getattr(self.process, producer_name), 'VS{}WP'.format(target), cms.vstring(*cut_expressions))
895 
896 
897  def getDpfTauVersion(self, file_name):
898  """returns the DNN version. File name should contain a version label with data takig year (2011-2, 2015-8) and \
899  version number (vX), e.g. 2017v0, in general the following format: {year}v{version}"""
900  version_search = re.search('201[125678]v([0-9]+)[\._]', file_name)
901  if not version_search:
902  raise RuntimeError('File "{}" has an invalid name pattern, should be in the format "{year}v{version}". \
903  Unable to extract version number.'.format(file_name))
904  version = version_search.group(1)
905  return int(version)
906 
907  def getDeepTauVersion(self, file_name):
908  """returns the DeepTau year, version, subversion. File name should contain a version label with data takig year \
909  (2011-2, 2015-8), version number (vX) and subversion (pX), e.g. 2017v0p6, in general the following format: \
910  {year}v{version}p{subversion}"""
911  version_search = re.search('(201[125678])v([0-9]+)(p[0-9]+|)[\._]', file_name)
912  if not version_search:
913  raise RuntimeError('File "{}" has an invalid name pattern, should be in the format "{year}v{version}p{subversion}". \
914  Unable to extract version number.'.format(file_name))
915  year = version_search.group(1)
916  version = version_search.group(2)
917  subversion = version_search.group(3)
918  if len(subversion) > 0:
919  subversion = subversion[1:]
920  else:
921  subversion = 0
922  return int(year), int(version), int(subversion)
runTauIdMVA.TauIDEmbedder.processDeepProducer
def processDeepProducer(self, producer_name, tauIDSources, workingPoints_)
Definition: runTauIdMVA.py:882
resolutioncreator_cfi.object
object
Definition: resolutioncreator_cfi.py:4
runTauIdMVA.TauIDEmbedder.rerunIsolationNewDMMVArun2016v1Task
rerunIsolationNewDMMVArun2016v1Task
Definition: runTauIdMVA.py:529
runTauIdMVA.TauIDEmbedder.versionToInt
def versionToInt(release=9, subversion=4, patch=0, debug=False)
Definition: runTauIdMVA.py:77
runTauIdMVA.TauIDEmbedder.toKeep
toKeep
Definition: runTauIdMVA.py:38
runTauIdMVA.TauIDEmbedder.rerunIsolationNewDMMVArun2017v2Task
rerunIsolationNewDMMVArun2017v2Task
Definition: runTauIdMVA.py:329
runTauIdMVA.TauIDEmbedder.__init__
def __init__(self, process, debug=False, updatedTauName="slimmedTausNewID", toKeep=["deepTau2017v2p1"], tauIdDiscrMVA_trainings_run2_2017={ 'tauIdMVAIsoDBoldDMwLT2017' :"tauIdMVAIsoDBoldDMwLT2017", }, tauIdDiscrMVA_WPs_run2_2017={ 'tauIdMVAIsoDBoldDMwLT2017' :{ 'Eff95' :"DBoldDMwLTEff95", 'Eff90' :"DBoldDMwLTEff90", 'Eff80' :"DBoldDMwLTEff80", 'Eff70' :"DBoldDMwLTEff70", 'Eff60' :"DBoldDMwLTEff60", 'Eff50' :"DBoldDMwLTEff50", 'Eff40' :"DBoldDMwLTEff40" } }, tauIdDiscrMVA_2017_version="v1", conditionDB="" # preparational DB:'frontier://FrontierPrep/CMS_CONDITIONS')
Definition: runTauIdMVA.py:18
relativeConstraints.keys
keys
Definition: relativeConstraints.py:89
cms::dd::split
std::vector< std::string_view > split(std::string_view, const char *)
runTauIdMVA.TauIDEmbedder.process
process
Definition: runTauIdMVA.py:20
runTauIdMVA.TauIDEmbedder.getDpfTauVersion
def getDpfTauVersion(self, file_name)
Definition: runTauIdMVA.py:897
runTauIdMVA.TauIDEmbedder.runTauID
def runTauID(self)
Definition: runTauIdMVA.py:126
mps_monitormerge.items
list items
Definition: mps_monitormerge.py:29
PATTauDiscriminantCutMultiplexer_cfi
runTauIdMVA.TauIDEmbedder.getDeepTauVersion
def getDeepTauVersion(self, file_name)
Definition: runTauIdMVA.py:907
runTauIdMVA.TauIDEmbedder
Definition: runTauIdMVA.py:9
str
#define str(s)
Definition: TestProcessor.cc:48
svgfig.load
def load(fileName)
Definition: svgfig.py:547
runTauIdMVA.TauIDEmbedder.rerunIsolationOldDMMVArun2016v1Task
rerunIsolationOldDMMVArun2016v1Task
Definition: runTauIdMVA.py:480
runTauIdMVA.TauIDEmbedder.get_cmssw_version_number
def get_cmssw_version_number(klass, debug=False)
Definition: runTauIdMVA.py:66
runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_trainings_run2_2017
tauIdDiscrMVA_trainings_run2_2017
Definition: runTauIdMVA.py:32
TauDiscriminatorTools
createfilelist.int
int
Definition: createfilelist.py:10
runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017
def loadMVA_WPs_run2_2017(self)
Definition: runTauIdMVA.py:96
edm::print
S & print(S &os, JobReport::InputFile const &f)
Definition: JobReport.cc:66
runTauIdMVA.TauIDEmbedder.rerunIsolationOldDMMVArun2017v1Task
rerunIsolationOldDMMVArun2017v1Task
Definition: runTauIdMVA.py:186
runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_2017_version
tauIdDiscrMVA_2017_version
Definition: runTauIdMVA.py:34
runTauIdMVA.TauIDEmbedder.is_above_cmssw_version
def is_above_cmssw_version(klass, release=9, subversion=4, patch=0, debug=False)
Definition: runTauIdMVA.py:84
runTauIdMVA.TauIDEmbedder.rerunIsolationOldDMMVArun2017v2Task
rerunIsolationOldDMMVArun2017v2Task
Definition: runTauIdMVA.py:258
runTauIdMVA.TauIDEmbedder.debug
debug
Definition: runTauIdMVA.py:21
PATTauDiscriminationByMVAIsolationRun2_cff
format
runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_WPs_run2_2017
tauIdDiscrMVA_WPs_run2_2017
Definition: runTauIdMVA.py:33
pileupCalc.upper
upper
Definition: pileupCalc.py:214
runTauIdMVA.TauIDEmbedder.rerunIsolationOldDMdR0p3MVArun2017v2Task
rerunIsolationOldDMdR0p3MVArun2017v2Task
Definition: runTauIdMVA.py:404
runTauIdMVA.TauIDEmbedder.updatedTauName
updatedTauName
Definition: runTauIdMVA.py:22
runTauIdMVA.TauIDEmbedder.get_cmssw_version
def get_cmssw_version(debug=False)
Definition: runTauIdMVA.py:59
runTauIdMVA.TauIDEmbedder.tauIDMVAinputs
def tauIDMVAinputs(self, module, wp)
Definition: runTauIdMVA.py:93
Generated for CMSSW Reference Manual by doxygen 1.8.16