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 195 of file TauToolHolder.py.

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 

◆ CellWeightToolCfg()

def TauToolHolder.CellWeightToolCfg (   flags)

cell weight tool

Definition at line 225 of file TauToolHolder.py.

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

◆ ElectronVetoVarsCfg()

def TauToolHolder.ElectronVetoVarsCfg (   flags)

ele veto variables

Definition at line 208 of file TauToolHolder.py.

208 def ElectronVetoVarsCfg(flags):
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 

◆ EnergyCalibrationLCCfg()

def TauToolHolder.EnergyCalibrationLCCfg (   flags)

Tau energy calibration.

Definition at line 181 of file TauToolHolder.py.

181 def EnergyCalibrationLCCfg(flags):
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 

◆ 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 701 of file TauToolHolder.py.

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

◆ MvaTESVariableDecoratorCfg()

def TauToolHolder.MvaTESVariableDecoratorCfg (   flags)

MvaTESVariableDecorator.

Definition at line 687 of file TauToolHolder.py.

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

◆ Pi0ClusterCreatorCfg()

def TauToolHolder.Pi0ClusterCreatorCfg (   flags)

create Pi0 clusters

Definition at line 593 of file TauToolHolder.py.

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

◆ Pi0ClusterFinderCfg()

def TauToolHolder.Pi0ClusterFinderCfg (   flags)

Pi0 algo Cluster finder for Pi0 algo.

Definition at line 292 of file TauToolHolder.py.

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

◆ Pi0ClusterScalerCfg()

def TauToolHolder.Pi0ClusterScalerCfg (   flags)

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

Definition at line 605 of file TauToolHolder.py.

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

◆ Pi0ScoreCalculatorCfg()

def TauToolHolder.Pi0ScoreCalculatorCfg (   flags)

calculate MVA scores of pi0 clusters

Definition at line 617 of file TauToolHolder.py.

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

◆ Pi0SelectorCfg()

def TauToolHolder.Pi0SelectorCfg (   flags)

select pi0 clusters

Definition at line 630 of file TauToolHolder.py.

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

◆ TauAODMuonRemovalCfg()

def TauToolHolder.TauAODMuonRemovalCfg (   flags)

muon removal tool

Definition at line 935 of file TauToolHolder.py.

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

◆ TauAODSelectorCfg()

def TauToolHolder.TauAODSelectorCfg (   flags)

Definition at line 907 of file TauToolHolder.py.

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

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

◆ TauCaloClusterBadChannelCfg()

def TauToolHolder.TauCaloClusterBadChannelCfg (   flags)

Definition at line 581 of file TauToolHolder.py.

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

◆ TauCaloClusterCellWeightCalibCfg()

def TauToolHolder.TauCaloClusterCellWeightCalibCfg (   flags)

Definition at line 455 of file TauToolHolder.py.

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

◆ TauCaloClusterLocalCalibCfg()

def TauToolHolder.TauCaloClusterLocalCalibCfg (   flags)

Definition at line 402 of file TauToolHolder.py.

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

◆ TauCaloClusterMomentsMakerCfg()

def TauToolHolder.TauCaloClusterMomentsMakerCfg (   flags)

Definition at line 541 of file TauToolHolder.py.

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

◆ TauCaloDMCalibCfg()

def TauToolHolder.TauCaloDMCalibCfg (   flags)

Definition at line 429 of file TauToolHolder.py.

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

◆ TauCaloLCClassificationCfg()

def TauToolHolder.TauCaloLCClassificationCfg (   flags)

Calo Tools.

Definition at line 325 of file TauToolHolder.py.

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

◆ TauCaloLCDeadMaterialCfg()

def TauToolHolder.TauCaloLCDeadMaterialCfg (   flags)

Definition at line 387 of file TauToolHolder.py.

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

◆ TauCaloLCOutOfClusterCfg()

def TauToolHolder.TauCaloLCOutOfClusterCfg (   flags)

Definition at line 361 of file TauToolHolder.py.

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

◆ TauCaloLCOutPi0Cfg()

def TauToolHolder.TauCaloLCOutPi0Cfg (   flags)

Definition at line 374 of file TauToolHolder.py.

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

◆ TauCaloLCWeightCfg()

def TauToolHolder.TauCaloLCWeightCfg (   flags)

Definition at line 342 of file TauToolHolder.py.

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

◆ TauCaloOOCCalibCfg()

def TauToolHolder.TauCaloOOCCalibCfg (   flags)

