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 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 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, applyLooseTrackSel=False)
 
def TauWPDecoratorJetRNNCfg (flags)
 
def TauGNNEvaluatorCfg (flags, version=0, applyLooseTrackSel=False, applyTightTrackSel=False, tauContainerName="")
 
def TauWPDecoratorGNNCfg (flags, version, tauContainerName="")
 
def TauEleRNNEvaluatorCfg (flags, applyLooseTrackSel=False)
 
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 194 of file TauToolHolder.py.

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

◆ ElectronVetoVarsCfg()

def TauToolHolder.ElectronVetoVarsCfg (   flags)

ele veto variables

Definition at line 207 of file TauToolHolder.py.

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

◆ EnergyCalibrationLCCfg()

def TauToolHolder.EnergyCalibrationLCCfg (   flags)

Tau energy calibration.

Definition at line 180 of file TauToolHolder.py.

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

◆ getParticleCache()

def TauToolHolder.getParticleCache (   flags)

Definition at line 70 of file TauToolHolder.py.

70 def getParticleCache(flags):
71  #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
72  if flags.Common.ProductionStep is ProductionStep.Reconstruction:
73  ParticleCache = "ParticleCaloExtension"
74  else:
75  ParticleCache = ""
76 
77  return ParticleCache
78 

◆ JetSeedBuilderCfg()

def TauToolHolder.JetSeedBuilderCfg (   flags)

JetSeedBuilder.

Definition at line 20 of file TauToolHolder.py.

20 def JetSeedBuilderCfg(flags):
21  result = ComponentAccumulator()
22  _name = flags.Tau.ActiveConfig.prefix + 'JetSeedBuilder'
23 
24  JetSeedBuilder = CompFactory.getComp("JetSeedBuilder")
25  JetSeedBuilder = JetSeedBuilder(name = _name)
26 
27  result.setPrivateTools(JetSeedBuilder)
28  return result
29 

◆ MvaTESEvaluatorCfg()

def TauToolHolder.MvaTESEvaluatorCfg (   flags)

MvaTESEvaluator.

Definition at line 662 of file TauToolHolder.py.

662 def MvaTESEvaluatorCfg(flags):
663  result = ComponentAccumulator()
664  _name = flags.Tau.ActiveConfig.prefix + 'MvaTESEvaluator'
665 
666  MvaTESEvaluator = CompFactory.getComp("MvaTESEvaluator")
667  MvaTESEvaluator = MvaTESEvaluator(name = _name,
668  WeightFileName = flags.Tau.MvaTESConfig,
669  WeightFileName0p = flags.Tau.MvaTESConfig0p )
670 
671  result.setPrivateTools(MvaTESEvaluator)
672  return result
673 

◆ MvaTESVariableDecoratorCfg()

def TauToolHolder.MvaTESVariableDecoratorCfg (   flags)

MvaTESVariableDecorator.

Definition at line 642 of file TauToolHolder.py.

642 def MvaTESVariableDecoratorCfg(flags):
643  result = ComponentAccumulator()
644  _name = flags.Tau.ActiveConfig.prefix + 'MvaTESVariableDecorator'
645 
646  eventShapeCollection = flags.Tau.ActiveConfig.EventShapeCollection
647  if 'EMPFlow' in flags.Tau.ActiveConfig.SeedJetCollection:
648  eventShapeCollection = "Kt4EMPFlowEventShape"
649  elif 'EMTopo' in flags.Tau.ActiveConfig.SeedJetCollection:
650  eventShapeCollection ="Kt4EMTopoOriginEventShape"
651 
652  MvaTESVariableDecorator = CompFactory.getComp("MvaTESVariableDecorator")
653  MvaTESVariableDecorator = MvaTESVariableDecorator(name = _name,
654  Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
655  EventShapeKey = eventShapeCollection,
656  VertexCorrection = flags.Tau.doVertexCorrection)
657  result.setPrivateTools(MvaTESVariableDecorator)
658  return result
659 

◆ Pi0ClusterCreatorCfg()

def TauToolHolder.Pi0ClusterCreatorCfg (   flags)

create Pi0 clusters

Definition at line 539 of file TauToolHolder.py.

539 def Pi0ClusterCreatorCfg(flags):
540  result = ComponentAccumulator()
541  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterCreator'
542 
543  # TauPi0ClusterCreator accesses cells via links only, which doesn't
544  # make a scheduler dependency. So make additional explicit dependencies
545  # on cells in the input file.
546  extraInputs = []
547  for typ, nam in [i.split('#') for i in flags.Input.TypedCollections]:
548  if typ == 'CaloCellContainer':
549  extraInputs += [('CaloCellContainer', nam)]
550 
551  TauPi0ClusterCreator = CompFactory.getComp("TauPi0ClusterCreator")
552  TauPi0ClusterCreator = TauPi0ClusterCreator(name = _name,
553  ExtraInputs = extraInputs)
554 
555  result.setPrivateTools(TauPi0ClusterCreator)
556  return result
557 

◆ Pi0ClusterFinderCfg()

def TauToolHolder.Pi0ClusterFinderCfg (   flags)

Pi0 algo Cluster finder for Pi0 algo.

Definition at line 254 of file TauToolHolder.py.

254 def Pi0ClusterFinderCfg(flags):
255  result = ComponentAccumulator()
256  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterFinder'
257 
258  TauPi0CreateROI = CompFactory.getComp("TauPi0CreateROI")
259 
260  myTauPi0CreateROI = TauPi0CreateROI(
261  name = _name,
262  Key_caloCellInputContainer = "AllCalo",
263  Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
264  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
265  RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
266  )
267 
268  result.setPrivateTools(myTauPi0CreateROI)
269  return result
270 

◆ Pi0ClusterScalerCfg()

def TauToolHolder.Pi0ClusterScalerCfg (   flags)

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

Definition at line 560 of file TauToolHolder.py.

560 def Pi0ClusterScalerCfg(flags):
561  result = ComponentAccumulator()
562  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterScaler'
563 
564  TauPi0ClusterScaler = CompFactory.getComp("TauPi0ClusterScaler")
565  TauPi0ClusterScaler = TauPi0ClusterScaler(name = _name)
566 
567  result.setPrivateTools(TauPi0ClusterScaler)
568  return result
569 

◆ Pi0ScoreCalculatorCfg()

def TauToolHolder.Pi0ScoreCalculatorCfg (   flags)

calculate MVA scores of pi0 clusters

Definition at line 572 of file TauToolHolder.py.

572 def Pi0ScoreCalculatorCfg(flags):
573  result = ComponentAccumulator()
574  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ScoreCalculator'
575 
576  TauPi0ScoreCalculator = CompFactory.getComp("TauPi0ScoreCalculator")
577  TauPi0ScoreCalculator = TauPi0ScoreCalculator(name = _name,
578  BDTWeightFile = flags.Tau.Pi0ScoreConfig)
579 
580  result.setPrivateTools(TauPi0ScoreCalculator)
581  return result
582 

◆ Pi0SelectorCfg()

def TauToolHolder.Pi0SelectorCfg (   flags)

select pi0 clusters

Definition at line 585 of file TauToolHolder.py.

