ATLAS Offline Software
Functions
TauToolHolder Namespace Reference

Functions

def JetSeedBuilderCfg (flags)
 JetSeedBuilder. More...
 
def TauVertexFinderCfg (flags)
 
def TauAxisCfg (flags)
 Tau energy calibration and tau axis direction. More...
 
def getParticleCache (flags)
 
def TauTrackFinderCfg (flags)
 Tau-Track Association. More...
 
def TauClusterFinderCfg (flags)
 Associate the cluster in jet constituents to the tau candidate. More...
 
def TauVertexedClusterDecoratorCfg (flags)
 
def TauTrackRNNCfg (flags)
 
def TauTrackRNNClassifierCfg (flags)
 
def EnergyCalibrationLCCfg (flags)
 Tau energy calibration. More...
 
def CellVariablesCfg (flags)
 Tau cell variables calculation. More...
 
def ElectronVetoVarsCfg (flags)
 ele veto variables More...
 
def CellWeightToolCfg (flags)
 cell weight tool More...
 
def TauShotFinderCfg (flags)
 Photon Shot Finder. More...
 
def Pi0ClusterFinderCfg (flags)
 Pi0 algo Cluster finder for Pi0 algo. More...
 
def TauCellFinalizerCfg (flags)
 Cell finalizer tool for BuildAlg. More...
 
def TauCaloLCClassificationCfg (flags)
 Calo Tools. More...
 
def TauCaloLCWeightCfg (flags)
 
def TauCaloLCOutOfClusterCfg (flags)
 
def TauCaloLCOutPi0Cfg (flags)
 
def TauCaloLCDeadMaterialCfg (flags)
 
def TauCaloClusterLocalCalibCfg (flags)
 
def TauCaloOOCCalibCfg (flags)
 
def TauCaloDMCalibCfg (flags)
 
def TauCaloOOCPi0CalibCfg (flags)
 
def TauCaloClusterCellWeightCalibCfg (flags)
 
def TauCaloTopoClusterMakerCfg (flags)
 
def TauCaloTopoClusterSplitterCfg (flags)
 
def TauCaloClusterMomentsMakerCfg (flags)
 
def TauCaloClusterBadChannelCfg (flags)
 
def Pi0ClusterCreatorCfg (flags)
 create Pi0 clusters More...
 
def Pi0ClusterScalerCfg (flags)
 Set energy of cluster to take care of charged pion energy deposited in the ECAL. More...
 
def Pi0ScoreCalculatorCfg (flags)
 calculate MVA scores of pi0 clusters More...
 
def Pi0SelectorCfg (flags)
 select pi0 clusters More...
 
def TauVertexVariablesCfg (flags)
 Tau Vertex Variables. More...
 
def TauCommonCalcVarsCfg (flags)
 Tau Variables. More...
 
def TauSubstructureCfg (flags)
 Tau Variables. More...
 
def MvaTESVariableDecoratorCfg (flags)
 MvaTESVariableDecorator. More...
 
def MvaTESEvaluatorCfg (flags)
 MvaTESEvaluator. More...
 
def TauIDVarCalculatorCfg (flags)
 
def TauJetRNNEvaluatorCfg (flags)
 
def TauWPDecoratorJetRNNCfg (flags)
 
def TauGNNEvaluatorCfg (flags, version=0)
 
def TauWPDecoratorGNNCfg (flags, version)
 
def TauEleRNNEvaluatorCfg (flags)
 
def TauWPDecoratorEleRNNCfg (flags)
 
def TauWPDecoratorEleRNNFixCfg (flags)
 
def TauDecayModeNNClassifierCfg (flags)
 
def TauAODSelectorCfg (flags)
 
def TauCombinedTESCfg (flags)
 TauCombinedTES. More...
 
def TauAODMuonRemovalCfg (flags)
 muon removal tool More...
 
def TauEleOverlapChecker (flags)
 

Function Documentation

◆ CellVariablesCfg()

def TauToolHolder.CellVariablesCfg (   flags)

Tau cell variables calculation.

Definition at line 197 of file TauToolHolder.py.

197 def CellVariablesCfg(flags):
198  result = ComponentAccumulator()
199  _name = flags.Tau.ActiveConfig.prefix + 'CellVariables'
200 
201  TauCellVariables = CompFactory.getComp("TauCellVariables")
202  TauCellVariables = TauCellVariables(name = _name,
203  VertexCorrection = True)
204 
205  result.setPrivateTools(TauCellVariables)
206  return result
207 

◆ CellWeightToolCfg()

def TauToolHolder.CellWeightToolCfg (   flags)

cell weight tool

Definition at line 227 of file TauToolHolder.py.

227 def CellWeightToolCfg(flags):
228  result = ComponentAccumulator()
229 
230  # copied from CaloClusterCorrection/python/StandardCellWeightCalib
231  H1WeightToolCSC12Generic = CompFactory.H1WeightToolCSC12Generic # CaloClusterCorrection
232  isMC = flags.Input.isMC
233 
234  finder = "Cone"
235  mainparam = 0.4
236  inputn = "Topo"
237  onlyCellWeight = False
238  from CaloClusterCorrection.StandardCellWeightCalib import H1Calibration, editParm
239  (key,folder,tag) = H1Calibration.getCalibDBParams(flags, finder, mainparam, inputn, onlyCellWeight, isMC)
240  # H1Calibration.loadCaloFolder(result, flags, folder, tag, isMC)
241  from IOVDbSvc.IOVDbSvcConfig import addFolders
242  if isMC:
243  dbString="CALO_OFL"
244  else:
245  dbString="CALO"
246  if (folder,tag) not in H1Calibration.loaded_folder:
247  if H1Calibration.overrideFolder():
248  result.merge(addFolders(flags, folder+'<tag>'+tag+'</tag>', detDb=dbString, className='CaloRec::ToolConstants') )
249  else:
250  result.merge(addFolders(flags, folder, detDb=dbString, className='CaloRec::ToolConstants') )
251 
252  H1Calibration.loaded_folder.append( (folder,tag) )
253 
254  #-- configure tool
255  toolName = finder + editParm(mainparam) + inputn
256  cellcalibtool = H1WeightToolCSC12Generic("H1Weight"+toolName)
257  cellcalibtool.DBHandleKey = key
258  result.setPrivateTools(cellcalibtool)
259  # --
260  return result
261 

◆ ElectronVetoVarsCfg()

def TauToolHolder.ElectronVetoVarsCfg (   flags)

ele veto variables

Definition at line 210 of file TauToolHolder.py.

210 def ElectronVetoVarsCfg(flags):
211  result = ComponentAccumulator()
212  _name = flags.Tau.ActiveConfig.prefix + 'TauElectronVetoVars'
213 
214  from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg
215 
216  TauElectronVetoVariables = CompFactory.getComp("TauElectronVetoVariables")
217  TauElectronVetoVariables = TauElectronVetoVariables(name = _name,
218  VertexCorrection = True,
219  ParticleCaloExtensionTool = result.popToolsAndMerge(ParticleCaloExtensionToolCfg(flags)),
220  tauEVParticleCache = getParticleCache(flags))
221 
222  result.setPrivateTools(TauElectronVetoVariables)
223  return result
224 

◆ EnergyCalibrationLCCfg()

def TauToolHolder.EnergyCalibrationLCCfg (   flags)