Definition at line 416 of file TauToolHolder.py.

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

◆ TauCaloOOCPi0CalibCfg()

def TauToolHolder.TauCaloOOCPi0CalibCfg (   flags)

Definition at line 442 of file TauToolHolder.py.

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

◆ TauCaloTopoClusterMakerCfg()

def TauToolHolder.TauCaloTopoClusterMakerCfg (   flags)

Definition at line 471 of file TauToolHolder.py.

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

◆ TauCaloTopoClusterSplitterCfg()

def TauToolHolder.TauCaloTopoClusterSplitterCfg (   flags)

Definition at line 517 of file TauToolHolder.py.

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

◆ TauCellFinalizerCfg()

def TauToolHolder.TauCellFinalizerCfg (   flags)

Cell finalizer tool for BuildAlg.

Definition at line 311 of file TauToolHolder.py.

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

◆ TauClusterFinderCfg()

def TauToolHolder.TauClusterFinderCfg (   flags)

Associate the cluster in jet constituents to the tau candidate.

Definition at line 117 of file TauToolHolder.py.

117 def TauClusterFinderCfg(flags):
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 

◆ TauCombinedTESCfg()

def TauToolHolder.TauCombinedTESCfg (   flags)

TauCombinedTES.

Definition at line 922 of file TauToolHolder.py.

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

◆ TauCommonCalcVarsCfg()

def TauToolHolder.TauCommonCalcVarsCfg (   flags)

Tau Variables.

Definition at line 663 of file TauToolHolder.py.

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

◆ TauDecayModeNNClassifierCfg()

def TauToolHolder.TauDecayModeNNClassifierCfg (   flags)

Definition at line 896 of file TauToolHolder.py.

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

◆ TauEleOverlapChecker()

def TauToolHolder.TauEleOverlapChecker (   flags)

Definition at line 949 of file TauToolHolder.py.

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

◆ TauEleRNNEvaluatorCfg()

def TauToolHolder.TauEleRNNEvaluatorCfg (   flags)

Definition at line 825 of file TauToolHolder.py.

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

◆ TauGNNEvaluatorCfg()

def TauToolHolder.TauGNNEvaluatorCfg (   flags,
  version = 0 
)

Definition at line 779 of file TauToolHolder.py.

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

◆ TauIDVarCalculatorCfg()

def TauToolHolder.TauIDVarCalculatorCfg (   flags)

Definition at line 713 of file TauToolHolder.py.

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

◆ TauJetRNNEvaluatorCfg()

def TauToolHolder.TauJetRNNEvaluatorCfg (   flags)

Definition at line 724 of file TauToolHolder.py.

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

◆ TauShotFinderCfg()

def TauToolHolder.TauShotFinderCfg (   flags)

Photon Shot Finder.

Definition at line 262 of file TauToolHolder.py.

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

◆ TauSubstructureCfg()

def TauToolHolder.TauSubstructureCfg (   flags)

Tau Variables.

Definition at line 675 of file TauToolHolder.py.

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

◆ 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  )
112  result.setPrivateTools(TauTrackFinder)
113  return result
114 

◆ TauTrackRNNCfg()

def TauToolHolder.TauTrackRNNCfg (   flags)

Definition at line 145 of file TauToolHolder.py.

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 

◆ TauTrackRNNClassifierCfg()

def TauToolHolder.TauTrackRNNClassifierCfg (   flags)

Definition at line 158 of file TauToolHolder.py.

158 def TauTrackRNNClassifierCfg(flags):
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 

◆ TauVertexedClusterDecoratorCfg()

def TauToolHolder.TauVertexedClusterDecoratorCfg (   flags)

Definition at line 133 of file TauToolHolder.py.

133 def TauVertexedClusterDecoratorCfg(flags):
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 

◆ 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 645 of file TauToolHolder.py.

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

◆ TauWPDecoratorEleRNNCfg()

def TauToolHolder.TauWPDecoratorEleRNNCfg (   flags)

Definition at line 848 of file TauToolHolder.py.

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

◆ TauWPDecoratorEleRNNFixCfg()

def TauToolHolder.TauWPDecoratorEleRNNFixCfg (   flags)

Definition at line 876 of file TauToolHolder.py.

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

◆ TauWPDecoratorGNNCfg()

def TauToolHolder.TauWPDecoratorGNNCfg (   flags,
  version 
)

Definition at line 805 of file TauToolHolder.py.

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

◆ TauWPDecoratorJetRNNCfg()