585 def Pi0SelectorCfg(flags):
586  result = ComponentAccumulator()
587  _name = flags.Tau.ActiveConfig.prefix + 'Pi0Selector'
588 
589  TauPi0Selector = CompFactory.getComp("TauPi0Selector")
590  TauPi0Selector = TauPi0Selector(name = _name,
591  ClusterEtCut = flags.Tau.pi0EtCuts,
592  ClusterBDTCut_1prong = flags.Tau.pi0MVACuts_1prong,
593  ClusterBDTCut_mprong = flags.Tau.pi0MVACuts_mprong)
594 
595  result.setPrivateTools(TauPi0Selector)
596  return result
597 

◆ TauAODMuonRemovalCfg()

def TauToolHolder.TauAODMuonRemovalCfg (   flags)

muon removal tool

Definition at line 904 of file TauToolHolder.py.

904 def TauAODMuonRemovalCfg(flags):
905  result = ComponentAccumulator()
906  _name = flags.Tau.ActiveConfig.prefix + 'MuonRemoval'
907  TauAODMuonRemovalTool = CompFactory.getComp("TauAODMuonRemovalTool")
908  myMuonRemoval = TauAODMuonRemovalTool( name = _name,
909  Key_MuonInputContainer = 'Muons',
910  doMuonTrkRm = True,
911  doMuonClsRm = True,
912  muonIDWP = 'Medium'
913  )
914  result.setPrivateTools(myMuonRemoval)
915  return result
916 
917 # electron excluder tool

◆ TauAODSelectorCfg()

def TauToolHolder.TauAODSelectorCfg (   flags)

Definition at line 876 of file TauToolHolder.py.

876 def TauAODSelectorCfg(flags):
877  result = ComponentAccumulator()
878  _name = flags.Tau.ActiveConfig.prefix + 'TauAODSelector'
879 
880  TauAODSelector = CompFactory.getComp("TauAODSelector")
881  myTauAODSelector = TauAODSelector(name=_name,
882  Min0pTauPt = flags.Tau.MinPt0p,
883  MinTauPt = flags.Tau.MinPt,
884  doEarlyStopping = flags.Tau.doEarlyStopping and not flags.Output.doWriteESD)
885 
886  result.setPrivateTools(myTauAODSelector)
887  return result
888 

◆ TauAxisCfg()

def TauToolHolder.TauAxisCfg (   flags)

Tau energy calibration and tau axis direction.

Definition at line 56 of file TauToolHolder.py.

56 def TauAxisCfg(flags):
57  result = ComponentAccumulator()
58  _name = flags.Tau.ActiveConfig.prefix + 'TauAxis'
59 
60  TauAxisSetter = CompFactory.getComp("TauAxisSetter")
61  TauAxisSetter = TauAxisSetter( name = _name,
62  ClusterCone = 0.2,
63  VertexCorrection = flags.Tau.doVertexCorrection )
64 
65  result.setPrivateTools(TauAxisSetter)
66  return result
67 

◆ TauCaloClusterBadChannelCfg()

def TauToolHolder.TauCaloClusterBadChannelCfg (   flags)

Definition at line 527 of file TauToolHolder.py.

527 def TauCaloClusterBadChannelCfg(flags):
528  result = ComponentAccumulator()
529  _name = flags.Tau.ActiveConfig.prefix + 'CaloClusterBadChannelList'
530 
531  CaloClusterBadChannelListCorr = CompFactory.getComp("CaloClusterBadChannelList")
532  BadChannelListCorrForTaus = CaloClusterBadChannelListCorr(_name)
533 
534  result.setPrivateTools(BadChannelListCorrForTaus)
535  return result
536 

◆ TauCaloClusterLocalCalibCfg()

def TauToolHolder.TauCaloClusterLocalCalibCfg (   flags)

Definition at line 364 of file TauToolHolder.py.

364 def TauCaloClusterLocalCalibCfg(flags):
365  result = ComponentAccumulator()
366  _name = flags.Tau.ActiveConfig.prefix + 'CaloLocalCalib'
367 
368  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
369  LocalCalib = CaloClusterLocalCalib(_name)
370  LocalCalib.ClusterClassificationTool = [result.popToolsAndMerge(TauCaloLCClassificationCfg(flags))]
371  LocalCalib.ClusterRecoStatus = [1,2]
372  LocalCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCWeightCfg(flags))]
373  LocalCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
374 
375  result.setPrivateTools(LocalCalib)
376  return result
377 

◆ TauCaloClusterMomentsMakerCfg()

def TauToolHolder.TauCaloClusterMomentsMakerCfg (   flags)

Definition at line 487 of file TauToolHolder.py.

487 def TauCaloClusterMomentsMakerCfg(flags):
488  result = ComponentAccumulator()
489  _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoMoments'
490 
491  # Schedule total noise cond alg
492  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
493  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
494  # Schedule electronic noise cond alg (needed for LC weights)
495  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
496 
497  CaloClusterMomentsMaker = CompFactory.getComp("CaloClusterMomentsMaker")
498  TopoMomentsForTaus = CaloClusterMomentsMaker(_name)
499  TopoMomentsForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
500  TopoMomentsForTaus.MaxAxisAngle = 20*deg
501  TopoMomentsForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
502  TopoMomentsForTaus.MinBadLArQuality = 4000
503  TopoMomentsForTaus.MomentsNames = ["FIRST_PHI"
504  ,"FIRST_ETA"
505  ,"SECOND_R"
506  ,"SECOND_LAMBDA"
507  ,"DELTA_PHI"
508  ,"DELTA_THETA"
509  ,"DELTA_ALPHA"
510  ,"CENTER_X"
511  ,"CENTER_Y"
512  ,"CENTER_Z"
513  ,"CENTER_MAG"
514  ,"CENTER_LAMBDA"
515  ,"LATERAL"
516  ,"LONGITUDINAL"
517  ,"ENG_FRAC_EM"
518  ,"ENG_FRAC_MAX"
519  ,"ENG_FRAC_CORE"
520  ,"FIRST_ENG_DENS"
521  ,"SECOND_ENG_DENS"
522  ,"ISOLATION"]
523 
524  result.setPrivateTools(TopoMomentsForTaus)
525  return result
526 

◆ TauCaloDMCalibCfg()

def TauToolHolder.TauCaloDMCalibCfg (   flags)

Definition at line 391 of file TauToolHolder.py.

391 def TauCaloDMCalibCfg(flags):
392  result = ComponentAccumulator()
393  _name = flags.Tau.ActiveConfig.prefix + 'DMCalib'
394 
395  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
396  DMCalib = CaloClusterLocalCalib(_name)
397  DMCalib.ClusterRecoStatus = [1,2]
398  DMCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCDeadMaterialCfg(flags))]
399  DMCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
400 
401  result.setPrivateTools(DMCalib)
402  return result
403 

◆ TauCaloLCClassificationCfg()

def TauToolHolder.TauCaloLCClassificationCfg (   flags)

Calo Tools.

Definition at line 287 of file TauToolHolder.py.