Tau energy calibration.

Definition at line 183 of file TauToolHolder.py.

183 def EnergyCalibrationLCCfg(flags):
184  result = ComponentAccumulator()
185  _name = flags.Tau.ActiveConfig.prefix +'EnergyCalibrationLC'
186 
187  TauCalibrateLC = CompFactory.getComp("TauCalibrateLC")
188  TauCalibrateLC = TauCalibrateLC(name = _name,
189  calibrationFile = flags.Tau.CalibrateLCConfig,
190  Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection)
191 
192  result.setPrivateTools(TauCalibrateLC)
193  return result
194 

◆ getParticleCache()

def TauToolHolder.getParticleCache (   flags)

Definition at line 71 of file TauToolHolder.py.

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 

◆ JetSeedBuilderCfg()

def TauToolHolder.JetSeedBuilderCfg (   flags)

JetSeedBuilder.

Definition at line 21 of file TauToolHolder.py.

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 

◆ MvaTESEvaluatorCfg()

def TauToolHolder.MvaTESEvaluatorCfg (   flags)

MvaTESEvaluator.

Definition at line 703 of file TauToolHolder.py.

703 def MvaTESEvaluatorCfg(flags):
704  result = ComponentAccumulator()
705  _name = flags.Tau.ActiveConfig.prefix + 'MvaTESEvaluator'
706 
707  MvaTESEvaluator = CompFactory.getComp("MvaTESEvaluator")
708  MvaTESEvaluator = MvaTESEvaluator(name = _name,
709  WeightFileName = flags.Tau.MvaTESConfig,
710  WeightFileName0p = flags.Tau.MvaTESConfig0p )
711 
712  result.setPrivateTools(MvaTESEvaluator)
713  return result
714 

◆ MvaTESVariableDecoratorCfg()

def TauToolHolder.MvaTESVariableDecoratorCfg (   flags)

MvaTESVariableDecorator.

Definition at line 689 of file TauToolHolder.py.

689 def MvaTESVariableDecoratorCfg(flags):
690  result = ComponentAccumulator()
691  _name = flags.Tau.ActiveConfig.prefix + 'MvaTESVariableDecorator'
692 
693  MvaTESVariableDecorator = CompFactory.getComp("MvaTESVariableDecorator")
694  MvaTESVariableDecorator = MvaTESVariableDecorator(name = _name,
695  Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
696  EventShapeKey = flags.Tau.ActiveConfig.EventShapeCollection,
697  VertexCorrection = True)
698  result.setPrivateTools(MvaTESVariableDecorator)
699  return result
700 

◆ Pi0ClusterCreatorCfg()

def TauToolHolder.Pi0ClusterCreatorCfg (   flags)

create Pi0 clusters

Definition at line 595 of file TauToolHolder.py.

595 def Pi0ClusterCreatorCfg(flags):
596  result = ComponentAccumulator()
597  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterCreator'
598 
599  TauPi0ClusterCreator = CompFactory.getComp("TauPi0ClusterCreator")
600  TauPi0ClusterCreator = TauPi0ClusterCreator(name = _name)
601 
602  result.setPrivateTools(TauPi0ClusterCreator)
603  return result
604 

◆ Pi0ClusterFinderCfg()

def TauToolHolder.Pi0ClusterFinderCfg (   flags)

Pi0 algo Cluster finder for Pi0 algo.

Definition at line 294 of file TauToolHolder.py.

294 def Pi0ClusterFinderCfg(flags):
295  result = ComponentAccumulator()
296  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterFinder'
297 
298  TauPi0CreateROI = CompFactory.getComp("TauPi0CreateROI")
299 
300  myTauPi0CreateROI = TauPi0CreateROI(
301  name = _name,
302  Key_caloCellInputContainer = "AllCalo",
303  Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
304  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
305  RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
306  )
307 
308  result.setPrivateTools(myTauPi0CreateROI)
309  return result
310 

◆ Pi0ClusterScalerCfg()

def TauToolHolder.Pi0ClusterScalerCfg (   flags)

Set energy of cluster to take care of charged pion energy deposited in the ECAL.

Definition at line 607 of file TauToolHolder.py.

607 def Pi0ClusterScalerCfg(flags):
608  result = ComponentAccumulator()
609  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterScaler'
610 
611  TauPi0ClusterScaler = CompFactory.getComp("TauPi0ClusterScaler")
612  TauPi0ClusterScaler = TauPi0ClusterScaler(name = _name)
613 
614  result.setPrivateTools(TauPi0ClusterScaler)
615  return result
616 

◆ Pi0ScoreCalculatorCfg()

def TauToolHolder.Pi0ScoreCalculatorCfg (   flags)

calculate MVA scores of pi0 clusters

Definition at line 619 of file TauToolHolder.py.

619 def Pi0ScoreCalculatorCfg(flags):
620  result = ComponentAccumulator()
621  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ScoreCalculator'
622 
623  TauPi0ScoreCalculator = CompFactory.getComp("TauPi0ScoreCalculator")
624  TauPi0ScoreCalculator = TauPi0ScoreCalculator(name = _name,
625  BDTWeightFile = flags.Tau.Pi0ScoreConfig)
626 
627  result.setPrivateTools(TauPi0ScoreCalculator)
628  return result
629 

◆ Pi0SelectorCfg()

def TauToolHolder.Pi0SelectorCfg (   flags)

select pi0 clusters

Definition at line 632 of file TauToolHolder.py.

632 def Pi0SelectorCfg(flags):
633  result = ComponentAccumulator()
634  _name = flags.Tau.ActiveConfig.prefix + 'Pi0Selector'
635 
636  TauPi0Selector = CompFactory.getComp("TauPi0Selector")
637  TauPi0Selector = TauPi0Selector(name = _name,
638  ClusterEtCut = flags.Tau.pi0EtCuts,
639  ClusterBDTCut_1prong = flags.Tau.pi0MVACuts_1prong,
640  ClusterBDTCut_mprong = flags.Tau.pi0MVACuts_mprong)
641 
642  result.setPrivateTools(TauPi0Selector)
643  return result
644 

◆ TauAODMuonRemovalCfg()

def TauToolHolder.TauAODMuonRemovalCfg (   flags)

muon removal tool

Definition at line 937 of file TauToolHolder.py.

937 def TauAODMuonRemovalCfg(flags):
938  result = ComponentAccumulator()
939  _name = flags.Tau.ActiveConfig.prefix + 'MuonRemoval'
940  TauAODLeptonRemovalTool = CompFactory.getComp("TauAODLeptonRemovalTool")
941  myMuonRemoval = TauAODLeptonRemovalTool( name = _name,
942  Key_MuonInputContainer = 'Muons',
943  doMuonTrkRm = True,
944  doMuonClsRm = True,
945  muonIDWP = 'Medium'
946  )
947  result.setPrivateTools(myMuonRemoval)
948  return result
949 
950 # electron excluder tool

◆ TauAODSelectorCfg()

def TauToolHolder.TauAODSelectorCfg (   flags)

Definition at line 909 of file TauToolHolder.py.

