CMS 3D CMS Logo
List of all members | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes
runTauIdMVA.TauIDEmbedder Class Reference
Inheritance diagram for runTauIdMVA.TauIDEmbedder:

Public Member Functions

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')
 
def get_cmssw_version_number (klass, debug=False)
 
def getDeepTauVersion (self, file_name)
 
def getDpfTauVersion (self, file_name)
 
def is_above_cmssw_version (klass, release=9, subversion=4, patch=0, debug=False)
 
def loadMVA_WPs_run2_2017 (self)
 
def processDeepProducer (self, producer_name, tauIDSources, workingPoints_)
 
def runTauID (self)
 
def tauIDMVAinputs (self, module, wp)
 

Static Public Member Functions

def get_cmssw_version (debug=False)
 
def versionToInt (release=9, subversion=4, patch=0, debug=False)
 

Public Attributes

 debug
 
 process
 
 rerunIsolationNewDMMVArun2016v1Task
 
 rerunIsolationNewDMMVArun2017v2Task
 
 rerunIsolationOldDMdR0p3MVArun2017v2Task
 
 rerunIsolationOldDMMVArun2016v1Task
 
 rerunIsolationOldDMMVArun2017v1Task
 
 rerunIsolationOldDMMVArun2017v2Task
 
 tauIdDiscrMVA_2017_version
 
 tauIdDiscrMVA_trainings_run2_2017
 
 tauIdDiscrMVA_WPs_run2_2017
 
 toKeep
 
 updatedTauName
 

Static Public Attributes

 availableDiscriminators
 

Detailed Description

class to rerun the tau seq and acces trainings from the database

Definition at line 9 of file runTauIdMVA.py.

Constructor & Destructor Documentation

◆ __init__()

def runTauIdMVA.TauIDEmbedder.__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 at line 18 of file runTauIdMVA.py.

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 

Member Function Documentation

◆ get_cmssw_version()

def runTauIdMVA.TauIDEmbedder.get_cmssw_version (   debug = False)
static 
returns 'CMSSW_X_Y_Z'

Definition at line 59 of file runTauIdMVA.py.

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 

◆ get_cmssw_version_number()

def runTauIdMVA.TauIDEmbedder.get_cmssw_version_number (   klass,
  debug = False 
) 
returns '(release, subversion, patch)' (without 'CMSSW_')

Definition at line 66 of file runTauIdMVA.py.

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 

References createfilelist.int, and cms::dd.split().

◆ getDeepTauVersion()

def runTauIdMVA.TauIDEmbedder.getDeepTauVersion (   self,
  file_name 
) 
returns the DeepTau year, version, subversion. File name should contain a version label with data takig year \
(2011-2, 2015-8), version number (vX) and subversion (pX), e.g. 2017v0p6, in general the following format: \
{year}v{version}p{subversion}

Definition at line 907 of file runTauIdMVA.py.

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)

References createfilelist.int.

◆ getDpfTauVersion()

def runTauIdMVA.TauIDEmbedder.getDpfTauVersion (   self,
  file_name 
) 
returns the DNN version. File name should contain a version label with data takig year (2011-2, 2015-8) and \
   version number (vX), e.g. 2017v0, in general the following format: {year}v{version}

Definition at line 897 of file runTauIdMVA.py.

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 

References createfilelist.int.

◆ is_above_cmssw_version()

def runTauIdMVA.TauIDEmbedder.is_above_cmssw_version (   klass,
  release = 9,
  subversion = 4,
  patch = 0,
  debug = False 
)

Definition at line 84 of file runTauIdMVA.py.

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 

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

◆ loadMVA_WPs_run2_2017()

def runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017 (   self)

Definition at line 96 of file runTauIdMVA.py.

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 