287 def TauCaloLCClassificationCfg(flags):
288  result = ComponentAccumulator()
289  _name = flags.Tau.ActiveConfig.prefix + 'LCClassify'
290 
291  CaloLCClassificationTool = CompFactory.getComp("CaloLCClassificationTool")
292  LCClassify = CaloLCClassificationTool(_name)
293  LCClassify.ClassificationKey = "EMFracClassify"
294  LCClassify.UseSpread = False
295  LCClassify.MaxProbability = 0.5
296  # add the moments EM_PROBABILITY, HAD_WEIGHT, OOC_WEIGHT, DM_WEIGHT to the AOD:
297  LCClassify.StoreClassificationProbabilityInAOD = True
298  LCClassify.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
299  LCClassify.UseNormalizedEnergyDensity = True
300 
301  result.setPrivateTools(LCClassify)
302  return result
303 

◆ TauCaloLCDeadMaterialCfg()

def TauToolHolder.TauCaloLCDeadMaterialCfg (   flags)

Definition at line 349 of file TauToolHolder.py.

349 def TauCaloLCDeadMaterialCfg(flags):
350  result = ComponentAccumulator()
351  _name = flags.Tau.ActiveConfig.prefix + 'CaloLCDeadMaterialTool'
352 
353  CaloLCDeadMaterialTool = CompFactory.getComp("CaloLCDeadMaterialTool")
354  LCDeadMaterial = CaloLCDeadMaterialTool(_name)
355  LCDeadMaterial.HadDMCoeffKey = "HadDMCoeff2"
356  LCDeadMaterial.ClusterRecoStatus = 0
357  LCDeadMaterial.WeightModeDM = 2
358  LCDeadMaterial.UseHadProbability = True
359  LCDeadMaterial.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
360 
361  result.setPrivateTools(LCDeadMaterial)
362  return result
363 

◆ TauCaloLCOutOfClusterCfg()

def TauToolHolder.TauCaloLCOutOfClusterCfg (   flags)

Definition at line 323 of file TauToolHolder.py.

323 def TauCaloLCOutOfClusterCfg(flags):
324  result = ComponentAccumulator()
325  _name = flags.Tau.ActiveConfig.prefix + 'CaloLCOutOfClusterTool'
326 
327  CaloLCOutOfClusterTool = CompFactory.getComp("CaloLCOutOfClusterTool")
328  LCOut = CaloLCOutOfClusterTool(_name)
329  LCOut.CorrectionKey = "OOCCorrection"
330  LCOut.UseEmProbability = False
331  LCOut.UseHadProbability = True
332 
333  result.setPrivateTools(LCOut)
334  return result
335 

◆ TauCaloLCOutPi0Cfg()

def TauToolHolder.TauCaloLCOutPi0Cfg (   flags)

Definition at line 336 of file TauToolHolder.py.

336 def TauCaloLCOutPi0Cfg(flags):
337  result = ComponentAccumulator()
338  _name = flags.Tau.ActiveConfig.prefix + 'LCOutPi0'
339 
340  CaloLCOutOfClusterTool = CompFactory.getComp("CaloLCOutOfClusterTool")
341  LCOutPi0 = CaloLCOutOfClusterTool(_name)
342  LCOutPi0.CorrectionKey = "OOCPi0Correction"
343  LCOutPi0.UseEmProbability = True
344  LCOutPi0.UseHadProbability = False
345 
346  result.setPrivateTools(LCOutPi0)
347  return result
348 

◆ TauCaloLCWeightCfg()

def TauToolHolder.TauCaloLCWeightCfg (   flags)

Definition at line 304 of file TauToolHolder.py.

304 def TauCaloLCWeightCfg(flags):
305  result = ComponentAccumulator()
306  _name = flags.Tau.ActiveConfig.prefix + 'CaloLCWeightTool'
307 
308  # Schedule total noise cond alg
309  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
310  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
311  # Schedule electronic noise cond alg (needed for LC weights)
312  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
313 
314  CaloLCWeightTool = CompFactory.getComp("CaloLCWeightTool")
315  LCWeight = CaloLCWeightTool(_name)
316  LCWeight.CorrectionKey = "H1ClusterCellWeights"
317  LCWeight.SignalOverNoiseCut = 2.0
318  LCWeight.UseHadProbability = True
319 
320  result.setPrivateTools(LCWeight)
321  return result
322 

◆ TauCaloOOCCalibCfg()

def TauToolHolder.TauCaloOOCCalibCfg (   flags)

Definition at line 378 of file TauToolHolder.py.

378 def TauCaloOOCCalibCfg(flags):
379  result = ComponentAccumulator()
380  _name = flags.Tau.ActiveConfig.prefix + 'OOCCalibTool'
381 
382  CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
383  OOCCalib = CaloClusterLocalCalib (_name)
384  OOCCalib.ClusterRecoStatus = [1,2]
385  OOCCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCOutOfClusterCfg(flags))]
386  OOCCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
387 
388  result.setPrivateTools(OOCCalib)
389  return result
390 

◆ TauCaloOOCPi0CalibCfg()

def TauToolHolder.TauCaloOOCPi0CalibCfg (   flags)

Definition at line 404 of file TauToolHolder.py.

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

◆ TauCaloTopoClusterMakerCfg()

def TauToolHolder.TauCaloTopoClusterMakerCfg (   flags)

Definition at line 417 of file TauToolHolder.py.

417 def TauCaloTopoClusterMakerCfg(flags):
418  result = ComponentAccumulator()
419  _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoClusterMaker'
420 
421  # Schedule total noise cond alg
422  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
423  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
424  # Schedule electronic noise cond alg (needed for LC weights)
425  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
426 
427  CaloTopoClusterMaker = CompFactory.getComp("CaloTopoClusterMaker")
428  TopoClusterForTaus = CaloTopoClusterMaker(_name)
429 
430  TopoClusterForTaus.CellsName = flags.Tau.ActiveConfig.TauCommonPi0Cells
431  TopoClusterForTaus.CalorimeterNames=["LAREM"]
432  TopoClusterForTaus.SeedSamplingNames = ["PreSamplerB", "EMB1", "EMB2", "PreSamplerE", "EME1", "EME2"]
433  TopoClusterForTaus.NeighborOption = "super3D"
434  TopoClusterForTaus.RestrictHECIWandFCalNeighbors = False
435  TopoClusterForTaus.RestrictPSNeighbors = True
436  TopoClusterForTaus.CellThresholdOnEorAbsEinSigma = 0.0
437  TopoClusterForTaus.NeighborThresholdOnEorAbsEinSigma = 2.0
438  TopoClusterForTaus.SeedThresholdOnEorAbsEinSigma = 4.0
439  TopoClusterForTaus.SeedCutsInAbsE = True
440  TopoClusterForTaus.ClusterCutsInAbsEt = True
441  TopoClusterForTaus.ClusterEtorAbsEtCut = 0.5*GeV # 0.0*MeV in standard CaloCalTopoCluster JobOptions!
442  TopoClusterForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
443  # timing cut on seed cell to suppress out-of-time pileup
444  TopoClusterForTaus.SeedCutsInT = flags.Calo.TopoCluster.doTimeCut
445  TopoClusterForTaus.CutOOTseed = flags.Calo.TopoCluster.extendTimeCut and flags.Calo.TopoCluster.doTimeCut
446  TopoClusterForTaus.UseTimeCutUpperLimit = flags.Calo.TopoCluster.useUpperLimitForTimeCut
447  TopoClusterForTaus.TimeCutUpperLimit = flags.Calo.TopoCluster.timeCutUpperLimit
448  TopoClusterForTaus.XTalkEM2 = flags.Calo.TopoCluster.xtalkEM2
449  TopoClusterForTaus.XTalkEM2D = flags.Calo.TopoCluster.xtalkEM2D
450  TopoClusterForTaus.XTalkEM2n = flags.Calo.TopoCluster.xtalkEM2n
451  TopoClusterForTaus.XTalkEM3 = flags.Calo.TopoCluster.xtalkEM3
452  TopoClusterForTaus.XTalkEMEta = flags.Calo.TopoCluster.xtalkEMEta
453  TopoClusterForTaus.XTalkDeltaT = flags.Calo.TopoCluster.xtalkDeltaT
454  TopoClusterForTaus.XTalk2Eratio1 = flags.Calo.TopoCluster.xtalk2Eratio1
455  TopoClusterForTaus.XTalk2Eratio2 = flags.Calo.TopoCluster.xtalk2Eratio2
456  TopoClusterForTaus.XTalk3Eratio = flags.Calo.TopoCluster.xtalk3Eratio
457  TopoClusterForTaus.XTalkEtaEratio = flags.Calo.TopoCluster.xtalkEtaEratio
458  TopoClusterForTaus.XTalk2DEratio = flags.Calo.TopoCluster.xtalk2DEratio
459 
460  result.setPrivateTools(TopoClusterForTaus)
461  return result
462 