909 def TauAODSelectorCfg(flags):
910  result = ComponentAccumulator()
911  _name = flags.Tau.ActiveConfig.prefix + 'TauAODSelector'
912 
913  TauAODSelector = CompFactory.getComp("TauAODSelector")
914  myTauAODSelector = TauAODSelector(name=_name,
915  Min0pTauPt = flags.Tau.MinPt0p,
916  MinTauPt = flags.Tau.MinPt,
917  doEarlyStopping = flags.Tau.doEarlyStopping and not flags.Output.doWriteESD)
918 
919  result.setPrivateTools(myTauAODSelector)
920  return result
921 

◆ TauAxisCfg()

def TauToolHolder.TauAxisCfg (   flags)

Tau energy calibration and tau axis direction.

Definition at line 57 of file TauToolHolder.py.

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 = True )
65 
66  result.setPrivateTools(TauAxisSetter)
67  return result
68 

◆ TauCaloClusterBadChannelCfg()

def TauToolHolder.TauCaloClusterBadChannelCfg (   flags)

Definition at line 583 of file TauToolHolder.py.

583 def TauCaloClusterBadChannelCfg(flags):
584  result = ComponentAccumulator()
585  _name = flags.Tau.ActiveConfig.prefix + 'CaloClusterBadChannelList'
586 
587  CaloClusterBadChannelListCorr = CompFactory.getComp("CaloClusterBadChannelList")
588  BadChannelListCorrForTaus = CaloClusterBadChannelListCorr(_name)
589 
590  result.setPrivateTools(BadChannelListCorrForTaus)
591  return result
592 

◆ TauCaloClusterCellWeightCalibCfg()

def TauToolHolder.TauCaloClusterCellWeightCalibCfg (   flags)

Definition at line 457 of file TauToolHolder.py.

457 def TauCaloClusterCellWeightCalibCfg(flags):
458  result = ComponentAccumulator()
459  _name = flags.Tau.ActiveConfig.prefix + 'CellWeights'
460 
461  CaloClusterCellWeightCalib = CompFactory.getComp("CaloClusterCellWeightCalib")
462  CellWeights = CaloClusterCellWeightCalib(_name)
463  CellWeights.CellSignalWeightTool = result.popToolsAndMerge(CellWeightToolCfg(flags))
464  CellWeights.Direction = "AbsSignal" #-- use absolute cell energies for eta/phi calculation
465  CellWeights.BelowThresholdLikeAll = True #-- treat clusters below thresholds the same as all others
466  CellWeights.BelowThresholdDirection = "AbsSignal" #-- alternative direction calculation for below threshold clusters, ignored if BelowThresholdLikeAll = True
467  CellWeights.EnergyThreshold = 0.0*MeV #-- threshold for possible change of direction calculation
468  CellWeights.IgnoreGeoWeights = False #-- ignore geometrical cell signal weights if True
469 
470  result.setPrivateTools(CellWeights)
471  return result
472 

◆ TauCaloClusterLocalCalibCfg()

def TauToolHolder.TauCaloClusterLocalCalibCfg (   flags)

Definition at line 404 of file TauToolHolder.py.

404 def TauCaloClusterLocalCalibCfg(flags):
405  result = ComponentAccumulator()
406  _name = flags.Tau.ActiveConfig.prefix + 'CaloLocalCalib'
407 
408  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
409  LocalCalib = CaloClusterLocalCalib(_name)
410  LocalCalib.ClusterClassificationTool = [result.popToolsAndMerge(TauCaloLCClassificationCfg(flags))]
411  LocalCalib.ClusterRecoStatus = [1,2]
412  LocalCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCWeightCfg(flags))]
413  LocalCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
414 
415  result.setPrivateTools(LocalCalib)
416  return result
417 

◆ TauCaloClusterMomentsMakerCfg()

def TauToolHolder.TauCaloClusterMomentsMakerCfg (   flags)

Definition at line 543 of file TauToolHolder.py.

543 def TauCaloClusterMomentsMakerCfg(flags):
544  result = ComponentAccumulator()
545  _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoMoments'
546 
547  # Schedule total noise cond alg
548  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
549  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
550  # Schedule electronic noise cond alg (needed for LC weights)
551  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
552 
553  CaloClusterMomentsMaker = CompFactory.getComp("CaloClusterMomentsMaker")
554  TopoMomentsForTaus = CaloClusterMomentsMaker(_name)
555  TopoMomentsForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
556  TopoMomentsForTaus.MaxAxisAngle = 20*deg
557  TopoMomentsForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
558  TopoMomentsForTaus.MinBadLArQuality = 4000
559  TopoMomentsForTaus.MomentsNames = ["FIRST_PHI"
560  ,"FIRST_ETA"
561  ,"SECOND_R"
562  ,"SECOND_LAMBDA"
563  ,"DELTA_PHI"
564  ,"DELTA_THETA"
565  ,"DELTA_ALPHA"
566  ,"CENTER_X"
567  ,"CENTER_Y"
568  ,"CENTER_Z"
569  ,"CENTER_MAG"
570  ,"CENTER_LAMBDA"
571  ,"LATERAL"
572  ,"LONGITUDINAL"
573  ,"ENG_FRAC_EM"
574  ,"ENG_FRAC_MAX"
575  ,"ENG_FRAC_CORE"
576  ,"FIRST_ENG_DENS"
577  ,"SECOND_ENG_DENS"
578  ,"ISOLATION"]
579 
580  result.setPrivateTools(TopoMomentsForTaus)
581  return result
582 

◆ TauCaloDMCalibCfg()

def TauToolHolder.TauCaloDMCalibCfg (   flags)

Definition at line 431 of file TauToolHolder.py.

431 def TauCaloDMCalibCfg(flags):
432  result = ComponentAccumulator()
433  _name = flags.Tau.ActiveConfig.prefix + 'DMCalib'
434 
435  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
436  DMCalib = CaloClusterLocalCalib(_name)
437  DMCalib.ClusterRecoStatus = [1,2]
438  DMCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCDeadMaterialCfg(flags))]
439  DMCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
440 
441  result.setPrivateTools(DMCalib)
442  return result
443 

◆ TauCaloLCClassificationCfg()

def TauToolHolder.TauCaloLCClassificationCfg (   flags)

Calo Tools.

Definition at line 327 of file TauToolHolder.py.

327 def TauCaloLCClassificationCfg(flags):
328  result = ComponentAccumulator()
329  _name = flags.Tau.ActiveConfig.prefix + 'LCClassify'
330 
331  CaloLCClassificationTool = CompFactory.getComp("CaloLCClassificationTool")
332  LCClassify = CaloLCClassificationTool(_name)
333  LCClassify.ClassificationKey = "EMFracClassify"
334  LCClassify.UseSpread = False
335  LCClassify.MaxProbability = 0.5
336  # add the moments EM_PROBABILITY, HAD_WEIGHT, OOC_WEIGHT, DM_WEIGHT to the AOD:
337  LCClassify.StoreClassificationProbabilityInAOD = True
338  LCClassify.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
339  LCClassify.UseNormalizedEnergyDensity = True
340 
341  result.setPrivateTools(LCClassify)
342  return result
343 

◆ TauCaloLCDeadMaterialCfg()

def TauToolHolder.TauCaloLCDeadMaterialCfg (   flags)

Definition at line 389 of file TauToolHolder.py.

