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,
  deepTau2026v2p5,
  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 924 of file runTauIdMVA.py.

References createfilelist.int.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

924  def getDeepTauVersion(self, file_name):
925  """returns the DeepTau year, version, subversion. File name should contain a version label with data takig year \
926  (2011-2, 2015-8), version number (vX) and subversion (pX), e.g. 2017v0p6, in general the following format: \
927  {year}v{version}p{subversion}"""
928  version_search = re.search('(20[1,2][125678])v([0-9]+)(p[0-9]+|)[\._]', file_name)
929  if not version_search:
930  raise RuntimeError('File "{}" has an invalid name pattern, should be in the format "{year}v{version}p{subversion}". \
931  Unable to extract version number.'.format(file_name))
932  year = version_search.group(1)
933  version = version_search.group(2)
934  subversion = version_search.group(3)
935  if len(subversion) > 0:
936  subversion = subversion[1:]
937  else:
938  subversion = 0
939  return int(year), int(version), int(subversion)
940 

◆ 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, l1ct::EGInputSelectorEmuConfig.debug, Cordic.debug, DTDigiToRawModule.debug, CSCRPCData.debug, CSCTMBScope.debug, DTDigiToRaw.debug, L1SeedConePFJetProducer.debug, magneticfield::eSector.debug, ALIUtils.debug, magneticfield::bRod.debug, CSCSegAlgoPreClustering.debug, DTSegment4DT0Corrector.debug, DTRecSegment4DProducer.debug, crabFunctions.CrabController.debug, DTSegmentsTask.debug, DTRecHitProducer.debug, magneticfield::bSector.debug, DTOccupancyEfficiency.debug, runTauIdMVA.TauIDEmbedder.debug, RPCPointProducer.debug, MuonSeedProducer.debug, CSCGEMData.debug, DTTTrigCorrectionFirst.debug, DTDDUUnpacker.debug, pkg.AbstractPkg.debug, magneticfield::bSlab.debug, MuScleFitFilter.debug, JetAnaPythia< Jet >.debug, CSCDCCEventData.debug, DTRecSegment2DProducer.debug, DTRecSegment2DExtendedProducer.debug, DTT0CalibrationRMS.debug, TritonService::FallbackOpts.debug, DTTTrigWriter.debug, DTTPDeadWriter.debug, PPSAlignmentConfigurationESSource.debug, magneticfield::bLayer.debug, CSCSegAlgoShowering.debug, DTOccupancyPoint.debug, MuScleFitPlotter.debug, l1ct::PFTkEGAlgoEmuConfig.debug, DTNoiseComputation.debug, GEMCSCSegAlgoRR.debug, L1CaloJetHTTProducer.debug, DTROS25Unpacker.debug, rrapi.RRApi.debug, DTSpyReader.debug, util.rrapi.RRApi.debug, DTT0Calibration.debug, DTTTrigSyncT0Only.debug, ME0SegmentAlgorithm.debug, DTEfficiencyTask.debug, GEMSegmentAlgorithm.debug, PythiaFilterEMJetHeep.debug, CSCDDUEventData.debug, DTTTrigCalibration.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, CSCTimingExtractor.debug, DTLinearDriftAlgo.debug, MuonSeedCleaner.debug, DTVDriftCalibration.debug, DTNoDriftAlgo.debug, DTParametrizedDriftAlgo.debug, DTTTrigSyncFromDB.debug, CSCTMBData.debug, MagGeoBuilderFromDDD.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, 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 909 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().

909  def processDeepProducer(self, producer_name, tauIDSources, workingPoints_):
910  for target,points in workingPoints_.items():
911  setattr(tauIDSources, 'by{}VS{}raw'.format(producer_name[0].upper()+producer_name[1:], target),
912  cms.PSet(inputTag = cms.InputTag(producer_name+self.postfix, 'VS{}'.format(target)), workingPointIndex = cms.int32(-1)))
913 
914  cut_expressions = []
915  for index, (point,cut) in enumerate(points.items()):
916  cut_expressions.append(str(cut))
917 
918  setattr(tauIDSources, 'by{}{}VS{}'.format(point, producer_name[0].upper()+producer_name[1:], target),
919  cms.PSet(inputTag = cms.InputTag(producer_name+self.postfix, 'VS{}'.format(target)), workingPointIndex = cms.int32(index)))
920  if len(cut_expressions) > 0:
921  setattr(getattr(self.process, producer_name+self.postfix), 'VS{}WP'.format(target), cms.vstring(*cut_expressions))
922 
923 
str
#define str(s)
Definition: TestProcessor.cc:56

