Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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 707 of file TauToolHolder.py.

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

◆ 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  eventShapeCollection = flags.Tau.ActiveConfig.EventShapeCollection
692  if 'EMPFlow' in flags.Tau.ActiveConfig.SeedJetCollection:
693  eventShapeCollection = "Kt4EMPFlowEventShape"
694  elif 'EMTopo' in flags.Tau.ActiveConfig.SeedJetCollection:
695  eventShapeCollection ="Kt4EMTopoOriginEventShape"
696 
697  MvaTESVariableDecorator = CompFactory.getComp("MvaTESVariableDecorator")
698  MvaTESVariableDecorator = MvaTESVariableDecorator(name = _name,
699  Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
700  EventShapeKey = eventShapeCollection,
701  VertexCorrection = flags.Tau.doVertexCorrection)
702  result.setPrivateTools(MvaTESVariableDecorator)
703  return result
704 

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

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

◆ TauAODSelectorCfg()

def TauToolHolder.TauAODSelectorCfg (   flags)

Definition at line 913 of file TauToolHolder.py.

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

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

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

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

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

◆ TauEleOverlapChecker()

def TauToolHolder.TauEleOverlapChecker (   flags)

Definition at line 955 of file TauToolHolder.py.

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

◆ TauEleRNNEvaluatorCfg()

def TauToolHolder.TauEleRNNEvaluatorCfg (   flags)

Definition at line 831 of file TauToolHolder.py.

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

◆ TauGNNEvaluatorCfg()

def TauToolHolder.TauGNNEvaluatorCfg (   flags,
  version = 0 
)

Definition at line 785 of file TauToolHolder.py.

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

◆ TauIDVarCalculatorCfg()

def TauToolHolder.TauIDVarCalculatorCfg (   flags)

Definition at line 719 of file TauToolHolder.py.

719 def TauIDVarCalculatorCfg(flags):
720  result = ComponentAccumulator()
721  _name = flags.Tau.ActiveConfig.prefix + 'TauIDVarCalculator'
722 
723  TauIDVarCalculator = CompFactory.getComp("TauIDVarCalculator")
724  myTauIDVarCalculator = TauIDVarCalculator(name=_name,
725  VertexCorrection = flags.Tau.doVertexCorrection)
726 
727  result.setPrivateTools(myTauIDVarCalculator)
728  return result
729 

◆ TauJetRNNEvaluatorCfg()

def TauToolHolder.TauJetRNNEvaluatorCfg (   flags)

Definition at line 730 of file TauToolHolder.py.

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

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

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

◆ TauWPDecoratorEleRNNFixCfg()

def TauToolHolder.TauWPDecoratorEleRNNFixCfg (   flags)

Definition at line 882 of file TauToolHolder.py.

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

◆ TauWPDecoratorGNNCfg()

def TauToolHolder.TauWPDecoratorGNNCfg (   flags,
  version 
)

Definition at line 811 of file TauToolHolder.py.

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

◆ TauWPDecoratorJetRNNCfg()

def TauToolHolder.TauWPDecoratorJetRNNCfg (   flags)

Definition at line 755 of file TauToolHolder.py.

755 def TauWPDecoratorJetRNNCfg(flags):
756  import PyUtils.RootUtils as ru
757  ROOT = ru.import_root()
758  import cppyy
759  cppyy.load_library('libxAODTau_cDict')
760 
761  result = ComponentAccumulator()
762  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorJetRNN'
763 
764  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
765  WPConf = flags.Tau.TauJetRNNWPConfig
766  myTauWPDecorator = TauWPDecorator( name=_name,
767  flatteningFile1Prong = WPConf[0],
768  flatteningFile2Prong = WPConf[1],
769  flatteningFile3Prong = WPConf[2],
770  CutEnumVals =
771  [ ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigVeryLoose,
772  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigLoose,
773  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigMedium,
774  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigTight ],
775  SigEff1P = [0.95, 0.85, 0.75, 0.60],
776  SigEff2P = [0.95, 0.75, 0.60, 0.45],
777  SigEff3P = [0.95, 0.75, 0.60, 0.45],
778  ScoreName = "RNNJetScore",
779  NewScoreName = "RNNJetScoreSigTrans",
780  DefineWPs = True )
781 
782  result.setPrivateTools(myTauWPDecorator)
783  return result
784 
TauToolHolder.TauDecayModeNNClassifierCfg
def TauDecayModeNNClassifierCfg(flags)
Definition: TauToolHolder.py:902
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:941
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:707
TauToolHolder.TauEleRNNEvaluatorCfg
def TauEleRNNEvaluatorCfg(flags)
Definition: TauToolHolder.py:831
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:730
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:785
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:955
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:81
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:811
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:913
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:854
TauToolHolder.TauCombinedTESCfg
def TauCombinedTESCfg(flags)
TauCombinedTES.
Definition: TauToolHolder.py:928
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:882
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:755
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:719
CaloTopoClusterMaker
topological cluster maker.
Definition: CaloTopoClusterMaker.h:48
TrackToCaloConfig.ParticleCaloExtensionToolCfg
def ParticleCaloExtensionToolCfg(flags, name='ParticleCaloExtensionTool', **kwargs)
Definition: TrackToCaloConfig.py:10
Generated on Thu Mar 13 2025 22:03:21 for ATLAS Offline Software by   doxygen 1.8.18