◆ TauCaloTopoClusterSplitterCfg()

def TauToolHolder.TauCaloTopoClusterSplitterCfg (   flags)

Definition at line 463 of file TauToolHolder.py.

463 def TauCaloTopoClusterSplitterCfg(flags):
464 
465  result = ComponentAccumulator()
466  _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoClusterSplitter'
467 
468  CaloTopoClusterSplitter = CompFactory.getComp("CaloTopoClusterSplitter")
469  TopoSplitterForTaus = CaloTopoClusterSplitter(_name)
470 
471  # cells from the following samplings will be able to form local
472  # maxima. The excluded samplings are PreSamplerB, EMB1,
473  # PreSamplerE, EME1, all Tile samplings, all HEC samplings and the
474  # two rear FCal samplings.
475  TopoSplitterForTaus.SamplingNames = ["EMB2","EME2"] # Do we want to use EMB3 and EME3?
476  # cells from the following samplings will also be able to form
477  # local maxima but only if they are not overlapping in eta and phi
478  # with local maxima in previous samplings from the primary list.
479  TopoSplitterForTaus.SecondarySamplingNames = ["EMB1","EME1"]
480  TopoSplitterForTaus.ShareBorderCells = True
481  TopoSplitterForTaus.RestrictHECIWandFCalNeighbors = False
482  TopoSplitterForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
483 
484  result.setPrivateTools(TopoSplitterForTaus)
485  return result
486 

◆ TauCellFinalizerCfg()

def TauToolHolder.TauCellFinalizerCfg (   flags)

Cell finalizer tool for BuildAlg.

Definition at line 273 of file TauToolHolder.py.

273 def TauCellFinalizerCfg(flags):
274  result = ComponentAccumulator()
275  _name = flags.Tau.ActiveConfig.prefix + 'tauPi0CellContainerFinalizer'
276 
277  CaloCellContainerFinalizerTool = CompFactory.getComp("CaloCellContainerFinalizerTool")
278  TauCellContainerFinalizer = CaloCellContainerFinalizerTool(name=_name)
279 
280  result.setPrivateTools(TauCellContainerFinalizer)
281  return result
282 

◆ TauClusterFinderCfg()

def TauToolHolder.TauClusterFinderCfg (   flags)

Associate the cluster in jet constituents to the tau candidate.

Definition at line 116 of file TauToolHolder.py.

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

◆ TauCombinedTESCfg()

def TauToolHolder.TauCombinedTESCfg (   flags)

TauCombinedTES.

Definition at line 891 of file TauToolHolder.py.

891 def TauCombinedTESCfg(flags):
892  result = ComponentAccumulator()
893  _name = flags.Tau.ActiveConfig.prefix + 'TauCombinedTES'
894 
895  TauCombinedTES = CompFactory.getComp("TauCombinedTES")
896  myTauCombinedTES = TauCombinedTES(name = _name,
897  WeightFileName = flags.Tau.CombinedTESConfig)
898 
899  result.setPrivateTools(myTauCombinedTES)
900  return result
901 

◆ TauCommonCalcVarsCfg()

def TauToolHolder.TauCommonCalcVarsCfg (   flags)

Tau Variables.

Definition at line 618 of file TauToolHolder.py.

618 def TauCommonCalcVarsCfg(flags):
619  result = ComponentAccumulator()
620  _name = flags.Tau.ActiveConfig.prefix + 'TauCommonCalcVars'
621 
622  TauCommonCalcVars = CompFactory.getComp("TauCommonCalcVars")
623  TauCommonCalcVars = TauCommonCalcVars(name = _name)
624 
625  result.setPrivateTools(TauCommonCalcVars)
626  return result
627 

◆ TauDecayModeNNClassifierCfg()

def TauToolHolder.TauDecayModeNNClassifierCfg (   flags)

Definition at line 865 of file TauToolHolder.py.

865 def TauDecayModeNNClassifierCfg(flags):
866  result = ComponentAccumulator()
867  _name = flags.Tau.ActiveConfig.prefix + 'TauDecayModeNNClassifier'
868 
869  TauDecayModeNNClassifier = CompFactory.getComp("TauDecayModeNNClassifier")
870  myTauDecayModeNNClassifier = TauDecayModeNNClassifier(name=_name,
871  WeightFile=flags.Tau.DecayModeNNClassifierConfig)
872 
873  result.setPrivateTools(myTauDecayModeNNClassifier)
874  return result
875 

◆ TauEleOverlapChecker()

def TauToolHolder.TauEleOverlapChecker (   flags)

Definition at line 918 of file TauToolHolder.py.

918 def TauEleOverlapChecker(flags):
919  result = ComponentAccumulator()
920  _name = flags.Tau.ActiveConfig.prefix + 'TauEleOverlapChecker'
921  TauEleOverlapChecker = CompFactory.getComp("TauEleOverlapChecker")
922  myTauEleOverlapChecker = TauEleOverlapChecker(
923  name = _name,
924  Key_RemovedClustersContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
925  Key_RemovedTracksContainer = flags.Tau.ActiveConfig.RemovedElectronTracks,
926  CheckingCone = flags.Tau.ActiveConfig.EleRM_CheckingConeSize,
927  )
928  result.setPrivateTools(myTauEleOverlapChecker)
929  return result

◆ TauEleRNNEvaluatorCfg()

def TauToolHolder.TauEleRNNEvaluatorCfg (   flags,
  applyLooseTrackSel = False 
)

Definition at line 792 of file TauToolHolder.py.