389 def TauCaloLCDeadMaterialCfg(flags):
390  result = ComponentAccumulator()
391  _name = flags.Tau.ActiveConfig.prefix + 'CaloLCDeadMaterialTool'
392 
393  CaloLCDeadMaterialTool = CompFactory.getComp("CaloLCDeadMaterialTool")
394  LCDeadMaterial = CaloLCDeadMaterialTool(_name)
395  LCDeadMaterial.HadDMCoeffKey = "HadDMCoeff2"
396  LCDeadMaterial.ClusterRecoStatus = 0
397  LCDeadMaterial.WeightModeDM = 2
398  LCDeadMaterial.UseHadProbability = True
399  LCDeadMaterial.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
400 
401  result.setPrivateTools(LCDeadMaterial)
402  return result
403 

◆ TauCaloLCOutOfClusterCfg()

def TauToolHolder.TauCaloLCOutOfClusterCfg (   flags)

Definition at line 363 of file TauToolHolder.py.

363 def TauCaloLCOutOfClusterCfg(flags):
364  result = ComponentAccumulator()
365  _name = flags.Tau.ActiveConfig.prefix + 'CaloLCOutOfClusterTool'
366 
367  CaloLCOutOfClusterTool = CompFactory.getComp("CaloLCOutOfClusterTool")
368  LCOut = CaloLCOutOfClusterTool(_name)
369  LCOut.CorrectionKey = "OOCCorrection"
370  LCOut.UseEmProbability = False
371  LCOut.UseHadProbability = True
372 
373  result.setPrivateTools(LCOut)
374  return result
375 

◆ TauCaloLCOutPi0Cfg()

def TauToolHolder.TauCaloLCOutPi0Cfg (   flags)

Definition at line 376 of file TauToolHolder.py.

376 def TauCaloLCOutPi0Cfg(flags):
377  result = ComponentAccumulator()
378  _name = flags.Tau.ActiveConfig.prefix + 'LCOutPi0'
379 
380  CaloLCOutOfClusterTool = CompFactory.getComp("CaloLCOutOfClusterTool")
381  LCOutPi0 = CaloLCOutOfClusterTool(_name)
382  LCOutPi0.CorrectionKey = "OOCPi0Correction"
383  LCOutPi0.UseEmProbability = True
384  LCOutPi0.UseHadProbability = False
385 
386  result.setPrivateTools(LCOutPi0)
387  return result
388 

◆ TauCaloLCWeightCfg()

def TauToolHolder.TauCaloLCWeightCfg (   flags)

Definition at line 344 of file TauToolHolder.py.

344 def TauCaloLCWeightCfg(flags):
345  result = ComponentAccumulator()
346  _name = flags.Tau.ActiveConfig.prefix + 'CaloLCWeightTool'
347 
348  # Schedule total noise cond alg
349  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
350  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
351  # Schedule electronic noise cond alg (needed for LC weights)
352  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
353 
354  CaloLCWeightTool = CompFactory.getComp("CaloLCWeightTool")
355  LCWeight = CaloLCWeightTool(_name)
356  LCWeight.CorrectionKey = "H1ClusterCellWeights"
357  LCWeight.SignalOverNoiseCut = 2.0
358  LCWeight.UseHadProbability = True
359 
360  result.setPrivateTools(LCWeight)
361  return result
362 

◆ TauCaloOOCCalibCfg()

def TauToolHolder.TauCaloOOCCalibCfg (   flags)

Definition at line 418 of file TauToolHolder.py.

418 def TauCaloOOCCalibCfg(flags):
419  result = ComponentAccumulator()
420  _name = flags.Tau.ActiveConfig.prefix + 'OOCCalibTool'
421 
422  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
423  OOCCalib = CaloClusterLocalCalib (_name)
424  OOCCalib.ClusterRecoStatus = [1,2]
425  OOCCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCOutOfClusterCfg(flags))]
426  OOCCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
427 
428  result.setPrivateTools(OOCCalib)
429  return result
430 

◆ TauCaloOOCPi0CalibCfg()

def TauToolHolder.TauCaloOOCPi0CalibCfg (   flags)

Definition at line 444 of file TauToolHolder.py.

444 def TauCaloOOCPi0CalibCfg(flags):
445  result = ComponentAccumulator()
446  _name = flags.Tau.ActiveConfig.prefix + 'OOCPi0CalibTool'
447 
448  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
449  OOCPi0Calib = CaloClusterLocalCalib (_name)
450  OOCPi0Calib.ClusterRecoStatus = [1,2]
451  OOCPi0Calib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCOutPi0Cfg(flags))]
452  OOCPi0Calib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
453 
454  result.setPrivateTools(OOCPi0Calib)
455  return result
456 

◆ TauCaloTopoClusterMakerCfg()

def TauToolHolder.TauCaloTopoClusterMakerCfg (   flags)

Definition at line 473 of file TauToolHolder.py.

473 def TauCaloTopoClusterMakerCfg(flags):
474  result = ComponentAccumulator()
475  _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoClusterMaker'
476 
477  # Schedule total noise cond alg
478  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
479  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
480  # Schedule electronic noise cond alg (needed for LC weights)
481  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
482 
483  CaloTopoClusterMaker = CompFactory.getComp("CaloTopoClusterMaker")
484  TopoClusterForTaus = CaloTopoClusterMaker(_name)
485 
486  TopoClusterForTaus.CellsName = flags.Tau.ActiveConfig.TauCommonPi0Cells
487  TopoClusterForTaus.CalorimeterNames=["LAREM"]
488  TopoClusterForTaus.SeedSamplingNames = ["PreSamplerB", "EMB1", "EMB2", "PreSamplerE", "EME1", "EME2"]
489  TopoClusterForTaus.NeighborOption = "super3D"
490  TopoClusterForTaus.RestrictHECIWandFCalNeighbors = False
491  TopoClusterForTaus.RestrictPSNeighbors = True
492  TopoClusterForTaus.CellThresholdOnEorAbsEinSigma = 0.0
493  TopoClusterForTaus.NeighborThresholdOnEorAbsEinSigma = 2.0
494  TopoClusterForTaus.SeedThresholdOnEorAbsEinSigma = 4.0
495  TopoClusterForTaus.SeedCutsInAbsE = True
496  TopoClusterForTaus.ClusterCutsInAbsEt = True
497  TopoClusterForTaus.ClusterEtorAbsEtCut = 0.5*GeV # 0.0*MeV in standard CaloCalTopoCluster JobOptions!
498  TopoClusterForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
499  # timing cut on seed cell to suppress out-of-time pileup
500  TopoClusterForTaus.SeedCutsInT = flags.Calo.TopoCluster.doTimeCut
501  TopoClusterForTaus.CutOOTseed = flags.Calo.TopoCluster.extendTimeCut and flags.Calo.TopoCluster.doTimeCut
502  TopoClusterForTaus.UseTimeCutUpperLimit = flags.Calo.TopoCluster.useUpperLimitForTimeCut
503  TopoClusterForTaus.TimeCutUpperLimit = flags.Calo.TopoCluster.timeCutUpperLimit
504  TopoClusterForTaus.XTalkEM2 = flags.Calo.TopoCluster.xtalkEM2
505  TopoClusterForTaus.XTalkEM2D = flags.Calo.TopoCluster.xtalkEM2D
506  TopoClusterForTaus.XTalkEM2n = flags.Calo.TopoCluster.xtalkEM2n
507  TopoClusterForTaus.XTalkEM3 = flags.Calo.TopoCluster.xtalkEM3
508  TopoClusterForTaus.XTalkEMEta = flags.Calo.TopoCluster.xtalkEMEta
509  TopoClusterForTaus.XTalkDeltaT = flags.Calo.TopoCluster.xtalkDeltaT
510  TopoClusterForTaus.XTalk2Eratio1 = flags.Calo.TopoCluster.xtalk2Eratio1
511  TopoClusterForTaus.XTalk2Eratio2 = flags.Calo.TopoCluster.xtalk2Eratio2
512  TopoClusterForTaus.XTalk3Eratio = flags.Calo.TopoCluster.xtalk3Eratio
513  TopoClusterForTaus.XTalkEtaEratio = flags.Calo.TopoCluster.xtalkEtaEratio
514  TopoClusterForTaus.XTalk2DEratio = flags.Calo.TopoCluster.xtalk2DEratio
515 
516  result.setPrivateTools(TopoClusterForTaus)
517  return result
518 

