ATLAS Offline Software
TauToolHolder.py
Go to the documentation of this file.
1 # Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
2 
3 
10 
11 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
12 from AthenaConfiguration.ComponentFactory import CompFactory
13 from AthenaConfiguration.AccumulatorCache import AccumulatorCache
14 from AthenaConfiguration.Enums import ProductionStep
15 from AthenaCommon.SystemOfUnits import GeV, MeV, deg
16 
17 
18 
20 @AccumulatorCache
21 def JetSeedBuilderCfg(flags):
22  result = ComponentAccumulator()
23  _name = flags.Tau.ActiveConfig.prefix + 'JetSeedBuilder'
24 
25  JetSeedBuilder = CompFactory.getComp("JetSeedBuilder")
26  JetSeedBuilder = JetSeedBuilder(name = _name)
27 
28  result.setPrivateTools(JetSeedBuilder)
29  return result
30 
31 
32 def TauVertexFinderCfg(flags):
33  result = ComponentAccumulator()
34  _name = flags.Tau.ActiveConfig.prefix + 'TauVertexFinder'
35 
36  from InDetConfig.InDetTrackSelectionToolConfig import Tau_InDetTrackSelectionToolForTJVACfg
37  from TrackVertexAssociationTool.TrackVertexAssociationToolConfig import TauTTVAToolCfg
38 
39  # Algorithm that overwrites numTrack() and charge() of tauJets in container
40  # from tauRecTools.tauRecToolsConf import TauVertexFinder
41  TauVertexFinder = CompFactory.getComp("TauVertexFinder")
42  TauVertexFinder = TauVertexFinder(name = _name,
43  UseTJVA = flags.Tau.doTJVA,
44  AssociatedTracks="GhostTrack", # OK??
45  InDetTrackSelectionToolForTJVA = result.popToolsAndMerge(Tau_InDetTrackSelectionToolForTJVACfg(flags)),
46  Key_trackPartInputContainer= flags.Tau.ActiveConfig.TrackCollection,
47  Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
48  TVATool = result.popToolsAndMerge(TauTTVAToolCfg(flags)),
49  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
50  )
51 
52  result.setPrivateTools(TauVertexFinder)
53  return result
54 
55 
57 def TauAxisCfg(flags):
58  result = ComponentAccumulator()
59  _name = flags.Tau.ActiveConfig.prefix + 'TauAxis'
60 
61  TauAxisSetter = CompFactory.getComp("TauAxisSetter")
62  TauAxisSetter = TauAxisSetter( name = _name,
63  ClusterCone = 0.2,
64  VertexCorrection = flags.Tau.doVertexCorrection )
65 
66  result.setPrivateTools(TauAxisSetter)
67  return result
68 
69 
70 
71 def getParticleCache(flags):
72  #If reading from ESD we not create a cache of extrapolations to the calorimeter, so we should signify this by setting the cache key to a null string
73  if flags.Common.ProductionStep is ProductionStep.Reconstruction:
74  ParticleCache = "ParticleCaloExtension"
75  else:
76  ParticleCache = ""
77 
78  return ParticleCache
79 
80 
82 def TauTrackFinderCfg(flags):
83  result = ComponentAccumulator()
84  _name = flags.Tau.ActiveConfig.prefix + 'TauTrackFinder'
85 
86  # BeamSpot Conditions
87  from BeamSpotConditions.BeamSpotConditionsConfig import BeamSpotCondAlgCfg
88  result.merge(BeamSpotCondAlgCfg(flags))
89 
90  from TrackToVertex.TrackToVertexConfig import TrackToVertexCfg
91  from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg
92  from TrkConfig.TrkVertexFitterUtilsConfig import AtlasTrackToVertexIPEstimatorCfg
93  from InDetConfig.InDetTrackSelectorToolConfig import TauRecInDetTrackSelectorToolCfg
94 
95  TauTrackFinder = CompFactory.getComp("TauTrackFinder")
96  TauTrackFinder = TauTrackFinder(name = _name,
97  MaxJetDrTau = 0.2,
98  MaxJetDrWide = 0.4,
99  TrackSelectorToolTau = result.popToolsAndMerge(TauRecInDetTrackSelectorToolCfg(flags)),
100  TrackToVertexTool = result.popToolsAndMerge(TrackToVertexCfg(flags)),
101  ParticleCaloExtensionTool = result.popToolsAndMerge(ParticleCaloExtensionToolCfg(flags)),
102  tauParticleCache = getParticleCache(flags), # only returns a string
103  removeDuplicateCoreTracks = flags.Tau.RemoveDupeCoreTracks,
104  useGhostTracks = flags.Tau.useGhostTracks,
105  ghostTrackDR = flags.Tau.ghostTrackDR,
106  Key_jetContainer = (flags.Tau.ActiveConfig.SeedJetCollection if flags.Tau.useGhostTracks else ""),
107  Key_trackPartInputContainer = flags.Tau.ActiveConfig.TrackCollection,
108  Key_LargeD0TrackInputContainer = (flags.Tau.ActiveConfig.LargeD0TrackCollection if flags.Tau.associateLRT else ""),
109  TrackToVertexIPEstimator = result.popToolsAndMerge(AtlasTrackToVertexIPEstimatorCfg(flags)),
110  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
111  )
112  result.setPrivateTools(TauTrackFinder)
113  return result
114 
115 
118  result = ComponentAccumulator()
119  _name = flags.Tau.ActiveConfig.prefix + 'TauClusterFinder'
120 
121 
122  TauClusterFinder = CompFactory.getComp("TauClusterFinder")
123  TauClusterFinder = TauClusterFinder(
124  name = _name,
125  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
126  )
127 
128 
129  result.setPrivateTools(TauClusterFinder)
130  return result
131 
132 
134  result = ComponentAccumulator()
135  _name = flags.Tau.ActiveConfig.prefix + 'TauVertexedClusterDecorator'
136 
137  TauVertexedClusterDecorator = CompFactory.getComp("TauVertexedClusterDecorator")
138  myTauVertexedClusterDecorator = TauVertexedClusterDecorator(name = _name,
139  SeedJet = flags.Tau.ActiveConfig.SeedJetCollection)
140 
141  result.setPrivateTools(myTauVertexedClusterDecorator)
142  return result
143 
144 
145 def TauTrackRNNCfg(flags):
146  result = ComponentAccumulator()
147  _name = flags.Tau.ActiveConfig.prefix + 'TauTrackRNNClassifier'
148 
149  TrackRNN = CompFactory.tauRecTools.TrackRNN
150  _RNN = TrackRNN(name = _name + "_TrackRNN",
151  InputWeightsPath = flags.Tau.tauRNNTrackClassConfig,
152  calibFolder = flags.Tau.tauRecToolsCVMFSPath )
153 
154  result.setPrivateTools(_RNN)
155  return result
156 
157 
159  result = ComponentAccumulator()
160  _name = flags.Tau.ActiveConfig.prefix + 'TauTrackRNNClassifier'
161 
162  # create tool alg
163  TauTrackRNNClassifier = CompFactory.tauRecTools.TauTrackRNNClassifier
164 
165  import cppyy
166  cppyy.load_library('libxAODTau_cDict')
167 
168  _classifyLRT = True
169  if flags.Tau.associateLRT and not flags.Tau.classifyLRT:
170  _classifyLRT = False
171 
172  myTauTrackClassifier = TauTrackRNNClassifier( name = _name,
173  Classifiers = [ result.popToolsAndMerge(TauTrackRNNCfg(flags)) ],
174  classifyLRT = _classifyLRT )
175 
176  result.setPrivateTools(myTauTrackClassifier)
177  return result
178 
179 
182  result = ComponentAccumulator()
183  _name = flags.Tau.ActiveConfig.prefix +'EnergyCalibrationLC'
184 
185  TauCalibrateLC = CompFactory.getComp("TauCalibrateLC")
186  TauCalibrateLC = TauCalibrateLC(name = _name,
187  calibrationFile = flags.Tau.CalibrateLCConfig,
188  Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection)
189 
190  result.setPrivateTools(TauCalibrateLC)
191  return result
192 
193 
195 def CellVariablesCfg(flags):
196  result = ComponentAccumulator()
197  _name = flags.Tau.ActiveConfig.prefix + 'CellVariables'
198 
199  TauCellVariables = CompFactory.getComp("TauCellVariables")
200  TauCellVariables = TauCellVariables(name = _name,
201  VertexCorrection = flags.Tau.doVertexCorrection)
202 
203  result.setPrivateTools(TauCellVariables)
204  return result
205 
206 
209  result = ComponentAccumulator()
210  _name = flags.Tau.ActiveConfig.prefix + 'TauElectronVetoVars'
211 
212  from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg
213 
214  TauElectronVetoVariables = CompFactory.getComp("TauElectronVetoVariables")
215  TauElectronVetoVariables = TauElectronVetoVariables(name = _name,
216  VertexCorrection = flags.Tau.doVertexCorrection,
217  ParticleCaloExtensionTool = result.popToolsAndMerge(ParticleCaloExtensionToolCfg(flags)),
218  tauEVParticleCache = getParticleCache(flags))
219 
220  result.setPrivateTools(TauElectronVetoVariables)
221  return result
222 
223 
225 def CellWeightToolCfg(flags):
226  result = ComponentAccumulator()
227 
228  # copied from CaloClusterCorrection/python/StandardCellWeightCalib
229  H1WeightToolCSC12Generic = CompFactory.H1WeightToolCSC12Generic # CaloClusterCorrection
230  isMC = flags.Input.isMC
231 
232  finder = "Cone"
233  mainparam = 0.4
234  inputn = "Topo"
235  onlyCellWeight = False
236  from CaloClusterCorrection.StandardCellWeightCalib import H1Calibration, editParm
237  (key,folder,tag) = H1Calibration.getCalibDBParams(flags, finder, mainparam, inputn, onlyCellWeight, isMC)
238  # H1Calibration.loadCaloFolder(result, flags, folder, tag, isMC)
239  from IOVDbSvc.IOVDbSvcConfig import addFolders
240  if isMC:
241  dbString="CALO_OFL"
242  else:
243  dbString="CALO"
244  if (folder,tag) not in H1Calibration.loaded_folder:
245  if H1Calibration.overrideFolder():
246  result.merge(addFolders(flags, folder+'<tag>'+tag+'</tag>', detDb=dbString, className='CaloRec::ToolConstants') )
247  else:
248  result.merge(addFolders(flags, folder, detDb=dbString, className='CaloRec::ToolConstants') )
249 
250  H1Calibration.loaded_folder.append( (folder,tag) )
251 
252  #-- configure tool
253  toolName = finder + editParm(mainparam) + inputn
254  cellcalibtool = H1WeightToolCSC12Generic("H1Weight"+toolName)
255  cellcalibtool.DBHandleKey = key
256  result.setPrivateTools(cellcalibtool)
257  # --
258  return result
259 
260 
262 def TauShotFinderCfg(flags):
263  result = ComponentAccumulator()
264  _name = flags.Tau.ActiveConfig.prefix + 'TauShotFinder'
265 
266  shotPtCut_1Photon = flags.Tau.shotPtCut_1Photon
267  shotPtCut_2Photons = flags.Tau.shotPtCut_2Photons
268 
269 
270  from CaloClusterCorrection.StandardCellWeightCalib import getCellWeightTool
271  CaloWeightTool = getCellWeightTool(flags=flags)
272 
273 
274  TauShotFinder = CompFactory.getComp("TauShotFinder")
275  TauShotFinder = TauShotFinder(
276  name = _name,
277  CaloWeightTool = result.popToolsAndMerge(CaloWeightTool),
278  NCellsInEta = 5,
279  MinPtCut = shotPtCut_1Photon,
280  AutoDoubleShotCut = shotPtCut_2Photons,
281  Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
282  RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
283  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
284  )
285 
286  result.setPrivateTools(TauShotFinder)
287  return result
288 
289 
293  result = ComponentAccumulator()
294  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterFinder'
295 
296  TauPi0CreateROI = CompFactory.getComp("TauPi0CreateROI")
297 
298  myTauPi0CreateROI = TauPi0CreateROI(
299  name = _name,
300  Key_caloCellInputContainer = "AllCalo",
301  Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
302  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
303  RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
304  )
305 
306  result.setPrivateTools(myTauPi0CreateROI)
307  return result
308 
309 
312  result = ComponentAccumulator()
313  _name = flags.Tau.ActiveConfig.prefix + 'tauPi0CellContainerFinalizer'
314 
315  CaloCellContainerFinalizerTool = CompFactory.getComp("CaloCellContainerFinalizerTool")
316  TauCellContainerFinalizer = CaloCellContainerFinalizerTool(name=_name)
317 
318  result.setPrivateTools(TauCellContainerFinalizer)
319  return result
320 
321 
324 
326  result = ComponentAccumulator()
327  _name = flags.Tau.ActiveConfig.prefix + 'LCClassify'
328 
329  CaloLCClassificationTool = CompFactory.getComp("CaloLCClassificationTool")
330  LCClassify = CaloLCClassificationTool(_name)
331  LCClassify.ClassificationKey = "EMFracClassify"
332  LCClassify.UseSpread = False
333  LCClassify.MaxProbability = 0.5
334  # add the moments EM_PROBABILITY, HAD_WEIGHT, OOC_WEIGHT, DM_WEIGHT to the AOD:
335  LCClassify.StoreClassificationProbabilityInAOD = True
336  LCClassify.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
337  LCClassify.UseNormalizedEnergyDensity = True
338 
339  result.setPrivateTools(LCClassify)
340  return result
341 
343  result = ComponentAccumulator()
344  _name = flags.Tau.ActiveConfig.prefix + 'CaloLCWeightTool'
345 
346  # Schedule total noise cond alg
347  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
348  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
349  # Schedule electronic noise cond alg (needed for LC weights)
350  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
351 
352  CaloLCWeightTool = CompFactory.getComp("CaloLCWeightTool")
353  LCWeight = CaloLCWeightTool(_name)
354  LCWeight.CorrectionKey = "H1ClusterCellWeights"
355  LCWeight.SignalOverNoiseCut = 2.0
356  LCWeight.UseHadProbability = True
357 
358  result.setPrivateTools(LCWeight)
359  return result
360 
362  result = ComponentAccumulator()
363  _name = flags.Tau.ActiveConfig.prefix + 'CaloLCOutOfClusterTool'
364 
365  CaloLCOutOfClusterTool = CompFactory.getComp("CaloLCOutOfClusterTool")
366  LCOut = CaloLCOutOfClusterTool(_name)
367  LCOut.CorrectionKey = "OOCCorrection"
368  LCOut.UseEmProbability = False
369  LCOut.UseHadProbability = True
370 
371  result.setPrivateTools(LCOut)
372  return result
373 
375  result = ComponentAccumulator()
376  _name = flags.Tau.ActiveConfig.prefix + 'LCOutPi0'
377 
378  CaloLCOutOfClusterTool = CompFactory.getComp("CaloLCOutOfClusterTool")
379  LCOutPi0 = CaloLCOutOfClusterTool(_name)
380  LCOutPi0.CorrectionKey = "OOCPi0Correction"
381  LCOutPi0.UseEmProbability = True
382  LCOutPi0.UseHadProbability = False
383 
384  result.setPrivateTools(LCOutPi0)
385  return result
386 
388  result = ComponentAccumulator()
389  _name = flags.Tau.ActiveConfig.prefix + 'CaloLCDeadMaterialTool'
390 
391  CaloLCDeadMaterialTool = CompFactory.getComp("CaloLCDeadMaterialTool")
392  LCDeadMaterial = CaloLCDeadMaterialTool(_name)
393  LCDeadMaterial.HadDMCoeffKey = "HadDMCoeff2"
394  LCDeadMaterial.ClusterRecoStatus = 0
395  LCDeadMaterial.WeightModeDM = 2
396  LCDeadMaterial.UseHadProbability = True
397  LCDeadMaterial.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
398 
399  result.setPrivateTools(LCDeadMaterial)
400  return result
401 
403  result = ComponentAccumulator()
404  _name = flags.Tau.ActiveConfig.prefix + 'CaloLocalCalib'
405 
406  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
407  LocalCalib = CaloClusterLocalCalib(_name)
408  LocalCalib.ClusterClassificationTool = [result.popToolsAndMerge(TauCaloLCClassificationCfg(flags))]
409  LocalCalib.ClusterRecoStatus = [1,2]
410  LocalCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCWeightCfg(flags))]
411  LocalCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
412 
413  result.setPrivateTools(LocalCalib)
414  return result
415 
417  result = ComponentAccumulator()
418  _name = flags.Tau.ActiveConfig.prefix + 'OOCCalibTool'
419 
420  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
421  OOCCalib = CaloClusterLocalCalib (_name)
422  OOCCalib.ClusterRecoStatus = [1,2]
423  OOCCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCOutOfClusterCfg(flags))]
424  OOCCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
425 
426  result.setPrivateTools(OOCCalib)
427  return result
428 
429 def TauCaloDMCalibCfg(flags):
430  result = ComponentAccumulator()
431  _name = flags.Tau.ActiveConfig.prefix + 'DMCalib'
432 
433  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
434  DMCalib = CaloClusterLocalCalib(_name)
435  DMCalib.ClusterRecoStatus = [1,2]
436  DMCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCDeadMaterialCfg(flags))]
437  DMCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
438 
439  result.setPrivateTools(DMCalib)
440  return result
441 
443  result = ComponentAccumulator()
444  _name = flags.Tau.ActiveConfig.prefix + 'OOCPi0CalibTool'
445 
446  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
447  OOCPi0Calib = CaloClusterLocalCalib (_name)
448  OOCPi0Calib.ClusterRecoStatus = [1,2]
449  OOCPi0Calib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCOutPi0Cfg(flags))]
450  OOCPi0Calib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
451 
452  result.setPrivateTools(OOCPi0Calib)
453  return result
454 
456  result = ComponentAccumulator()
457  _name = flags.Tau.ActiveConfig.prefix + 'CellWeights'
458 
459  CaloClusterCellWeightCalib = CompFactory.getComp("CaloClusterCellWeightCalib")
460  CellWeights = CaloClusterCellWeightCalib(_name)
461  CellWeights.CellSignalWeightTool = result.popToolsAndMerge(CellWeightToolCfg(flags))
462  CellWeights.Direction = "AbsSignal" #-- use absolute cell energies for eta/phi calculation
463  CellWeights.BelowThresholdLikeAll = True #-- treat clusters below thresholds the same as all others
464  CellWeights.BelowThresholdDirection = "AbsSignal" #-- alternative direction calculation for below threshold clusters, ignored if BelowThresholdLikeAll = True
465  CellWeights.EnergyThreshold = 0.0*MeV #-- threshold for possible change of direction calculation
466  CellWeights.IgnoreGeoWeights = False #-- ignore geometrical cell signal weights if True
467 
468  result.setPrivateTools(CellWeights)
469  return result
470 
472  result = ComponentAccumulator()
473  _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoClusterMaker'
474 
475  # Schedule total noise cond alg
476  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
477  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
478  # Schedule electronic noise cond alg (needed for LC weights)
479  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
480 
481  CaloTopoClusterMaker = CompFactory.getComp("CaloTopoClusterMaker")
482  TopoClusterForTaus = CaloTopoClusterMaker(_name)
483 
484  TopoClusterForTaus.CellsName = flags.Tau.ActiveConfig.TauCommonPi0Cells
485  TopoClusterForTaus.CalorimeterNames=["LAREM"]
486  TopoClusterForTaus.SeedSamplingNames = ["PreSamplerB", "EMB1", "EMB2", "PreSamplerE", "EME1", "EME2"]
487  TopoClusterForTaus.NeighborOption = "super3D"
488  TopoClusterForTaus.RestrictHECIWandFCalNeighbors = False
489  TopoClusterForTaus.RestrictPSNeighbors = True
490  TopoClusterForTaus.CellThresholdOnEorAbsEinSigma = 0.0
491  TopoClusterForTaus.NeighborThresholdOnEorAbsEinSigma = 2.0
492  TopoClusterForTaus.SeedThresholdOnEorAbsEinSigma = 4.0
493  TopoClusterForTaus.SeedCutsInAbsE = True
494  TopoClusterForTaus.ClusterCutsInAbsEt = True
495  TopoClusterForTaus.ClusterEtorAbsEtCut = 0.5*GeV # 0.0*MeV in standard CaloCalTopoCluster JobOptions!
496  TopoClusterForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
497  # timing cut on seed cell to suppress out-of-time pileup
498  TopoClusterForTaus.SeedCutsInT = flags.Calo.TopoCluster.doTimeCut
499  TopoClusterForTaus.CutOOTseed = flags.Calo.TopoCluster.extendTimeCut and flags.Calo.TopoCluster.doTimeCut
500  TopoClusterForTaus.UseTimeCutUpperLimit = flags.Calo.TopoCluster.useUpperLimitForTimeCut
501  TopoClusterForTaus.TimeCutUpperLimit = flags.Calo.TopoCluster.timeCutUpperLimit
502  TopoClusterForTaus.XTalkEM2 = flags.Calo.TopoCluster.xtalkEM2
503  TopoClusterForTaus.XTalkEM2D = flags.Calo.TopoCluster.xtalkEM2D
504  TopoClusterForTaus.XTalkEM2n = flags.Calo.TopoCluster.xtalkEM2n
505  TopoClusterForTaus.XTalkEM3 = flags.Calo.TopoCluster.xtalkEM3
506  TopoClusterForTaus.XTalkEMEta = flags.Calo.TopoCluster.xtalkEMEta
507  TopoClusterForTaus.XTalkDeltaT = flags.Calo.TopoCluster.xtalkDeltaT
508  TopoClusterForTaus.XTalk2Eratio1 = flags.Calo.TopoCluster.xtalk2Eratio1
509  TopoClusterForTaus.XTalk2Eratio2 = flags.Calo.TopoCluster.xtalk2Eratio2
510  TopoClusterForTaus.XTalk3Eratio = flags.Calo.TopoCluster.xtalk3Eratio
511  TopoClusterForTaus.XTalkEtaEratio = flags.Calo.TopoCluster.xtalkEtaEratio
512  TopoClusterForTaus.XTalk2DEratio = flags.Calo.TopoCluster.xtalk2DEratio
513 
514  result.setPrivateTools(TopoClusterForTaus)
515  return result
516 
518 
519  result = ComponentAccumulator()
520  _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoClusterSplitter'
521 
522  CaloTopoClusterSplitter = CompFactory.getComp("CaloTopoClusterSplitter")
523  TopoSplitterForTaus = CaloTopoClusterSplitter(_name)
524 
525  # cells from the following samplings will be able to form local
526  # maxima. The excluded samplings are PreSamplerB, EMB1,
527  # PreSamplerE, EME1, all Tile samplings, all HEC samplings and the
528  # two rear FCal samplings.
529  TopoSplitterForTaus.SamplingNames = ["EMB2","EME2"] # Do we want to use EMB3 and EME3?
530  # cells from the following samplings will also be able to form
531  # local maxima but only if they are not overlapping in eta and phi
532  # with local maxima in previous samplings from the primary list.
533  TopoSplitterForTaus.SecondarySamplingNames = ["EMB1","EME1"]
534  TopoSplitterForTaus.ShareBorderCells = True
535  TopoSplitterForTaus.RestrictHECIWandFCalNeighbors = False
536  TopoSplitterForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
537 
538  result.setPrivateTools(TopoSplitterForTaus)
539  return result
540 
542  result = ComponentAccumulator()
543  _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoMoments'
544 
545  # Schedule total noise cond alg
546  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
547  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
548  # Schedule electronic noise cond alg (needed for LC weights)
549  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
550 
551  CaloClusterMomentsMaker = CompFactory.getComp("CaloClusterMomentsMaker")
552  TopoMomentsForTaus = CaloClusterMomentsMaker(_name)
553  TopoMomentsForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
554  TopoMomentsForTaus.MaxAxisAngle = 20*deg
555  TopoMomentsForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
556  TopoMomentsForTaus.MinBadLArQuality = 4000
557  TopoMomentsForTaus.MomentsNames = ["FIRST_PHI"
558  ,"FIRST_ETA"
559  ,"SECOND_R"
560  ,"SECOND_LAMBDA"
561  ,"DELTA_PHI"
562  ,"DELTA_THETA"
563  ,"DELTA_ALPHA"
564  ,"CENTER_X"
565  ,"CENTER_Y"
566  ,"CENTER_Z"
567  ,"CENTER_MAG"
568  ,"CENTER_LAMBDA"
569  ,"LATERAL"
570  ,"LONGITUDINAL"
571  ,"ENG_FRAC_EM"
572  ,"ENG_FRAC_MAX"
573  ,"ENG_FRAC_CORE"
574  ,"FIRST_ENG_DENS"
575  ,"SECOND_ENG_DENS"
576  ,"ISOLATION"]
577 
578  result.setPrivateTools(TopoMomentsForTaus)
579  return result
580 
582  result = ComponentAccumulator()
583  _name = flags.Tau.ActiveConfig.prefix + 'CaloClusterBadChannelList'
584 
585  CaloClusterBadChannelListCorr = CompFactory.getComp("CaloClusterBadChannelList")
586  BadChannelListCorrForTaus = CaloClusterBadChannelListCorr(_name)
587 
588  result.setPrivateTools(BadChannelListCorrForTaus)
589  return result
590 
591 
594  result = ComponentAccumulator()
595  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterCreator'
596 
597  TauPi0ClusterCreator = CompFactory.getComp("TauPi0ClusterCreator")
598  TauPi0ClusterCreator = TauPi0ClusterCreator(name = _name)
599 
600  result.setPrivateTools(TauPi0ClusterCreator)
601  return result
602 
603 
606  result = ComponentAccumulator()
607  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterScaler'
608 
609  TauPi0ClusterScaler = CompFactory.getComp("TauPi0ClusterScaler")
610  TauPi0ClusterScaler = TauPi0ClusterScaler(name = _name)
611 
612  result.setPrivateTools(TauPi0ClusterScaler)
613  return result
614 
615 
618  result = ComponentAccumulator()
619  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ScoreCalculator'
620 
621  TauPi0ScoreCalculator = CompFactory.getComp("TauPi0ScoreCalculator")
622  TauPi0ScoreCalculator = TauPi0ScoreCalculator(name = _name,
623  BDTWeightFile = flags.Tau.Pi0ScoreConfig)
624 
625  result.setPrivateTools(TauPi0ScoreCalculator)
626  return result
627 
628 
630 def Pi0SelectorCfg(flags):
631  result = ComponentAccumulator()
632  _name = flags.Tau.ActiveConfig.prefix + 'Pi0Selector'
633 
634  TauPi0Selector = CompFactory.getComp("TauPi0Selector")
635  TauPi0Selector = TauPi0Selector(name = _name,
636  ClusterEtCut = flags.Tau.pi0EtCuts,
637  ClusterBDTCut_1prong = flags.Tau.pi0MVACuts_1prong,
638  ClusterBDTCut_mprong = flags.Tau.pi0MVACuts_mprong)
639 
640  result.setPrivateTools(TauPi0Selector)
641  return result
642 
643 
646  result = ComponentAccumulator()
647  _name = flags.Tau.ActiveConfig.prefix + 'TauVertexVariables'
648 
649  from TrkConfig.TrkVertexFittersConfig import TauAdaptiveVertexFitterCfg
650  from TrkConfig.TrkVertexSeedFinderToolsConfig import (
651  CrossDistancesSeedFinderCfg)
652 
653  TauVertexVariables = CompFactory.getComp("TauVertexVariables")
654  TauVertexVariables = TauVertexVariables( name = _name,
655  VertexFitter = result.popToolsAndMerge(TauAdaptiveVertexFitterCfg(flags)),
656  SeedFinder = result.popToolsAndMerge(CrossDistancesSeedFinderCfg(flags)) )
657 
658  result.setPrivateTools(TauVertexVariables)
659  return result
660 
661 
664  result = ComponentAccumulator()
665  _name = flags.Tau.ActiveConfig.prefix + 'TauCommonCalcVars'
666 
667  TauCommonCalcVars = CompFactory.getComp("TauCommonCalcVars")
668  TauCommonCalcVars = TauCommonCalcVars(name = _name)
669 
670  result.setPrivateTools(TauCommonCalcVars)
671  return result
672 
673 
676  result = ComponentAccumulator()
677  _name = flags.Tau.ActiveConfig.prefix + 'TauSubstructure'
678 
679  TauSubstructureVariables = CompFactory.getComp("TauSubstructureVariables")
680  TauSubstructureVariables = TauSubstructureVariables( name = _name )
681 
682  result.setPrivateTools(TauSubstructureVariables)
683  return result
684 
685 
688  result = ComponentAccumulator()
689  _name = flags.Tau.ActiveConfig.prefix + 'MvaTESVariableDecorator'
690 
691  MvaTESVariableDecorator = CompFactory.getComp("MvaTESVariableDecorator")
692  MvaTESVariableDecorator = MvaTESVariableDecorator(name = _name,
693  Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
694  EventShapeKey = flags.Tau.ActiveConfig.EventShapeCollection,
695  VertexCorrection = flags.Tau.doVertexCorrection)
696  result.setPrivateTools(MvaTESVariableDecorator)
697  return result
698 
699 
702  result = ComponentAccumulator()
703  _name = flags.Tau.ActiveConfig.prefix + 'MvaTESEvaluator'
704 
705  MvaTESEvaluator = CompFactory.getComp("MvaTESEvaluator")
706  MvaTESEvaluator = MvaTESEvaluator(name = _name,
707  WeightFileName = flags.Tau.MvaTESConfig,
708  WeightFileName0p = flags.Tau.MvaTESConfig0p )
709 
710  result.setPrivateTools(MvaTESEvaluator)
711  return result
712 
714  result = ComponentAccumulator()
715  _name = flags.Tau.ActiveConfig.prefix + 'TauIDVarCalculator'
716 
717  TauIDVarCalculator = CompFactory.getComp("TauIDVarCalculator")
718  myTauIDVarCalculator = TauIDVarCalculator(name=_name,
719  VertexCorrection = flags.Tau.doVertexCorrection)
720 
721  result.setPrivateTools(myTauIDVarCalculator)
722  return result
723 
725  result = ComponentAccumulator()
726  _name = flags.Tau.ActiveConfig.prefix + 'TauJetRNN'
727 
728  TauJetRNNEvaluator = CompFactory.getComp("TauJetRNNEvaluator")
729  RNNConf = flags.Tau.TauJetRNNConfig
730  myTauJetRNNEvaluator = TauJetRNNEvaluator(name = _name,
731  NetworkFile0P = "",
732  NetworkFile1P = RNNConf[0],
733  NetworkFile2P = RNNConf[1],
734  NetworkFile3P = RNNConf[2],
735  OutputVarname = "RNNJetScore",
736  MaxTracks = 10,
737  MaxClusters = 6,
738  MaxClusterDR = 1.0,
739  VertexCorrection = flags.Tau.doVertexCorrection,
740  InputLayerScalar = "scalar",
741  InputLayerTracks = "tracks",
742  InputLayerClusters = "clusters",
743  OutputLayer = "rnnid_output",
744  OutputNode = "sig_prob")
745 
746  result.setPrivateTools(myTauJetRNNEvaluator)
747  return result
748 
750  import PyUtils.RootUtils as ru
751  ROOT = ru.import_root()
752  import cppyy
753  cppyy.load_library('libxAODTau_cDict')
754 
755  result = ComponentAccumulator()
756  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorJetRNN'
757 
758  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
759  WPConf = flags.Tau.TauJetRNNWPConfig
760  myTauWPDecorator = TauWPDecorator( name=_name,
761  flatteningFile1Prong = WPConf[0],
762  flatteningFile2Prong = WPConf[1],
763  flatteningFile3Prong = WPConf[2],
764  CutEnumVals =
765  [ ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigVeryLoose,
766  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigLoose,
767  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigMedium,
768  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigTight ],
769  SigEff1P = [0.95, 0.85, 0.75, 0.60],
770  SigEff2P = [0.95, 0.75, 0.60, 0.45],
771  SigEff3P = [0.95, 0.75, 0.60, 0.45],
772  ScoreName = "RNNJetScore",
773  NewScoreName = "RNNJetScoreSigTrans",
774  DefineWPs = True )
775 
776  result.setPrivateTools(myTauWPDecorator)
777  return result
778 
779 def TauGNNEvaluatorCfg(flags, version=0):
780  result = ComponentAccumulator()
781  _name = flags.Tau.ActiveConfig.prefix + 'TauGNN_v' + str(version)
782 
783  TauGNNEvaluator = CompFactory.getComp("TauGNNEvaluator")
784  GNNConf = flags.Tau.TauGNNConfig[version]
785  myTauGNNEvaluator = TauGNNEvaluator(name = _name,
786  NetworkFileInclusive = GNNConf,
787  OutputVarname = flags.Tau.GNTauScoreName[version],
788  OutputPTau = "GNTauProbTau",
789  OutputPJet = "GNTauProbJet",
790  MaxTracks = flags.Tau.GNTauMaxTracks[version],
791  MaxClusters = flags.Tau.GNTauMaxClusters[version],
792  MaxClusterDR = 15.0,
793  MinTauPt = flags.Tau.MinPtDAOD,
794  VertexCorrection = flags.Tau.doVertexCorrection,
795  DecorateTracks = False,
796  InputLayerScalar = "tau_vars",
797  InputLayerTracks = "track_vars",
798  InputLayerClusters = "cluster_vars",
799  NodeNameTau=flags.Tau.GNTauNodeNameTau,
800  NodeNameJet=flags.Tau.GNTauNodeNameJet)
801 
802  result.setPrivateTools(myTauGNNEvaluator)
803  return result
804 
805 def TauWPDecoratorGNNCfg(flags, version):
806  result = ComponentAccumulator()
807  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorGNN_v' + str(version)
808 
809  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
810  WPConf = flags.Tau.TauGNNWP[version]
811  myTauWPDecorator = TauWPDecorator(name=_name,
812  flatteningFile1Prong = WPConf[0],
813  flatteningFile2Prong = WPConf[1],
814  flatteningFile3Prong = WPConf[2],
815  DecorWPNames = flags.Tau.GNTauDecorWPNames[version],
816  DecorWPCutEffs1P = [0.95, 0.85, 0.75, 0.60],
817  DecorWPCutEffs2P = [0.95, 0.75, 0.60, 0.45],
818  DecorWPCutEffs3P = [0.95, 0.75, 0.60, 0.45],
819  ScoreName = flags.Tau.GNTauScoreName[version],
820  NewScoreName = flags.Tau.GNTauTransScoreName[version],
821  DefineWPs = True)
822  result.setPrivateTools(myTauWPDecorator)
823  return result
824 
826  result = ComponentAccumulator()
827  _name = flags.Tau.ActiveConfig.prefix + 'TauEleRNN'
828 
829  TauJetRNNEvaluator = CompFactory.getComp("TauJetRNNEvaluator")
830  RNNConf = flags.Tau.TauEleRNNConfig
831  myTauEleRNNEvaluator = TauJetRNNEvaluator(name = _name,
832  NetworkFile1P = RNNConf[0],
833  NetworkFile3P = RNNConf[1],
834  OutputVarname = "RNNEleScore",
835  MaxTracks = 10,
836  MaxClusters = 6,
837  MaxClusterDR = 1.0,
838  VertexCorrection = flags.Tau.doVertexCorrection,
839  InputLayerScalar = "scalar",
840  InputLayerTracks = "tracks",
841  InputLayerClusters = "clusters",
842  OutputLayer = "rnneveto_output",
843  OutputNode = "sig_prob")
844 
845  result.setPrivateTools(myTauEleRNNEvaluator)
846  return result
847 
849  import PyUtils.RootUtils as ru
850  ROOT = ru.import_root()
851  import cppyy
852  cppyy.load_library('libxAODTau_cDict')
853 
854  result = ComponentAccumulator()
855  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNN'
856 
857  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
858  WPConf = flags.Tau.TauEleRNNWPConfig
859  myTauEleWPDecorator = TauWPDecorator( name=_name,
860  flatteningFile1Prong = WPConf[0],
861  flatteningFile3Prong = WPConf[1],
862  CutEnumVals =
863  [ ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNLoose,
864  ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNMedium,
865  ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNTight ],
866  SigEff1P = [0.95, 0.90, 0.85],
867  SigEff3P = [0.98, 0.95, 0.90],
868  UseAbsEta = True ,
869  ScoreName = "RNNEleScore",
870  NewScoreName = "RNNEleScoreSigTrans",
871  DefineWPs = True)
872 
873  result.setPrivateTools(myTauEleWPDecorator)
874  return result
875 
877  result = ComponentAccumulator()
878  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNNFix_v1'
879 
880  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
881  WPConf = flags.Tau.TauEleRNNWPfix
882  myTauEleWPDecorator = TauWPDecorator(name = _name,
883  flatteningFile1Prong = WPConf[0],
884  flatteningFile3Prong = WPConf[1],
885  DecorWPNames = [ "EleRNNLoose_v1", "EleRNNMedium_v1", "EleRNNTight_v1" ],
886  DecorWPCutEffs1P = [0.95, 0.90, 0.85],
887  DecorWPCutEffs3P = [0.98, 0.95, 0.90],
888  UseAbsEta = True,
889  ScoreName = "RNNEleScore",
890  NewScoreName = "RNNEleScoreSigTrans_v1",
891  DefineWPs = True)
892 
893  result.setPrivateTools(myTauEleWPDecorator)
894  return result
895 
897  result = ComponentAccumulator()
898  _name = flags.Tau.ActiveConfig.prefix + 'TauDecayModeNNClassifier'
899 
900  TauDecayModeNNClassifier = CompFactory.getComp("TauDecayModeNNClassifier")
901  myTauDecayModeNNClassifier = TauDecayModeNNClassifier(name=_name,
902  WeightFile=flags.Tau.DecayModeNNClassifierConfig)
903 
904  result.setPrivateTools(myTauDecayModeNNClassifier)
905  return result
906 
907 def TauAODSelectorCfg(flags):
908  result = ComponentAccumulator()
909  _name = flags.Tau.ActiveConfig.prefix + 'TauAODSelector'
910 
911  TauAODSelector = CompFactory.getComp("TauAODSelector")
912  myTauAODSelector = TauAODSelector(name=_name,
913  Min0pTauPt = flags.Tau.MinPt0p,
914  MinTauPt = flags.Tau.MinPt,
915  doEarlyStopping = flags.Tau.doEarlyStopping and not flags.Output.doWriteESD)
916 
917  result.setPrivateTools(myTauAODSelector)
918  return result
919 
920 
922 def TauCombinedTESCfg(flags):
923  result = ComponentAccumulator()
924  _name = flags.Tau.ActiveConfig.prefix + 'TauCombinedTES'
925 
926  TauCombinedTES = CompFactory.getComp("TauCombinedTES")
927  myTauCombinedTES = TauCombinedTES(name = _name,
928  WeightFileName = flags.Tau.CombinedTESConfig)
929 
930  result.setPrivateTools(myTauCombinedTES)
931  return result
932 
933 
936  result = ComponentAccumulator()
937  _name = flags.Tau.ActiveConfig.prefix + 'MuonRemoval'
938  TauAODMuonRemovalTool = CompFactory.getComp("TauAODMuonRemovalTool")
939  myMuonRemoval = TauAODMuonRemovalTool( name = _name,
940  Key_MuonInputContainer = 'Muons',
941  doMuonTrkRm = True,
942  doMuonClsRm = True,
943  muonIDWP = 'Medium'
944  )
945  result.setPrivateTools(myMuonRemoval)
946  return result
947 
948 # electron excluder tool
950  result = ComponentAccumulator()
951  _name = flags.Tau.ActiveConfig.prefix + 'TauEleOverlapChecker'
952  TauEleOverlapChecker = CompFactory.getComp("TauEleOverlapChecker")
953  myTauEleOverlapChecker = TauEleOverlapChecker(
954  name = _name,
955  Key_RemovedClustersContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
956  Key_RemovedTracksContainer = flags.Tau.ActiveConfig.RemovedElectronTracks,
957  CheckingCone = flags.Tau.ActiveConfig.EleRM_CheckingConeSize,
958  )
959  result.setPrivateTools(myTauEleOverlapChecker)
960  return result
TauToolHolder.TauDecayModeNNClassifierCfg
def TauDecayModeNNClassifierCfg(flags)
Definition: TauToolHolder.py:896
TauWPDecorator
Implementation of tool to decorate flattened BDT score and working points.
Definition: TauWPDecorator.h:34
TauCommonCalcVars
Calculate variables which rely on tracks and precalculated cell/cluster information.
Definition: TauCommonCalcVars.h:20
TauAODSelector
Definition: TauAODSelector.h:10
TauSubstructureVariables
Calculate variables from the tau substructure.
Definition: TauSubstructureVariables.h:20
python.TrkVertexFittersConfig.TauAdaptiveVertexFitterCfg
def TauAdaptiveVertexFitterCfg(flags, name="TauAdaptiveVertexFitter", **kwargs)
Definition: TrkVertexFittersConfig.py:97
TauToolHolder.TauTrackRNNCfg
def TauTrackRNNCfg(flags)
Definition: TauToolHolder.py:145
TauToolHolder.TauClusterFinderCfg
def TauClusterFinderCfg(flags)
Associate the cluster in jet constituents to the tau candidate.
Definition: TauToolHolder.py:117
SystemOfUnits
TauToolHolder.TauVertexedClusterDecoratorCfg
def TauVertexedClusterDecoratorCfg(flags)
Definition: TauToolHolder.py:133
TauPi0CreateROI
Find the cells used to create pi0 cluster.
Definition: TauPi0CreateROI.h:30
TauToolHolder.TauAODMuonRemovalCfg
def TauAODMuonRemovalCfg(flags)
muon removal tool
Definition: TauToolHolder.py:935
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
TauEleOverlapChecker
Select only the tau within the removal direction.
Definition: TauEleOverlapChecker.h:25
TauToolHolder.Pi0ScoreCalculatorCfg
def Pi0ScoreCalculatorCfg(flags)
calculate MVA scores of pi0 clusters
Definition: TauToolHolder.py:617
TauToolHolder.TauCaloClusterBadChannelCfg
def TauCaloClusterBadChannelCfg(flags)
Definition: TauToolHolder.py:581
TauVertexVariables
Class for calculating vertex variables.
Definition: TauVertexVariables.h:23
python.TrkVertexFitterUtilsConfig.AtlasTrackToVertexIPEstimatorCfg
def AtlasTrackToVertexIPEstimatorCfg(flags, name='AtlasTrackToVertexIPEstimator', **kwargs)
Definition: TrkVertexFitterUtilsConfig.py:63
python.BeamSpotConditionsConfig.BeamSpotCondAlgCfg
def BeamSpotCondAlgCfg(flags, name="BeamSpotCondAlg", **kwargs)
Definition: BeamSpotConditionsConfig.py:7
TauToolHolder.MvaTESEvaluatorCfg
def MvaTESEvaluatorCfg(flags)
MvaTESEvaluator.
Definition: TauToolHolder.py:701
TauToolHolder.TauEleRNNEvaluatorCfg
def TauEleRNNEvaluatorCfg(flags)
Definition: TauToolHolder.py:825
CaloCellContainerFinalizerTool
Definition: CaloCellContainerFinalizerTool.h:20
TauToolHolder.TauAxisCfg
def TauAxisCfg(flags)
Tau energy calibration and tau axis direction.
Definition: TauToolHolder.py:57
python.InDetTrackSelectorToolConfig.TauRecInDetTrackSelectorToolCfg
def TauRecInDetTrackSelectorToolCfg(flags, name='tauRec_InDetTrackSelectorTool', **kwargs)
Definition: InDetTrackSelectorToolConfig.py:197
TauCombinedTES
Definition: TauCombinedTES.h:19
TauToolHolder.TauCaloDMCalibCfg
def TauCaloDMCalibCfg(flags)
Definition: TauToolHolder.py:429
TrackVertexAssociationToolConfig.TauTTVAToolCfg
def TauTTVAToolCfg(flags, name="TVATool", **kwargs)
Definition: TrackVertexAssociationToolConfig.py:42
TauToolHolder.TauTrackRNNClassifierCfg
def TauTrackRNNClassifierCfg(flags)
Definition: TauToolHolder.py:158
TauToolHolder.TauJetRNNEvaluatorCfg
def TauJetRNNEvaluatorCfg(flags)
Definition: TauToolHolder.py:724
CaloClusterLocalCalib
Cluster correction tool which applies local hadronic calibration w eights to the cells....
Definition: CaloClusterLocalCalib.h:32
TauToolHolder.TauCaloTopoClusterSplitterCfg
def TauCaloTopoClusterSplitterCfg(flags)
Definition: TauToolHolder.py:517
TauToolHolder.Pi0ClusterCreatorCfg
def Pi0ClusterCreatorCfg(flags)
create Pi0 clusters
Definition: TauToolHolder.py:593
CaloTopoClusterSplitter
topological cluster splitter.
Definition: CaloTopoClusterSplitter.h:48
StandardCellWeightCalib.editParm
def editParm(param)
Definition: StandardCellWeightCalib.py:14
TauToolHolder.MvaTESVariableDecoratorCfg
def MvaTESVariableDecoratorCfg(flags)
MvaTESVariableDecorator.
Definition: TauToolHolder.py:687
TauPi0ClusterCreator
Creates Pi0 clusters (Pi0 Finder).
Definition: TauPi0ClusterCreator.h:28
CaloClusterBadChannelListCorr
Definition: CaloClusterBadChannelListCorr.py:1
TauToolHolder.TauCaloLCClassificationCfg
def TauCaloLCClassificationCfg(flags)
Calo Tools.
Definition: TauToolHolder.py:325
H1WeightToolCSC12Generic
Definition: H1WeightToolCSC12Generic.h:28
TauToolHolder.TauCaloClusterMomentsMakerCfg
def TauCaloClusterMomentsMakerCfg(flags)
Definition: TauToolHolder.py:541
TauToolHolder.ElectronVetoVarsCfg
def ElectronVetoVarsCfg(flags)
ele veto variables
Definition: TauToolHolder.py:208
TauToolHolder.CellWeightToolCfg
def CellWeightToolCfg(flags)
cell weight tool
Definition: TauToolHolder.py:225
TauCalibrateLC
Implementation of tau energy scale (TES) with eta and pile-up correction.
Definition: TauCalibrateLC.h:24
TauToolHolder.TauCaloTopoClusterMakerCfg
def TauCaloTopoClusterMakerCfg(flags)
Definition: TauToolHolder.py:471
TauToolHolder.TauGNNEvaluatorCfg
def TauGNNEvaluatorCfg(flags, version=0)
Definition: TauToolHolder.py:779
StandardCellWeightCalib.getCellWeightTool
def getCellWeightTool(flags, finder="Cone", mainparam=0.4, input="Topo", onlyCellWeight=False)
Definition: StandardCellWeightCalib.py:178
MvaTESVariableDecorator
Definition: MvaTESVariableDecorator.h:15
TauPi0ScoreCalculator
Selectes pi0Candidates (Pi0 Finder).
Definition: TauPi0ScoreCalculator.h:24
TauToolHolder.getParticleCache
def getParticleCache(flags)
Definition: TauToolHolder.py:71
TauToolHolder.TauEleOverlapChecker
def TauEleOverlapChecker(flags)
Definition: TauToolHolder.py:949
TauToolHolder.TauSubstructureCfg
def TauSubstructureCfg(flags)
Tau Variables.
Definition: TauToolHolder.py:675
TauVertexedClusterDecorator
Decorate CaloVertexedTopoCluster to the tau candidate.
Definition: TauVertexedClusterDecorator.h:18
TauAxisSetter
Set Tau "Detector Axis" and "Intermediate Axis".
Definition: TauAxisSetter.h:28
python.CaloNoiseCondAlgConfig.CaloNoiseCondAlgCfg
def CaloNoiseCondAlgCfg(flags, noisetype="totalNoise")
Definition: CaloNoiseCondAlgConfig.py:11
CaloLCWeightTool
calculates hadronic cell weights based on cluster and cell quantities
Definition: CaloLCWeightTool.h:34
TauToolHolder.TauVertexFinderCfg
def TauVertexFinderCfg(flags)
Definition: TauToolHolder.py:32
TauPi0ClusterScaler
scale cluster energy to take care of charged pion energy
Definition: TauPi0ClusterScaler.h:22
TauDecayModeNNClassifier
Tau decay mode classifier using a neural network.
Definition: TauDecayModeNNClassifier.h:33
TauToolHolder.TauCaloOOCCalibCfg
def TauCaloOOCCalibCfg(flags)
Definition: TauToolHolder.py:416
TauToolHolder.TauCaloLCDeadMaterialCfg
def TauCaloLCDeadMaterialCfg(flags)
Definition: TauToolHolder.py:387
python.IOVDbSvcConfig.addFolders
def addFolders(flags, folderStrings, detDb=None, className=None, extensible=False, tag=None, db=None, modifiers='')
Definition: IOVDbSvcConfig.py:72
TauToolHolder.TauCaloOOCPi0CalibCfg
def TauCaloOOCPi0CalibCfg(flags)
Definition: TauToolHolder.py:442
TauPi0Selector
Apply Et and BDT score cut to pi0s.
Definition: TauPi0Selector.h:20
python.InDetTrackSelectionToolConfig.Tau_InDetTrackSelectionToolForTJVACfg
def Tau_InDetTrackSelectionToolForTJVACfg(flags, name="tauRec_InDetTrackSelectionToolForTJVA", **kwargs)
Definition: InDetTrackSelectionToolConfig.py:162
TauIDVarCalculator
This class implements a tool to calculate ID input variables and add them to the tau aux store.
Definition: TauIDVarCalculator.h:18
TauToolHolder.Pi0SelectorCfg
def Pi0SelectorCfg(flags)
select pi0 clusters
Definition: TauToolHolder.py:630
TauToolHolder.TauVertexVariablesCfg
def TauVertexVariablesCfg(flags)
Tau Vertex Variables.
Definition: TauToolHolder.py:645
TauToolHolder.CellVariablesCfg
def CellVariablesCfg(flags)
Tau cell variables calculation.
Definition: TauToolHolder.py:195
TauToolHolder.EnergyCalibrationLCCfg
def EnergyCalibrationLCCfg(flags)
Tau energy calibration.
Definition: TauToolHolder.py:181
TauElectronVetoVariables
Calculate variables sensitive on electrons.
Definition: TauElectronVetoVariables.h:27
TauToolHolder.TauWPDecoratorGNNCfg
def TauWPDecoratorGNNCfg(flags, version)
Definition: TauToolHolder.py:805
TauCellVariables
Calculate tau calorimeter variables from cell information.
Definition: TauCellVariables.h:16
CaloLCClassificationTool
classify clusters according to their probability to stem from an em object
Definition: CaloLCClassificationTool.h:29
TauToolHolder.TauAODSelectorCfg
def TauAODSelectorCfg(flags)
Definition: TauToolHolder.py:907
TauToolHolder.TauCaloLCOutPi0Cfg
def TauCaloLCOutPi0Cfg(flags)
Definition: TauToolHolder.py:374
TauToolHolder.TauCaloClusterLocalCalibCfg
def TauCaloClusterLocalCalibCfg(flags)
Definition: TauToolHolder.py:402
TauVertexFinder
Associate a vertex (origin) to the tau candidate.
Definition: TauVertexFinder.h:29
CaloLCOutOfClusterTool
calculates out-of-cluster corrections based on cluster quantities
Definition: CaloLCOutOfClusterTool.h:28
JetSeedBuilder
Class to build tau jet seed.
Definition: JetSeedBuilder.h:17
TauTrackFinder
Associate tracks to the tau candidate.
Definition: TauTrackFinder.h:39
TauAODMuonRemovalTool
the tool meant to run at AOD level, to remove the muon found inside the TauJet.
Definition: TauAODMuonRemovalTool.h:21
TauToolHolder.JetSeedBuilderCfg
def JetSeedBuilderCfg(flags)
JetSeedBuilder.
Definition: TauToolHolder.py:21
TauToolHolder.TauCaloClusterCellWeightCalibCfg
def TauCaloClusterCellWeightCalibCfg(flags)
Definition: TauToolHolder.py:455
TauToolHolder.TauWPDecoratorEleRNNCfg
def TauWPDecoratorEleRNNCfg(flags)
Definition: TauToolHolder.py:848
TauToolHolder.TauCombinedTESCfg
def TauCombinedTESCfg(flags)
TauCombinedTES.
Definition: TauToolHolder.py:922
CaloClusterMomentsMaker
Calculate moments for CaloCluster objects.
Definition: CaloClusterMomentsMaker.h:50
TauToolHolder.TauCellFinalizerCfg
def TauCellFinalizerCfg(flags)
Cell finalizer tool for BuildAlg.
Definition: TauToolHolder.py:311
TauToolHolder.TauCommonCalcVarsCfg
def TauCommonCalcVarsCfg(flags)
Tau Variables.
Definition: TauToolHolder.py:663
TauClusterFinder
Associate the clusters used in the seed jet to the tau candidate.
Definition: TauClusterFinder.h:21
TauGNNEvaluator
Tool to calculate tau identification score from .onnx inputs.
Definition: TauGNNEvaluator.h:26
TauToolHolder.TauWPDecoratorEleRNNFixCfg
def TauWPDecoratorEleRNNFixCfg(flags)
Definition: TauToolHolder.py:876
TauToolHolder.TauCaloLCWeightCfg
def TauCaloLCWeightCfg(flags)
Definition: TauToolHolder.py:342
TrackToVertexConfig.TrackToVertexCfg
def TrackToVertexCfg(flags, name="AtlasTrackToVertexTool", **kwargs)
Definition: TrackToVertexConfig.py:6
CaloClusterCellWeightCalib
Definition: CaloClusterCellWeightCalib.h:17
MvaTESEvaluator
Definition: MvaTESEvaluator.h:16
TauToolHolder.TauShotFinderCfg
def TauShotFinderCfg(flags)
Photon Shot Finder.
Definition: TauToolHolder.py:262
str
Definition: BTagTrackIpAccessor.cxx:11
TauToolHolder.Pi0ClusterScalerCfg
def Pi0ClusterScalerCfg(flags)
Set energy of cluster to take care of charged pion energy deposited in the ECAL.
Definition: TauToolHolder.py:605
TauShotFinder
Definition: TauShotFinder.h:30
python.TrkVertexSeedFinderToolsConfig.CrossDistancesSeedFinderCfg
def CrossDistancesSeedFinderCfg(flags, name="CrossDistancesSeedFinder", **kwargs)
Definition: TrkVertexSeedFinderToolsConfig.py:33
CaloLCDeadMaterialTool
dead material correction tool for local hadronic calibration
Definition: CaloLCDeadMaterialTool.h:40
TauToolHolder.TauCaloLCOutOfClusterCfg
def TauCaloLCOutOfClusterCfg(flags)
Definition: TauToolHolder.py:361
TauToolHolder.TauTrackFinderCfg
def TauTrackFinderCfg(flags)
Tau-Track Association.
Definition: TauToolHolder.py:82
TauToolHolder.TauWPDecoratorJetRNNCfg
def TauWPDecoratorJetRNNCfg(flags)
Definition: TauToolHolder.py:749
TauToolHolder.Pi0ClusterFinderCfg
def Pi0ClusterFinderCfg(flags)
Pi0 algo Cluster finder for Pi0 algo.
Definition: TauToolHolder.py:292
TauJetRNNEvaluator
Tool to calculate a tau identification score based on neural networks.
Definition: TauJetRNNEvaluator.h:27
TauToolHolder.TauIDVarCalculatorCfg
def TauIDVarCalculatorCfg(flags)
Definition: TauToolHolder.py:713
CaloTopoClusterMaker
topological cluster maker.
Definition: CaloTopoClusterMaker.h:48
TrackToCaloConfig.ParticleCaloExtensionToolCfg
def ParticleCaloExtensionToolCfg(flags, name='ParticleCaloExtensionTool', **kwargs)
Definition: TrackToCaloConfig.py:10