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

Static Public Member Functions

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

Public Attributes

 cms
 
 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 8 of file runTauIdMVA.py.

Constructor & Destructor Documentation

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

Definition at line 26 of file runTauIdMVA.py.

26  'Eff90' : "DBoldDMwLTEff90",
27  'Eff80' : "DBoldDMwLTEff80",
28  'Eff70' : "DBoldDMwLTEff70",
29  'Eff60' : "DBoldDMwLTEff60",
30  'Eff50' : "DBoldDMwLTEff50",
31  'Eff40' : "DBoldDMwLTEff40"
32  }
33  },
34  tauIdDiscrMVA_2017_version = "v1",
35  conditionDB = "" # preparational DB: 'frontier://FrontierPrep/CMS_CONDITIONS'
36  ):
37  super(TauIDEmbedder, self).__init__()
38  self.process = process
39  self.cms = cms
40  self.debug = debug
41  self.originalTauName = originalTauName
42  self.updatedTauName = updatedTauName
43  self.postfix = postfix
44  self.process.load('RecoTauTag.Configuration.loadRecoTauTagMVAsFromPrepDB_cfi')
45  if len(conditionDB) != 0:
46  self.process.CondDBTauConnection.connect = cms.string(conditionDB)
47  self.process.loadRecoTauTagMVAsFromPrepDB.connect = cms.string(conditionDB)
48  # if debug:
49  # print self.process.CondDBTauConnection.connect
50  # print dir(self.process.loadRecoTauTagMVAsFromPrepDB)
51  # print self.process.loadRecoTauTagMVAsFromPrepDB.parameterNames_
52 
53  self.tauIdDiscrMVA_trainings_run2_2017 = tauIdDiscrMVA_trainings_run2_2017
54  self.tauIdDiscrMVA_WPs_run2_2017 = tauIdDiscrMVA_WPs_run2_2017
55  self.tauIdDiscrMVA_2017_version = tauIdDiscrMVA_2017_version
56  for discr in toKeep:
57  if discr not in TauIDEmbedder.availableDiscriminators:
58  raise RuntimeError('TauIDEmbedder: discriminator "{}" is not supported'.format(discr))
59  self.toKeep = toKeep
60 
61 

Member Function Documentation

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

Definition at line 63 of file runTauIdMVA.py.

63  def get_cmssw_version(debug = False):
64  """returns 'CMSSW_X_Y_Z'"""
65  cmssw_version = os.environ["CMSSW_VERSION"]
66  if debug: print ("get_cmssw_version:", cmssw_version)
67  return cmssw_version
68 
runTauIdMVA.TauIDEmbedder.get_cmssw_version
def get_cmssw_version(debug=False)
Definition: runTauIdMVA.py:63
def runTauIdMVA.TauIDEmbedder.get_cmssw_version_number (   klass,
  debug = False 
) 
returns '(release, subversion, patch)' (without 'CMSSW_')

Definition at line 70 of file runTauIdMVA.py.

References createfilelist.int, and split.

70  def get_cmssw_version_number(klass, debug = False):
71  """returns '(release, subversion, patch)' (without 'CMSSW_')"""
72  v = klass.get_cmssw_version().split("CMSSW_")[1].split("_")[0:3]
73  if debug: print ("get_cmssw_version_number:", v)
74  if v[2] == "X":
75  patch = -1
76  else:
77  patch = int(v[2])
78  return int(v[0]), int(v[1]), patch
79 
runTauIdMVA.TauIDEmbedder.get_cmssw_version_number
def get_cmssw_version_number(klass, debug=False)
Definition: runTauIdMVA.py:70
split
double split
Definition: MVATrainer.cc:139
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 1001 of file runTauIdMVA.py.

References createfilelist.int.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

1001  def getDeepTauVersion(self, file_name):
1002  """returns the DeepTau year, version, subversion. File name should contain a version label with data takig year \
1003  (2011-2, 2015-8), version number (vX) and subversion (pX), e.g. 2017v0p6, in general the following format: \
1004  {year}v{version}p{subversion}"""
1005  version_search = re.search('(201[125678])v([0-9]+)(p[0-9]+|)[\._]', file_name)
1006  if not version_search:
1007  raise RuntimeError('File "{}" has an invalid name pattern, should be in the format "{year}v{version}p{subversion}". \
1008  Unable to extract version number.'.format(file_name))
1009  year = version_search.group(1)
1010  version = version_search.group(2)
1011  subversion = version_search.group(3)
1012  if len(subversion) > 0:
1013  subversion = subversion[1:]
1014  else:
1015  subversion = 0
1016  return int(year), int(version), int(subversion)
1017 
runTauIdMVA.TauIDEmbedder.getDeepTauVersion
def getDeepTauVersion(self, file_name)
Definition: runTauIdMVA.py:1001
def runTauIdMVA.TauIDEmbedder.getDpfTauVersion (   self,
  file_name 
) 
returns the DNN version. File name should contain a version label with data takig year (2011-2, 2015-8) and \
   version number (vX), e.g. 2017v0, in general the following format: {year}v{version}

Definition at line 991 of file runTauIdMVA.py.

References createfilelist.int.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

991  def getDpfTauVersion(self, file_name):
992  """returns the DNN version. File name should contain a version label with data takig year (2011-2, 2015-8) and \
993  version number (vX), e.g. 2017v0, in general the following format: {year}v{version}"""
994  version_search = re.search('201[125678]v([0-9]+)[\._]', file_name)
995  if not version_search:
996  raise RuntimeError('File "{}" has an invalid name pattern, should be in the format "{year}v{version}". \
997  Unable to extract version number.'.format(file_name))
998  version = version_search.group(1)
999  return int(version)
1000 
runTauIdMVA.TauIDEmbedder.getDpfTauVersion
def getDpfTauVersion(self, file_name)
Definition: runTauIdMVA.py:991
def runTauIdMVA.TauIDEmbedder.is_above_cmssw_version (   klass,
  release = 9,
  subversion = 4,
  patch = 0,
  debug = False 
)

Definition at line 88 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

88  def is_above_cmssw_version(klass, release=9, subversion=4, patch=0, debug = False):
89  split_cmssw_version = klass.get_cmssw_version_number()
90  if klass.versionToInt(release, subversion, patch) > klass.versionToInt(split_cmssw_version[0], split_cmssw_version[1], split_cmssw_version[2]):
91  if debug: print ("is_above_cmssw_version:", False)
92  return False
93  else:
94  if debug: print ("is_above_cmssw_version:", True)
95  return True
96 
runTauIdMVA.TauIDEmbedder.is_above_cmssw_version
def is_above_cmssw_version(klass, release=9, subversion=4, patch=0, debug=False)
Definition: runTauIdMVA.py:88
def runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017 (   self)

Definition at line 97 of file runTauIdMVA.py.