◆ TauCaloTopoClusterSplitterCfg()

def TauToolHolder.TauCaloTopoClusterSplitterCfg (   flags)

Definition at line 519 of file TauToolHolder.py.

519 def TauCaloTopoClusterSplitterCfg(flags):
520 
521  result = ComponentAccumulator()
522  _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoClusterSplitter'
523 
524  CaloTopoClusterSplitter = CompFactory.getComp("CaloTopoClusterSplitter")
525  TopoSplitterForTaus = CaloTopoClusterSplitter(_name)
526 
527  # cells from the following samplings will be able to form local
528  # maxima. The excluded samplings are PreSamplerB, EMB1,
529  # PreSamplerE, EME1, all Tile samplings, all HEC samplings and the
530  # two rear FCal samplings.
531  TopoSplitterForTaus.SamplingNames = ["EMB2","EME2"] # Do we want to use EMB3 and EME3?
532  # cells from the following samplings will also be able to form
533  # local maxima but only if they are not overlapping in eta and phi
534  # with local maxima in previous samplings from the primary list.
535  TopoSplitterForTaus.SecondarySamplingNames = ["EMB1","EME1"]
536  TopoSplitterForTaus.ShareBorderCells = True
537  TopoSplitterForTaus.RestrictHECIWandFCalNeighbors = False
538  TopoSplitterForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
539 
540  result.setPrivateTools(TopoSplitterForTaus)
541  return result
542 

◆ TauCellFinalizerCfg()

def TauToolHolder.TauCellFinalizerCfg (   flags)

Cell finalizer tool for BuildAlg.

Definition at line 313 of file TauToolHolder.py.

313 def TauCellFinalizerCfg(flags):
314  result = ComponentAccumulator()
315  _name = flags.Tau.ActiveConfig.prefix + 'tauPi0CellContainerFinalizer'
316 
317  CaloCellContainerFinalizerTool = CompFactory.getComp("CaloCellContainerFinalizerTool")
318  TauCellContainerFinalizer = CaloCellContainerFinalizerTool(name=_name)
319 
320  result.setPrivateTools(TauCellContainerFinalizer)
321  return result
322 

◆ TauClusterFinderCfg()

def TauToolHolder.TauClusterFinderCfg (   flags)

Associate the cluster in jet constituents to the tau candidate.

Definition at line 119 of file TauToolHolder.py.

119 def TauClusterFinderCfg(flags):
120  result = ComponentAccumulator()
121  _name = flags.Tau.ActiveConfig.prefix + 'TauClusterFinder'
122 
123 
124  TauClusterFinder = CompFactory.getComp("TauClusterFinder")
125  TauClusterFinder = TauClusterFinder(
126  name = _name,
127  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
128  )
129 
130 
131  result.setPrivateTools(TauClusterFinder)
132  return result
133 

◆ TauCombinedTESCfg()

def TauToolHolder.TauCombinedTESCfg (   flags)

TauCombinedTES.

Definition at line 924 of file TauToolHolder.py.

924 def TauCombinedTESCfg(flags):
925  result = ComponentAccumulator()
926  _name = flags.Tau.ActiveConfig.prefix + 'TauCombinedTES'
927 
928  TauCombinedTES = CompFactory.getComp("TauCombinedTES")
929  myTauCombinedTES = TauCombinedTES(name = _name,
930  WeightFileName = flags.Tau.CombinedTESConfig)
931 
932  result.setPrivateTools(myTauCombinedTES)
933  return result
934 

◆ TauCommonCalcVarsCfg()

def TauToolHolder.TauCommonCalcVarsCfg (   flags)

Tau Variables.

Definition at line 665 of file TauToolHolder.py.

665 def TauCommonCalcVarsCfg(flags):
666  result = ComponentAccumulator()
667  _name = flags.Tau.ActiveConfig.prefix + 'TauCommonCalcVars'
668 
669  TauCommonCalcVars = CompFactory.getComp("TauCommonCalcVars")
670  TauCommonCalcVars = TauCommonCalcVars(name = _name)
671 
672  result.setPrivateTools(TauCommonCalcVars)
673  return result
674 

◆ TauDecayModeNNClassifierCfg()

def TauToolHolder.TauDecayModeNNClassifierCfg (   flags)

Definition at line 898 of file TauToolHolder.py.

898 def TauDecayModeNNClassifierCfg(flags):
899  result = ComponentAccumulator()
900  _name = flags.Tau.ActiveConfig.prefix + 'TauDecayModeNNClassifier'
901 
902  TauDecayModeNNClassifier = CompFactory.getComp("TauDecayModeNNClassifier")
903  myTauDecayModeNNClassifier = TauDecayModeNNClassifier(name=_name,
904  WeightFile=flags.Tau.DecayModeNNClassifierConfig)
905 
906  result.setPrivateTools(myTauDecayModeNNClassifier)
907  return result
908 

◆ TauEleOverlapChecker()

def TauToolHolder.TauEleOverlapChecker (   flags)

Definition at line 951 of file TauToolHolder.py.

951 def TauEleOverlapChecker(flags):
952  result = ComponentAccumulator()
953  _name = flags.Tau.ActiveConfig.prefix + 'TauEleOverlapChecker'
954  TauEleOverlapChecker = CompFactory.getComp("TauEleOverlapChecker")
955  myTauEleOverlapChecker = TauEleOverlapChecker(
956  name = _name,
957  Key_RemovedClustersContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
958  Key_RemovedTracksContainer = flags.Tau.ActiveConfig.RemovedElectronTracks,
959  CheckingCone = flags.Tau.ActiveConfig.EleRM_CheckingConeSize,
960  )
961  result.setPrivateTools(myTauEleOverlapChecker)
962  return result

◆ TauEleRNNEvaluatorCfg()

def TauToolHolder.TauEleRNNEvaluatorCfg (   flags)

Definition at line 827 of file TauToolHolder.py.