def TauToolHolder.TauWPDecoratorJetRNNCfg (   flags)

Definition at line 749 of file TauToolHolder.py.

749 def TauWPDecoratorJetRNNCfg(flags):
750  import PyUtils.RootUtils as ru
751  ROOT = ru.import_root()
752  import cppyy
753  cppyy.load_library('libxAODTau_cDict')
754 
755  result = ComponentAccumulator()
756  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorJetRNN'
757 
758  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
759  WPConf = flags.Tau.TauJetRNNWPConfig
760  myTauWPDecorator = TauWPDecorator( name=_name,
761  flatteningFile1Prong = WPConf[0],
762  flatteningFile2Prong = WPConf[1],
763  flatteningFile3Prong = WPConf[2],
764  CutEnumVals =
765  [ ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigVeryLoose,
766  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigLoose,
767  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigMedium,
768  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigTight ],
769  SigEff1P = [0.95, 0.85, 0.75, 0.60],
770  SigEff2P = [0.95, 0.75, 0.60, 0.45],
771  SigEff3P = [0.95, 0.75, 0.60, 0.45],
772  ScoreName = "RNNJetScore",
773  NewScoreName = "RNNJetScoreSigTrans",
774  DefineWPs = True )
775 
776  result.setPrivateTools(myTauWPDecorator)
777  return result
778 
TauToolHolder.TauDecayModeNNClassifierCfg
def TauDecayModeNNClassifierCfg(flags)
Definition: TauToolHolder.py:896
TauWPDecorator
Implementation of tool to decorate flattened BDT score and working points.
Definition: TauWPDecorator.h:34
TauCommonCalcVars
Calculate variables which rely on tracks and precalculated cell/cluster information.
Definition: TauCommonCalcVars.h:20
TauAODSelector
Definition: TauAODSelector.h:10
TauSubstructureVariables
Calculate variables from the tau substructure.
Definition: TauSubstructureVariables.h:20
python.TrkVertexFittersConfig.TauAdaptiveVertexFitterCfg
def TauAdaptiveVertexFitterCfg(flags, name="TauAdaptiveVertexFitter", **kwargs)
Definition: TrkVertexFittersConfig.py:97
TauToolHolder.TauTrackRNNCfg
def TauTrackRNNCfg(flags)
Definition: TauToolHolder.py:145
TauToolHolder.TauClusterFinderCfg
def TauClusterFinderCfg(flags)
Associate the cluster in jet constituents to the tau candidate.
Definition: TauToolHolder.py:117
TauToolHolder.TauVertexedClusterDecoratorCfg
def TauVertexedClusterDecoratorCfg(flags)
Definition: TauToolHolder.py:133
TauPi0CreateROI
Find the cells used to create pi0 cluster.
Definition: TauPi0CreateROI.h:30
TauToolHolder.TauAODMuonRemovalCfg
def TauAODMuonRemovalCfg(flags)
muon removal tool
Definition: TauToolHolder.py:935
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
TauEleOverlapChecker
Select only the tau within the removal direction.
Definition: TauEleOverlapChecker.h:25
TauToolHolder.Pi0ScoreCalculatorCfg
def Pi0ScoreCalculatorCfg(flags)
calculate MVA scores of pi0 clusters
Definition: TauToolHolder.py:617
TauToolHolder.TauCaloClusterBadChannelCfg
def TauCaloClusterBadChannelCfg(flags)
Definition: TauToolHolder.py:581
TauVertexVariables
Class for calculating vertex variables.
Definition: TauVertexVariables.h:23
python.TrkVertexFitterUtilsConfig.AtlasTrackToVertexIPEstimatorCfg
def AtlasTrackToVertexIPEstimatorCfg(flags, name='AtlasTrackToVertexIPEstimator', **kwargs)
Definition: TrkVertexFitterUtilsConfig.py:63
python.BeamSpotConditionsConfig.BeamSpotCondAlgCfg
def BeamSpotCondAlgCfg(flags, name="BeamSpotCondAlg", **kwargs)
Definition: BeamSpotConditionsConfig.py:7
TauToolHolder.MvaTESEvaluatorCfg
def MvaTESEvaluatorCfg(flags)
MvaTESEvaluator.
Definition: TauToolHolder.py:701
TauToolHolder.TauEleRNNEvaluatorCfg
def TauEleRNNEvaluatorCfg(flags)
Definition: TauToolHolder.py:825
CaloCellContainerFinalizerTool
Definition: CaloCellContainerFinalizerTool.h:20
TauToolHolder.TauAxisCfg
def TauAxisCfg(flags)
Tau energy calibration and tau axis direction.
Definition: TauToolHolder.py:57
python.InDetTrackSelectorToolConfig.TauRecInDetTrackSelectorToolCfg
def TauRecInDetTrackSelectorToolCfg(flags, name='tauRec_InDetTrackSelectorTool', **kwargs)
Definition: InDetTrackSelectorToolConfig.py:197
TauCombinedTES
Definition: TauCombinedTES.h:19
TauToolHolder.TauCaloDMCalibCfg
def TauCaloDMCalibCfg(flags)
Definition: TauToolHolder.py:429
TrackVertexAssociationToolConfig.TauTTVAToolCfg
def TauTTVAToolCfg(flags, name="TVATool", **kwargs)
Definition: TrackVertexAssociationToolConfig.py:42
TauToolHolder.TauTrackRNNClassifierCfg
def TauTrackRNNClassifierCfg(flags)
Definition: TauToolHolder.py:158
TauToolHolder.TauJetRNNEvaluatorCfg
def TauJetRNNEvaluatorCfg(flags)
Definition: TauToolHolder.py:724
CaloClusterLocalCalib
Cluster correction tool which applies local hadronic calibration w eights to the cells....
Definition: CaloClusterLocalCalib.h:32
TauToolHolder.TauCaloTopoClusterSplitterCfg
def TauCaloTopoClusterSplitterCfg(flags)
Definition: TauToolHolder.py:517
TauToolHolder.Pi0ClusterCreatorCfg
def Pi0ClusterCreatorCfg(flags)
create Pi0 clusters
Definition: TauToolHolder.py:593
CaloTopoClusterSplitter
topological cluster splitter.
Definition: CaloTopoClusterSplitter.h:48
StandardCellWeightCalib.editParm
def editParm(param)
Definition: StandardCellWeightCalib.py:14
TauToolHolder.MvaTESVariableDecoratorCfg
def MvaTESVariableDecoratorCfg(flags)
MvaTESVariableDecorator.
Definition: TauToolHolder.py:687
TauPi0ClusterCreator
Creates Pi0 clusters (Pi0 Finder).
Definition: TauPi0ClusterCreator.h:28
CaloClusterBadChannelListCorr
Definition: CaloClusterBadChannelListCorr.py:1
TauToolHolder.TauCaloLCClassificationCfg
def TauCaloLCClassificationCfg(flags)
Calo Tools.
Definition: TauToolHolder.py:325
H1WeightToolCSC12Generic
Definition: H1WeightToolCSC12Generic.h:28
TauToolHolder.TauCaloClusterMomentsMakerCfg
def TauCaloClusterMomentsMakerCfg(flags)
Definition: TauToolHolder.py:541
TauToolHolder.ElectronVetoVarsCfg
def ElectronVetoVarsCfg(flags)
ele veto variables
Definition: TauToolHolder.py:208
TauToolHolder.CellWeightToolCfg
def CellWeightToolCfg(flags)
cell weight tool
Definition: TauToolHolder.py:225
TauCalibrateLC
Implementation of tau energy scale (TES) with eta and pile-up correction.
Definition: TauCalibrateLC.h:24
TauToolHolder.TauCaloTopoClusterMakerCfg
def TauCaloTopoClusterMakerCfg(flags)
Definition: TauToolHolder.py:471
TauToolHolder.TauGNNEvaluatorCfg
def TauGNNEvaluatorCfg(flags, version=0)
Definition: TauToolHolder.py:779
StandardCellWeightCalib.getCellWeightTool
def getCellWeightTool(flags, finder="Cone", mainparam=0.4, input="Topo", onlyCellWeight=False)
Definition: StandardCellWeightCalib.py:178
MvaTESVariableDecorator
Definition: MvaTESVariableDecorator.h:15
TauPi0ScoreCalculator
Selectes pi0Candidates (Pi0 Finder).
Definition: TauPi0ScoreCalculator.h:24
TauToolHolder.getParticleCache
def getParticleCache(flags)
Definition: TauToolHolder.py:71
TauToolHolder.TauEleOverlapChecker
def TauEleOverlapChecker(flags)
Definition: TauToolHolder.py:949
TauToolHolder.TauSubstructureCfg
def TauSubstructureCfg(flags)
Tau Variables.
Definition: TauToolHolder.py:675
TauVertexedClusterDecorator
Decorate CaloVertexedTopoCluster to the tau candidate.
Definition: TauVertexedClusterDecorator.h:18
TauAxisSetter
Set Tau "Detector Axis" and "Intermediate Axis".
Definition: TauAxisSetter.h:28
python.CaloNoiseCondAlgConfig.CaloNoiseCondAlgCfg
def CaloNoiseCondAlgCfg(flags, noisetype="totalNoise")
Definition: CaloNoiseCondAlgConfig.py:11
CaloLCWeightTool
calculates hadronic cell weights based on cluster and cell quantities
Definition: CaloLCWeightTool.h:34
TauToolHolder.TauVertexFinderCfg
def TauVertexFinderCfg(flags)
Definition: TauToolHolder.py:32
TauPi0ClusterScaler
scale cluster energy to take care of charged pion energy
Definition: TauPi0ClusterScaler.h:22
TauDecayModeNNClassifier
Tau decay mode classifier using a neural network.
Definition: TauDecayModeNNClassifier.h:33
TauToolHolder.TauCaloOOCCalibCfg
def TauCaloOOCCalibCfg(flags)
Definition: TauToolHolder.py:416
TauToolHolder.TauCaloLCDeadMaterialCfg
def TauCaloLCDeadMaterialCfg(flags)
Definition: TauToolHolder.py:387
python.IOVDbSvcConfig.addFolders
def addFolders(flags, folderStrings, detDb=None, className=None, extensible=False, tag=None, db=None, modifiers='')
Definition: IOVDbSvcConfig.py:72
TauToolHolder.TauCaloOOCPi0CalibCfg
def TauCaloOOCPi0CalibCfg(flags)
Definition: TauToolHolder.py:442
TauPi0Selector
Apply Et and BDT score cut to pi0s.
Definition: TauPi0Selector.h:20
python.InDetTrackSelectionToolConfig.Tau_InDetTrackSelectionToolForTJVACfg
def Tau_InDetTrackSelectionToolForTJVACfg(flags, name="tauRec_InDetTrackSelectionToolForTJVA", **kwargs)
Definition: InDetTrackSelectionToolConfig.py:162
TauIDVarCalculator
This class implements a tool to calculate ID input variables and add them to the tau aux store.
Definition: TauIDVarCalculator.h:18
TauToolHolder.Pi0SelectorCfg
def Pi0SelectorCfg(flags)
select pi0 clusters
Definition: TauToolHolder.py:630
TauToolHolder.TauVertexVariablesCfg
def TauVertexVariablesCfg(flags)
Tau Vertex Variables.
Definition: TauToolHolder.py:645
TauToolHolder.CellVariablesCfg
def CellVariablesCfg(flags)
Tau cell variables calculation.
Definition: TauToolHolder.py:195
TauToolHolder.EnergyCalibrationLCCfg
def EnergyCalibrationLCCfg(flags)
Tau energy calibration.
Definition: TauToolHolder.py:181
TauElectronVetoVariables
Calculate variables sensitive on electrons.
Definition: TauElectronVetoVariables.h:27
TauToolHolder.TauWPDecoratorGNNCfg
def TauWPDecoratorGNNCfg(flags, version)
Definition: TauToolHolder.py:805
TauCellVariables
Calculate tau calorimeter variables from cell information.
Definition: TauCellVariables.h:16
CaloLCClassificationTool
classify clusters according to their probability to stem from an em object
Definition: CaloLCClassificationTool.h:29
TauToolHolder.TauCaloLCOutPi0Cfg
def TauCaloLCOutPi0Cfg(flags)
Definition: TauToolHolder.py:374
TauToolHolder.TauAODSelectorCfg
def TauAODSelectorCfg(flags)
Definition: TauToolHolder.py:907
TauToolHolder.TauCaloClusterLocalCalibCfg
def TauCaloClusterLocalCalibCfg(flags)
Definition: TauToolHolder.py:402
TauVertexFinder
Associate a vertex (origin) to the tau candidate.
Definition: TauVertexFinder.h:29
CaloLCOutOfClusterTool
calculates out-of-cluster corrections based on cluster quantities
Definition: CaloLCOutOfClusterTool.h:28
JetSeedBuilder
Class to build tau jet seed.
Definition: JetSeedBuilder.h:17
TauTrackFinder
Associate tracks to the tau candidate.
Definition: TauTrackFinder.h:39
TauAODMuonRemovalTool
the tool meant to run at AOD level, to remove the muon found inside the TauJet.
Definition: TauAODMuonRemovalTool.h:21
TauToolHolder.JetSeedBuilderCfg
def JetSeedBuilderCfg(flags)
JetSeedBuilder.
Definition: TauToolHolder.py:21
TauToolHolder.TauCaloClusterCellWeightCalibCfg
def TauCaloClusterCellWeightCalibCfg(flags)
Definition: TauToolHolder.py:455
TauToolHolder.TauWPDecoratorEleRNNCfg
def TauWPDecoratorEleRNNCfg(flags)
Definition: TauToolHolder.py:848
TauToolHolder.TauCombinedTESCfg
def TauCombinedTESCfg(flags)
TauCombinedTES.
Definition: TauToolHolder.py:922
CaloClusterMomentsMaker
Calculate moments for CaloCluster objects.
Definition: CaloClusterMomentsMaker.h:50
TauToolHolder.TauCellFinalizerCfg
def TauCellFinalizerCfg(flags)
Cell finalizer tool for BuildAlg.
Definition: TauToolHolder.py:311
TauToolHolder.TauCommonCalcVarsCfg
def TauCommonCalcVarsCfg(flags)
Tau Variables.
Definition: TauToolHolder.py:663
TauClusterFinder
Associate the clusters used in the seed jet to the tau candidate.
Definition: TauClusterFinder.h:21
TauGNNEvaluator
Tool to calculate tau identification score from .onnx inputs.
Definition: TauGNNEvaluator.h:26
TauToolHolder.TauWPDecoratorEleRNNFixCfg
def TauWPDecoratorEleRNNFixCfg(flags)
Definition: TauToolHolder.py:876
TauToolHolder.TauCaloLCWeightCfg
def TauCaloLCWeightCfg(flags)
Definition: TauToolHolder.py:342
TrackToVertexConfig.TrackToVertexCfg
def TrackToVertexCfg(flags, name="AtlasTrackToVertexTool", **kwargs)
Definition: TrackToVertexConfig.py:6
CaloClusterCellWeightCalib
Definition: CaloClusterCellWeightCalib.h:17
MvaTESEvaluator
Definition: MvaTESEvaluator.h:16
TauToolHolder.TauShotFinderCfg
def TauShotFinderCfg(flags)
Photon Shot Finder.
Definition: TauToolHolder.py:262
str
Definition: BTagTrackIpAccessor.cxx:11
TauToolHolder.Pi0ClusterScalerCfg
def Pi0ClusterScalerCfg(flags)
Set energy of cluster to take care of charged pion energy deposited in the ECAL.
Definition: TauToolHolder.py:605
TauShotFinder
Definition: TauShotFinder.h:30
python.TrkVertexSeedFinderToolsConfig.CrossDistancesSeedFinderCfg
def CrossDistancesSeedFinderCfg(flags, name="CrossDistancesSeedFinder", **kwargs)
Definition: TrkVertexSeedFinderToolsConfig.py:33
CaloLCDeadMaterialTool
dead material correction tool for local hadronic calibration
Definition: CaloLCDeadMaterialTool.h:40
TauToolHolder.TauCaloLCOutOfClusterCfg
def TauCaloLCOutOfClusterCfg(flags)
Definition: TauToolHolder.py:361
TauToolHolder.TauTrackFinderCfg
def TauTrackFinderCfg(flags)
Tau-Track Association.
Definition: TauToolHolder.py:82
TauToolHolder.TauWPDecoratorJetRNNCfg
def TauWPDecoratorJetRNNCfg(flags)
Definition: TauToolHolder.py:749
TauToolHolder.Pi0ClusterFinderCfg
def Pi0ClusterFinderCfg(flags)
Pi0 algo Cluster finder for Pi0 algo.
Definition: TauToolHolder.py:292
TauJetRNNEvaluator
Tool to calculate a tau identification score based on neural networks.
Definition: TauJetRNNEvaluator.h:27
TauToolHolder.TauIDVarCalculatorCfg
def TauIDVarCalculatorCfg(flags)
Definition: TauToolHolder.py:713
CaloTopoClusterMaker
topological cluster maker.
Definition: CaloTopoClusterMaker.h:48
TrackToCaloConfig.ParticleCaloExtensionToolCfg
def ParticleCaloExtensionToolCfg(flags, name='ParticleCaloExtensionTool', **kwargs)
Definition: TrackToCaloConfig.py:10
Generated on Sun Dec 22 2024 22:08:31 for ATLAS Offline Software by   doxygen 1.8.18