References dumpTrg.constants.debug, dumpWBM.constants.debug, dumpRunInfo.constants.debug, InterpolationDebug.debug, lumiPatch.constants.debug, DTDigiToRawModule.debug, CSCRPCData.debug, CSCDCCUnpacker.debug, CSCTMBScope.debug, CSCSegAlgoPreClustering.debug, ALIUtils.debug, DTRecHitProducer.debug, RPCPointProducer.debug, crabFunctions.CrabController.debug, DTDigiToRaw.debug, DTSegment4DT0Corrector.debug, DTRecSegment4DProducer.debug, runTauIdMVA.TauIDEmbedder.debug, MuonSeedProducer.debug, HiggsToZZ4LeptonsSkimEff.debug, DTTTrigCorrectionFirst.debug, HiggsTo2GammaSkim.debug, HiggsToZZ4LeptonsPreFilter.debug, DTSegmentsTask.debug, QCDSingleJetFilter.debug, pkg.AbstractPkg.debug, HiggsToZZ4LeptonsSkim.debug, JetAnaPythia< Jet >.debug, CSCDCCEventData.debug, MuScleFitFilter.debug, DTTPDeadWriter.debug, DTRecSegment2DProducer.debug, DTT0CalibrationRMS.debug, DTTTrigWriter.debug, DTRecSegment2DExtendedProducer.debug, SiPixelRawToDigi.debug, DTDDUUnpacker.debug, CSCAnodeLCTAnalyzer.debug, CSCCathodeLCTAnalyzer.debug, MuScleFitPlotter.debug, DTOccupancyPoint.debug, DTTTrigSyncT0Only.debug, CSCSegAlgoShowering.debug, util.rrapi.RRApi.debug, GEMCSCSegAlgoRR.debug, rrapi.RRApi.debug, ME0SegmentAlgorithm.debug, DTNoiseComputation.debug, DTSpyReader.debug, DTROS25Unpacker.debug, HeavyChHiggsToTauNuSkim.debug, DTT0Calibration.debug, GEMSegmentAlgorithm.debug, DTTTrigCalibration.debug, DTEfficiencyTask.debug, DTRunConditionVar.debug, CSCDDUEventData.debug, HCALResponse.debug, DTCombinatorialPatternReco4D.debug, DTMeantimerPatternReco4D.debug, DTRefitAndCombineReco4D.debug, DTClusterer.debug, DTChamberEfficiencyTask.debug, DTTMax.debug, MuonSeedCreator.debug, DTChamberEfficiency.debug, CSCCLCTData.debug, CSCTimingExtractor.debug, DTTTrigSyncFromDB.debug, PythiaFilterEMJetHeep.debug, DTVDriftCalibration.debug, DTTimingExtractor.debug, DTLinearDriftAlgo.debug, MuonSeedCleaner.debug, CSCTMBData.debug, DTParametrizedDriftAlgo.debug, PixelDataFormatter.debug, DTTTrigSyncTOFCorr.debug, DTCombinatorialPatternReco.debug, DTNoDriftAlgo.debug, MuonSeedBuilder.debug, DTMeantimerPatternReco.debug, DTLinearDriftFromDBAlgo.debug, DTCombinatorialExtendedPatternReco.debug, MuScleFitUtils.debug, DTSegmentUpdator.debug, CSCSegAlgoDF.debug, MagGeoBuilderFromDDD.debug, CSCEventData.debug, CSCTriggerPrimitivesReader.debug, BaseParticlePropagator.debug, RPCEfficiency.debug, CSCTMBHeader.debug, CSCSegAlgoST.debug, CSCALCTTrailer.debug, CSCALCTHeader.debug, EcalBoundaryInfoCalculator< EcalDetId >.debug, crabFunctions.CrabTask.debug, Pythia8::PowhegHooksBB4L.debug, HltDiff.debug, relativeConstraints.keys, runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_2017_version, and runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_WPs_run2_2017.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

97  def loadMVA_WPs_run2_2017(self):
98  if self.debug: print ("loadMVA_WPs_run2_2017: performed")
99  global cms
100  for training, gbrForestName in self.tauIdDiscrMVA_trainings_run2_2017.items():
101 
102  self.process.loadRecoTauTagMVAsFromPrepDB.toGet.append(
103  self.cms.PSet(
104  record = self.cms.string('GBRWrapperRcd'),
105  tag = self.cms.string("RecoTauTag_%s%s" % (gbrForestName, self.tauIdDiscrMVA_2017_version)),
106  label = self.cms.untracked.string("RecoTauTag_%s%s" % (gbrForestName, self.tauIdDiscrMVA_2017_version))
107  )
108  )
109 
110  for WP in self.tauIdDiscrMVA_WPs_run2_2017[training].keys():
111  self.process.loadRecoTauTagMVAsFromPrepDB.toGet.append(
112  self.cms.PSet(
113  record = self.cms.string('PhysicsTGraphPayloadRcd'),
114  tag = self.cms.string("RecoTauTag_%s%s_WP%s" % (gbrForestName, self.tauIdDiscrMVA_2017_version, WP)),
115  label = self.cms.untracked.string("RecoTauTag_%s%s_WP%s" % (gbrForestName, self.tauIdDiscrMVA_2017_version, WP))
116  )
117  )
118 
119  self.process.loadRecoTauTagMVAsFromPrepDB.toGet.append(
120  self.cms.PSet(
121  record = self.cms.string('PhysicsTFormulaPayloadRcd'),
122  tag = self.cms.string("RecoTauTag_%s%s_mvaOutput_normalization" % (gbrForestName, self.tauIdDiscrMVA_2017_version)),
123  label = self.cms.untracked.string("RecoTauTag_%s%s_mvaOutput_normalization" % (gbrForestName, self.tauIdDiscrMVA_2017_version))
124  )
125  )
126 
runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017
def loadMVA_WPs_run2_2017(self)
Definition: runTauIdMVA.py:97
def runTauIdMVA.TauIDEmbedder.processDeepProducer (   self,
  producer_name,
  tauIDSources,
  workingPoints_ 
)

Definition at line 977 of file runTauIdMVA.py.

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

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

977  def processDeepProducer(self, producer_name, tauIDSources, workingPoints_):
978  for target,points in six.iteritems(workingPoints_):
979  cuts = self.cms.PSet()
980  setattr(tauIDSources, 'by{}VS{}raw'.format(producer_name[0].upper()+producer_name[1:], target),
981  self.cms.InputTag(producer_name+self.postfix, 'VS{}'.format(target)))
982  for point,cut in six.iteritems(points):
983  setattr(cuts, point, self.cms.string(str(cut)))
984 
985  setattr(tauIDSources, 'by{}{}VS{}'.format(point, producer_name[0].upper()+producer_name[1:], target),
986  self.cms.InputTag(producer_name+self.postfix, 'VS{}{}'.format(target, point)))
987 
988  setattr(getattr(self.process, producer_name+self.postfix), 'VS{}WP'.format(target), cuts)
989 
990 
runTauIdMVA.TauIDEmbedder.processDeepProducer
def processDeepProducer(self, producer_name, tauIDSources, workingPoints_)
Definition: runTauIdMVA.py:977
str
#define str(s)
Definition: TestProcessor.cc:48
def runTauIdMVA.TauIDEmbedder.runTauID (   self)

Definition at line 127 of file runTauIdMVA.py.

References dumpTrg.constants.debug, dumpWBM.constants.debug, dumpRunInfo.constants.debug, InterpolationDebug.debug, lumiPatch.constants.debug, DTDigiToRawModule.debug, CSCRPCData.debug, CSCDCCUnpacker.debug, ALIUtils.debug, CSCSegAlgoPreClustering.debug, CSCTMBScope.debug, DTRecHitProducer.debug, RPCPointProducer.debug, crabFunctions.CrabController.debug, DTDigiToRaw.debug, DTRecSegment4DProducer.debug, DTSegment4DT0Corrector.debug, runTauIdMVA.TauIDEmbedder.debug, MuonSeedProducer.debug, HiggsToZZ4LeptonsSkimEff.debug, DTTTrigCorrectionFirst.debug, HiggsTo2GammaSkim.debug, HiggsToZZ4LeptonsPreFilter.debug, QCDSingleJetFilter.debug, DTSegmentsTask.debug, pkg.AbstractPkg.debug, JetAnaPythia< Jet >.debug, HiggsToZZ4LeptonsSkim.debug, DTTPDeadWriter.debug, MuScleFitFilter.debug, CSCDCCEventData.debug, DTRecSegment2DProducer.debug, DTT0CalibrationRMS.debug, DTRecSegment2DExtendedProducer.debug, SiPixelRawToDigi.debug, DTTTrigWriter.debug, DTDDUUnpacker.debug, CSCAnodeLCTAnalyzer.debug, CSCCathodeLCTAnalyzer.debug, MuScleFitPlotter.debug, DTTTrigSyncT0Only.debug, DTOccupancyPoint.debug, CSCSegAlgoShowering.debug, util.rrapi.RRApi.debug, GEMCSCSegAlgoRR.debug, rrapi.RRApi.debug, DTNoiseComputation.debug, ME0SegmentAlgorithm.debug, DTSpyReader.debug, DTT0Calibration.debug, DTROS25Unpacker.debug, GEMSegmentAlgorithm.debug, HeavyChHiggsToTauNuSkim.debug, DTTTrigCalibration.debug, CSCDDUEventData.debug, DTEfficiencyTask.debug, DTRunConditionVar.debug, HCALResponse.debug, DTCombinatorialPatternReco4D.debug, DTMeantimerPatternReco4D.debug, DTRefitAndCombineReco4D.debug, DTClusterer.debug, DTChamberEfficiencyTask.debug, MuonSeedCreator.debug, DTTMax.debug, DTChamberEfficiency.debug, CSCCLCTData.debug, DTTTrigSyncFromDB.debug, CSCTimingExtractor.debug, PythiaFilterEMJetHeep.debug, DTVDriftCalibration.debug, DTTimingExtractor.debug, DTLinearDriftAlgo.debug, MuonSeedCleaner.debug, CSCTMBData.debug, DTParametrizedDriftAlgo.debug, PixelDataFormatter.debug, DTTTrigSyncTOFCorr.debug, DTCombinatorialPatternReco.debug, MuonSeedBuilder.debug, DTNoDriftAlgo.debug, DTMeantimerPatternReco.debug, DTLinearDriftFromDBAlgo.debug, DTCombinatorialExtendedPatternReco.debug, MuScleFitUtils.debug, DTSegmentUpdator.debug, CSCSegAlgoDF.debug, MagGeoBuilderFromDDD.debug, CSCEventData.debug, CSCTriggerPrimitivesReader.debug, BaseParticlePropagator.debug, RPCEfficiency.debug, CSCTMBHeader.debug, CSCSegAlgoST.debug, CSCALCTTrailer.debug, CSCALCTHeader.debug, EcalBoundaryInfoCalculator< EcalDetId >.debug, crabFunctions.CrabTask.debug, Pythia8::PowhegHooksBB4L.debug, HltDiff.debug, runTauIdMVA.TauIDEmbedder.getDeepTauVersion(), runTauIdMVA.TauIDEmbedder.getDpfTauVersion(), runTauIdMVA.TauIDEmbedder.is_above_cmssw_version(), runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017(), runTauIdMVA.TauIDEmbedder.originalTauName, runTauIdMVA.TauIDEmbedder.postfix, edm.print(), edm::ProductLabels.process, runTauIdMVA.TauIDEmbedder.process, DTT0WireWorkflow.DTT0WireWorkflow.process, DTVdriftWorkflow.DTvdriftWorkflow.process, cscdqm::HWStandbyType.process, DTTtrigWorkflow.DTttrigWorkflow.process, EgammaHLTValidationUtils.EgammaDQMModuleMaker.process, Config.Process.process, DTWorkflow.DTWorkflow.process, ConfigBuilder.ConfigBuilder.process, JsonOutputProducer::JsonConfigurationBlock.process, runTauIdMVA.TauIDEmbedder.processDeepProducer(), runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_2017_version, runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_trainings_run2_2017, runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_WPs_run2_2017, runTauIdMVA.TauIDEmbedder.toKeep, and runTauIdMVA.TauIDEmbedder.updatedTauName.