792 def TauEleRNNEvaluatorCfg(flags, applyLooseTrackSel=False):
793  result = ComponentAccumulator()
794  _name = flags.Tau.ActiveConfig.prefix + 'TauEleRNN'
795 
796  TauJetRNNEvaluator = CompFactory.getComp("TauJetRNNEvaluator")
797  RNNConf = flags.Tau.TauEleRNNConfig
798  myTauEleRNNEvaluator = TauJetRNNEvaluator(name = _name,
799  useTRT = flags.Detector.EnableTRT,
800  NetworkFile1P = RNNConf[0],
801  NetworkFile3P = RNNConf[1],
802  OutputVarname = "RNNEleScore",
803  MaxTracks = 10,
804  MaxClusters = 6,
805  MaxClusterDR = 1.0,
806  ApplyLooseTrackSel = applyLooseTrackSel,
807  VertexCorrection = flags.Tau.doVertexCorrection,
808  InputLayerScalar = "scalar",
809  InputLayerTracks = "tracks",
810  InputLayerClusters = "clusters",
811  OutputLayer = "rnneveto_output",
812  OutputNode = "sig_prob")
813 
814  result.setPrivateTools(myTauEleRNNEvaluator)
815  return result
816 

◆ TauGNNEvaluatorCfg()

def TauToolHolder.TauGNNEvaluatorCfg (   flags,
  version = 0,
  applyLooseTrackSel = False,
  applyTightTrackSel = False,
  tauContainerName = "" 
)

Definition at line 741 of file TauToolHolder.py.

741 def TauGNNEvaluatorCfg(flags, version=0, applyLooseTrackSel=False, applyTightTrackSel=False, tauContainerName=""):
742  result = ComponentAccumulator()
743  _name = flags.Tau.ActiveConfig.prefix + 'TauGNN_v' + str(version)
744 
745  TauGNNEvaluator = CompFactory.getComp("TauGNNEvaluator")
746  GNNConf = flags.Tau.TauGNNConfig[version]
747  myTauGNNEvaluator = TauGNNEvaluator(name = _name,
748  useTRT = flags.Detector.EnableTRT,
749  NetworkFileInclusive = GNNConf,
750  OutputVarname = flags.Tau.GNTauScoreName[version],
751  OutputPTau = "GNTauProbTau",
752  OutputPJet = "GNTauProbJet",
753  MaxTracks = flags.Tau.GNTauMaxTracks[version],
754  MaxClusters = flags.Tau.GNTauMaxClusters[version],
755  MaxClusterDR = 15.0,
756  MinTauPt = flags.Tau.MinPtDAOD,
757  ApplyLooseTrackSel = applyLooseTrackSel,
758  ApplyTightTrackSel = applyTightTrackSel,
759  VertexCorrection = flags.Tau.doVertexCorrection,
760  InputLayerScalar = 'tau_vars',
761  InputLayerTracks = 'track_vars',
762  InputLayerClusters = 'cluster_vars',
763  NodeNameTau=flags.Tau.GNTauNodeNameTau,
764  NodeNameJet=flags.Tau.GNTauNodeNameJet,
765  TauContainerName = tauContainerName,
766  )
767 
768  result.setPrivateTools(myTauGNNEvaluator)
769  return result
770 

◆ TauIDVarCalculatorCfg()

def TauToolHolder.TauIDVarCalculatorCfg (   flags)

Definition at line 674 of file TauToolHolder.py.

674 def TauIDVarCalculatorCfg(flags):
675  result = ComponentAccumulator()
676  _name = flags.Tau.ActiveConfig.prefix + 'TauIDVarCalculator'
677 
678  TauIDVarCalculator = CompFactory.getComp("TauIDVarCalculator")
679  myTauIDVarCalculator = TauIDVarCalculator(name=_name,
680  VertexCorrection = flags.Tau.doVertexCorrection)
681 
682  result.setPrivateTools(myTauIDVarCalculator)
683  return result
684 

◆ TauJetRNNEvaluatorCfg()

def TauToolHolder.TauJetRNNEvaluatorCfg (   flags,
  applyLooseTrackSel = False 
)

Definition at line 685 of file TauToolHolder.py.

685 def TauJetRNNEvaluatorCfg(flags, applyLooseTrackSel=False):
686  result = ComponentAccumulator()
687  _name = flags.Tau.ActiveConfig.prefix + 'TauJetRNN'
688 
689  TauJetRNNEvaluator = CompFactory.getComp("TauJetRNNEvaluator")
690  RNNConf = flags.Tau.TauJetRNNConfig
691  myTauJetRNNEvaluator = TauJetRNNEvaluator(name = _name,
692  NetworkFile0P = "",
693  NetworkFile1P = RNNConf[0],
694  NetworkFile2P = RNNConf[1],
695  NetworkFile3P = RNNConf[2],
696  OutputVarname = "RNNJetScore",
697  MaxTracks = 10,
698  MaxClusters = 6,
699  MaxClusterDR = 1.0,
700  ApplyLooseTrackSel = applyLooseTrackSel,
701  VertexCorrection = flags.Tau.doVertexCorrection,
702  InputLayerScalar = "scalar",
703  InputLayerTracks = "tracks",
704  InputLayerClusters = "clusters",
705  OutputLayer = "rnnid_output",
706  OutputNode = "sig_prob")
707 
708  result.setPrivateTools(myTauJetRNNEvaluator)
709  return result
710 

◆ TauShotFinderCfg()

def TauToolHolder.TauShotFinderCfg (   flags)

Photon Shot Finder.

Definition at line 224 of file TauToolHolder.py.

224 def TauShotFinderCfg(flags):
225  result = ComponentAccumulator()
226  _name = flags.Tau.ActiveConfig.prefix + 'TauShotFinder'
227 
228  shotPtCut_1Photon = flags.Tau.shotPtCut_1Photon
229  shotPtCut_2Photons = flags.Tau.shotPtCut_2Photons
230 
231 
232  from CaloClusterCorrection.StandardCellWeightCalib import getCellWeightTool
233  CaloWeightTool = getCellWeightTool(flags=flags)
234 
235 
236  TauShotFinder = CompFactory.getComp("TauShotFinder")
237  TauShotFinder = TauShotFinder(
238  name = _name,
239  CaloWeightTool = result.popToolsAndMerge(CaloWeightTool),
240  NCellsInEta = 5,
241  MinPtCut = shotPtCut_1Photon,
242  AutoDoubleShotCut = shotPtCut_2Photons,
243  Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
244  RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
245  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
246  )
247 
248  result.setPrivateTools(TauShotFinder)
249  return result
250 

◆ TauSubstructureCfg()

def TauToolHolder.TauSubstructureCfg (   flags)

Tau Variables.

Definition at line 630 of file TauToolHolder.py.

630 def TauSubstructureCfg(flags):
631  result = ComponentAccumulator()
632  _name = flags.Tau.ActiveConfig.prefix + 'TauSubstructure'
633 
634  TauSubstructureVariables = CompFactory.getComp("TauSubstructureVariables")
635  TauSubstructureVariables = TauSubstructureVariables( name = _name )
636 
637  result.setPrivateTools(TauSubstructureVariables)
638  return result
639 

◆ TauTrackFinderCfg()

def TauToolHolder.TauTrackFinderCfg (   flags)

Tau-Track Association.

Definition at line 81 of file TauToolHolder.py.

