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