827 def TauEleRNNEvaluatorCfg(flags):
828  result = ComponentAccumulator()
829  _name = flags.Tau.ActiveConfig.prefix + 'TauEleRNN'
830 
831  TauJetRNNEvaluator = CompFactory.getComp("TauJetRNNEvaluator")
832  RNNConf = flags.Tau.TauEleRNNConfig
833  myTauEleRNNEvaluator = TauJetRNNEvaluator(name = _name,
834  NetworkFile1P = RNNConf[0],
835  NetworkFile3P = RNNConf[1],
836  OutputVarname = "RNNEleScore",
837  MaxTracks = 10,
838  MaxClusters = 6,
839  MaxClusterDR = 1.0,
840  VertexCorrection = True,
841  InputLayerScalar = "scalar",
842  InputLayerTracks = "tracks",
843  InputLayerClusters = "clusters",
844  OutputLayer = "rnneveto_output",
845  OutputNode = "sig_prob")
846 
847  result.setPrivateTools(myTauEleRNNEvaluator)
848  return result
849 

◆ TauGNNEvaluatorCfg()

def TauToolHolder.TauGNNEvaluatorCfg (   flags,
  version = 0 
)

Definition at line 781 of file TauToolHolder.py.

781 def TauGNNEvaluatorCfg(flags, version=0):
782  result = ComponentAccumulator()
783  _name = flags.Tau.ActiveConfig.prefix + 'TauGNN_v' + str(version)
784 
785  TauGNNEvaluator = CompFactory.getComp("TauGNNEvaluator")
786  GNNConf = flags.Tau.TauGNNConfig[version]
787  myTauGNNEvaluator = TauGNNEvaluator(name = _name,
788  NetworkFile = GNNConf,
789  OutputVarname = flags.Tau.GNTauScoreName[version],
790  OutputPTau = "GNTauProbTau",
791  OutputPJet = "GNTauProbJet",
792  MaxTracks = flags.Tau.GNTauMaxTracks[version],
793  MaxClusters = flags.Tau.GNTauMaxClusters[version],
794  MaxClusterDR = 15.0,
795  MinTauPt = flags.Tau.MinPtDAOD,
796  VertexCorrection = True,
797  DecorateTracks = False,
798  InputLayerScalar = "tau_vars",
799  InputLayerTracks = "track_vars",
800  InputLayerClusters = "cluster_vars",
801  NodeNameTau=flags.Tau.GNTauNodeNameTau,
802  NodeNameJet=flags.Tau.GNTauNodeNameJet)
803 
804  result.setPrivateTools(myTauGNNEvaluator)
805  return result
806 

◆ TauIDVarCalculatorCfg()

def TauToolHolder.TauIDVarCalculatorCfg (   flags)

Definition at line 715 of file TauToolHolder.py.

715 def TauIDVarCalculatorCfg(flags):
716  result = ComponentAccumulator()
717  _name = flags.Tau.ActiveConfig.prefix + 'TauIDVarCalculator'
718 
719  TauIDVarCalculator = CompFactory.getComp("TauIDVarCalculator")
720  myTauIDVarCalculator = TauIDVarCalculator(name=_name,
721  VertexCorrection = True)
722 
723  result.setPrivateTools(myTauIDVarCalculator)
724  return result
725 

◆ TauJetRNNEvaluatorCfg()

def TauToolHolder.TauJetRNNEvaluatorCfg (   flags)

Definition at line 726 of file TauToolHolder.py.

726 def TauJetRNNEvaluatorCfg(flags):
727  result = ComponentAccumulator()
728  _name = flags.Tau.ActiveConfig.prefix + 'TauJetRNN'
729 
730  TauJetRNNEvaluator = CompFactory.getComp("TauJetRNNEvaluator")
731  RNNConf = flags.Tau.TauJetRNNConfig
732  myTauJetRNNEvaluator = TauJetRNNEvaluator(name = _name,
733  NetworkFile0P = "",
734  NetworkFile1P = RNNConf[0],
735  NetworkFile2P = RNNConf[1],
736  NetworkFile3P = RNNConf[2],
737  OutputVarname = "RNNJetScore",
738  MaxTracks = 10,
739  MaxClusters = 6,
740  MaxClusterDR = 1.0,
741  VertexCorrection = True,
742  InputLayerScalar = "scalar",
743  InputLayerTracks = "tracks",
744  InputLayerClusters = "clusters",
745  OutputLayer = "rnnid_output",
746  OutputNode = "sig_prob")
747 
748  result.setPrivateTools(myTauJetRNNEvaluator)
749  return result
750 

◆ TauShotFinderCfg()

def TauToolHolder.TauShotFinderCfg (   flags)

Photon Shot Finder.

Definition at line 264 of file TauToolHolder.py.

264 def TauShotFinderCfg(flags):
265  result = ComponentAccumulator()
266  _name = flags.Tau.ActiveConfig.prefix + 'TauShotFinder'
267 
268  shotPtCut_1Photon = flags.Tau.shotPtCut_1Photon
269  shotPtCut_2Photons = flags.Tau.shotPtCut_2Photons
270 
271 
272  from CaloClusterCorrection.StandardCellWeightCalib import getCellWeightTool
273  CaloWeightTool = getCellWeightTool(flags=flags)
274 
275 
276  TauShotFinder = CompFactory.getComp("TauShotFinder")
277  TauShotFinder = TauShotFinder(
278  name = _name,
279  CaloWeightTool = result.popToolsAndMerge(CaloWeightTool),
280  NCellsInEta = 5,
281  MinPtCut = shotPtCut_1Photon,
282  AutoDoubleShotCut = shotPtCut_2Photons,
283  Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
284  RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
285  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
286  )
287 
288  result.setPrivateTools(TauShotFinder)
289  return result
290 

◆ TauSubstructureCfg()

def TauToolHolder.TauSubstructureCfg (   flags)

Tau Variables.

Definition at line 677 of file TauToolHolder.py.

677 def TauSubstructureCfg(flags):
678  result = ComponentAccumulator()
679  _name = flags.Tau.ActiveConfig.prefix + 'TauSubstructure'
680 
681  TauSubstructureVariables = CompFactory.getComp("TauSubstructureVariables")
682  TauSubstructureVariables = TauSubstructureVariables( name = _name )
683 
684  result.setPrivateTools(TauSubstructureVariables)
685  return result
686 

◆ TauTrackFinderCfg()

def TauToolHolder.TauTrackFinderCfg (   flags)

Tau-Track Association.

Definition at line 82 of file TauToolHolder.py.

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  #maxDeltaZ0wrtLeadTrk = 2, #in mm
112  #removeTracksOutsideZ0wrtLeadTrk = True
113  )
114  result.setPrivateTools(TauTrackFinder)
115  return result
116 

◆ TauTrackRNNCfg()

def TauToolHolder.TauTrackRNNCfg (   flags)

Definition at line 147 of file TauToolHolder.py.

147 def TauTrackRNNCfg(flags):
148  result = ComponentAccumulator()
149  _name = flags.Tau.ActiveConfig.prefix + 'TauTrackRNNClassifier'
150 
151  TrackRNN = CompFactory.tauRecTools.TrackRNN
152  _RNN = TrackRNN(name = _name + "_TrackRNN",
153  InputWeightsPath = flags.Tau.tauRNNTrackClassConfig,
154  calibFolder = flags.Tau.tauRecToolsCVMFSPath )
155 
156  result.setPrivateTools(_RNN)
157  return result
158 

◆ TauTrackRNNClassifierCfg()

def TauToolHolder.TauTrackRNNClassifierCfg (   flags)

Definition at line 160 of file TauToolHolder.py.