81 def TauTrackFinderCfg(flags):
82  result = ComponentAccumulator()
83  _name = flags.Tau.ActiveConfig.prefix + 'TauTrackFinder'
84 
85  # BeamSpot Conditions
86  from BeamSpotConditions.BeamSpotConditionsConfig import BeamSpotCondAlgCfg
87  result.merge(BeamSpotCondAlgCfg(flags))
88 
89  from TrackToVertex.TrackToVertexConfig import TrackToVertexCfg
90  from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg
91  from TrkConfig.TrkVertexFitterUtilsConfig import AtlasTrackToVertexIPEstimatorCfg
92  from InDetConfig.InDetTrackSelectorToolConfig import TauRecInDetTrackSelectorToolCfg
93 
94  TauTrackFinder = CompFactory.getComp("TauTrackFinder")
95  TauTrackFinder = TauTrackFinder(name = _name,
96  MaxJetDrTau = 0.2,
97  MaxJetDrWide = 0.4,
98  TrackSelectorToolTau = result.popToolsAndMerge(TauRecInDetTrackSelectorToolCfg(flags)),
99  TrackToVertexTool = result.popToolsAndMerge(TrackToVertexCfg(flags)),
100  ParticleCaloExtensionTool = result.popToolsAndMerge(ParticleCaloExtensionToolCfg(flags)),
101  tauParticleCache = getParticleCache(flags), # only returns a string
102  removeDuplicateCoreTracks = flags.Tau.RemoveDupeCoreTracks,
103  useGhostTracks = flags.Tau.useGhostTracks,
104  ghostTrackDR = flags.Tau.ghostTrackDR,
105  Key_jetContainer = (flags.Tau.ActiveConfig.SeedJetCollection if flags.Tau.useGhostTracks else ""),
106  Key_trackPartInputContainer = flags.Tau.ActiveConfig.TrackCollection,
107  Key_LargeD0TrackInputContainer = (flags.Tau.ActiveConfig.LargeD0TrackCollection if flags.Tau.associateLRT else ""),
108  TrackToVertexIPEstimator = result.popToolsAndMerge(AtlasTrackToVertexIPEstimatorCfg(flags)),
109  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
110  )
111  result.setPrivateTools(TauTrackFinder)
112  return result
113 

◆ TauTrackRNNCfg()

def TauToolHolder.TauTrackRNNCfg (   flags)

Definition at line 144 of file TauToolHolder.py.

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

◆ TauTrackRNNClassifierCfg()

def TauToolHolder.TauTrackRNNClassifierCfg (   flags)

Definition at line 157 of file TauToolHolder.py.

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

◆ TauVertexedClusterDecoratorCfg()

def TauToolHolder.TauVertexedClusterDecoratorCfg (   flags)

Definition at line 132 of file TauToolHolder.py.

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

◆ TauVertexFinderCfg()

def TauToolHolder.TauVertexFinderCfg (   flags)

Definition at line 31 of file TauToolHolder.py.

31 def TauVertexFinderCfg(flags):
32  result = ComponentAccumulator()
33  _name = flags.Tau.ActiveConfig.prefix + 'TauVertexFinder'
34 
35  from InDetConfig.InDetTrackSelectionToolConfig import Tau_InDetTrackSelectionToolForTJVACfg
36  from TrackVertexAssociationTool.TrackVertexAssociationToolConfig import TauTTVAToolCfg
37 
38  # Algorithm that overwrites numTrack() and charge() of tauJets in container
39  # from tauRecTools.tauRecToolsConf import TauVertexFinder
40  TauVertexFinder = CompFactory.getComp("TauVertexFinder")
41  TauVertexFinder = TauVertexFinder(name = _name,
42  UseTJVA = flags.Tau.doTJVA,
43  AssociatedTracks="GhostTrack", # OK??
44  InDetTrackSelectionToolForTJVA = result.popToolsAndMerge(Tau_InDetTrackSelectionToolForTJVACfg(flags)),
45  Key_trackPartInputContainer= flags.Tau.ActiveConfig.TrackCollection,
46  Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
47  TVATool = result.popToolsAndMerge(TauTTVAToolCfg(flags)),
48  inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
49  )
50 
51  result.setPrivateTools(TauVertexFinder)
52  return result
53 

◆ TauVertexVariablesCfg()

def TauToolHolder.TauVertexVariablesCfg (   flags)

Tau Vertex Variables.

Definition at line 600 of file TauToolHolder.py.

600 def TauVertexVariablesCfg(flags):
601  result = ComponentAccumulator()
602  _name = flags.Tau.ActiveConfig.prefix + 'TauVertexVariables'
603 
604  from TrkConfig.TrkVertexFittersConfig import TauAdaptiveVertexFitterCfg
605  from TrkConfig.TrkVertexSeedFinderToolsConfig import (
606  CrossDistancesSeedFinderCfg)
607 
608  TauVertexVariables = CompFactory.getComp("TauVertexVariables")
609  TauVertexVariables = TauVertexVariables( name = _name,
610  VertexFitter = result.popToolsAndMerge(TauAdaptiveVertexFitterCfg(flags)),
611  SeedFinder = result.popToolsAndMerge(CrossDistancesSeedFinderCfg(flags)) )
612 
613  result.setPrivateTools(TauVertexVariables)
614  return result
615 

◆ TauWPDecoratorEleRNNCfg()

def TauToolHolder.TauWPDecoratorEleRNNCfg (   flags)

Definition at line 817 of file TauToolHolder.py.

817 def TauWPDecoratorEleRNNCfg(flags):
818  import PyUtils.RootUtils as ru
819  ROOT = ru.import_root()
820  import cppyy
821  cppyy.load_library('libxAODTau_cDict')
822 
823  result = ComponentAccumulator()
824  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNN'
825 
826  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
827  WPConf = flags.Tau.TauEleRNNWPConfig
828  myTauEleWPDecorator = TauWPDecorator( name=_name,
829  flatteningFile1Prong = WPConf[0],
830  flatteningFile3Prong = WPConf[1],
831  CutEnumVals =
832  [ ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNLoose,
833  ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNMedium,
834  ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNTight ],
835  SigEff1P = [0.95, 0.90, 0.85],
836  SigEff3P = [0.98, 0.95, 0.90],
837  UseAbsEta = True ,
838  ScoreName = "RNNEleScore",
839  NewScoreName = "RNNEleScoreSigTrans",
840  DefineWPs = True)
841 
842  result.setPrivateTools(myTauEleWPDecorator)
843  return result
844 

◆ TauWPDecoratorEleRNNFixCfg()

def TauToolHolder.TauWPDecoratorEleRNNFixCfg (   flags)

Definition at line 845 of file TauToolHolder.py.

845 def TauWPDecoratorEleRNNFixCfg(flags):
846  result = ComponentAccumulator()
847  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNNFix_v1'
848 
849  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
850  WPConf = flags.Tau.TauEleRNNWPfix
851  myTauEleWPDecorator = TauWPDecorator(name = _name,
852  flatteningFile1Prong = WPConf[0],
853  flatteningFile3Prong = WPConf[1],
854  DecorWPNames = [ "EleRNNLoose_v1", "EleRNNMedium_v1", "EleRNNTight_v1" ],
855  DecorWPCutEffs1P = [0.95, 0.90, 0.85],
856  DecorWPCutEffs3P = [0.98, 0.95, 0.90],
857  UseAbsEta = True,
858  ScoreName = "RNNEleScore",
859  NewScoreName = "RNNEleScoreSigTrans_v1",
860  DefineWPs = True)
861 
862  result.setPrivateTools(myTauEleWPDecorator)
863  return result
864 

◆ TauWPDecoratorGNNCfg()

