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__
 
def get_cmssw_version_number (klass, debug=False)
 
def getDeepTauVersion (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
 
 originalTauName
 
 postfix
 
 process
 
 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 11 of file runTauIdMVA.py.

Constructor & Destructor Documentation

◆ __init__()

def runTauIdMVA.TauIDEmbedder.__init__ (   self,
  process,
  debug = False,
  originalTauName = "slimmedTaus",
  updatedTauName = "slimmedTausNewID",
  postfix = "",
  toKeep = ["deepTau2017v2p1",
  deepTau2018v2p5,
  tauIdDiscrMVA_trainings_run2_2017 = { 'tauIdMVAIsoDBoldDMwLT2017' : "tauIdMVAIsoDBoldDMwLT2017",
  tauIdDiscrMVA_WPs_run2_2017 = {                     'tauIdMVAIsoDBoldDMwLT2017' : {                         'Eff95' : "DBoldDMwLTEff95",
  Eff90 
)

Definition at line 30 of file runTauIdMVA.py.

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 
submitPVValidationJobs.__init__
def __init__(self, dataset, job_number, job_id, job_name, isDA, isMC, applyBOWS, applyEXTRACOND, extraconditions, runboundary, lumilist, intlumi, maxevents, gt, allFromGT, alignmentDB, alignmentTAG, apeDB, apeTAG, bowDB, bowTAG, vertextype, tracktype, refittertype, ttrhtype, applyruncontrol, ptcut, CMSSW_dir, the_dir)
Definition: submitPVValidationJobs.py:365
svgfig.load
def load(fileName)
Definition: svgfig.py:547

Member Function Documentation

◆ get_cmssw_version()

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

Definition at line 65 of file runTauIdMVA.py.

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 

◆ get_cmssw_version_number()

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

Definition at line 72 of file runTauIdMVA.py.

References createfilelist.int, and submitPVValidationJobs.split().

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 

◆ 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 887 of file runTauIdMVA.py.

References createfilelist.int.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

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)
903 

◆ is_above_cmssw_version()

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

Definition at line 90 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

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 

◆ loadMVA_WPs_run2_2017()

def runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017 (   self)

Definition at line 102 of file runTauIdMVA.py.

References HcalOfflineHarvesting.debug, PedestalTask.debug, QIE10Task.debug, QIE11Task.debug, RecHitTask.debug, UMNioTask.debug, ZDCTask.debug, HcalOnlineHarvesting.debug, HFRaddamTask.debug, LaserTask.debug, NoCQTask.debug, RawTask.debug, TPTask.debug, InterpolationDebug.debug, DigiTask.debug, LEDTask.debug, DTDigiToRawModule.debug, Cordic.debug, CSCRPCData.debug, CSCTMBScope.debug, magneticfield::eSector.debug, ALIUtils.debug, DTDigiToRaw.debug, magneticfield::bRod.debug, CSCSegAlgoPreClustering.debug, DTSegment4DT0Corrector.debug, DTRecSegment4DProducer.debug, crabFunctions.CrabController.debug, DTRecHitProducer.debug, DTSegmentsTask.debug, RPCPointProducer.debug, magneticfield::bSector.debug, DTOccupancyEfficiency.debug, runTauIdMVA.TauIDEmbedder.debug, MuonSeedProducer.debug, CSCGEMData.debug, DTTTrigCorrectionFirst.debug, DTDDUUnpacker.debug, pkg.AbstractPkg.debug, magneticfield::bSlab.debug, MuScleFitFilter.debug, JetAnaPythia< Jet >.debug, CSCDCCEventData.debug, DTRecSegment2DProducer.debug, DTT0CalibrationRMS.debug, DTRecSegment2DExtendedProducer.debug, TritonService::FallbackOpts.debug, DTTTrigWriter.debug, DTTPDeadWriter.debug, PPSAlignmentConfigurationESSource.debug, magneticfield::bLayer.debug, CSCSegAlgoShowering.debug, DTOccupancyPoint.debug, MuScleFitPlotter.debug, DTNoiseComputation.debug, GEMCSCSegAlgoRR.debug, L1CaloJetHTTProducer.debug, DTROS25Unpacker.debug, rrapi.RRApi.debug, DTSpyReader.debug, util.rrapi.RRApi.debug, DTT0Calibration.debug, DTTTrigSyncT0Only.debug, ME0SegmentAlgorithm.debug, GEMSegmentAlgorithm.debug, DTEfficiencyTask.debug, DTTTrigCalibration.debug, PythiaFilterEMJetHeep.debug, CSCDDUEventData.debug, DTRunConditionVar.debug, DTChamberEfficiencyTask.debug, HCALResponse.debug, DTCombinatorialPatternReco4D.debug, DTMeantimerPatternReco4D.debug, DTRefitAndCombineReco4D.debug, DTClusterer.debug, DTChamberEfficiency.debug, FCDTask.debug, CSCComparatorData.debug, CSCDCCUnpacker.debug, MuonSeedCreator.debug, DTTMax.debug, L1TowerCalibrator.debug, DTLinearDriftAlgo.debug, CSCTimingExtractor.debug, MuonSeedCleaner.debug, DTVDriftCalibration.debug, DTNoDriftAlgo.debug, DTParametrizedDriftAlgo.debug, DTTTrigSyncFromDB.debug, MagGeoBuilderFromDDD.debug, CSCTMBData.debug, DTTTrigSyncTOFCorr.debug, DTCombinatorialPatternReco.debug, DTTimingExtractor.debug, DTMeantimerPatternReco.debug, MuonSeedBuilder.debug, DTCombinatorialExtendedPatternReco.debug, L1CaloJetProducer.debug, DTSegmentUpdator.debug, CSCSegAlgoDF.debug, DTLinearDriftFromDBAlgo.debug, MuScleFitUtils.debug, CSCEventData.debug, BaseParticlePropagator.debug, CSCTMBHeader.debug, magneticfield::BaseVolumeHandle.debug, CSCSegAlgoST.debug, CSCALCTTrailer.debug, notcub::CachingHostAllocator.debug, notcub::CachingDeviceAllocator.debug, CSCALCTHeader.debug, EcalBoundaryInfoCalculator< EcalDetId >.debug, adaptToRunAtMiniAOD.adaptToRunAtMiniAOD.debug, crabFunctions.CrabTask.debug, Pythia8::PowhegHooksBB4L.debug, HltDiff.debug, mps_monitormerge.items, relativeConstraints.keys, edm::ProductLabels.process, DTT0WireWorkflow.DTT0WireWorkflow.process, runTauIdMVA.TauIDEmbedder.process, DTVdriftWorkflow.DTvdriftWorkflow.process, cscdqm::HWStandbyType.process, DTTtrigWorkflow.DTttrigWorkflow.process, EgammaHLTValidationUtils.EgammaDQMModuleMaker.process, Config.Process.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, adaptToRunAtMiniAOD.adaptToRunAtMiniAOD.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().

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 
mps_monitormerge.items
list items
Definition: mps_monitormerge.py:29

◆ processDeepProducer()

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

Definition at line 872 of file runTauIdMVA.py.

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

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

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 
str
#define str(s)
Definition: TestProcessor.cc:54

◆ runTauID()

def runTauIdMVA.TauIDEmbedder.runTauID (   self)

Definition at line 132 of file runTauIdMVA.py.

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

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 
patTauDiscriminationAgainstElectronMVA6_cfi
taus_updatedMVAIds_cff.tauIDMVAinputs
def tauIDMVAinputs(module, wp)
Definition: taus_updatedMVAIds_cff.py:316
print
void print(TMatrixD &m, const char *label=nullptr, bool mathematicaFormat=false)
Definition: Utilities.cc:47
PATTauDiscriminantCutMultiplexer_cfi

◆ tauIDMVAinputs()

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

Definition at line 99 of file runTauIdMVA.py.

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

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

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 
taus_updatedMVAIds_cff.tauIDMVAinputs
def tauIDMVAinputs(module, wp)
Definition: taus_updatedMVAIds_cff.py:316

◆ versionToInt()

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

Definition at line 83 of file runTauIdMVA.py.

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 

Member Data Documentation

◆ availableDiscriminators

runTauIdMVA.TauIDEmbedder.availableDiscriminators
static

Definition at line 13 of file runTauIdMVA.py.

◆ debug

runTauIdMVA.TauIDEmbedder.debug

Definition at line 43 of file runTauIdMVA.py.

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

◆ originalTauName

runTauIdMVA.TauIDEmbedder.originalTauName

Definition at line 44 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

◆ postfix

runTauIdMVA.TauIDEmbedder.postfix

Definition at line 46 of file runTauIdMVA.py.

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

◆ process

runTauIdMVA.TauIDEmbedder.process

Definition at line 42 of file runTauIdMVA.py.

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

◆ tauIdDiscrMVA_2017_version

runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_2017_version

Definition at line 58 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 56 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 57 of file runTauIdMVA.py.

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

◆ toKeep

runTauIdMVA.TauIDEmbedder.toKeep

Definition at line 62 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

◆ updatedTauName

runTauIdMVA.TauIDEmbedder.updatedTauName

Definition at line 45 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

Generated for CMSSW Reference Manual by doxygen 1.8.14