References DigiComparisonTask.debug, TestTask.debug, TPComparisonTask.debug, QIE11Task.debug, PedestalTask.debug, RecHitTask.debug, QIE10Task.debug, UMNioTask.debug, ZDCTask.debug, HcalOfflineHarvesting.debug, HcalOnlineHarvesting.debug, HFRaddamTask.debug, LaserTask.debug, NoCQTask.debug, RawTask.debug, TPTask.debug, InterpolationDebug.debug, DigiTask.debug, LEDTask.debug, runTauIdMVA.TauIDEmbedder.debug, DTDigiToRawModule.debug, CSCRPCData.debug, CSCTMBScope.debug, ALIUtils.debug, magneticfield::eSector.debug, CSCDCCUnpacker.debug, DTDigiToRaw.debug, magneticfield::bRod.debug, CSCSegAlgoPreClustering.debug, DTSegment4DT0Corrector.debug, DTRecHitProducer.debug, DTRecSegment4DProducer.debug, RPCPointProducer.debug, crabFunctions.CrabController.debug, DTSegmentsTask.debug, QCDSingleJetFilter.debug, MuonSeedProducer.debug, HiggsTo2GammaSkim.debug, HiggsToZZ4LeptonsSkimEff.debug, magneticfield::bSector.debug, HiggsToZZ4LeptonsPreFilter.debug, DTOccupancyEfficiency.debug, DTTTrigCorrectionFirst.debug, HiggsToZZ4LeptonsSkim.debug, DTRecSegment2DProducer.debug, DTDDUUnpacker.debug, DTTPDeadWriter.debug, pkg.AbstractPkg.debug, DTTTrigWriter.debug, magneticfield::bSlab.debug, JetAnaPythia< Jet >.debug, DTRecSegment2DExtendedProducer.debug, DTT0CalibrationRMS.debug, MuScleFitFilter.debug, CSCDCCEventData.debug, SiPixelRawToDigi.debug, CSCAnodeLCTAnalyzer.debug, CSCCathodeLCTAnalyzer.debug, DTNoiseComputation.debug, magneticfield::bLayer.debug, CSCSegAlgoShowering.debug, DTOccupancyPoint.debug, MuScleFitPlotter.debug, GEMCSCSegAlgoRR.debug, DTTTrigSyncT0Only.debug, DTROS25Unpacker.debug, rrapi.RRApi.debug, DTSpyReader.debug, util.rrapi.RRApi.debug, DTEfficiencyTask.debug, DTT0Calibration.debug, ME0SegmentAlgorithm.debug, DTTTrigCalibration.debug, DTRunConditionVar.debug, HeavyChHiggsToTauNuSkim.debug, GEMSegmentAlgorithm.debug, PythiaFilterEMJetHeep.debug, CSCDDUEventData.debug, DTChamberEfficiencyTask.debug, DTCombinatorialPatternReco4D.debug, DTMeantimerPatternReco4D.debug, DTRefitAndCombineReco4D.debug, HCALResponse.debug, DTClusterer.debug, DTChamberEfficiency.debug, FCDTask.debug, CSCCLCTData.debug, MuonSeedCreator.debug, DTTMax.debug, DTLinearDriftAlgo.debug, CSCTimingExtractor.debug, DTVDriftCalibration.debug, DTTTrigSyncFromDB.debug, MuonSeedCleaner.debug, CSCTMBData.debug, DTNoDriftAlgo.debug, DTParametrizedDriftAlgo.debug, DTCombinatorialPatternReco.debug, MagGeoBuilderFromDDD.debug, PixelDataFormatter.debug, DTTimingExtractor.debug, DTMeantimerPatternReco.debug, DTCombinatorialExtendedPatternReco.debug, DTTTrigSyncTOFCorr.debug, MuonSeedBuilder.debug, DTLinearDriftFromDBAlgo.debug, DTSegmentUpdator.debug, CSCTMBHeader.debug, CSCSegAlgoDF.debug, CSCEventData.debug, MuScleFitUtils.debug, BaseParticlePropagator.debug, CSCTriggerPrimitivesReader.debug, magneticfield::BaseVolumeHandle.debug, CSCSegAlgoST.debug, CSCALCTTrailer.debug, CSCALCTHeader.debug, notcub::CachingHostAllocator.debug, notcub::CachingDeviceAllocator.debug, EcalBoundaryInfoCalculator< EcalDetId >.debug, crabFunctions.CrabTask.debug, Pythia8::PowhegHooksBB4L.debug, HltDiff.debug, mps_monitormerge.items, relativeConstraints.keys, edm::ProductLabels.process, runTauIdMVA.TauIDEmbedder.process, DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, cscdqm::HWStandbyType.process, DTTtrigWorkflow.DTttrigWorkflow.process, EgammaHLTValidationUtils.EgammaDQMModuleMaker.process, Config.Process.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, JsonOutputProducer::JsonConfigurationBlock.process, Config.TestModuleCommand.process, runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_2017_version, runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_trainings_run2_2017, and runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_WPs_run2_2017.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

◆ processDeepProducer()

def runTauIdMVA.TauIDEmbedder.processDeepProducer (   self,
  producer_name,
  tauIDSources,
  workingPoints_ 
)

Definition at line 882 of file runTauIdMVA.py.

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 

References edm::ProductLabels.process, runTauIdMVA.TauIDEmbedder.process, DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, cscdqm::HWStandbyType.process, DTTtrigWorkflow.DTttrigWorkflow.process, EgammaHLTValidationUtils.EgammaDQMModuleMaker.process, Config.Process.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, JsonOutputProducer::JsonConfigurationBlock.process, Config.TestModuleCommand.process, str, and pileupCalc.upper.

◆ runTauID()

def runTauIdMVA.TauIDEmbedder.runTauID (   self)

Definition at line 126 of file runTauIdMVA.py.

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 