127  def runTauID(self):
128  _rerunMvaIsolationTask = self.cms.Task()
129  _rerunMvaIsolationSequence = self.cms.Sequence()
130  tauIDSources = self.cms.PSet()
131 
132  # rerun the seq to obtain the 2017 nom training with 0.5 iso cone, old DM, ptph>1, trained on 2017MCv1
133  if "2017v1" in self.toKeep:
134  self.tauIdDiscrMVA_2017_version = "v1"
135  self.tauIdDiscrMVA_trainings_run2_2017 = {
136  'tauIdMVAIsoDBoldDMwLT2017' : "tauIdMVAIsoDBoldDMwLT2017",
137  }
138  self.tauIdDiscrMVA_WPs_run2_2017 = {
139  'tauIdMVAIsoDBoldDMwLT2017' : {
140  'Eff95' : "DBoldDMwLTEff95",
141  'Eff90' : "DBoldDMwLTEff90",
142  'Eff80' : "DBoldDMwLTEff80",
143  'Eff70' : "DBoldDMwLTEff70",
144  'Eff60' : "DBoldDMwLTEff60",
145  'Eff50' : "DBoldDMwLTEff50",
146  'Eff40' : "DBoldDMwLTEff40"
147  }
148  }
149  # update the list of available in DB samples
150  if not self.is_above_cmssw_version(9, 4, 4, self.debug):
151  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")
152  self.loadMVA_WPs_run2_2017()
153 
154  _byIsolationOldDMMVArun2017v1raw = "rerunDiscriminationByIsolationOldDMMVArun2017v1raw"+self.postfix
155  setattr(self.process,_byIsolationOldDMMVArun2017v1raw,patDiscriminationByIsolationMVArun2v1raw.clone(
156  PATTauProducer = self.originalTauName,
157  Prediscriminants = noPrediscriminants,
158  loadMVAfromDB = self.cms.bool(True),
159  mvaName = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v1"),
160  mvaOpt = self.cms.string("DBoldDMwLTwGJ"),
161  verbosity = self.cms.int32(0)
162  ))
163 
164  _byIsolationOldDMMVArun2017v1VLoose = "rerunDiscriminationByIsolationOldDMMVArun2017v1VLoose"+self.postfix
165  setattr(self.process,_byIsolationOldDMMVArun2017v1VLoose,patDiscriminationByIsolationMVArun2v1VLoose.clone(
166  PATTauProducer = self.originalTauName,
167  Prediscriminants = noPrediscriminants,
168  toMultiplex = _byIsolationOldDMMVArun2017v1raw,
169  key = _byIsolationOldDMMVArun2017v1raw+':category',
170  loadMVAfromDB = self.cms.bool(True),
171  mvaOutput_normalization = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v1_mvaOutput_normalization"), #writeTauIdDiscrMVAoutputNormalizations
172  mapping = self.cms.VPSet(
173  self.cms.PSet(
174  category = self.cms.uint32(0),
175  cut = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v1_WPEff90"), #writeTauIdDiscrWPs
176  variable = self.cms.string("pt"),
177  )
178  )
179  ))
180  _byIsolationOldDMMVArun2017v1VLooseProd = getattr(self.process,_byIsolationOldDMMVArun2017v1VLoose)
181 
182  _rerunIsolationOldDMMVArun2017v1Task = self.cms.Task(
183  getattr(self.process,_byIsolationOldDMMVArun2017v1raw),
184  _byIsolationOldDMMVArun2017v1VLooseProd
185  )
186  tauIDSources.byIsolationMVArun2017v1DBoldDMwLTraw2017 = self.cms.InputTag(_byIsolationOldDMMVArun2017v1raw)
187  tauIDSources.byVLooseIsolationMVArun2017v1DBoldDMwLT2017 = self.cms.InputTag(_byIsolationOldDMMVArun2017v1VLoose)
188 
189  wp_to_eff_match = {
190  "VVLoose" : "WPEff95",
191  "Loose" : "WPEff80",
192  "Medium" : "WPEff70",
193  "Tight" : "WPEff60",
194  "VTight" : "WPEff50",
195  "VVTight" : "WPEff40"
196  }
197  for wp,wpEff in wp_to_eff_match.items():
198  _aWP = "rerunDiscriminationByIsolationOldDMMVArun2017v1"+wp+self.postfix
199  setattr(self.process,_aWP,_byIsolationOldDMMVArun2017v1VLooseProd.clone())
200  _aWPProd = getattr(self.process,_aWP)
201  _aWPProd.mapping[0].cut = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v1_"+wpEff)
202  _rerunIsolationOldDMMVArun2017v1Task.add(_aWPProd)
203  setattr(tauIDSources,"by"+wp+"IsolationMVArun2017v1DBoldDMwLT2017",self.cms.InputTag(_aWP))
204 
205  _rerunMvaIsolationTask.add(_rerunIsolationOldDMMVArun2017v1Task)
206  _rerunMvaIsolationSequence += self.cms.Sequence(_rerunIsolationOldDMMVArun2017v1Task)
207 
208  if "2017v2" in self.toKeep:
209  self.tauIdDiscrMVA_2017_version = "v2"
210  self.tauIdDiscrMVA_trainings_run2_2017 = {
211  'tauIdMVAIsoDBoldDMwLT2017' : "tauIdMVAIsoDBoldDMwLT2017",
212  }
213  self.tauIdDiscrMVA_WPs_run2_2017 = {
214  'tauIdMVAIsoDBoldDMwLT2017' : {
215  'Eff95' : "DBoldDMwLTEff95",
216  'Eff90' : "DBoldDMwLTEff90",
217  'Eff80' : "DBoldDMwLTEff80",
218  'Eff70' : "DBoldDMwLTEff70",
219  'Eff60' : "DBoldDMwLTEff60",
220  'Eff50' : "DBoldDMwLTEff50",
221  'Eff40' : "DBoldDMwLTEff40"
222  }
223  }
224 
225  if not self.is_above_cmssw_version(9, 4, 5, self.debug):
226  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")
227  self.loadMVA_WPs_run2_2017()
228 
229  _byIsolationOldDMMVArun2017v2raw = "rerunDiscriminationByIsolationOldDMMVArun2017v2raw"+self.postfix
230  setattr(self.process,_byIsolationOldDMMVArun2017v2raw,patDiscriminationByIsolationMVArun2v1raw.clone(
231  PATTauProducer = self.originalTauName,
232  Prediscriminants = noPrediscriminants,
233  loadMVAfromDB = self.cms.bool(True),
234  mvaName = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v2"),
235  mvaOpt = self.cms.string("DBoldDMwLTwGJ"),
236  verbosity = self.cms.int32(0)
237  ))
238 
239  _byIsolationOldDMMVArun2017v2VLoose = "rerunDiscriminationByIsolationOldDMMVArun2017v2VLoose"+self.postfix
240  setattr(self.process,_byIsolationOldDMMVArun2017v2VLoose,patDiscriminationByIsolationMVArun2v1VLoose.clone(
241  PATTauProducer = self.originalTauName,
242  Prediscriminants = noPrediscriminants,
243  toMultiplex = _byIsolationOldDMMVArun2017v2raw,
244  key = _byIsolationOldDMMVArun2017v2raw+':category',
245  loadMVAfromDB = self.cms.bool(True),
246  mvaOutput_normalization = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v2_mvaOutput_normalization"), #writeTauIdDiscrMVAoutputNormalizations
247  mapping = self.cms.VPSet(
248  self.cms.PSet(
249  category = self.cms.uint32(0),
250  cut = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v2_WPEff90"), #writeTauIdDiscrWPs
251  variable = self.cms.string("pt"),
252  )
253  ),
254  verbosity = self.cms.int32(0)
255  ))
256  _byIsolationOldDMMVArun2017v2VLooseProd = getattr(self.process,_byIsolationOldDMMVArun2017v2VLoose)
257 
258  _rerunIsolationOldDMMVArun2017v2Task = self.cms.Task(
259  getattr(self.process,_byIsolationOldDMMVArun2017v2raw),
260  _byIsolationOldDMMVArun2017v2VLooseProd
261  )
262  tauIDSources.byIsolationMVArun2017v2DBoldDMwLTraw2017 = self.cms.InputTag(_byIsolationOldDMMVArun2017v2raw)
263  tauIDSources.byVLooseIsolationMVArun2017v2DBoldDMwLT2017 = self.cms.InputTag(_byIsolationOldDMMVArun2017v2VLoose)
264 
265  wp_to_eff_match = {
266  "VVLoose" : "WPEff95",
267  "Loose" : "WPEff80",
268  "Medium" : "WPEff70",
269  "Tight" : "WPEff60",
270  "VTight" : "WPEff50",
271  "VVTight" : "WPEff40"
272  }
273  for wp,wpEff in wp_to_eff_match.items():
274  _aWP = "rerunDiscriminationByIsolationOldDMMVArun2017v2"+wp+self.postfix
275  setattr(self.process,_aWP,_byIsolationOldDMMVArun2017v2VLooseProd.clone())
276  _aWPProd = getattr(self.process,_aWP)
277  _aWPProd.mapping[0].cut = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2017v2_"+wpEff)
278  _rerunIsolationOldDMMVArun2017v2Task.add(_aWPProd)
279  setattr(tauIDSources,"by"+wp+"IsolationMVArun2017v2DBoldDMwLT2017",self.cms.InputTag(_aWP))
280 
281  _rerunMvaIsolationTask.add(_rerunIsolationOldDMMVArun2017v2Task)
282  _rerunMvaIsolationSequence += self.cms.Sequence(_rerunIsolationOldDMMVArun2017v2Task)
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 = self.cms.bool(True),
310  mvaName = self.cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2017v2"),
311  mvaOpt = self.cms.string("DBnewDMwLTwGJ"),
312  verbosity = self.cms.int32(0)
313  ))
314 
315  _byIsolationNewDMMVArun2017v2VLoose = "rerunDiscriminationByIsolationNewDMMVArun2017v2VLoose"+self.postfix
316  setattr(self.process,_byIsolationNewDMMVArun2017v2VLoose,patDiscriminationByIsolationMVArun2v1VLoose.clone(
317  PATTauProducer = self.originalTauName,
318  Prediscriminants = noPrediscriminants,
319  toMultiplex = _byIsolationNewDMMVArun2017v2raw,
320  key = _byIsolationNewDMMVArun2017v2raw+':category',
321  loadMVAfromDB = self.cms.bool(True),
322  mvaOutput_normalization = self.cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2017v2_mvaOutput_normalization"), #writeTauIdDiscrMVAoutputNormalizations
323  mapping = self.cms.VPSet(
324  self.cms.PSet(
325  category = self.cms.uint32(0),
326  cut = self.cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2017v2_WPEff90"), #writeTauIdDiscrWPs
327  variable = self.cms.string("pt"),
328  )
329  ),
330  verbosity = self.cms.int32(0)
331  ))
332  _byIsolationNewDMMVArun2017v2VLooseProd = getattr(self.process,_byIsolationNewDMMVArun2017v2VLoose)
333 
334  _rerunIsolationNewDMMVArun2017v2Task = self.cms.Task(
335  getattr(self.process,_byIsolationNewDMMVArun2017v2raw),
336  _byIsolationNewDMMVArun2017v2VLooseProd
337  )
338  tauIDSources.byIsolationMVArun2017v2DBnewDMwLTraw2017 = self.cms.InputTag(_byIsolationNewDMMVArun2017v2raw)
339  tauIDSources.byVLooseIsolationMVArun2017v2DBnewDMwLT2017 = self.cms.InputTag(_byIsolationNewDMMVArun2017v2VLoose)
340 
341  wp_to_eff_match = {
342  "VVLoose" : "WPEff95",
343  "Loose" : "WPEff80",
344  "Medium" : "WPEff70",
345  "Tight" : "WPEff60",
346  "VTight" : "WPEff50",
347  "VVTight" : "WPEff40"
348  }
349  for wp,wpEff in wp_to_eff_match.items():
350  _aWP = "rerunDiscriminationByIsolationNewDMMVArun2017v2"+wp+self.postfix
351  setattr(self.process,_aWP,_byIsolationNewDMMVArun2017v2VLooseProd.clone())
352  _aWPProd = getattr(self.process,_aWP)
353  _aWPProd.mapping[0].cut = self.cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2017v2_"+wpEff)
354  _rerunIsolationNewDMMVArun2017v2Task.add(_aWPProd)
355  setattr(tauIDSources,"by"+wp+"IsolationMVArun2017v2DBnewDMwLT2017",self.cms.InputTag(_aWP))
356 
357  _rerunMvaIsolationTask.add(_rerunIsolationNewDMMVArun2017v2Task)
358  _rerunMvaIsolationSequence += self.cms.Sequence(_rerunIsolationNewDMMVArun2017v2Task)
359 
360  if "dR0p32017v2" in self.toKeep:
361  self.tauIdDiscrMVA_2017_version = "v2"
362  self.tauIdDiscrMVA_trainings_run2_2017 = {
363  'tauIdMVAIsoDBoldDMdR0p3wLT2017' : "tauIdMVAIsoDBoldDMdR0p3wLT2017",
364  }
365  self.tauIdDiscrMVA_WPs_run2_2017 = {
366  'tauIdMVAIsoDBoldDMdR0p3wLT2017' : {
367  'Eff95' : "DBoldDMdR0p3wLTEff95",
368  'Eff90' : "DBoldDMdR0p3wLTEff90",
369  'Eff80' : "DBoldDMdR0p3wLTEff80",
370  'Eff70' : "DBoldDMdR0p3wLTEff70",
371  'Eff60' : "DBoldDMdR0p3wLTEff60",
372  'Eff50' : "DBoldDMdR0p3wLTEff50",
373  'Eff40' : "DBoldDMdR0p3wLTEff40"
374  }
375  }
376 
377  if not self.is_above_cmssw_version(9, 4, 5, self.debug):
378  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")
379  self.loadMVA_WPs_run2_2017()
380 
381  _byIsolationOldDMdR0p3MVArun2017v2raw = "rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2raw"+self.postfix
382  setattr(self.process,_byIsolationOldDMdR0p3MVArun2017v2raw,patDiscriminationByIsolationMVArun2v1raw.clone(
383  PATTauProducer = self.originalTauName,
384  Prediscriminants = noPrediscriminants,
385  loadMVAfromDB = self.cms.bool(True),
386  mvaName = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMdR0p3wLT2017v2"),
387  mvaOpt = self.cms.string("DBoldDMwLTwGJ"),
388  srcChargedIsoPtSum = self.cms.string('chargedIsoPtSumdR03'),
389  srcFootprintCorrection = self.cms.string('footprintCorrectiondR03'),
390  srcNeutralIsoPtSum = self.cms.string('neutralIsoPtSumdR03'),
391  srcPhotonPtSumOutsideSignalCone = self.cms.string('photonPtSumOutsideSignalConedR03'),
392  verbosity = self.cms.int32(0)
393  ))
394 
395  _byIsolationOldDMdR0p3MVArun2017v2VLoose = "rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2VLoose"+self.postfix
396  setattr(self.process,_byIsolationOldDMdR0p3MVArun2017v2VLoose,patDiscriminationByIsolationMVArun2v1VLoose.clone(
397  PATTauProducer = self.originalTauName,
398  Prediscriminants = noPrediscriminants,
399  toMultiplex = _byIsolationOldDMdR0p3MVArun2017v2raw,
400  key = _byIsolationOldDMdR0p3MVArun2017v2raw+':category',
401  loadMVAfromDB = self.cms.bool(True),
402  mvaOutput_normalization = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMdR0p3wLT2017v2_mvaOutput_normalization"), #writeTauIdDiscrMVAoutputNormalizations
403  mapping = self.cms.VPSet(
404  self.cms.PSet(
405  category = self.cms.uint32(0),
406  cut = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMdR0p3wLT2017v2_WPEff90"), #writeTauIdDiscrWPs
407  variable = self.cms.string("pt"),
408  )
409  ),
410  verbosity = self.cms.int32(0)
411  ))
412  _byIsolationOldDMdR0p3MVArun2017v2VLooseProd = getattr(self.process,_byIsolationOldDMdR0p3MVArun2017v2VLoose)
413 
414  _rerunIsolationOldDMdR0p3MVArun2017v2Task = self.cms.Task(
415  getattr(self.process,_byIsolationOldDMdR0p3MVArun2017v2raw),
416  _byIsolationOldDMdR0p3MVArun2017v2VLooseProd
417  )
418  tauIDSources.byIsolationMVArun2017v2DBoldDMdR0p3wLTraw2017 = self.cms.InputTag(_byIsolationOldDMdR0p3MVArun2017v2raw)
419  tauIDSources.byVLooseIsolationMVArun2017v2DBoldDMdR0p3wLT2017 = self.cms.InputTag(_byIsolationOldDMdR0p3MVArun2017v2VLoose)
420 
421  wp_to_eff_match = {
422  "VVLoose" : "WPEff95",
423  "Loose" : "WPEff80",
424  "Medium" : "WPEff70",
425  "Tight" : "WPEff60",
426  "VTight" : "WPEff50",
427  "VVTight" : "WPEff40"
428  }
429  for wp,wpEff in wp_to_eff_match.items():
430  _aWP = "rerunDiscriminationByIsolationOldDMdR0p3MVArun2017v2"+wp+self.postfix
431  setattr(self.process,_aWP,_byIsolationOldDMdR0p3MVArun2017v2VLooseProd.clone())
432  _aWPProd = getattr(self.process,_aWP)
433  _aWPProd.mapping[0].cut = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMdR0p3wLT2017v2_"+wpEff)
434  _rerunIsolationOldDMdR0p3MVArun2017v2Task.add(_aWPProd)
435  setattr(tauIDSources,"by"+wp+"IsolationMVArun2017v2DBoldDMdR0p3wLT2017",self.cms.InputTag(_aWP))
436 
437  _rerunMvaIsolationTask.add(_rerunIsolationOldDMdR0p3MVArun2017v2Task)
438  _rerunMvaIsolationSequence += self.cms.Sequence(_rerunIsolationOldDMdR0p3MVArun2017v2Task)
439 
440  # 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
441  # self.process.rerunDiscriminationByIsolationOldDMMVArun2v2raw = patDiscriminationByIsolationMVArun2v1raw.clone(
442  # PATTauProducer = self.originalTauName,
443  # Prediscriminants = noPrediscriminants,
444  # loadMVAfromDB = self.cms.bool(True),
445  # mvaName = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v2"),
446  # mvaOpt = self.cms.string("DBoldDMwLTwGJ"),
447  # verbosity = self.cms.int32(0)
448  # )
449  # #
450  # self.process.rerunDiscriminationByIsolationOldDMMVArun2v2VLoose = patDiscriminationByIsolationMVArun2v1VLoose.clone(
451  # PATTauProducer = self.originalTauName,
452  # Prediscriminants = noPrediscriminants,
453  # toMultiplex = self.cms.InputTag('rerunDiscriminationByIsolationOldDMMVArun2v2raw'),
454  # key = self.cms.InputTag('rerunDiscriminationByIsolationOldDMMVArun2v2raw:category'),#?
455  # loadMVAfromDB = self.cms.bool(True),
456  # mvaOutput_normalization = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v2_mvaOutput_normalization"), #writeTauIdDiscrMVAoutputNormalizations
457  # mapping = self.cms.VPSet(
458  # self.cms.PSet(
459  # category = self.cms.uint32(0),
460  # cut = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v2_WPEff90"), #writeTauIdDiscrWPs
461  # variable = self.cms.string("pt"),
462  # )
463  # )
464  # )
465 
466  # 2016 training strategy(v1), trained on 2016MC, old DM
467  if "2016v1" in self.toKeep:
468  _byIsolationOldDMMVArun2016v1raw = "rerunDiscriminationByIsolationOldDMMVArun2v1raw"+self.postfix
469  setattr(self.process,_byIsolationOldDMMVArun2016v1raw,patDiscriminationByIsolationMVArun2v1raw.clone(
470  PATTauProducer = self.originalTauName,
471  Prediscriminants = noPrediscriminants,
472  loadMVAfromDB = self.cms.bool(True),
473  mvaName = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v1"),
474  mvaOpt = self.cms.string("DBoldDMwLT"),
475  verbosity = self.cms.int32(0)
476  ))
477 
478  _byIsolationOldDMMVArun2016v1VLoose = "rerunDiscriminationByIsolationOldDMMVArun2v1VLoose"+self.postfix
479  setattr(self.process,_byIsolationOldDMMVArun2016v1VLoose,patDiscriminationByIsolationMVArun2v1VLoose.clone(
480  PATTauProducer = self.originalTauName,
481  Prediscriminants = noPrediscriminants,
482  toMultiplex = _byIsolationOldDMMVArun2016v1raw,
483  key = _byIsolationOldDMMVArun2016v1raw+':category',
484  loadMVAfromDB = self.cms.bool(True),
485  mvaOutput_normalization = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v1_mvaOutput_normalization"),
486  mapping = self.cms.VPSet(
487  self.cms.PSet(
488  category = self.cms.uint32(0),
489  cut = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v1_WPEff90"),
490  variable = self.cms.string("pt"),
491  )
492  )
493  ))
494  _byIsolationOldDMMVArun2016v1VLooseProd = getattr(self.process,_byIsolationOldDMMVArun2016v1VLoose)
495 
496  _rerunIsolationOldDMMVArun2016v1Task = self.cms.Task(
497  getattr(self.process,_byIsolationOldDMMVArun2016v1raw),
498  _byIsolationOldDMMVArun2016v1VLooseProd
499  )
500  tauIDSources.byIsolationMVArun2v1DBoldDMwLTraw2016 = self.cms.InputTag(_byIsolationOldDMMVArun2016v1raw)
501  tauIDSources.byVLooseIsolationMVArun2v2DBoldDMwLT2016 = self.cms.InputTag(_byIsolationOldDMMVArun2016v1VLoose)
502 
503  wp_to_eff_match = {
504  "Loose" : "WPEff80",
505  "Medium" : "WPEff70",
506  "Tight" : "WPEff60",
507  "VTight" : "WPEff50",
508  "VVTight" : "WPEff40"
509  }
510  for wp,wpEff in wp_to_eff_match.items():
511  _aWP = "rerunDiscriminationByIsolationOldDMMVArun2v1"+wp+self.postfix
512  setattr(self.process,_aWP,_byIsolationOldDMMVArun2016v1VLooseProd.clone())
513  _aWPProd = getattr(self.process,_aWP)
514  _aWPProd.mapping[0].cut = self.cms.string("RecoTauTag_tauIdMVAIsoDBoldDMwLT2016v1_"+wpEff)
515  _rerunIsolationOldDMMVArun2016v1Task.add(_aWPProd)
516  setattr(tauIDSources,"by"+wp+"IsolationMVArun2v1DBoldDMwLT2016",self.cms.InputTag(_aWP))
517 
518  _rerunMvaIsolationTask.add(_rerunIsolationOldDMMVArun2016v1Task)
519  _rerunMvaIsolationSequence += self.cms.Sequence(_rerunIsolationOldDMMVArun2016v1Task)
520 
521  # 2016 training strategy(v1), trained on 2016MC, new DM
522  if "newDM2016v1" in self.toKeep:
523  _byIsolationNewDMMVArun2016v1raw = "rerunDiscriminationByIsolationNewDMMVArun2v1raw"+self.postfix
524  setattr(self.process,_byIsolationNewDMMVArun2016v1raw,patDiscriminationByIsolationMVArun2v1raw.clone(
525  PATTauProducer = self.originalTauName,
526  Prediscriminants = noPrediscriminants,
527  loadMVAfromDB = self.cms.bool(True),
528  mvaName = self.cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2016v1"),
529  mvaOpt = self.cms.string("DBnewDMwLT"),
530  verbosity = self.cms.int32(0)
531  ))
532 
533  _byIsolationNewDMMVArun2016v1VLoose = "rerunDiscriminationByIsolationNewDMMVArun2v1VLoose"+self.postfix
534  setattr(self.process,_byIsolationNewDMMVArun2016v1VLoose,patDiscriminationByIsolationMVArun2v1VLoose.clone(
535  PATTauProducer = self.originalTauName,
536  Prediscriminants = noPrediscriminants,
537  toMultiplex = _byIsolationNewDMMVArun2016v1raw,
538  key = _byIsolationNewDMMVArun2016v1raw+':category',
539  loadMVAfromDB = self.cms.bool(True),
540  mvaOutput_normalization = self.cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2016v1_mvaOutput_normalization"),
541  mapping = self.cms.VPSet(
542  self.cms.PSet(
543  category = self.cms.uint32(0),
544  cut = self.cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2016v1_WPEff90"),
545  variable = self.cms.string("pt"),
546  )
547  )
548  ))
549  _byIsolationNewDMMVArun2016v1VLooseProd = getattr(self.process,_byIsolationNewDMMVArun2016v1VLoose)
550 
551  _rerunIsolationNewDMMVArun2016v1Task = self.cms.Task(
552  getattr(self.process,_byIsolationNewDMMVArun2016v1raw),
553  _byIsolationNewDMMVArun2016v1VLooseProd
554  )
555  tauIDSources.byIsolationMVArun2v1DBnewDMwLTraw2016 = self.cms.InputTag(_byIsolationNewDMMVArun2016v1raw)
556  tauIDSources.byVLooseIsolationMVArun2v2DBnewDMwLT2016 = self.cms.InputTag(_byIsolationNewDMMVArun2016v1VLoose)
557 
558  wp_to_eff_match = {
559  "Loose" : "WPEff80",
560  "Medium" : "WPEff70",
561  "Tight" : "WPEff60",
562  "VTight" : "WPEff50",
563  "VVTight" : "WPEff40"
564  }
565  for wp,wpEff in wp_to_eff_match.items():
566  _aWP = "rerunDiscriminationByIsolationNewDMMVArun2v1"+wp+self.postfix
567  setattr(self.process,_aWP,_byIsolationNewDMMVArun2016v1VLooseProd.clone())
568  _aWPProd = getattr(self.process,_aWP)
569  _aWPProd.mapping[0].cut = self.cms.string("RecoTauTag_tauIdMVAIsoDBnewDMwLT2016v1_"+wpEff)
570  _rerunIsolationNewDMMVArun2016v1Task.add(_aWPProd)
571  setattr(tauIDSources,"by"+wp+"IsolationMVArun2v1DBnewDMwLT2016",self.cms.InputTag(_aWP))
572 
573  _rerunMvaIsolationTask.add(_rerunIsolationNewDMMVArun2016v1Task)
574  _rerunMvaIsolationSequence += self.cms.Sequence(_rerunIsolationNewDMMVArun2016v1Task)
575 
576  if "deepTau2017v1" in self.toKeep:
577  if self.debug: print ("Adding DeepTau IDs")
578 
579  _deepTauName = "deepTau2017v1"
580  workingPoints_ = {
581  "e": {
582  "VVVLoose" : 0.96424,
583  "VVLoose" : 0.98992,
584  "VLoose" : 0.99574,
585  "Loose": 0.99831,
586  "Medium": 0.99868,
587  "Tight": 0.99898,
588  "VTight": 0.99911,
589  "VVTight": 0.99918
590  },
591  "mu": {
592  "VVVLoose" : 0.959619,
593  "VVLoose" : 0.997687,
594  "VLoose" : 0.999392,
595  "Loose": 0.999755,
596  "Medium": 0.999854,
597  "Tight": 0.999886,
598  "VTight": 0.999944,
599  "VVTight": 0.9999971
600  },
601 
602  "jet": {
603  "VVVLoose" : 0.5329,
604  "VVLoose" : 0.7645,
605  "VLoose" : 0.8623,
606  "Loose": 0.9140,
607  "Medium": 0.9464,
608  "Tight": 0.9635,
609  "VTight": 0.9760,
610  "VVTight": 0.9859
611  }
612  }
613  file_names = ['RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v1_20L1024N_quantized.pb']
614  setattr(self.process,_deepTauName+self.postfix,self.cms.EDProducer("DeepTauId",
615  electrons = self.cms.InputTag('slimmedElectrons'),
616  muons = self.cms.InputTag('slimmedMuons'),
617  taus = self.cms.InputTag(self.originalTauName),
618  pfcands = self.cms.InputTag('packedPFCandidates'),
619  vertices = self.cms.InputTag('offlineSlimmedPrimaryVertices'),
620  rho = self.cms.InputTag('fixedGridRhoAll'),
621  graph_file = self.cms.vstring(file_names),
622  mem_mapped = self.cms.bool(False),
623  version = self.cms.uint32(self.getDeepTauVersion(file_names[0])[1]),
624  debug_level = self.cms.int32(0),
625  disable_dxy_pca = self.cms.bool(False)
626 
627  ))
628 
629  self.processDeepProducer(_deepTauName, tauIDSources, workingPoints_)
630 
631  _deepTauProducer = getattr(self.process,_deepTauName+self.postfix)
632  _rerunMvaIsolationTask.add(_deepTauProducer)
633  _rerunMvaIsolationSequence += _deepTauProducer
634 
635  if "deepTau2017v2" in self.toKeep:
636  if self.debug: print ("Adding DeepTau IDs")
637 
638  _deepTauName = "deepTau2017v2"
639  workingPoints_ = {
640  "e": {
641  "VVVLoose": 0.0630386,
642  "VVLoose": 0.1686942,
643  "VLoose": 0.3628130,
644  "Loose": 0.6815435,
645  "Medium": 0.8847544,
646  "Tight": 0.9675541,
647  "VTight": 0.9859251,
648  "VVTight": 0.9928449,
649  },
650  "mu": {
651  "VLoose": 0.1058354,
652  "Loose": 0.2158633,
653  "Medium": 0.5551894,
654  "Tight": 0.8754835,
655  },
656  "jet": {
657  "VVVLoose": 0.2599605,
658  "VVLoose": 0.4249705,
659  "VLoose": 0.5983682,
660  "Loose": 0.7848675,
661  "Medium": 0.8834768,
662  "Tight": 0.9308689,
663  "VTight": 0.9573137,
664  "VVTight": 0.9733927,
665  },
666  }
667 
668  file_names = [
669  'core:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_core.pb',
670  'inner:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_inner.pb',
671  'outer:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_outer.pb',
672  ]
673  setattr(self.process,_deepTauName+self.postfix,self.cms.EDProducer("DeepTauId",
674  electrons = self.cms.InputTag('slimmedElectrons'),
675  muons = self.cms.InputTag('slimmedMuons'),
676  taus = self.cms.InputTag(self.originalTauName),
677  pfcands = self.cms.InputTag('packedPFCandidates'),
678  vertices = self.cms.InputTag('offlineSlimmedPrimaryVertices'),
679  rho = self.cms.InputTag('fixedGridRhoAll'),
680  graph_file = self.cms.vstring(file_names),
681  mem_mapped = self.cms.bool(True),
682  version = self.cms.uint32(self.getDeepTauVersion(file_names[0])[1]),
683  debug_level = self.cms.int32(0),
684  disable_dxy_pca = self.cms.bool(False)
685 
686  ))
687 
688  self.processDeepProducer(_deepTauName, tauIDSources, workingPoints_)
689 
690  _deepTauProducer = getattr(self.process,_deepTauName+self.postfix)
691  _rerunMvaIsolationTask.add(_deepTauProducer)
692  _rerunMvaIsolationSequence += _deepTauProducer
693 
694  if "deepTau2017v2p1" in self.toKeep:
695  if self.debug: print ("Adding DeepTau IDs")
696 
697  _deepTauName = "deepTau2017v2p1"
698  workingPoints_ = {
699  "e": {
700  "VVVLoose": 0.0630386,
701  "VVLoose": 0.1686942,
702  "VLoose": 0.3628130,
703  "Loose": 0.6815435,
704  "Medium": 0.8847544,
705  "Tight": 0.9675541,
706  "VTight": 0.9859251,
707  "VVTight": 0.9928449,
708  },
709  "mu": {
710  "VLoose": 0.1058354,
711  "Loose": 0.2158633,
712  "Medium": 0.5551894,
713  "Tight": 0.8754835,
714  },
715  "jet": {
716  "VVVLoose": 0.2599605,
717  "VVLoose": 0.4249705,
718  "VLoose": 0.5983682,
719  "Loose": 0.7848675,
720  "Medium": 0.8834768,
721  "Tight": 0.9308689,
722  "VTight": 0.9573137,
723  "VVTight": 0.9733927,
724  },
725  }
726 
727  file_names = [
728  'core:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_core.pb',
729  'inner:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_inner.pb',
730  'outer:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_outer.pb',
731  ]
732  setattr(self.process,_deepTauName+self.postfix,self.cms.EDProducer("DeepTauId",
733  electrons = self.cms.InputTag('slimmedElectrons'),
734  muons = self.cms.InputTag('slimmedMuons'),
735  taus = self.cms.InputTag(self.originalTauName),
736  pfcands = self.cms.InputTag('packedPFCandidates'),
737  vertices = self.cms.InputTag('offlineSlimmedPrimaryVertices'),
738  rho = self.cms.InputTag('fixedGridRhoAll'),
739  graph_file = self.cms.vstring(file_names),
740  mem_mapped = self.cms.bool(True),
741  version = self.cms.uint32(self.getDeepTauVersion(file_names[0])[1]),
742  debug_level = self.cms.int32(0),
743  disable_dxy_pca = self.cms.bool(True)
744 
745  ))
746 
747  self.processDeepProducer(_deepTauName, tauIDSources, workingPoints_)
748 
749  _deepTauProducer = getattr(self.process,_deepTauName+self.postfix)
750  _rerunMvaIsolationTask.add(_deepTauProducer)
751  _rerunMvaIsolationSequence += _deepTauProducer
752 
753  if "DPFTau_2016_v0" in self.toKeep:
754  if self.debug: print ("Adding DPFTau isolation (v0)")
755 
756  _deepTauName = "DPFTau_2016_v0"
757  workingPoints_ = {
758  "all": {
759  "Tight" : "if(decayMode == 0) return (0.898328 - 0.000160992 * pt);" + \
760  "if(decayMode == 1) return (0.910138 - 0.000229923 * pt);" + \
761  "if(decayMode == 10) return (0.873958 - 0.0002328 * pt);" + \
762  "return 99.0;"
763  #"Tight" : "? decayMode == 0 ? (0.898328 - 0.000160992 * pt) : " +
764  # "(? decayMode == 1 ? 0.910138 - 0.000229923 * pt : " +
765  # "(? decayMode == 10 ? (0.873958 - 0.0002328 * pt) : 1))"
766  # "Tight" : "(decayMode == 0) * (0.898328 - 0.000160992 * pt) + \
767  # (decayMode == 1) * (0.910138 - 0.000229923 * pt) + \
768  # (decayMode == 10) * (0.873958 - 0.0002328 * pt) "
769  }
770  }
771  file_names = [ 'RecoTauTag/TrainingFiles/data/DPFTauId/DPFIsolation_2017v0_quantized.pb' ]
772  setattr(self.process,_deepTauName+self.postfix,self.cms.EDProducer("DPFIsolation",
773  pfcands = self.cms.InputTag('packedPFCandidates'),
774  taus = self.cms.InputTag(self.originalTauName),
775  vertices = self.cms.InputTag('offlineSlimmedPrimaryVertices'),
776  graph_file = self.cms.vstring(file_names),
777  version = self.cms.uint32(self.getDpfTauVersion(file_names[0])),
778  mem_mapped = self.cms.bool(False)
779  ))
780 
781  self.processDeepProducer(_deepTauName, tauIDSources, workingPoints_)
782 
783  _deepTauProducer = getattr(self.process,_deepTauName+self.postfix)
784  _rerunMvaIsolationTask.add(_deepTauProducer)
785  _rerunMvaIsolationSequence += _deepTauProducer
786 
787  if "DPFTau_2016_v1" in self.toKeep:
788  print ("Adding DPFTau isolation (v1)")
789  print ("WARNING: WPs are not defined for DPFTau_2016_v1")
790  print ("WARNING: The score of DPFTau_2016_v1 is inverted: i.e. for Sig->0, for Bkg->1 with -1 for undefined input (preselection not passed).")
791 
792  _deepTauName = "DPFTau_2016_v1"
793  workingPoints_ = {
794  "all": {"Tight" : 0.123} #FIXME: define WP
795  }
796 
797  file_names = [ 'RecoTauTag/TrainingFiles/data/DPFTauId/DPFIsolation_2017v1_quantized.pb' ]
798  setattr(self.process,_deepTauName+self.postfix,self.cms.EDProducer("DPFIsolation",
799  pfcands = self.cms.InputTag('packedPFCandidates'),
800  taus = self.cms.InputTag(self.originalTauName),
801  vertices = self.cms.InputTag('offlineSlimmedPrimaryVertices'),
802  graph_file = self.cms.vstring(file_names),
803  version = self.cms.uint32(self.getDpfTauVersion(file_names[0])),
804  mem_mapped = self.cms.bool(False)
805  ))
806 
807  self.processDeepProducer(_deepTauName, tauIDSources, workingPoints_)
808 
809  _deepTauProducer = getattr(self.process,_deepTauName+self.postfix)
810  _rerunMvaIsolationTask.add(_deepTauProducer)
811  _rerunMvaIsolationSequence += _deepTauProducer
812 
813  if "againstEle2018" in self.toKeep:
814  antiElectronDiscrMVA6_version = "MVA6v3_noeveto"
815  ### Define new anti-e discriminants
816  ## Raw
817  from RecoTauTag.RecoTau.PATTauDiscriminationAgainstElectronMVA6_cfi import patTauDiscriminationAgainstElectronMVA6
818  _byElectronRejectionMVA62018Raw = "patTauDiscriminationByElectronRejectionMVA62018Raw"+self.postfix
819  setattr(self.process,_byElectronRejectionMVA62018Raw,patTauDiscriminationAgainstElectronMVA6.clone(
820  PATTauProducer = self.originalTauName,
821  Prediscriminants = noPrediscriminants, #already selected for MiniAOD
822  vetoEcalCracks = self.cms.bool(False), #keep taus in EB-EE cracks
823  mvaName_NoEleMatch_wGwoGSF_BL = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_BL',
824  mvaName_NoEleMatch_wGwoGSF_EC = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_EC',
825  mvaName_NoEleMatch_woGwoGSF_BL = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_BL',
826  mvaName_NoEleMatch_woGwoGSF_EC = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_EC',
827  mvaName_wGwGSF_BL = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_BL',
828  mvaName_wGwGSF_EC = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_EC',
829  mvaName_woGwGSF_BL = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_BL',
830  mvaName_woGwGSF_EC = 'RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_EC'
831  ))
832  ## WPs
833  from RecoTauTag.RecoTau.PATTauDiscriminantCutMultiplexer_cfi import patTauDiscriminantCutMultiplexer
834  # VLoose
835  _byElectronRejectionMVA62018VLoose = "patTauDiscriminationByVLooseElectronRejectionMVA62018"+self.postfix
836  setattr(self.process,_byElectronRejectionMVA62018VLoose,patTauDiscriminantCutMultiplexer.clone(
837  PATTauProducer = self.originalTauName,
838  Prediscriminants = noPrediscriminants,
839  toMultiplex = _byElectronRejectionMVA62018Raw,
840  key = _byElectronRejectionMVA62018Raw+":category",
841  mapping = self.cms.VPSet(
842  self.cms.PSet(
843  category = self.cms.uint32(0),
844  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_BL_WPeff98'),
845  variable = self.cms.string('pt')
846  ),
847  self.cms.PSet(
848  category = self.cms.uint32(2),
849  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_BL_WPeff98'),
850  variable = self.cms.string('pt')
851  ),
852  self.cms.PSet(
853  category = self.cms.uint32(5),
854  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_BL_WPeff98'),
855  variable = self.cms.string('pt')
856  ),
857  self.cms.PSet(
858  category = self.cms.uint32(7),
859  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_BL_WPeff98'),
860  variable = self.cms.string('pt')
861  ),
862  self.cms.PSet(
863  category = self.cms.uint32(8),
864  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_EC_WPeff98'),
865  variable = self.cms.string('pt')
866  ),
867  self.cms.PSet(
868  category = self.cms.uint32(10),
869  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_EC_WPeff98'),
870  variable = self.cms.string('pt')
871  ),
872  self.cms.PSet(
873  category = self.cms.uint32(13),
874  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_EC_WPeff98'),
875  variable = self.cms.string('pt')
876  ),
877  self.cms.PSet(
878  category = self.cms.uint32(15),
879  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_EC_WPeff98'),
880  variable = self.cms.string('pt')
881  )
882  )
883  ))
884  _byElectronRejectionMVA62018VLooseProd = getattr(self.process,_byElectronRejectionMVA62018VLoose)
885 
886  _patTauDiscriminationByElectronRejectionMVA62018Task = self.cms.Task(
887  getattr(self.process,_byElectronRejectionMVA62018Raw),
888  _byElectronRejectionMVA62018VLooseProd
889  )
890  _againstElectronTauIDSources = self.cms.PSet(
891  againstElectronMVA6Raw2018 = self.cms.InputTag(_byElectronRejectionMVA62018Raw),
892  againstElectronMVA6category2018 = self.cms.InputTag(_byElectronRejectionMVA62018Raw,"category"),
893  againstElectronVLooseMVA62018 = self.cms.InputTag(_byElectronRejectionMVA62018VLoose)
894  )
895  # Other WPs
896  wp_to_eff_match = {
897  "Loose" : "WPeff90",
898  "Medium" : "WPeff80",
899  "Tight" : "WPeff70",
900  "VTight" : "WPeff60",
901  }
902  for wp,wpEff in wp_to_eff_match.items():
903  _aWP = "patTauDiscriminationBy"+wp+"ElectronRejectionMVA62018"+self.postfix
904  setattr(self.process,_aWP,_byElectronRejectionMVA62018VLooseProd.clone(
905  mapping = self.cms.VPSet(
906  self.cms.PSet(
907  category = self.cms.uint32(0),
908  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_BL_'+wpEff),
909  variable = self.cms.string('pt')
910  ),
911  self.cms.PSet(
912  category = self.cms.uint32(2),
913  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_BL_'+wpEff),
914  variable = self.cms.string('pt')
915  ),
916  self.cms.PSet(
917  category = self.cms.uint32(5),
918  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_BL_'+wpEff),
919  variable = self.cms.string('pt')
920  ),
921  self.cms.PSet(
922  category = self.cms.uint32(7),
923  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_BL_'+wpEff),
924  variable = self.cms.string('pt')
925  ),
926  self.cms.PSet(
927  category = self.cms.uint32(8),
928  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_woGwoGSF_EC_'+wpEff),
929  variable = self.cms.string('pt')
930  ),
931  self.cms.PSet(
932  category = self.cms.uint32(10),
933  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_NoEleMatch_wGwoGSF_EC_'+wpEff),
934  variable = self.cms.string('pt')
935  ),
936  self.cms.PSet(
937  category = self.cms.uint32(13),
938  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_woGwGSF_EC_'+wpEff),
939  variable = self.cms.string('pt')
940  ),
941  self.cms.PSet(
942  category = self.cms.uint32(15),
943  cut = self.cms.string('RecoTauTag_antiElectron'+antiElectronDiscrMVA6_version+'_gbr_wGwGSF_EC_'+wpEff),
944  variable = self.cms.string('pt')
945  )
946  )
947  ))
948  _patTauDiscriminationByElectronRejectionMVA62018Task.add(getattr(self.process,_aWP))
949  setattr(_againstElectronTauIDSources,"againstElectron"+wp+"MVA62018",self.cms.InputTag(_aWP))
950 
951  _rerunMvaIsolationTask.add(_patTauDiscriminationByElectronRejectionMVA62018Task)
952  _rerunMvaIsolationSequence += self.cms.Sequence(_patTauDiscriminationByElectronRejectionMVA62018Task)
953 
954  _tauIDSourcesWithAgainistEle = self.cms.PSet(
955  tauIDSources.clone(),
956  _againstElectronTauIDSources
957  )
958  tauIDSources =_tauIDSourcesWithAgainistEle.clone()
959 
960 
961  if self.debug: print('Embedding new TauIDs into \"'+self.updatedTauName+'\"')
962  if not hasattr(self.process, self.updatedTauName):
963  embedID = self.cms.EDProducer("PATTauIDEmbedder",
964  src = self.cms.InputTag(self.originalTauName),
965  tauIDSources = tauIDSources
966  )
967  setattr(self.process, self.updatedTauName, embedID)
968  else: #assume same type
969  tauIDSources = self.cms.PSet(
970  getattr(self.process, self.updatedTauName).tauIDSources,
971  tauIDSources)
972  getattr(self.process, self.updatedTauName).tauIDSources = tauIDSources
973  setattr(self.process,"rerunMvaIsolationTask"+self.postfix,_rerunMvaIsolationTask)
974  setattr(self.process,"rerunMvaIsolationSequence"+self.postfix,_rerunMvaIsolationSequence)
975 
976 
runTauIdMVA.TauIDEmbedder.is_above_cmssw_version
def is_above_cmssw_version(klass, release=9, subversion=4, patch=0, debug=False)
Definition: runTauIdMVA.py:88
runTauIdMVA.TauIDEmbedder.getDeepTauVersion
def getDeepTauVersion(self, file_name)
Definition: runTauIdMVA.py:1001
runTauIdMVA.TauIDEmbedder.getDpfTauVersion
def getDpfTauVersion(self, file_name)
Definition: runTauIdMVA.py:991
runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017
def loadMVA_WPs_run2_2017(self)
Definition: runTauIdMVA.py:97
edm::print
S & print(S &os, JobReport::InputFile const &f)
Definition: JobReport.cc:66
runTauIdMVA.TauIDEmbedder.processDeepProducer
def processDeepProducer(self, producer_name, tauIDSources, workingPoints_)
Definition: runTauIdMVA.py:977
PATTauDiscriminantCutMultiplexer_cfi
def runTauIdMVA.TauIDEmbedder.versionToInt (   release = 9,
  subversion = 4,
  patch = 0,
  debug = False 
)
static

