Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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, 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 TauShotFinderCfg(flags):
226  result = ComponentAccumulator()
227  _name = flags.Tau.ActiveConfig.prefix + 'TauShotFinder'
228 
229  shotPtCut_1Photon = flags.Tau.shotPtCut_1Photon
230  shotPtCut_2Photons = flags.Tau.shotPtCut_2Photons
231 
232 
233  from CaloClusterCorrection.StandardCellWeightCalib import getCellWeightTool
234  CaloWeightTool = getCellWeightTool(flags=flags)
235 
236 
237  TauShotFinder = CompFactory.getComp("TauShotFinder")
238  TauShotFinder = TauShotFinder(
239  name = _name,
240  CaloWeightTool = result.popToolsAndMerge(CaloWeightTool),
241  NCellsInEta = 5,
242  MinPtCut = shotPtCut_1Photon,
243  AutoDoubleShotCut = shotPtCut_2Photons,
244  Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
245  RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
246  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
247  )
248 
249  result.setPrivateTools(TauShotFinder)
250  return result
251 
252 
256  result = ComponentAccumulator()
257  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterFinder'
258 
259  TauPi0CreateROI = CompFactory.getComp("TauPi0CreateROI")
260 
261  myTauPi0CreateROI = TauPi0CreateROI(
262  name = _name,
263  Key_caloCellInputContainer = "AllCalo",
264  Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
265  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
266  RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
267  )
268 
269  result.setPrivateTools(myTauPi0CreateROI)
270  return result
271 
272 
275  result = ComponentAccumulator()
276  _name = flags.Tau.ActiveConfig.prefix + 'tauPi0CellContainerFinalizer'
277 
278  CaloCellContainerFinalizerTool = CompFactory.getComp("CaloCellContainerFinalizerTool")
279  TauCellContainerFinalizer = CaloCellContainerFinalizerTool(name=_name)
280 
281  result.setPrivateTools(TauCellContainerFinalizer)
282  return result
283 
284 
287 
289  result = ComponentAccumulator()
290  _name = flags.Tau.ActiveConfig.prefix + 'LCClassify'
291 
292  CaloLCClassificationTool = CompFactory.getComp("CaloLCClassificationTool")
293  LCClassify = CaloLCClassificationTool(_name)
294  LCClassify.ClassificationKey = "EMFracClassify"
295  LCClassify.UseSpread = False
296  LCClassify.MaxProbability = 0.5
297  # add the moments EM_PROBABILITY, HAD_WEIGHT, OOC_WEIGHT, DM_WEIGHT to the AOD:
298  LCClassify.StoreClassificationProbabilityInAOD = True
299  LCClassify.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
300  LCClassify.UseNormalizedEnergyDensity = True
301 
302  result.setPrivateTools(LCClassify)
303  return result
304 
306  result = ComponentAccumulator()
307  _name = flags.Tau.ActiveConfig.prefix + 'CaloLCWeightTool'
308 
309  # Schedule total noise cond alg
310  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
311  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
312  # Schedule electronic noise cond alg (needed for LC weights)
313  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
314 
315  CaloLCWeightTool = CompFactory.getComp("CaloLCWeightTool")
316  LCWeight = CaloLCWeightTool(_name)
317  LCWeight.CorrectionKey = "H1ClusterCellWeights"
318  LCWeight.SignalOverNoiseCut = 2.0
319  LCWeight.UseHadProbability = True
320 
321  result.setPrivateTools(LCWeight)
322  return result
323 
325  result = ComponentAccumulator()
326  _name = flags.Tau.ActiveConfig.prefix + 'CaloLCOutOfClusterTool'
327 
328  CaloLCOutOfClusterTool = CompFactory.getComp("CaloLCOutOfClusterTool")
329  LCOut = CaloLCOutOfClusterTool(_name)
330  LCOut.CorrectionKey = "OOCCorrection"
331  LCOut.UseEmProbability = False
332  LCOut.UseHadProbability = True
333 
334  result.setPrivateTools(LCOut)
335  return result
336 
338  result = ComponentAccumulator()
339  _name = flags.Tau.ActiveConfig.prefix + 'LCOutPi0'
340 
341  CaloLCOutOfClusterTool = CompFactory.getComp("CaloLCOutOfClusterTool")
342  LCOutPi0 = CaloLCOutOfClusterTool(_name)
343  LCOutPi0.CorrectionKey = "OOCPi0Correction"
344  LCOutPi0.UseEmProbability = True
345  LCOutPi0.UseHadProbability = False
346 
347  result.setPrivateTools(LCOutPi0)
348  return result
349 
351  result = ComponentAccumulator()
352  _name = flags.Tau.ActiveConfig.prefix + 'CaloLCDeadMaterialTool'
353 
354  CaloLCDeadMaterialTool = CompFactory.getComp("CaloLCDeadMaterialTool")
355  LCDeadMaterial = CaloLCDeadMaterialTool(_name)
356  LCDeadMaterial.HadDMCoeffKey = "HadDMCoeff2"
357  LCDeadMaterial.ClusterRecoStatus = 0
358  LCDeadMaterial.WeightModeDM = 2
359  LCDeadMaterial.UseHadProbability = True
360  LCDeadMaterial.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
361 
362  result.setPrivateTools(LCDeadMaterial)
363  return result
364 
366  result = ComponentAccumulator()
367  _name = flags.Tau.ActiveConfig.prefix + 'CaloLocalCalib'
368 
369  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
370  LocalCalib = CaloClusterLocalCalib(_name)
371  LocalCalib.ClusterClassificationTool = [result.popToolsAndMerge(TauCaloLCClassificationCfg(flags))]
372  LocalCalib.ClusterRecoStatus = [1,2]
373  LocalCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCWeightCfg(flags))]
374  LocalCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
375 
376  result.setPrivateTools(LocalCalib)
377  return result
378 
380  result = ComponentAccumulator()
381  _name = flags.Tau.ActiveConfig.prefix + 'OOCCalibTool'
382 
383  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
384  OOCCalib = CaloClusterLocalCalib (_name)
385  OOCCalib.ClusterRecoStatus = [1,2]
386  OOCCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCOutOfClusterCfg(flags))]
387  OOCCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
388 
389  result.setPrivateTools(OOCCalib)
390  return result
391 
392 def TauCaloDMCalibCfg(flags):
393  result = ComponentAccumulator()
394  _name = flags.Tau.ActiveConfig.prefix + 'DMCalib'
395 
396  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
397  DMCalib = CaloClusterLocalCalib(_name)
398  DMCalib.ClusterRecoStatus = [1,2]
399  DMCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCDeadMaterialCfg(flags))]
400  DMCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
401 
402  result.setPrivateTools(DMCalib)
403  return result
404 
406  result = ComponentAccumulator()
407  _name = flags.Tau.ActiveConfig.prefix + 'OOCPi0CalibTool'
408 
409  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
410  OOCPi0Calib = CaloClusterLocalCalib (_name)
411  OOCPi0Calib.ClusterRecoStatus = [1,2]
412  OOCPi0Calib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCOutPi0Cfg(flags))]
413  OOCPi0Calib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
414 
415  result.setPrivateTools(OOCPi0Calib)
416  return result
417 
419  result = ComponentAccumulator()
420  _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoClusterMaker'
421 
422  # Schedule total noise cond alg
423  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
424  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
425  # Schedule electronic noise cond alg (needed for LC weights)
426  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
427 
428  CaloTopoClusterMaker = CompFactory.getComp("CaloTopoClusterMaker")
429  TopoClusterForTaus = CaloTopoClusterMaker(_name)
430 
431  TopoClusterForTaus.CellsName = flags.Tau.ActiveConfig.TauCommonPi0Cells
432  TopoClusterForTaus.CalorimeterNames=["LAREM"]
433  TopoClusterForTaus.SeedSamplingNames = ["PreSamplerB", "EMB1", "EMB2", "PreSamplerE", "EME1", "EME2"]
434  TopoClusterForTaus.NeighborOption = "super3D"
435  TopoClusterForTaus.RestrictHECIWandFCalNeighbors = False
436  TopoClusterForTaus.RestrictPSNeighbors = True
437  TopoClusterForTaus.CellThresholdOnEorAbsEinSigma = 0.0
438  TopoClusterForTaus.NeighborThresholdOnEorAbsEinSigma = 2.0
439  TopoClusterForTaus.SeedThresholdOnEorAbsEinSigma = 4.0
440  TopoClusterForTaus.SeedCutsInAbsE = True
441  TopoClusterForTaus.ClusterCutsInAbsEt = True
442  TopoClusterForTaus.ClusterEtorAbsEtCut = 0.5*GeV # 0.0*MeV in standard CaloCalTopoCluster JobOptions!
443  TopoClusterForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
444  # timing cut on seed cell to suppress out-of-time pileup
445  TopoClusterForTaus.SeedCutsInT = flags.Calo.TopoCluster.doTimeCut
446  TopoClusterForTaus.CutOOTseed = flags.Calo.TopoCluster.extendTimeCut and flags.Calo.TopoCluster.doTimeCut
447  TopoClusterForTaus.UseTimeCutUpperLimit = flags.Calo.TopoCluster.useUpperLimitForTimeCut
448  TopoClusterForTaus.TimeCutUpperLimit = flags.Calo.TopoCluster.timeCutUpperLimit
449  TopoClusterForTaus.XTalkEM2 = flags.Calo.TopoCluster.xtalkEM2
450  TopoClusterForTaus.XTalkEM2D = flags.Calo.TopoCluster.xtalkEM2D
451  TopoClusterForTaus.XTalkEM2n = flags.Calo.TopoCluster.xtalkEM2n
452  TopoClusterForTaus.XTalkEM3 = flags.Calo.TopoCluster.xtalkEM3
453  TopoClusterForTaus.XTalkEMEta = flags.Calo.TopoCluster.xtalkEMEta
454  TopoClusterForTaus.XTalkDeltaT = flags.Calo.TopoCluster.xtalkDeltaT
455  TopoClusterForTaus.XTalk2Eratio1 = flags.Calo.TopoCluster.xtalk2Eratio1
456  TopoClusterForTaus.XTalk2Eratio2 = flags.Calo.TopoCluster.xtalk2Eratio2
457  TopoClusterForTaus.XTalk3Eratio = flags.Calo.TopoCluster.xtalk3Eratio
458  TopoClusterForTaus.XTalkEtaEratio = flags.Calo.TopoCluster.xtalkEtaEratio
459  TopoClusterForTaus.XTalk2DEratio = flags.Calo.TopoCluster.xtalk2DEratio
460 
461  result.setPrivateTools(TopoClusterForTaus)
462  return result
463 
465 
466  result = ComponentAccumulator()
467  _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoClusterSplitter'
468 
469  CaloTopoClusterSplitter = CompFactory.getComp("CaloTopoClusterSplitter")
470  TopoSplitterForTaus = CaloTopoClusterSplitter(_name)
471 
472  # cells from the following samplings will be able to form local
473  # maxima. The excluded samplings are PreSamplerB, EMB1,
474  # PreSamplerE, EME1, all Tile samplings, all HEC samplings and the
475  # two rear FCal samplings.
476  TopoSplitterForTaus.SamplingNames = ["EMB2","EME2"] # Do we want to use EMB3 and EME3?
477  # cells from the following samplings will also be able to form
478  # local maxima but only if they are not overlapping in eta and phi
479  # with local maxima in previous samplings from the primary list.
480  TopoSplitterForTaus.SecondarySamplingNames = ["EMB1","EME1"]
481  TopoSplitterForTaus.ShareBorderCells = True
482  TopoSplitterForTaus.RestrictHECIWandFCalNeighbors = False
483  TopoSplitterForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
484 
485  result.setPrivateTools(TopoSplitterForTaus)
486  return result
487 
489  result = ComponentAccumulator()
490  _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoMoments'
491 
492  # Schedule total noise cond alg
493  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
494  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
495  # Schedule electronic noise cond alg (needed for LC weights)
496  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
497 
498  CaloClusterMomentsMaker = CompFactory.getComp("CaloClusterMomentsMaker")
499  TopoMomentsForTaus = CaloClusterMomentsMaker(_name)
500  TopoMomentsForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
501  TopoMomentsForTaus.MaxAxisAngle = 20*deg
502  TopoMomentsForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
503  TopoMomentsForTaus.MinBadLArQuality = 4000
504  TopoMomentsForTaus.MomentsNames = ["FIRST_PHI"
505  ,"FIRST_ETA"
506  ,"SECOND_R"
507  ,"SECOND_LAMBDA"
508  ,"DELTA_PHI"
509  ,"DELTA_THETA"
510  ,"DELTA_ALPHA"
511  ,"CENTER_X"
512  ,"CENTER_Y"
513  ,"CENTER_Z"
514  ,"CENTER_MAG"
515  ,"CENTER_LAMBDA"
516  ,"LATERAL"
517  ,"LONGITUDINAL"
518  ,"ENG_FRAC_EM"
519  ,"ENG_FRAC_MAX"
520  ,"ENG_FRAC_CORE"
521  ,"FIRST_ENG_DENS"
522  ,"SECOND_ENG_DENS"
523  ,"ISOLATION"]
524 
525  result.setPrivateTools(TopoMomentsForTaus)
526  return result
527 
529  result = ComponentAccumulator()
530  _name = flags.Tau.ActiveConfig.prefix + 'CaloClusterBadChannelList'
531 
532  CaloClusterBadChannelListCorr = CompFactory.getComp("CaloClusterBadChannelList")
533  BadChannelListCorrForTaus = CaloClusterBadChannelListCorr(_name)
534 
535  result.setPrivateTools(BadChannelListCorrForTaus)
536  return result
537 
538 
541  result = ComponentAccumulator()
542  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterCreator'
543 
544  TauPi0ClusterCreator = CompFactory.getComp("TauPi0ClusterCreator")
545  TauPi0ClusterCreator = TauPi0ClusterCreator(name = _name)
546 
547  result.setPrivateTools(TauPi0ClusterCreator)
548  return result
549 
550 
553  result = ComponentAccumulator()
554  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterScaler'
555 
556  TauPi0ClusterScaler = CompFactory.getComp("TauPi0ClusterScaler")
557  TauPi0ClusterScaler = TauPi0ClusterScaler(name = _name)
558 
559  result.setPrivateTools(TauPi0ClusterScaler)
560  return result
561 
562 
565  result = ComponentAccumulator()
566  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ScoreCalculator'
567 
568  TauPi0ScoreCalculator = CompFactory.getComp("TauPi0ScoreCalculator")
569  TauPi0ScoreCalculator = TauPi0ScoreCalculator(name = _name,
570  BDTWeightFile = flags.Tau.Pi0ScoreConfig)
571 
572  result.setPrivateTools(TauPi0ScoreCalculator)
573  return result
574 
575 
577 def Pi0SelectorCfg(flags):
578  result = ComponentAccumulator()
579  _name = flags.Tau.ActiveConfig.prefix + 'Pi0Selector'
580 
581  TauPi0Selector = CompFactory.getComp("TauPi0Selector")
582  TauPi0Selector = TauPi0Selector(name = _name,
583  ClusterEtCut = flags.Tau.pi0EtCuts,
584  ClusterBDTCut_1prong = flags.Tau.pi0MVACuts_1prong,
585  ClusterBDTCut_mprong = flags.Tau.pi0MVACuts_mprong)
586 
587  result.setPrivateTools(TauPi0Selector)
588  return result
589 
590 
593  result = ComponentAccumulator()
594  _name = flags.Tau.ActiveConfig.prefix + 'TauVertexVariables'
595 
596  from TrkConfig.TrkVertexFittersConfig import TauAdaptiveVertexFitterCfg
597  from TrkConfig.TrkVertexSeedFinderToolsConfig import (
598  CrossDistancesSeedFinderCfg)
599 
600  TauVertexVariables = CompFactory.getComp("TauVertexVariables")
601  TauVertexVariables = TauVertexVariables( name = _name,
602  VertexFitter = result.popToolsAndMerge(TauAdaptiveVertexFitterCfg(flags)),
603  SeedFinder = result.popToolsAndMerge(CrossDistancesSeedFinderCfg(flags)) )
604 
605  result.setPrivateTools(TauVertexVariables)
606  return result
607 
608 
611  result = ComponentAccumulator()
612  _name = flags.Tau.ActiveConfig.prefix + 'TauCommonCalcVars'
613 
614  TauCommonCalcVars = CompFactory.getComp("TauCommonCalcVars")
615  TauCommonCalcVars = TauCommonCalcVars(name = _name)
616 
617  result.setPrivateTools(TauCommonCalcVars)
618  return result
619 
620 
623  result = ComponentAccumulator()
624  _name = flags.Tau.ActiveConfig.prefix + 'TauSubstructure'
625 
626  TauSubstructureVariables = CompFactory.getComp("TauSubstructureVariables")
627  TauSubstructureVariables = TauSubstructureVariables( name = _name )
628 
629  result.setPrivateTools(TauSubstructureVariables)
630  return result
631 
632 
635  result = ComponentAccumulator()
636  _name = flags.Tau.ActiveConfig.prefix + 'MvaTESVariableDecorator'
637 
638  eventShapeCollection = flags.Tau.ActiveConfig.EventShapeCollection
639  if 'EMPFlow' in flags.Tau.ActiveConfig.SeedJetCollection:
640  eventShapeCollection = "Kt4EMPFlowEventShape"
641  elif 'EMTopo' in flags.Tau.ActiveConfig.SeedJetCollection:
642  eventShapeCollection ="Kt4EMTopoOriginEventShape"
643 
644  MvaTESVariableDecorator = CompFactory.getComp("MvaTESVariableDecorator")
645  MvaTESVariableDecorator = MvaTESVariableDecorator(name = _name,
646  Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
647  EventShapeKey = eventShapeCollection,
648  VertexCorrection = flags.Tau.doVertexCorrection)
649  result.setPrivateTools(MvaTESVariableDecorator)
650  return result
651 
652 
655  result = ComponentAccumulator()
656  _name = flags.Tau.ActiveConfig.prefix + 'MvaTESEvaluator'
657 
658  MvaTESEvaluator = CompFactory.getComp("MvaTESEvaluator")
659  MvaTESEvaluator = MvaTESEvaluator(name = _name,
660  WeightFileName = flags.Tau.MvaTESConfig,
661  WeightFileName0p = flags.Tau.MvaTESConfig0p )
662 
663  result.setPrivateTools(MvaTESEvaluator)
664  return result
665 
667  result = ComponentAccumulator()
668  _name = flags.Tau.ActiveConfig.prefix + 'TauIDVarCalculator'
669 
670  TauIDVarCalculator = CompFactory.getComp("TauIDVarCalculator")
671  myTauIDVarCalculator = TauIDVarCalculator(name=_name,
672  VertexCorrection = flags.Tau.doVertexCorrection)
673 
674  result.setPrivateTools(myTauIDVarCalculator)
675  return result
676 
678  result = ComponentAccumulator()
679  _name = flags.Tau.ActiveConfig.prefix + 'TauJetRNN'
680 
681  TauJetRNNEvaluator = CompFactory.getComp("TauJetRNNEvaluator")
682  RNNConf = flags.Tau.TauJetRNNConfig
683  myTauJetRNNEvaluator = TauJetRNNEvaluator(name = _name,
684  NetworkFile0P = "",
685  NetworkFile1P = RNNConf[0],
686  NetworkFile2P = RNNConf[1],
687  NetworkFile3P = RNNConf[2],
688  OutputVarname = "RNNJetScore",
689  MaxTracks = 10,
690  MaxClusters = 6,
691  MaxClusterDR = 1.0,
692  VertexCorrection = flags.Tau.doVertexCorrection,
693  InputLayerScalar = "scalar",
694  InputLayerTracks = "tracks",
695  InputLayerClusters = "clusters",
696  OutputLayer = "rnnid_output",
697  OutputNode = "sig_prob")
698 
699  result.setPrivateTools(myTauJetRNNEvaluator)
700  return result
701 
703  import PyUtils.RootUtils as ru
704  ROOT = ru.import_root()
705  import cppyy
706  cppyy.load_library('libxAODTau_cDict')
707 
708  result = ComponentAccumulator()
709  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorJetRNN'
710 
711  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
712  WPConf = flags.Tau.TauJetRNNWPConfig
713  myTauWPDecorator = TauWPDecorator( name=_name,
714  flatteningFile1Prong = WPConf[0],
715  flatteningFile2Prong = WPConf[1],
716  flatteningFile3Prong = WPConf[2],
717  CutEnumVals =
718  [ ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigVeryLoose,
719  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigLoose,
720  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigMedium,
721  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigTight ],
722  SigEff1P = [0.95, 0.85, 0.75, 0.60],
723  SigEff2P = [0.95, 0.75, 0.60, 0.45],
724  SigEff3P = [0.95, 0.75, 0.60, 0.45],
725  ScoreName = "RNNJetScore",
726  NewScoreName = "RNNJetScoreSigTrans",
727  DefineWPs = True )
728 
729  result.setPrivateTools(myTauWPDecorator)
730  return result
731 
732 def TauGNNEvaluatorCfg(flags, version=0):
733  result = ComponentAccumulator()
734  _name = flags.Tau.ActiveConfig.prefix + 'TauGNN_v' + str(version)
735 
736  TauGNNEvaluator = CompFactory.getComp("TauGNNEvaluator")
737  GNNConf = flags.Tau.TauGNNConfig[version]
738  myTauGNNEvaluator = TauGNNEvaluator(name = _name,
739  NetworkFileInclusive = GNNConf,
740  OutputVarname = flags.Tau.GNTauScoreName[version],
741  OutputPTau = "GNTauProbTau",
742  OutputPJet = "GNTauProbJet",
743  MaxTracks = flags.Tau.GNTauMaxTracks[version],
744  MaxClusters = flags.Tau.GNTauMaxClusters[version],
745  MaxClusterDR = 15.0,
746  MinTauPt = flags.Tau.MinPtDAOD,
747  VertexCorrection = flags.Tau.doVertexCorrection,
748  DecorateTracks = False,
749  InputLayerScalar = "tau_vars",
750  InputLayerTracks = "track_vars",
751  InputLayerClusters = "cluster_vars",
752  NodeNameTau=flags.Tau.GNTauNodeNameTau,
753  NodeNameJet=flags.Tau.GNTauNodeNameJet)
754 
755  result.setPrivateTools(myTauGNNEvaluator)
756  return result
757 
758 def TauWPDecoratorGNNCfg(flags, version):
759  result = ComponentAccumulator()
760  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorGNN_v' + str(version)
761 
762  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
763  WPConf = flags.Tau.TauGNNWP[version]
764  myTauWPDecorator = TauWPDecorator(name=_name,
765  flatteningFile1Prong = WPConf[0],
766  flatteningFile2Prong = WPConf[1],
767  flatteningFile3Prong = WPConf[2],
768  DecorWPNames = flags.Tau.GNTauDecorWPNames[version],
769  DecorWPCutEffs1P = [0.95, 0.85, 0.75, 0.60],
770  DecorWPCutEffs2P = [0.95, 0.75, 0.60, 0.45],
771  DecorWPCutEffs3P = [0.95, 0.75, 0.60, 0.45],
772  ScoreName = flags.Tau.GNTauScoreName[version],
773  NewScoreName = flags.Tau.GNTauTransScoreName[version],
774  DefineWPs = True)
775  result.setPrivateTools(myTauWPDecorator)
776  return result
777 
779  result = ComponentAccumulator()
780  _name = flags.Tau.ActiveConfig.prefix + 'TauEleRNN'
781 
782  TauJetRNNEvaluator = CompFactory.getComp("TauJetRNNEvaluator")
783  RNNConf = flags.Tau.TauEleRNNConfig
784  myTauEleRNNEvaluator = TauJetRNNEvaluator(name = _name,
785  NetworkFile1P = RNNConf[0],
786  NetworkFile3P = RNNConf[1],
787  OutputVarname = "RNNEleScore",
788  MaxTracks = 10,
789  MaxClusters = 6,
790  MaxClusterDR = 1.0,
791  VertexCorrection = flags.Tau.doVertexCorrection,
792  InputLayerScalar = "scalar",
793  InputLayerTracks = "tracks",
794  InputLayerClusters = "clusters",
795  OutputLayer = "rnneveto_output",
796  OutputNode = "sig_prob")
797 
798  result.setPrivateTools(myTauEleRNNEvaluator)
799  return result
800 
802  import PyUtils.RootUtils as ru
803  ROOT = ru.import_root()
804  import cppyy
805  cppyy.load_library('libxAODTau_cDict')
806 
807  result = ComponentAccumulator()
808  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNN'
809 
810  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
811  WPConf = flags.Tau.TauEleRNNWPConfig
812  myTauEleWPDecorator = TauWPDecorator( name=_name,
813  flatteningFile1Prong = WPConf[0],
814  flatteningFile3Prong = WPConf[1],
815  CutEnumVals =
816  [ ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNLoose,
817  ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNMedium,
818  ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNTight ],
819  SigEff1P = [0.95, 0.90, 0.85],
820  SigEff3P = [0.98, 0.95, 0.90],
821  UseAbsEta = True ,
822  ScoreName = "RNNEleScore",
823  NewScoreName = "RNNEleScoreSigTrans",
824  DefineWPs = True)
825 
826  result.setPrivateTools(myTauEleWPDecorator)
827  return result
828 
830  result = ComponentAccumulator()
831  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNNFix_v1'
832 
833  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
834  WPConf = flags.Tau.TauEleRNNWPfix
835  myTauEleWPDecorator = TauWPDecorator(name = _name,
836  flatteningFile1Prong = WPConf[0],
837  flatteningFile3Prong = WPConf[1],
838  DecorWPNames = [ "EleRNNLoose_v1", "EleRNNMedium_v1", "EleRNNTight_v1" ],
839  DecorWPCutEffs1P = [0.95, 0.90, 0.85],
840  DecorWPCutEffs3P = [0.98, 0.95, 0.90],
841  UseAbsEta = True,
842  ScoreName = "RNNEleScore",
843  NewScoreName = "RNNEleScoreSigTrans_v1",
844  DefineWPs = True)
845 
846  result.setPrivateTools(myTauEleWPDecorator)
847  return result
848 
850  result = ComponentAccumulator()
851  _name = flags.Tau.ActiveConfig.prefix + 'TauDecayModeNNClassifier'
852 
853  TauDecayModeNNClassifier = CompFactory.getComp("TauDecayModeNNClassifier")
854  myTauDecayModeNNClassifier = TauDecayModeNNClassifier(name=_name,
855  WeightFile=flags.Tau.DecayModeNNClassifierConfig)
856 
857  result.setPrivateTools(myTauDecayModeNNClassifier)
858  return result
859 
860 def TauAODSelectorCfg(flags):
861  result = ComponentAccumulator()
862  _name = flags.Tau.ActiveConfig.prefix + 'TauAODSelector'
863 
864  TauAODSelector = CompFactory.getComp("TauAODSelector")
865  myTauAODSelector = TauAODSelector(name=_name,
866  Min0pTauPt = flags.Tau.MinPt0p,
867  MinTauPt = flags.Tau.MinPt,
868  doEarlyStopping = flags.Tau.doEarlyStopping and not flags.Output.doWriteESD)
869 
870  result.setPrivateTools(myTauAODSelector)
871  return result
872 
873 
875 def TauCombinedTESCfg(flags):
876  result = ComponentAccumulator()
877  _name = flags.Tau.ActiveConfig.prefix + 'TauCombinedTES'
878 
879  TauCombinedTES = CompFactory.getComp("TauCombinedTES")
880  myTauCombinedTES = TauCombinedTES(name = _name,
881  WeightFileName = flags.Tau.CombinedTESConfig)
882 
883  result.setPrivateTools(myTauCombinedTES)
884  return result
885 
886 
889  result = ComponentAccumulator()
890  _name = flags.Tau.ActiveConfig.prefix + 'MuonRemoval'
891  TauAODMuonRemovalTool = CompFactory.getComp("TauAODMuonRemovalTool")
892  myMuonRemoval = TauAODMuonRemovalTool( name = _name,
893  Key_MuonInputContainer = 'Muons',
894  doMuonTrkRm = True,
895  doMuonClsRm = True,
896  muonIDWP = 'Medium'
897  )
898  result.setPrivateTools(myMuonRemoval)
899  return result
900 
901 # electron excluder tool
903  result = ComponentAccumulator()
904  _name = flags.Tau.ActiveConfig.prefix + 'TauEleOverlapChecker'
905  TauEleOverlapChecker = CompFactory.getComp("TauEleOverlapChecker")
906  myTauEleOverlapChecker = TauEleOverlapChecker(
907  name = _name,
908  Key_RemovedClustersContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
909  Key_RemovedTracksContainer = flags.Tau.ActiveConfig.RemovedElectronTracks,
910  CheckingCone = flags.Tau.ActiveConfig.EleRM_CheckingConeSize,
911  )
912  result.setPrivateTools(myTauEleOverlapChecker)
913  return result
TauToolHolder.TauDecayModeNNClassifierCfg
def TauDecayModeNNClassifierCfg(flags)
Definition: TauToolHolder.py:849
TauWPDecorator
Implementation of tool to decorate flattened BDT score and working points.
Definition: TauWPDecorator.h:35
TauCommonCalcVars
Calculate variables which rely on tracks and precalculated cell/cluster information.
Definition: TauCommonCalcVars.h:20
TauAODSelector
Definition: TauAODSelector.h:11
TauSubstructureVariables
Calculate variables from the tau substructure.
Definition: TauSubstructureVariables.h:21
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:888
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:564
TauToolHolder.TauCaloClusterBadChannelCfg
def TauCaloClusterBadChannelCfg(flags)
Definition: TauToolHolder.py:528
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:654
TauToolHolder.TauEleRNNEvaluatorCfg
def TauEleRNNEvaluatorCfg(flags)
Definition: TauToolHolder.py:778
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:21
TauToolHolder.TauCaloDMCalibCfg
def TauCaloDMCalibCfg(flags)
Definition: TauToolHolder.py:392
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:677
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:464
TauToolHolder.Pi0ClusterCreatorCfg
def Pi0ClusterCreatorCfg(flags)
create Pi0 clusters
Definition: TauToolHolder.py:540
CaloTopoClusterSplitter
topological cluster splitter.
Definition: CaloTopoClusterSplitter.h:48
TauToolHolder.MvaTESVariableDecoratorCfg
def MvaTESVariableDecoratorCfg(flags)
MvaTESVariableDecorator.
Definition: TauToolHolder.py:634
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:288
TauToolHolder.TauCaloClusterMomentsMakerCfg
def TauCaloClusterMomentsMakerCfg(flags)
Definition: TauToolHolder.py:488
TauToolHolder.ElectronVetoVarsCfg
def ElectronVetoVarsCfg(flags)
ele veto variables
Definition: TauToolHolder.py:208
TauCalibrateLC
Implementation of tau energy scale (TES) with eta and pile-up correction.
Definition: TauCalibrateLC.h:25
TauToolHolder.TauCaloTopoClusterMakerCfg
def TauCaloTopoClusterMakerCfg(flags)
Definition: TauToolHolder.py:418
TauToolHolder.TauGNNEvaluatorCfg
def TauGNNEvaluatorCfg(flags, version=0)
Definition: TauToolHolder.py:732
StandardCellWeightCalib.getCellWeightTool
def getCellWeightTool(flags, finder="Cone", mainparam=0.4, input="Topo", onlyCellWeight=False)
Definition: StandardCellWeightCalib.py:178
MvaTESVariableDecorator
Definition: MvaTESVariableDecorator.h:16
TauPi0ScoreCalculator
Selectes pi0Candidates (Pi0 Finder).
Definition: TauPi0ScoreCalculator.h:25
TauToolHolder.getParticleCache
def getParticleCache(flags)
Definition: TauToolHolder.py:71
TauToolHolder.TauEleOverlapChecker
def TauEleOverlapChecker(flags)
Definition: TauToolHolder.py:902
TauToolHolder.TauSubstructureCfg
def TauSubstructureCfg(flags)
Tau Variables.
Definition: TauToolHolder.py:622
TauVertexedClusterDecorator
Decorate CaloVertexedTopoCluster to the tau candidate.
Definition: TauVertexedClusterDecorator.h:19
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:35
TauToolHolder.TauCaloOOCCalibCfg
def TauCaloOOCCalibCfg(flags)
Definition: TauToolHolder.py:379
TauToolHolder.TauCaloLCDeadMaterialCfg
def TauCaloLCDeadMaterialCfg(flags)
Definition: TauToolHolder.py:350
TauToolHolder.TauCaloOOCPi0CalibCfg
def TauCaloOOCPi0CalibCfg(flags)
Definition: TauToolHolder.py:405
TauPi0Selector
Apply Et and BDT score cut to pi0s.
Definition: TauPi0Selector.h:22
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:577
TauToolHolder.TauVertexVariablesCfg
def TauVertexVariablesCfg(flags)
Tau Vertex Variables.
Definition: TauToolHolder.py:592
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:758
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:860
TauToolHolder.TauCaloLCOutPi0Cfg
def TauCaloLCOutPi0Cfg(flags)
Definition: TauToolHolder.py:337
TauToolHolder.TauCaloClusterLocalCalibCfg
def TauCaloClusterLocalCalibCfg(flags)
Definition: TauToolHolder.py:365
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.TauWPDecoratorEleRNNCfg
def TauWPDecoratorEleRNNCfg(flags)
Definition: TauToolHolder.py:801
TauToolHolder.TauCombinedTESCfg
def TauCombinedTESCfg(flags)
TauCombinedTES.
Definition: TauToolHolder.py:875
CaloClusterMomentsMaker
Calculate moments for CaloCluster objects.
Definition: CaloClusterMomentsMaker.h:50
TauToolHolder.TauCellFinalizerCfg
def TauCellFinalizerCfg(flags)
Cell finalizer tool for BuildAlg.
Definition: TauToolHolder.py:274
TauToolHolder.TauCommonCalcVarsCfg
def TauCommonCalcVarsCfg(flags)
Tau Variables.
Definition: TauToolHolder.py:610
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:28
TauToolHolder.TauWPDecoratorEleRNNFixCfg
def TauWPDecoratorEleRNNFixCfg(flags)
Definition: TauToolHolder.py:829
TauToolHolder.TauCaloLCWeightCfg
def TauCaloLCWeightCfg(flags)
Definition: TauToolHolder.py:305
TrackToVertexConfig.TrackToVertexCfg
def TrackToVertexCfg(flags, name="AtlasTrackToVertexTool", **kwargs)
Definition: TrackToVertexConfig.py:6
MvaTESEvaluator
Definition: MvaTESEvaluator.h:18
TauToolHolder.TauShotFinderCfg
def TauShotFinderCfg(flags)
Photon Shot Finder.
Definition: TauToolHolder.py:225
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:552
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:324
TauToolHolder.TauTrackFinderCfg
def TauTrackFinderCfg(flags)
Tau-Track Association.
Definition: TauToolHolder.py:82
TauToolHolder.TauWPDecoratorJetRNNCfg
def TauWPDecoratorJetRNNCfg(flags)
Definition: TauToolHolder.py:702
TauToolHolder.Pi0ClusterFinderCfg
def Pi0ClusterFinderCfg(flags)
Pi0 algo Cluster finder for Pi0 algo.
Definition: TauToolHolder.py:255
TauJetRNNEvaluator
Tool to calculate a tau identification score based on neural networks.
Definition: TauJetRNNEvaluator.h:28
TauToolHolder.TauIDVarCalculatorCfg
def TauIDVarCalculatorCfg(flags)
Definition: TauToolHolder.py:666
CaloTopoClusterMaker
topological cluster maker.
Definition: CaloTopoClusterMaker.h:48
TrackToCaloConfig.ParticleCaloExtensionToolCfg
def ParticleCaloExtensionToolCfg(flags, name='ParticleCaloExtensionTool', **kwargs)
Definition: TrackToCaloConfig.py:10