References DigiComparisonTask.debug, TestTask.debug, TPComparisonTask.debug, HcalOfflineHarvesting.debug, HcalOnlineHarvesting.debug, HFRaddamTask.debug, LaserTask.debug, QIE10Task.debug, QIE11Task.debug, NoCQTask.debug, PedestalTask.debug, RecHitTask.debug, UMNioTask.debug, ZDCTask.debug, RawTask.debug, TPTask.debug, DigiTask.debug, LEDTask.debug, InterpolationDebug.debug, runTauIdMVA.TauIDEmbedder.debug, DTDigiToRawModule.debug, CSCRPCData.debug, CSCTMBScope.debug, CSCDCCUnpacker.debug, DTDigiToRaw.debug, ALIUtils.debug, magneticfield::eSector.debug, magneticfield::bRod.debug, CSCSegAlgoPreClustering.debug, DTSegment4DT0Corrector.debug, RPCPointProducer.debug, DTRecHitProducer.debug, DTRecSegment4DProducer.debug, crabFunctions.CrabController.debug, MuonSeedProducer.debug, QCDSingleJetFilter.debug, DTSegmentsTask.debug, HiggsTo2GammaSkim.debug, HiggsToZZ4LeptonsSkimEff.debug, magneticfield::bSector.debug, DTOccupancyEfficiency.debug, HiggsToZZ4LeptonsPreFilter.debug, DTTTrigCorrectionFirst.debug, HiggsToZZ4LeptonsSkim.debug, DTTPDeadWriter.debug, DTDDUUnpacker.debug, pkg.AbstractPkg.debug, DTRecSegment2DProducer.debug, DTTTrigWriter.debug, magneticfield::bSlab.debug, JetAnaPythia< Jet >.debug, DTRecSegment2DExtendedProducer.debug, SiPixelRawToDigi.debug, DTT0CalibrationRMS.debug, MuScleFitFilter.debug, CSCDCCEventData.debug, DTNoiseComputation.debug, CSCAnodeLCTAnalyzer.debug, CSCCathodeLCTAnalyzer.debug, magneticfield::bLayer.debug, CSCSegAlgoShowering.debug, DTOccupancyPoint.debug, MuScleFitPlotter.debug, GEMCSCSegAlgoRR.debug, DTTTrigSyncT0Only.debug, DTROS25Unpacker.debug, util.rrapi.RRApi.debug, rrapi.RRApi.debug, DTSpyReader.debug, DTEfficiencyTask.debug, DTT0Calibration.debug, ME0SegmentAlgorithm.debug, DTTTrigCalibration.debug, DTRunConditionVar.debug, PythiaFilterEMJetHeep.debug, HeavyChHiggsToTauNuSkim.debug, GEMSegmentAlgorithm.debug, CSCDDUEventData.debug, DTChamberEfficiencyTask.debug, DTMeantimerPatternReco4D.debug, HCALResponse.debug, DTCombinatorialPatternReco4D.debug, DTRefitAndCombineReco4D.debug, DTClusterer.debug, DTChamberEfficiency.debug, FCDTask.debug, CSCCLCTData.debug, MuonSeedCreator.debug, DTTMax.debug, DTLinearDriftAlgo.debug, CSCTimingExtractor.debug, DTTTrigSyncFromDB.debug, DTVDriftCalibration.debug, MuonSeedCleaner.debug, CSCTMBData.debug, DTParametrizedDriftAlgo.debug, DTNoDriftAlgo.debug, DTCombinatorialPatternReco.debug, MagGeoBuilderFromDDD.debug, PixelDataFormatter.debug, DTTimingExtractor.debug, DTMeantimerPatternReco.debug, DTTTrigSyncTOFCorr.debug, DTCombinatorialExtendedPatternReco.debug, MuonSeedBuilder.debug, DTLinearDriftFromDBAlgo.debug, DTSegmentUpdator.debug, CSCTMBHeader.debug, CSCSegAlgoDF.debug, CSCEventData.debug, MuScleFitUtils.debug, BaseParticlePropagator.debug, CSCTriggerPrimitivesReader.debug, magneticfield::BaseVolumeHandle.debug, CSCSegAlgoST.debug, CSCALCTTrailer.debug, CSCALCTHeader.debug, notcub::CachingHostAllocator.debug, notcub::CachingDeviceAllocator.debug, EcalBoundaryInfoCalculator< EcalDetId >.debug, crabFunctions.CrabTask.debug, Pythia8::PowhegHooksBB4L.debug, HltDiff.debug, runTauIdMVA.TauIDEmbedder.is_above_cmssw_version(), runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017(), edm::ProductLabels.process, runTauIdMVA.TauIDEmbedder.process, DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, cscdqm::HWStandbyType.process, DTTtrigWorkflow.DTttrigWorkflow.process, EgammaHLTValidationUtils.EgammaDQMModuleMaker.process, Config.Process.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, JsonOutputProducer::JsonConfigurationBlock.process, Config.TestModuleCommand.process, runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_2017_version, runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_trainings_run2_2017, runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_WPs_run2_2017, and runTauIdMVA.TauIDEmbedder.toKeep.