160 def TauTrackRNNClassifierCfg(flags):
161  result = ComponentAccumulator()
162  _name = flags.Tau.ActiveConfig.prefix + 'TauTrackRNNClassifier'
163 
164  # create tool alg
165  TauTrackRNNClassifier = CompFactory.tauRecTools.TauTrackRNNClassifier
166 
167  import cppyy
168  cppyy.load_library('libxAODTau_cDict')
169 
170  _classifyLRT = True
171  if flags.Tau.associateLRT and not flags.Tau.classifyLRT:
172  _classifyLRT = False
173 
174  myTauTrackClassifier = TauTrackRNNClassifier( name = _name,
175  Classifiers = [ result.popToolsAndMerge(TauTrackRNNCfg(flags)) ],
176  classifyLRT = _classifyLRT )
177 
178  result.setPrivateTools(myTauTrackClassifier)
179  return result
180 

◆ TauVertexedClusterDecoratorCfg()

def TauToolHolder.TauVertexedClusterDecoratorCfg (   flags)

Definition at line 135 of file TauToolHolder.py.

135 def TauVertexedClusterDecoratorCfg(flags):
136  result = ComponentAccumulator()
137  _name = flags.Tau.ActiveConfig.prefix + 'TauVertexedClusterDecorator'
138 
139  TauVertexedClusterDecorator = CompFactory.getComp("TauVertexedClusterDecorator")
140  myTauVertexedClusterDecorator = TauVertexedClusterDecorator(name = _name,
141  SeedJet = flags.Tau.ActiveConfig.SeedJetCollection)
142 
143  result.setPrivateTools(myTauVertexedClusterDecorator)
144  return result
145 

◆ TauVertexFinderCfg()

def TauToolHolder.TauVertexFinderCfg (   flags)

Definition at line 32 of file TauToolHolder.py.

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 

◆ TauVertexVariablesCfg()

def TauToolHolder.TauVertexVariablesCfg (   flags)

Tau Vertex Variables.

Definition at line 647 of file TauToolHolder.py.

647 def TauVertexVariablesCfg(flags):
648  result = ComponentAccumulator()
649  _name = flags.Tau.ActiveConfig.prefix + 'TauVertexVariables'
650 
651  from TrkConfig.TrkVertexFittersConfig import TauAdaptiveVertexFitterCfg
652  from TrkConfig.TrkVertexSeedFinderToolsConfig import (
653  CrossDistancesSeedFinderCfg)
654 
655  TauVertexVariables = CompFactory.getComp("TauVertexVariables")
656  TauVertexVariables = TauVertexVariables( name = _name,
657  VertexFitter = result.popToolsAndMerge(TauAdaptiveVertexFitterCfg(flags)),
658  SeedFinder = result.popToolsAndMerge(CrossDistancesSeedFinderCfg(flags)) )
659 
660  result.setPrivateTools(TauVertexVariables)
661  return result
662 

◆ TauWPDecoratorEleRNNCfg()

def TauToolHolder.TauWPDecoratorEleRNNCfg (   flags)

Definition at line 850 of file TauToolHolder.py.

850 def TauWPDecoratorEleRNNCfg(flags):
851  import PyUtils.RootUtils as ru
852  ROOT = ru.import_root()
853  import cppyy
854  cppyy.load_library('libxAODTau_cDict')
855 
856  result = ComponentAccumulator()
857  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNN'
858 
859  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
860  WPConf = flags.Tau.TauEleRNNWPConfig
861  myTauEleWPDecorator = TauWPDecorator( name=_name,
862  flatteningFile1Prong = WPConf[0],
863  flatteningFile3Prong = WPConf[1],
864  CutEnumVals =
865  [ ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNLoose,
866  ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNMedium,
867  ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNTight ],
868  SigEff1P = [0.95, 0.90, 0.85],
869  SigEff3P = [0.98, 0.95, 0.90],
870  UseAbsEta = True ,
871  ScoreName = "RNNEleScore",
872  NewScoreName = "RNNEleScoreSigTrans",
873  DefineWPs = True)
874 
875  result.setPrivateTools(myTauEleWPDecorator)
876  return result
877 

◆ TauWPDecoratorEleRNNFixCfg()

def TauToolHolder.TauWPDecoratorEleRNNFixCfg (   flags)

Definition at line 878 of file TauToolHolder.py.

878 def TauWPDecoratorEleRNNFixCfg(flags):
879  result = ComponentAccumulator()
880  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNNFix_v1'
881 
882  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
883  WPConf = flags.Tau.TauEleRNNWPfix
884  myTauEleWPDecorator = TauWPDecorator(name = _name,
885  flatteningFile1Prong = WPConf[0],
886  flatteningFile3Prong = WPConf[1],
887  DecorWPNames = [ "EleRNNLoose_v1", "EleRNNMedium_v1", "EleRNNTight_v1" ],
888  DecorWPCutEffs1P = [0.95, 0.90, 0.85],
889  DecorWPCutEffs3P = [0.98, 0.95, 0.90],
890  UseAbsEta = True,
891  ScoreName = "RNNEleScore",
892  NewScoreName = "RNNEleScoreSigTrans_v1",
893  DefineWPs = True)
894 
895  result.setPrivateTools(myTauEleWPDecorator)
896  return result
897 

◆ TauWPDecoratorGNNCfg()

def TauToolHolder.TauWPDecoratorGNNCfg (   flags,
  version 
)

Definition at line 807 of file TauToolHolder.py.

807 def TauWPDecoratorGNNCfg(flags, version):
808  result = ComponentAccumulator()
809  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorGNN_v' + str(version)
810 
811  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
812  WPConf = flags.Tau.TauGNNWP[version]
813  myTauWPDecorator = TauWPDecorator(name=_name,
814  flatteningFile1Prong = WPConf[0],
815  flatteningFile2Prong = WPConf[1],
816  flatteningFile3Prong = WPConf[2],
817  DecorWPNames = flags.Tau.GNTauDecorWPNames[version],
818  DecorWPCutEffs1P = [0.95, 0.85, 0.75, 0.60],
819  DecorWPCutEffs2P = [0.95, 0.75, 0.60, 0.45],
820  DecorWPCutEffs3P = [0.95, 0.75, 0.60, 0.45],
821  ScoreName = flags.Tau.GNTauScoreName[version],
822  NewScoreName = flags.Tau.GNTauTransScoreName[version],
823  DefineWPs = True)
824  result.setPrivateTools(myTauWPDecorator)
825  return result
826 

◆ TauWPDecoratorJetRNNCfg()

def TauToolHolder.TauWPDecoratorJetRNNCfg (   flags)

Definition at line 751 of file TauToolHolder.py.