def TauToolHolder.TauWPDecoratorGNNCfg (   flags,
  version,
  tauContainerName = "" 
)

Definition at line 771 of file TauToolHolder.py.

771 def TauWPDecoratorGNNCfg(flags, version, tauContainerName=""):
772  result = ComponentAccumulator()
773  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorGNN_v' + str(version)
774 
775  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
776  WPConf = flags.Tau.TauGNNWP[version]
777  myTauWPDecorator = TauWPDecorator(name=_name,
778  flatteningFile1Prong = WPConf[0],
779  flatteningFile2Prong = WPConf[1],
780  flatteningFile3Prong = WPConf[2],
781  TauContainerName = tauContainerName,
782  DecorWPNames = flags.Tau.GNTauDecorWPNames[version],
783  DecorWPCutEffs1P = [0.95, 0.85, 0.75, 0.60],
784  DecorWPCutEffs2P = [0.95, 0.75, 0.60, 0.45],
785  DecorWPCutEffs3P = [0.95, 0.75, 0.60, 0.45],
786  ScoreName = flags.Tau.GNTauScoreName[version],
787  NewScoreName = flags.Tau.GNTauTransScoreName[version],
788  DefineWPs = True)
789  result.setPrivateTools(myTauWPDecorator)
790  return result
791 

◆ TauWPDecoratorJetRNNCfg()

def TauToolHolder.TauWPDecoratorJetRNNCfg (   flags)

Definition at line 711 of file TauToolHolder.py.