◆ tauIDMVAinputs()

def runTauIdMVA.TauIDEmbedder.tauIDMVAinputs (   self,
  module,
  wp 
)

Definition at line 93 of file runTauIdMVA.py.

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 

References edm::ProductLabels.process, runTauIdMVA.TauIDEmbedder.process, DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, cscdqm::HWStandbyType.process, DTTtrigWorkflow.DTttrigWorkflow.process, EgammaHLTValidationUtils.EgammaDQMModuleMaker.process, Config.Process.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, JsonOutputProducer::JsonConfigurationBlock.process, and Config.TestModuleCommand.process.

◆ versionToInt()

def runTauIdMVA.TauIDEmbedder.versionToInt (   release = 9,
  subversion = 4,
  patch = 0,
  debug = False 
)
static

Definition at line 77 of file runTauIdMVA.py.

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 

Member Data Documentation

◆ availableDiscriminators

runTauIdMVA.TauIDEmbedder.availableDiscriminators
static

Definition at line 11 of file runTauIdMVA.py.

◆ debug

runTauIdMVA.TauIDEmbedder.debug

Definition at line 21 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017(), and runTauIdMVA.TauIDEmbedder.runTauID().

◆ process

runTauIdMVA.TauIDEmbedder.process

Definition at line 20 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017(), runTauIdMVA.TauIDEmbedder.processDeepProducer(), runTauIdMVA.TauIDEmbedder.runTauID(), and runTauIdMVA.TauIDEmbedder.tauIDMVAinputs().

◆ rerunIsolationNewDMMVArun2016v1Task

runTauIdMVA.TauIDEmbedder.rerunIsolationNewDMMVArun2016v1Task

Definition at line 529 of file runTauIdMVA.py.

◆ rerunIsolationNewDMMVArun2017v2Task

runTauIdMVA.TauIDEmbedder.rerunIsolationNewDMMVArun2017v2Task

Definition at line 329 of file runTauIdMVA.py.

◆ rerunIsolationOldDMdR0p3MVArun2017v2Task

runTauIdMVA.TauIDEmbedder.rerunIsolationOldDMdR0p3MVArun2017v2Task

Definition at line 404 of file runTauIdMVA.py.

◆ rerunIsolationOldDMMVArun2016v1Task

runTauIdMVA.TauIDEmbedder.rerunIsolationOldDMMVArun2016v1Task

Definition at line 480 of file runTauIdMVA.py.

◆ rerunIsolationOldDMMVArun2017v1Task

runTauIdMVA.TauIDEmbedder.rerunIsolationOldDMMVArun2017v1Task

Definition at line 186 of file runTauIdMVA.py.

◆ rerunIsolationOldDMMVArun2017v2Task

runTauIdMVA.TauIDEmbedder.rerunIsolationOldDMMVArun2017v2Task

Definition at line 258 of file runTauIdMVA.py.

◆ tauIdDiscrMVA_2017_version

runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_2017_version

Definition at line 34 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017(), and runTauIdMVA.TauIDEmbedder.runTauID().

◆ tauIdDiscrMVA_trainings_run2_2017

runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_trainings_run2_2017

Definition at line 32 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017(), and runTauIdMVA.TauIDEmbedder.runTauID().

◆ tauIdDiscrMVA_WPs_run2_2017

runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_WPs_run2_2017

Definition at line 33 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017(), and runTauIdMVA.TauIDEmbedder.runTauID().

◆ toKeep

runTauIdMVA.TauIDEmbedder.toKeep

Definition at line 38 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

◆ updatedTauName

runTauIdMVA.TauIDEmbedder.updatedTauName

Definition at line 22 of file runTauIdMVA.py.

taus_updatedMVAIds_cff.tauIDMVAinputs
def tauIDMVAinputs(module, wp)
Definition: taus_updatedMVAIds_cff.py:310
relativeConstraints.keys
keys
Definition: relativeConstraints.py:89
cms::dd::split
std::vector< std::string_view > split(std::string_view, const char *)
mps_monitormerge.items
list items
Definition: mps_monitormerge.py:29
PATTauDiscriminantCutMultiplexer_cfi
str
#define str(s)
Definition: TestProcessor.cc:48
svgfig.load
def load(fileName)
Definition: svgfig.py:547
createfilelist.int
int
Definition: createfilelist.py:10
edm::print
S & print(S &os, JobReport::InputFile const &f)
Definition: JobReport.cc:66
format
pileupCalc.upper
upper
Definition: pileupCalc.py:214
Generated for CMSSW Reference Manual by doxygen 1.8.16