751 def TauWPDecoratorJetRNNCfg(flags):
752  import PyUtils.RootUtils as ru
753  ROOT = ru.import_root()
754  import cppyy
755  cppyy.load_library('libxAODTau_cDict')
756 
757  result = ComponentAccumulator()
758  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorJetRNN'
759 
760  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
761  WPConf = flags.Tau.TauJetRNNWPConfig
762  myTauWPDecorator = TauWPDecorator( name=_name,
763  flatteningFile1Prong = WPConf[0],
764  flatteningFile2Prong = WPConf[1],
765  flatteningFile3Prong = WPConf[2],
766  CutEnumVals =
767  [ ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigVeryLoose,
768  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigLoose,
769  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigMedium,
770  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigTight ],
771  SigEff1P = [0.95, 0.85, 0.75, 0.60],
772  SigEff2P = [0.95, 0.75, 0.60, 0.45],
773  SigEff3P = [0.95, 0.75, 0.60, 0.45],
774  ScoreName = "RNNJetScore",
775  NewScoreName = "RNNJetScoreSigTrans",
776  DefineWPs = True )
777 
778  result.setPrivateTools(myTauWPDecorator)
779  return result
780 
TauToolHolder.TauDecayModeNNClassifierCfg
def TauDecayModeNNClassifierCfg(flags)
Definition: TauToolHolder.py:898
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:147
TauToolHolder.TauClusterFinderCfg
def TauClusterFinderCfg(flags)
Associate the cluster in jet constituents to the tau candidate.
Definition: TauToolHolder.py:119
TauToolHolder.TauVertexedClusterDecoratorCfg
def TauVertexedClusterDecoratorCfg(flags)
Definition: TauToolHolder.py:135
TauPi0CreateROI
Find the cells used to create pi0 cluster.
Definition: TauPi0CreateROI.h:30
TauToolHolder.TauAODMuonRemovalCfg
def TauAODMuonRemovalCfg(flags)
muon removal tool
Definition: TauToolHolder.py:937
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:619
TauToolHolder.TauCaloClusterBadChannelCfg
def TauCaloClusterBadChannelCfg(flags)
Definition: TauToolHolder.py:583
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:703
TauToolHolder.TauEleRNNEvaluatorCfg
def TauEleRNNEvaluatorCfg(flags)
Definition: TauToolHolder.py:827
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:431
TrackVertexAssociationToolConfig.TauTTVAToolCfg
def TauTTVAToolCfg(flags, name="TVATool", **kwargs)
Definition: TrackVertexAssociationToolConfig.py:42
TauToolHolder.TauTrackRNNClassifierCfg
def TauTrackRNNClassifierCfg(flags)
Definition: TauToolHolder.py:160
TauToolHolder.TauJetRNNEvaluatorCfg
def TauJetRNNEvaluatorCfg(flags)
Definition: TauToolHolder.py:726
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:519
TauToolHolder.Pi0ClusterCreatorCfg
def Pi0ClusterCreatorCfg(flags)
create Pi0 clusters
Definition: TauToolHolder.py:595
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:689
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:327
H1WeightToolCSC12Generic
Definition: H1WeightToolCSC12Generic.h:28
TauToolHolder.TauCaloClusterMomentsMakerCfg
def TauCaloClusterMomentsMakerCfg(flags)
Definition: TauToolHolder.py:543
TauToolHolder.ElectronVetoVarsCfg
def ElectronVetoVarsCfg(flags)
ele veto variables
Definition: TauToolHolder.py:210
TauToolHolder.CellWeightToolCfg
def CellWeightToolCfg(flags)
cell weight tool
Definition: TauToolHolder.py:227
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:473
TauToolHolder.TauGNNEvaluatorCfg
def TauGNNEvaluatorCfg(flags, version=0)
Definition: TauToolHolder.py:781
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:951
TauToolHolder.TauSubstructureCfg
def TauSubstructureCfg(flags)
Tau Variables.
Definition: TauToolHolder.py:677
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:418
TauToolHolder.TauCaloLCDeadMaterialCfg
def TauCaloLCDeadMaterialCfg(flags)
Definition: TauToolHolder.py:389
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:444
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:632
TauToolHolder.TauVertexVariablesCfg
def TauVertexVariablesCfg(flags)
Tau Vertex Variables.
Definition: TauToolHolder.py:647
TauToolHolder.CellVariablesCfg
def CellVariablesCfg(flags)
Tau cell variables calculation.
Definition: TauToolHolder.py:197
TauToolHolder.EnergyCalibrationLCCfg
def EnergyCalibrationLCCfg(flags)
Tau energy calibration.
Definition: TauToolHolder.py:183
TauElectronVetoVariables
Calculate variables sensitive on electrons.
Definition: TauElectronVetoVariables.h:27
TauToolHolder.TauWPDecoratorGNNCfg
def TauWPDecoratorGNNCfg(flags, version)
Definition: TauToolHolder.py:807
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.TauCaloLCOutPi0Cfg
def TauCaloLCOutPi0Cfg(flags)
Definition: TauToolHolder.py:376
TauToolHolder.TauAODSelectorCfg
def TauAODSelectorCfg(flags)
Definition: TauToolHolder.py:909
TauToolHolder.TauCaloClusterLocalCalibCfg
def TauCaloClusterLocalCalibCfg(flags)
Definition: TauToolHolder.py:404
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
TauToolHolder.JetSeedBuilderCfg
def JetSeedBuilderCfg(flags)
JetSeedBuilder.
Definition: TauToolHolder.py:21
TauToolHolder.TauCaloClusterCellWeightCalibCfg
def TauCaloClusterCellWeightCalibCfg(flags)
Definition: TauToolHolder.py:457
TauToolHolder.TauWPDecoratorEleRNNCfg
def TauWPDecoratorEleRNNCfg(flags)
Definition: TauToolHolder.py:850
TauToolHolder.TauCombinedTESCfg
def TauCombinedTESCfg(flags)
TauCombinedTES.
Definition: TauToolHolder.py:924
CaloClusterMomentsMaker
Calculate moments for CaloCluster objects.
Definition: CaloClusterMomentsMaker.h:50
TauToolHolder.TauCellFinalizerCfg
def TauCellFinalizerCfg(flags)
Cell finalizer tool for BuildAlg.
Definition: TauToolHolder.py:313
TauToolHolder.TauCommonCalcVarsCfg
def TauCommonCalcVarsCfg(flags)
Tau Variables.
Definition: TauToolHolder.py:665
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:878
TauToolHolder.TauCaloLCWeightCfg
def TauCaloLCWeightCfg(flags)
Definition: TauToolHolder.py:344
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:264
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:607
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:363
TauToolHolder.TauTrackFinderCfg
def TauTrackFinderCfg(flags)
Tau-Track Association.
Definition: TauToolHolder.py:82
TauToolHolder.TauWPDecoratorJetRNNCfg
def TauWPDecoratorJetRNNCfg(flags)
Definition: TauToolHolder.py:751
TauToolHolder.Pi0ClusterFinderCfg
def Pi0ClusterFinderCfg(flags)
Pi0 algo Cluster finder for Pi0 algo.
Definition: TauToolHolder.py:294
TauJetRNNEvaluator
Tool to calculate a tau identification score based on neural networks.
Definition: TauJetRNNEvaluator.h:27
TauToolHolder.TauIDVarCalculatorCfg
def TauIDVarCalculatorCfg(flags)
Definition: TauToolHolder.py:715
CaloTopoClusterMaker
topological cluster maker.
Definition: CaloTopoClusterMaker.h:48
TrackToCaloConfig.ParticleCaloExtensionToolCfg
def ParticleCaloExtensionToolCfg(flags, name='ParticleCaloExtensionTool', **kwargs)
Definition: TrackToCaloConfig.py:10
TauAODLeptonRemovalTool
the tool meant to run at AOD level, to remove the lepton found inside the TauJet.
Definition: TauAODLeptonRemovalTool.h:21
Generated on Thu Nov 7 2024 22:26:18 for ATLAS Offline Software by   doxygen 1.8.18