Definition at line 81 of file runTauIdMVA.py.

81  def versionToInt(release=9, subversion=4, patch=0, debug = False):
82  version = release * 10000 + subversion * 100 + patch + 1 # shifted by one to account for pre-releases.
83  if debug: print ("versionToInt:", version)
84  return version
85 
86 
runTauIdMVA.TauIDEmbedder.versionToInt
def versionToInt(release=9, subversion=4, patch=0, debug=False)
Definition: runTauIdMVA.py:81

Member Data Documentation

runTauIdMVA.TauIDEmbedder.availableDiscriminators
static

Definition at line 10 of file runTauIdMVA.py.

runTauIdMVA.TauIDEmbedder.cms

Definition at line 39 of file runTauIdMVA.py.

runTauIdMVA.TauIDEmbedder.debug

Definition at line 40 of file runTauIdMVA.py.

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

runTauIdMVA.TauIDEmbedder.originalTauName

Definition at line 41 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

runTauIdMVA.TauIDEmbedder.postfix

Definition at line 43 of file runTauIdMVA.py.

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

runTauIdMVA.TauIDEmbedder.process

Definition at line 38 of file runTauIdMVA.py.

Referenced by Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.dumpPython(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.open(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.outputEventContent(), runTauIdMVA.TauIDEmbedder.processDeepProducer(), runTauIdMVA.TauIDEmbedder.runTauID(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.setProcess(), and Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.setProperty().

runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_2017_version

Definition at line 55 of file runTauIdMVA.py.

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

runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_trainings_run2_2017

Definition at line 53 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

runTauIdMVA.TauIDEmbedder.tauIdDiscrMVA_WPs_run2_2017

Definition at line 54 of file runTauIdMVA.py.

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

runTauIdMVA.TauIDEmbedder.toKeep

Definition at line 59 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

runTauIdMVA.TauIDEmbedder.updatedTauName

Definition at line 42 of file runTauIdMVA.py.

Referenced by runTauIdMVA.TauIDEmbedder.runTauID().

Generated for CMSSW Reference Manual by doxygen 1.8.11