711 def TauWPDecoratorJetRNNCfg(flags):
712  import PyUtils.RootUtils as ru
713  ROOT = ru.import_root()
714  import cppyy
715  cppyy.load_library('libxAODTau_cDict')
716 
717  result = ComponentAccumulator()
718  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorJetRNN'
719 
720  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
721  WPConf = flags.Tau.TauJetRNNWPConfig
722  myTauWPDecorator = TauWPDecorator( name=_name,
723  flatteningFile1Prong = WPConf[0],
724  flatteningFile2Prong = WPConf[1],
725  flatteningFile3Prong = WPConf[2],
726  CutEnumVals =
727  [ ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigVeryLoose,
728  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigLoose,
729  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigMedium,
730  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigTight ],
731  SigEff1P = [0.95, 0.85, 0.75, 0.60],
732  SigEff2P = [0.95, 0.75, 0.60, 0.45],
733  SigEff3P = [0.95, 0.75, 0.60, 0.45],
734  ScoreName = "RNNJetScore",
735  NewScoreName = "RNNJetScoreSigTrans",
736  DefineWPs = True )
737 
738  result.setPrivateTools(myTauWPDecorator)
739  return result
740 
TauToolHolder.TauDecayModeNNClassifierCfg
def TauDecayModeNNClassifierCfg(flags)
Definition: TauToolHolder.py:865
TauWPDecorator
Implementation of tool to decorate flattened BDT score and working points.
Definition: TauWPDecorator.h:36
TauCommonCalcVars
Calculate variables which rely on tracks and precalculated cell/cluster information.
Definition: TauCommonCalcVars.h:20
TauAODSelector
Definition: TauAODSelector.h:11
TauSubstructureVariables
Calculate variables from the tau substructure.
Definition: TauSubstructureVariables.h:21
python.TrkVertexFittersConfig.TauAdaptiveVertexFitterCfg
def TauAdaptiveVertexFitterCfg(flags, name="TauAdaptiveVertexFitter", **kwargs)
Definition: TrkVertexFittersConfig.py:97
TauToolHolder.TauTrackRNNCfg
def TauTrackRNNCfg(flags)
Definition: TauToolHolder.py:144
TauToolHolder.TauClusterFinderCfg
def TauClusterFinderCfg(flags)
Associate the cluster in jet constituents to the tau candidate.
Definition: TauToolHolder.py:116
TauToolHolder.TauVertexedClusterDecoratorCfg
def TauVertexedClusterDecoratorCfg(flags)
Definition: TauToolHolder.py:132
TauPi0CreateROI
Find the cells used to create pi0 cluster.
Definition: TauPi0CreateROI.h:30
TauToolHolder.TauAODMuonRemovalCfg
def TauAODMuonRemovalCfg(flags)
muon removal tool
Definition: TauToolHolder.py:904
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:572
TauToolHolder.TauCaloClusterBadChannelCfg
def TauCaloClusterBadChannelCfg(flags)
Definition: TauToolHolder.py:527
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:662
TauToolHolder.TauGNNEvaluatorCfg
def TauGNNEvaluatorCfg(flags, version=0, applyLooseTrackSel=False, applyTightTrackSel=False, tauContainerName="")
Definition: TauToolHolder.py:741
CaloCellContainerFinalizerTool
Definition: CaloCellContainerFinalizerTool.h:20
TauToolHolder.TauAxisCfg
def TauAxisCfg(flags)
Tau energy calibration and tau axis direction.
Definition: TauToolHolder.py:56
python.InDetTrackSelectorToolConfig.TauRecInDetTrackSelectorToolCfg
def TauRecInDetTrackSelectorToolCfg(flags, name='tauRec_InDetTrackSelectorTool', **kwargs)
Definition: InDetTrackSelectorToolConfig.py:197
TauCombinedTES
Definition: TauCombinedTES.h:21
TauToolHolder.TauCaloDMCalibCfg
def TauCaloDMCalibCfg(flags)
Definition: TauToolHolder.py:391
TrackVertexAssociationToolConfig.TauTTVAToolCfg
def TauTTVAToolCfg(flags, name="TVATool", **kwargs)
Definition: TrackVertexAssociationToolConfig.py:42
TauToolHolder.TauTrackRNNClassifierCfg
def TauTrackRNNClassifierCfg(flags)
Definition: TauToolHolder.py:157
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:463
TauToolHolder.Pi0ClusterCreatorCfg
def Pi0ClusterCreatorCfg(flags)
create Pi0 clusters
Definition: TauToolHolder.py:539
CaloTopoClusterSplitter
topological cluster splitter.
Definition: CaloTopoClusterSplitter.h:48
TauToolHolder.MvaTESVariableDecoratorCfg
def MvaTESVariableDecoratorCfg(flags)
MvaTESVariableDecorator.
Definition: TauToolHolder.py:642
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:287
TauToolHolder.TauCaloClusterMomentsMakerCfg
def TauCaloClusterMomentsMakerCfg(flags)
Definition: TauToolHolder.py:487
TauToolHolder.ElectronVetoVarsCfg
def ElectronVetoVarsCfg(flags)
ele veto variables
Definition: TauToolHolder.py:207
TauToolHolder.TauWPDecoratorGNNCfg
def TauWPDecoratorGNNCfg(flags, version, tauContainerName="")
Definition: TauToolHolder.py:771
TauCalibrateLC
Implementation of tau energy scale (TES) with eta and pile-up correction.
Definition: TauCalibrateLC.h:25
TauToolHolder.TauCaloTopoClusterMakerCfg
def TauCaloTopoClusterMakerCfg(flags)
Definition: TauToolHolder.py:417
StandardCellWeightCalib.getCellWeightTool
def getCellWeightTool(flags, finder="Cone", mainparam=0.4, input="Topo", onlyCellWeight=False)
Definition: StandardCellWeightCalib.py:178
MvaTESVariableDecorator
Definition: MvaTESVariableDecorator.h:16
TauPi0ScoreCalculator
Selectes pi0Candidates (Pi0 Finder).
Definition: TauPi0ScoreCalculator.h:25
TauToolHolder.getParticleCache
def getParticleCache(flags)
Definition: TauToolHolder.py:70
TauToolHolder.TauEleOverlapChecker
def TauEleOverlapChecker(flags)
Definition: TauToolHolder.py:918
TauToolHolder.TauSubstructureCfg
def TauSubstructureCfg(flags)
Tau Variables.
Definition: TauToolHolder.py:630
TauVertexedClusterDecorator
Decorate CaloVertexedTopoCluster to the tau candidate.
Definition: TauVertexedClusterDecorator.h:19
TauAxisSetter
Set Tau "Detector Axis" and "Intermediate Axis".
Definition: TauAxisSetter.h:28
python.CaloNoiseCondAlgConfig.CaloNoiseCondAlgCfg
def CaloNoiseCondAlgCfg(flags, noisetype="totalNoise")
Definition: CaloNoiseCondAlgConfig.py:11
CaloLCWeightTool
calculates hadronic cell weights based on cluster and cell quantities
Definition: CaloLCWeightTool.h:34
TauToolHolder.TauVertexFinderCfg
def TauVertexFinderCfg(flags)
Definition: TauToolHolder.py:31
TauPi0ClusterScaler
scale cluster energy to take care of charged pion energy
Definition: TauPi0ClusterScaler.h:22
TauDecayModeNNClassifier
Tau decay mode classifier using a neural network.
Definition: TauDecayModeNNClassifier.h:35
TauToolHolder.TauCaloOOCCalibCfg
def TauCaloOOCCalibCfg(flags)
Definition: TauToolHolder.py:378
TauToolHolder.TauCaloLCDeadMaterialCfg
def TauCaloLCDeadMaterialCfg(flags)
Definition: TauToolHolder.py:349
TauToolHolder.TauCaloOOCPi0CalibCfg
def TauCaloOOCPi0CalibCfg(flags)
Definition: TauToolHolder.py:404
TauPi0Selector
Apply Et and BDT score cut to pi0s.
Definition: TauPi0Selector.h:22
python.InDetTrackSelectionToolConfig.Tau_InDetTrackSelectionToolForTJVACfg
def Tau_InDetTrackSelectionToolForTJVACfg(flags, name="tauRec_InDetTrackSelectionToolForTJVA", **kwargs)
Definition: InDetTrackSelectionToolConfig.py:151
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:585
TauToolHolder.TauVertexVariablesCfg
def TauVertexVariablesCfg(flags)
Tau Vertex Variables.
Definition: TauToolHolder.py:600
TauToolHolder.CellVariablesCfg
def CellVariablesCfg(flags)
Tau cell variables calculation.
Definition: TauToolHolder.py:194
TauToolHolder.EnergyCalibrationLCCfg
def EnergyCalibrationLCCfg(flags)
Tau energy calibration.
Definition: TauToolHolder.py:180
TauElectronVetoVariables
Calculate variables sensitive on electrons.
Definition: TauElectronVetoVariables.h:27
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:336
TauToolHolder.TauAODSelectorCfg
def TauAODSelectorCfg(flags)
Definition: TauToolHolder.py:876
TauToolHolder.TauCaloClusterLocalCalibCfg
def TauCaloClusterLocalCalibCfg(flags)
Definition: TauToolHolder.py:364
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:20
TauToolHolder.TauWPDecoratorEleRNNCfg
def TauWPDecoratorEleRNNCfg(flags)
Definition: TauToolHolder.py:817
TauToolHolder.TauCombinedTESCfg
def TauCombinedTESCfg(flags)
TauCombinedTES.
Definition: TauToolHolder.py:891
CaloClusterMomentsMaker
Calculate moments for CaloCluster objects.
Definition: CaloClusterMomentsMaker.h:50
TauToolHolder.TauCellFinalizerCfg
def TauCellFinalizerCfg(flags)
Cell finalizer tool for BuildAlg.
Definition: TauToolHolder.py:273
TauToolHolder.TauCommonCalcVarsCfg
def TauCommonCalcVarsCfg(flags)
Tau Variables.
Definition: TauToolHolder.py:618
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:29
TauToolHolder.TauWPDecoratorEleRNNFixCfg
def TauWPDecoratorEleRNNFixCfg(flags)
Definition: TauToolHolder.py:845
TauToolHolder.TauCaloLCWeightCfg
def TauCaloLCWeightCfg(flags)
Definition: TauToolHolder.py:304
TrackToVertexConfig.TrackToVertexCfg
def TrackToVertexCfg(flags, name="AtlasTrackToVertexTool", **kwargs)
Definition: TrackToVertexConfig.py:6
MvaTESEvaluator
Definition: MvaTESEvaluator.h:18
TauToolHolder.TauShotFinderCfg
def TauShotFinderCfg(flags)
Photon Shot Finder.
Definition: TauToolHolder.py:224
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:560
TauShotFinder
Definition: TauShotFinder.h:30
python.TrkVertexSeedFinderToolsConfig.CrossDistancesSeedFinderCfg
def CrossDistancesSeedFinderCfg(flags, name="CrossDistancesSeedFinder", **kwargs)
Definition: TrkVertexSeedFinderToolsConfig.py:33
TauToolHolder.TauEleRNNEvaluatorCfg
def TauEleRNNEvaluatorCfg(flags, applyLooseTrackSel=False)
Definition: TauToolHolder.py:792
CaloLCDeadMaterialTool
dead material correction tool for local hadronic calibration
Definition: CaloLCDeadMaterialTool.h:40
TauToolHolder.TauCaloLCOutOfClusterCfg
def TauCaloLCOutOfClusterCfg(flags)
Definition: TauToolHolder.py:323
TauToolHolder.TauTrackFinderCfg
def TauTrackFinderCfg(flags)
Tau-Track Association.
Definition: TauToolHolder.py:81
TauToolHolder.TauWPDecoratorJetRNNCfg
def TauWPDecoratorJetRNNCfg(flags)
Definition: TauToolHolder.py:711
TauToolHolder.Pi0ClusterFinderCfg
def Pi0ClusterFinderCfg(flags)
Pi0 algo Cluster finder for Pi0 algo.
Definition: TauToolHolder.py:254
TauJetRNNEvaluator
Tool to calculate a tau identification score based on neural networks.
Definition: TauJetRNNEvaluator.h:28
TauToolHolder.TauIDVarCalculatorCfg
def TauIDVarCalculatorCfg(flags)
Definition: TauToolHolder.py:674
CaloTopoClusterMaker
topological cluster maker.
Definition: CaloTopoClusterMaker.h:48
TrackToCaloConfig.ParticleCaloExtensionToolCfg
def ParticleCaloExtensionToolCfg(flags, name='ParticleCaloExtensionTool', **kwargs)
Definition: TrackToCaloConfig.py:10
TauToolHolder.TauJetRNNEvaluatorCfg
def TauJetRNNEvaluatorCfg(flags, applyLooseTrackSel=False)
Definition: TauToolHolder.py:685
Generated on Tue Oct 28 2025 22:13:52 for ATLAS Offline Software by   doxygen 1.8.18