◆ 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, l1ct::EGInputSelectorEmuConfig.debug, Cordic.debug, DTDigiToRawModule.debug, CSCRPCData.debug, CSCTMBScope.debug, DTDigiToRaw.debug, L1SeedConePFJetProducer.debug, magneticfield::eSector.debug, ALIUtils.debug, magneticfield::bRod.debug, CSCSegAlgoPreClustering.debug, DTSegment4DT0Corrector.debug, DTRecSegment4DProducer.debug, crabFunctions.CrabController.debug, DTSegmentsTask.debug, DTRecHitProducer.debug, magneticfield::bSector.debug, DTOccupancyEfficiency.debug, runTauIdMVA.TauIDEmbedder.debug, RPCPointProducer.debug, MuonSeedProducer.debug, CSCGEMData.debug, pkg.AbstractPkg.debug, DTDDUUnpacker.debug, DTTTrigCorrectionFirst.debug, magneticfield::bSlab.debug, MuScleFitFilter.debug, JetAnaPythia< Jet >.debug, DTRecSegment2DProducer.debug, CSCDCCEventData.debug, DTRecSegment2DExtendedProducer.debug, DTT0CalibrationRMS.debug, TritonService::FallbackOpts.debug, DTTTrigWriter.debug, DTTPDeadWriter.debug, PPSAlignmentConfigurationESSource.debug, magneticfield::bLayer.debug, CSCSegAlgoShowering.debug, MuScleFitPlotter.debug, DTOccupancyPoint.debug, l1ct::PFTkEGAlgoEmuConfig.debug, DTNoiseComputation.debug, GEMCSCSegAlgoRR.debug, L1CaloJetHTTProducer.debug, DTROS25Unpacker.debug, rrapi.RRApi.debug, DTSpyReader.debug, util.rrapi.RRApi.debug, DTT0Calibration.debug, DTTTrigSyncT0Only.debug, ME0SegmentAlgorithm.debug, DTEfficiencyTask.debug, PythiaFilterEMJetHeep.debug, GEMSegmentAlgorithm.debug, DTTTrigCalibration.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, CSCTimingExtractor.debug, DTLinearDriftAlgo.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, EcalBoundaryInfoCalculator< EcalDetId >.debug, adaptToRunAtMiniAOD.adaptToRunAtMiniAOD.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 v2 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  year = full_version[0],
579  version = full_version[1],
580  sub_version = 1 #MB: subversion cannot be properly deduced from file names; it should be 1 also for v2
581  ))
582 
583  self.processDeepProducer(_deepTauName, tauIDSources, workingPoints_)
584 
585  _deepTauProducer = getattr(self.process,_deepTauName+self.postfix)
586  _rerunMvaIsolationTask.add(_deepTauProducer)
587  _rerunMvaIsolationSequence += _deepTauProducer
588 
589 
590  if "deepTau2017v2p1" in self.toKeep:
591  if self.debug: print ("Adding DeepTau v2p1 IDs")
592 
593  _deepTauName = "deepTau2017v2p1"
594  workingPoints_ = WORKING_POINTS_v2p1
595 
596  file_names = [
597  'core:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_core.pb',
598  'inner:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_inner.pb',
599  'outer:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_outer.pb',
600  ]
601  full_version = self.getDeepTauVersion(file_names[0])
602  setattr(self.process,_deepTauName+self.postfix,DeepTau.clone(
603  Prediscriminants = noPrediscriminants,
604  taus = self.originalTauName,
605  graph_file = file_names,
606  year = full_version[0],
607  version = full_version[1],
608  sub_version = 1, #MB: subversion cannot be properly deduced from file names
609  disable_dxy_pca = True
610  ))
611 
612  self.processDeepProducer(_deepTauName, tauIDSources, workingPoints_)
613 
614  _deepTauProducer = getattr(self.process,_deepTauName+self.postfix)
615  _rerunMvaIsolationTask.add(_deepTauProducer)
616  _rerunMvaIsolationSequence += _deepTauProducer
617 
618  if "deepTau2018v2p5" in self.toKeep:
619  if self.debug: print ("Adding DeepTau v2p5 IDs")
620 
621  _deepTauName = "deepTau2018v2p5"
622  workingPoints_ = WORKING_POINTS_v2p5
623 
624  file_names = [
625  'core:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2018v2p5_core.pb',
626  'inner:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2018v2p5_inner.pb',
627  'outer:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2018v2p5_outer.pb',
628  ]
629  full_version = self.getDeepTauVersion(file_names[0])
630  setattr(self.process,_deepTauName+self.postfix,DeepTau.clone(
631  Prediscriminants = noPrediscriminants,
632  taus = self.originalTauName,
633  graph_file = file_names,
634  year = full_version[0],
635  version = full_version[1],
636  sub_version = full_version[2],
637  disable_dxy_pca = True,
638  disable_hcalFraction_workaround = True,
639  disable_CellIndex_workaround = True
640  ))
641 
642  self.processDeepProducer(_deepTauName, tauIDSources, workingPoints_)
643 
644  _deepTauProducer = getattr(self.process,_deepTauName+self.postfix)
645  _rerunMvaIsolationTask.add(_deepTauProducer)
646  _rerunMvaIsolationSequence += _deepTauProducer
647 
648  if "deepTau2026v2p5" in self.toKeep:
649  if self.debug: print ("Adding Phase2 DeepTau v2p5 IDs")
650 
651  _deepTauName = "deepTau2026v2p5"
652  workingPoints_ = WORKING_POINTS_PHASEII_v2p5
653 
654  file_names = [
655  'core:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2026v2p5_core.pb',
656  'inner:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2026v2p5_inner.pb',
657  'outer:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2026v2p5_outer.pb',
658  ]
659  full_version = self.getDeepTauVersion(file_names[0])
660  setattr(self.process,_deepTauName+self.postfix,DeepTau.clone(
661  Prediscriminants = noPrediscriminants,
662  taus = self.originalTauName,
663  graph_file = file_names,
664  year = full_version[0],
665  version = full_version[1],
666  sub_version = full_version[2],
667  disable_dxy_pca = True,
668  disable_hcalFraction_workaround = True,
669  disable_CellIndex_workaround = True
670  ))
671 
672  from RecoTauTag.RecoTau.mergedPhase2SlimmedElectronsForTauId_cff import mergedSlimmedElectronsForTauId
673  if not hasattr(self.process,"mergedSlimmedElectronsForTauId"):
674  self.process.mergedSlimmedElectronsForTauId = mergedSlimmedElectronsForTauId
675  setattr(getattr(self.process, _deepTauName+self.postfix), "electrons", cms.InputTag("mergedSlimmedElectronsForTauId"))
676  setattr(getattr(self.process, _deepTauName+self.postfix), "vertices", cms.InputTag("offlineSlimmedPrimaryVertices4D"))
677 
678  self.processDeepProducer(_deepTauName, tauIDSources, workingPoints_)
679 
680  _deepTauProducer = getattr(self.process,_deepTauName+self.postfix)
681  _rerunMvaIsolationTask.add(self.process.mergedSlimmedElectronsForTauId)
682  _rerunMvaIsolationTask.add(_deepTauProducer)
683  _rerunMvaIsolationSequence += self.process.mergedSlimmedElectronsForTauId
684  _rerunMvaIsolationSequence += _deepTauProducer
685 
686  if "againstEle2018" in self.toKeep:
687  antiElectronDiscrMVA6_version = "MVA6v3_noeveto"
688 
690  from RecoTauTag.RecoTau.patTauDiscriminationAgainstElectronMVA6_cfi import patTauDiscriminationAgainstElectronMVA6
691  _byElectronRejectionMVA62018Raw = "patTauDiscriminationByElectronRejectionMVA62018Raw"+self.postfix
692  setattr(self.process,_byElectronRejectionMVA62018Raw,patTauDiscriminationAgainstElectronMVA6.clone(
693  PATTauProducer = self.originalTauName,
694  Prediscriminants = noPrediscriminants, #already selected for MiniAOD
695  srcElectrons = cms.InputTag('slimmedElectrons'),
696  vetoEcalCracks = cms.bool(False), #keep taus in EB-EE cracks
697  mvaName_NoEleMatch_wGwoGSF_BL = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_BL',
698  mvaName_NoEleMatch_wGwoGSF_EC = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_EC',
699  mvaName_NoEleMatch_woGwoGSF_BL = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_BL',
700  mvaName_NoEleMatch_woGwoGSF_EC = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_EC',
701  mvaName_wGwGSF_BL = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_BL',
702  mvaName_wGwGSF_EC = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_EC',
703  mvaName_woGwGSF_BL = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_BL',
704  mvaName_woGwGSF_EC = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_EC'
705  ))
706 
707  from RecoTauTag.RecoTau.PATTauDiscriminantCutMultiplexer_cfi import patTauDiscriminantCutMultiplexer
708  _byElectronRejectionMVA62018 = "patTauDiscriminationByElectronRejectionMVA62018"+self.postfix
709  setattr(self.process,"patTauDiscriminationByElectronRejectionMVA62018"+self.postfix,patTauDiscriminantCutMultiplexer.clone(
710  PATTauProducer = self.originalTauName,
711  Prediscriminants = noPrediscriminants,
712  toMultiplex = _byElectronRejectionMVA62018Raw,
713  mapping = cms.VPSet(
714  cms.PSet(
715  category = cms.uint32(0),
716  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_BL'),
717  variable = cms.string('pt')
718  ),
719  cms.PSet(
720  category = cms.uint32(2),
721  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_BL'),
722  variable = cms.string('pt')
723  ),
724  cms.PSet(
725  category = cms.uint32(5),
726  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_BL'),
727  variable = cms.string('pt')
728  ),
729  cms.PSet(
730  category = cms.uint32(7),
731  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_BL'),
732  variable = cms.string('pt')
733  ),
734  cms.PSet(
735  category = cms.uint32(8),
736  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_EC'),
737  variable = cms.string('pt')
738  ),
739  cms.PSet(
740  category = cms.uint32(10),
741  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_EC'),
742  variable = cms.string('pt')
743  ),
744  cms.PSet(
745  category = cms.uint32(13),
746  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_EC'),
747  variable = cms.string('pt')
748  ),
749  cms.PSet(
750  category = cms.uint32(15),
751  cut = cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_EC'),
752  variable = cms.string('pt')
753  )
754  ),
755  workingPoints = cms.vstring(
756  "_WPeff98",
757  "_WPeff90",
758  "_WPeff80",
759  "_WPeff70",
760  "_WPeff60"
761  )
762  ))
763 
764  _patTauDiscriminationByElectronRejectionMVA62018Task = cms.Task(
765  getattr(self.process,_byElectronRejectionMVA62018Raw),
766  getattr(self.process,_byElectronRejectionMVA62018)
767  )
768  _rerunMvaIsolationTask.add(_patTauDiscriminationByElectronRejectionMVA62018Task)
769  _rerunMvaIsolationSequence += cms.Sequence(_patTauDiscriminationByElectronRejectionMVA62018Task)
770 
771  _againstElectronTauIDSources = cms.PSet(
772  againstElectronMVA6Raw2018 = self.tauIDMVAinputs(_byElectronRejectionMVA62018, "raw"),
773  againstElectronMVA6category2018 = self.tauIDMVAinputs(_byElectronRejectionMVA62018, "category"),
774  againstElectronVLooseMVA62018 = self.tauIDMVAinputs(_byElectronRejectionMVA62018, "_WPeff98"),
775  againstElectronLooseMVA62018 = self.tauIDMVAinputs(_byElectronRejectionMVA62018, "_WPeff90"),
776  againstElectronMediumMVA62018 = self.tauIDMVAinputs(_byElectronRejectionMVA62018, "_WPeff80"),
777  againstElectronTightMVA62018 = self.tauIDMVAinputs(_byElectronRejectionMVA62018, "_WPeff70"),
778  againstElectronVTightMVA62018 = self.tauIDMVAinputs(_byElectronRejectionMVA62018, "_WPeff60")
779  )
780  _tauIDSourcesWithAgainistEle = cms.PSet(
781  tauIDSources.clone(),
782  _againstElectronTauIDSources
783  )
784  tauIDSources =_tauIDSourcesWithAgainistEle.clone()
785 
786  if "newDMPhase2v1" in self.toKeep:
787  if self.debug: print ("Adding newDMPhase2v1 ID")
788  def tauIDMVAinputs(module, wp):
789  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)))
790  _byIsolationNewDMMVAPhase2raw = "rerunDiscriminationByIsolationMVADBnewDMwLTPhase2raw"+self.postfix
791  setattr(self.process,_byIsolationNewDMMVAPhase2raw,patDiscriminationByIsolationMVArun2v1raw.clone(
792  PATTauProducer = self.originalTauName,
793  Prediscriminants = noPrediscriminants,
794  loadMVAfromDB = True,
795  mvaName = 'RecoTauTag_tauIdMVAIsoPhase2',
796  mvaOpt = 'DBnewDMwLTwGJPhase2',
797  verbosity = 0
798  ))
799 
800  _byIsolationNewDMMVAPhase2 = "rerunDiscriminationByIsolationMVADBnewDMwLTPhase2"+self.postfix
801  setattr(self.process,_byIsolationNewDMMVAPhase2,patDiscriminationByIsolationMVArun2v1.clone(
802  PATTauProducer = self.originalTauName,
803  Prediscriminants = noPrediscriminants,
804  toMultiplex = _byIsolationNewDMMVAPhase2raw,
805  loadMVAfromDB = True,
806  mvaOutput_normalization = 'RecoTauTag_tauIdMVAIsoPhase2_mvaOutput_normalization',
807  mapping = cms.VPSet(
808  cms.PSet(
809  category = cms.uint32(0),
810  cut = cms.string("RecoTauTag_tauIdMVAIsoPhase2"),
811  variable = cms.string("pt"),
812  )
813  ),
814  workingPoints = cms.vstring(
815  "_VVLoose",
816  "_VLoose",
817  "_Loose",
818  "_Medium",
819  "_Tight",
820  "_VTight",
821  "_VVTight"
822  )
823  ))
824  _rerunIsolationMVADBnewDMwLTPhase2Task = cms.Task(
825  getattr(self.process,_byIsolationNewDMMVAPhase2raw),
826  getattr(self.process,_byIsolationNewDMMVAPhase2)
827  )
828  _rerunMvaIsolationTask.add(_rerunIsolationMVADBnewDMwLTPhase2Task)
829  _rerunMvaIsolationSequence += cms.Sequence(_rerunIsolationMVADBnewDMwLTPhase2Task)
830 
831  tauIDSources.byIsolationMVADBnewDMwLTPhase2raw = tauIDMVAinputs(_byIsolationNewDMMVAPhase2, "raw")
832  tauIDSources.byVVLooseIsolationMVADBnewDMwLTPhase2 = tauIDMVAinputs(_byIsolationNewDMMVAPhase2, "_VVLoose")
833  tauIDSources.byVLooseIsolationMVADBnewDMwLTPhase2 = tauIDMVAinputs(_byIsolationNewDMMVAPhase2, "_VLoose")
834  tauIDSources.byLooseIsolationMVADBnewDMwLTPhase2 = tauIDMVAinputs(_byIsolationNewDMMVAPhase2, "_Loose")
835  tauIDSources.byMediumIsolationMVADBnewDMwLTPhase2 = tauIDMVAinputs(_byIsolationNewDMMVAPhase2, "_Medium")
836  tauIDSources.byTightIsolationMVADBnewDMwLTPhase2 = tauIDMVAinputs(_byIsolationNewDMMVAPhase2, "_Tight")
837  tauIDSources.byVTightIsolationMVADBnewDMwLTPhase2 = tauIDMVAinputs(_byIsolationNewDMMVAPhase2, "_VTight")
838  tauIDSources.byVVTightIsolationMVADBnewDMwLTPhase2 = tauIDMVAinputs(_byIsolationNewDMMVAPhase2, "_VVTight")
839 
840  if "againstElePhase2v1" in self.toKeep:
841  if self.debug: print ("Adding anti-e Phase2v1 ID")
842 
844  from RecoTauTag.RecoTau.PATTauDiscriminationAgainstElectronMVA6Phase2_cff import patTauDiscriminationAgainstElectronMVA6Phase2Raw, patTauDiscriminationAgainstElectronMVA6Phase2, mergedSlimmedElectronsForTauId
845  _byElectronRejectionMVA6Phase2v1Raw = "patTauDiscriminationByElectronRejectionMVA6Phase2v1Raw"+self.postfix
846  setattr(self.process,_byElectronRejectionMVA6Phase2v1Raw,patTauDiscriminationAgainstElectronMVA6Phase2Raw.clone(
847  PATTauProducer = self.originalTauName,
848  Prediscriminants = noPrediscriminants #already selected for MiniAOD
849  ))
850 
851  _byElectronRejectionMVA6Phase2v1 = "patTauDiscriminationByElectronRejectionMVA6Phase2v1"+self.postfix
852  setattr(self.process,_byElectronRejectionMVA6Phase2v1,patTauDiscriminationAgainstElectronMVA6Phase2.clone(
853  PATTauProducer = self.originalTauName,
854  Prediscriminants = noPrediscriminants,
855  toMultiplex = _byElectronRejectionMVA6Phase2v1Raw
856  ))
857 
858  if not hasattr(self.process,"mergedSlimmedElectronsForTauId"):
859  self.process.mergedSlimmedElectronsForTauId = mergedSlimmedElectronsForTauId
860  _patTauDiscriminationByElectronRejectionMVA6Phase2v1Task = cms.Task(
861  self.process.mergedSlimmedElectronsForTauId,
862  getattr(self.process,_byElectronRejectionMVA6Phase2v1Raw),
863  getattr(self.process,_byElectronRejectionMVA6Phase2v1)
864  )
865  _rerunMvaIsolationTask.add(_patTauDiscriminationByElectronRejectionMVA6Phase2v1Task)
866  _rerunMvaIsolationSequence += cms.Sequence(_patTauDiscriminationByElectronRejectionMVA6Phase2v1Task)
867 
868  _againstElectronTauIDPhase2v1Sources = cms.PSet(
869  againstElectronMVA6RawPhase2v1 = self.tauIDMVAinputs(_byElectronRejectionMVA6Phase2v1, "raw"),
870  againstElectronMVA6categoryPhase2v1 = self.tauIDMVAinputs(_byElectronRejectionMVA6Phase2v1, "category"),
871  againstElectronVLooseMVA6Phase2v1 = self.tauIDMVAinputs(_byElectronRejectionMVA6Phase2v1, "_VLoose"),
872  againstElectronLooseMVA6Phase2v1 = self.tauIDMVAinputs(_byElectronRejectionMVA6Phase2v1, "_Loose"),
873  againstElectronMediumMVA6Phase2v1 = self.tauIDMVAinputs(_byElectronRejectionMVA6Phase2v1, "_Medium"),
874  againstElectronTightMVA6Phase2v1 = self.tauIDMVAinputs(_byElectronRejectionMVA6Phase2v1, "_Tight"),
875  againstElectronVTightMVA6Phase2v1 = self.tauIDMVAinputs(_byElectronRejectionMVA6Phase2v1, "_VTight")
876  )
877  _tauIDSourcesWithAgainistElePhase2v1 = cms.PSet(
878  tauIDSources.clone(),
879  _againstElectronTauIDPhase2v1Sources
880  )
881  tauIDSources =_tauIDSourcesWithAgainistElePhase2v1.clone()
882 
883  if self.debug: print('Embedding new TauIDs into \"'+self.updatedTauName+'\"')
884  if not hasattr(self.process, self.updatedTauName):
885  embedID = cms.EDProducer("PATTauIDEmbedder",
886  src = cms.InputTag(self.originalTauName),
887  tauIDSources = tauIDSources
888  )
889  setattr(self.process, self.updatedTauName, embedID)
890  else: #assume same type
891  tauIDSources = cms.PSet(
892  getattr(self.process, self.updatedTauName).tauIDSources,
893  tauIDSources)
894  getattr(self.process, self.updatedTauName).tauIDSources = tauIDSources
895  if not hasattr(self.process,"rerunMvaIsolationTask"+self.postfix):
896  setattr(self.process,"rerunMvaIsolationTask"+self.postfix,_rerunMvaIsolationTask)
897  else:
898  _updatedRerunMvaIsolationTask = getattr(self.process,"rerunMvaIsolationTask"+self.postfix)
899  _updatedRerunMvaIsolationTask.add(_rerunMvaIsolationTask)
900  setattr(self.process,"rerunMvaIsolationTask"+self.postfix,_updatedRerunMvaIsolationTask)
901  if not hasattr(self.process,"rerunMvaIsolationSequence"+self.postfix):
902  setattr(self.process,"rerunMvaIsolationSequence"+self.postfix,_rerunMvaIsolationSequence)
903  else:
904  _updatedRerunMvaIsolationSequence = getattr(self.process,"rerunMvaIsolationSequence"+self.postfix)
905  _updatedRerunMvaIsolationSequence += _rerunMvaIsolationSequence
906  setattr(self.process,"rerunMvaIsolationSequence"+self.postfix,_updatedRerunMvaIsolationSequence)
907 
908 
patTauDiscriminationAgainstElectronMVA6_cfi
RecoTauValidation_cfi.tauIDMVAinputs
def tauIDMVAinputs(module, wp)
Definition: RecoTauValidation_cfi.py:143
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 
RecoTauValidation_cfi.tauIDMVAinputs
def tauIDMVAinputs(module, wp)
Definition: RecoTauValidation_cfi.py:143

◆ 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