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

653 def MvaTESEvaluatorCfg(flags):
654  result = ComponentAccumulator()
655  _name = flags.Tau.ActiveConfig.prefix + 'MvaTESEvaluator'
656 
657  MvaTESEvaluator = CompFactory.getComp("MvaTESEvaluator")
658  MvaTESEvaluator = MvaTESEvaluator(name = _name,
659  WeightFileName = flags.Tau.MvaTESConfig,
660  WeightFileName0p = flags.Tau.MvaTESConfig0p )
661 
662  result.setPrivateTools(MvaTESEvaluator)
663  return result
664 

◆ MvaTESVariableDecoratorCfg()

def TauToolHolder.MvaTESVariableDecoratorCfg (   flags)

MvaTESVariableDecorator.

Definition at line 633 of file TauToolHolder.py.

633 def MvaTESVariableDecoratorCfg(flags):
634  result = ComponentAccumulator()
635  _name = flags.Tau.ActiveConfig.prefix + 'MvaTESVariableDecorator'
636 
637  eventShapeCollection = flags.Tau.ActiveConfig.EventShapeCollection
638  if 'EMPFlow' in flags.Tau.ActiveConfig.SeedJetCollection:
639  eventShapeCollection = "Kt4EMPFlowEventShape"
640  elif 'EMTopo' in flags.Tau.ActiveConfig.SeedJetCollection:
641  eventShapeCollection ="Kt4EMTopoOriginEventShape"
642 
643  MvaTESVariableDecorator = CompFactory.getComp("MvaTESVariableDecorator")
644  MvaTESVariableDecorator = MvaTESVariableDecorator(name = _name,
645  Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
646  EventShapeKey = eventShapeCollection,
647  VertexCorrection = flags.Tau.doVertexCorrection)
648  result.setPrivateTools(MvaTESVariableDecorator)
649  return result
650 

◆ 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 = CompFactory.getComp("TauPi0ClusterCreator")
544  TauPi0ClusterCreator = TauPi0ClusterCreator(name = _name)
545 
546  result.setPrivateTools(TauPi0ClusterCreator)
547  return result
548 

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

551 def Pi0ClusterScalerCfg(flags):
552  result = ComponentAccumulator()
553  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterScaler'
554 
555  TauPi0ClusterScaler = CompFactory.getComp("TauPi0ClusterScaler")
556  TauPi0ClusterScaler = TauPi0ClusterScaler(name = _name)
557 
558  result.setPrivateTools(TauPi0ClusterScaler)
559  return result
560 

◆ Pi0ScoreCalculatorCfg()

def TauToolHolder.Pi0ScoreCalculatorCfg (   flags)

calculate MVA scores of pi0 clusters

Definition at line 563 of file TauToolHolder.py.

563 def Pi0ScoreCalculatorCfg(flags):
564  result = ComponentAccumulator()
565  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ScoreCalculator'
566 
567  TauPi0ScoreCalculator = CompFactory.getComp("TauPi0ScoreCalculator")
568  TauPi0ScoreCalculator = TauPi0ScoreCalculator(name = _name,
569  BDTWeightFile = flags.Tau.Pi0ScoreConfig)
570 
571  result.setPrivateTools(TauPi0ScoreCalculator)
572  return result
573 

◆ Pi0SelectorCfg()

def TauToolHolder.Pi0SelectorCfg (   flags)

select pi0 clusters

Definition at line 576 of file TauToolHolder.py.

576 def Pi0SelectorCfg(flags):
577  result = ComponentAccumulator()
578  _name = flags.Tau.ActiveConfig.prefix + 'Pi0Selector'
579 
580  TauPi0Selector = CompFactory.getComp("TauPi0Selector")
581  TauPi0Selector = TauPi0Selector(name = _name,
582  ClusterEtCut = flags.Tau.pi0EtCuts,
583  ClusterBDTCut_1prong = flags.Tau.pi0MVACuts_1prong,
584  ClusterBDTCut_mprong = flags.Tau.pi0MVACuts_mprong)
585 
586  result.setPrivateTools(TauPi0Selector)
587  return result
588 

◆ TauAODMuonRemovalCfg()

def TauToolHolder.TauAODMuonRemovalCfg (   flags)

muon removal tool

Definition at line 892 of file TauToolHolder.py.

892 def TauAODMuonRemovalCfg(flags):
893  result = ComponentAccumulator()
894  _name = flags.Tau.ActiveConfig.prefix + 'MuonRemoval'
895  TauAODMuonRemovalTool = CompFactory.getComp("TauAODMuonRemovalTool")
896  myMuonRemoval = TauAODMuonRemovalTool( name = _name,
897  Key_MuonInputContainer = 'Muons',
898  doMuonTrkRm = True,
899  doMuonClsRm = True,
900  muonIDWP = 'Medium'
901  )
902  result.setPrivateTools(myMuonRemoval)
903  return result
904 
905 # electron excluder tool

◆ TauAODSelectorCfg()

def TauToolHolder.TauAODSelectorCfg (   flags)

Definition at line 864 of file TauToolHolder.py.

864 def TauAODSelectorCfg(flags):
865  result = ComponentAccumulator()
866  _name = flags.Tau.ActiveConfig.prefix + 'TauAODSelector'
867 
868  TauAODSelector = CompFactory.getComp("TauAODSelector")
869  myTauAODSelector = TauAODSelector(name=_name,
870  Min0pTauPt = flags.Tau.MinPt0p,
871  MinTauPt = flags.Tau.MinPt,
872  doEarlyStopping = flags.Tau.doEarlyStopping and not flags.Output.doWriteESD)
873 
874  result.setPrivateTools(myTauAODSelector)
875  return result
876 

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

879 def TauCombinedTESCfg(flags):
880  result = ComponentAccumulator()
881  _name = flags.Tau.ActiveConfig.prefix + 'TauCombinedTES'
882 
883  TauCombinedTES = CompFactory.getComp("TauCombinedTES")
884  myTauCombinedTES = TauCombinedTES(name = _name,
885  WeightFileName = flags.Tau.CombinedTESConfig)
886 
887  result.setPrivateTools(myTauCombinedTES)
888  return result
889 

◆ TauCommonCalcVarsCfg()

def TauToolHolder.TauCommonCalcVarsCfg (   flags)

Tau Variables.

Definition at line 609 of file TauToolHolder.py.

609 def TauCommonCalcVarsCfg(flags):
610  result = ComponentAccumulator()
611  _name = flags.Tau.ActiveConfig.prefix + 'TauCommonCalcVars'
612 
613  TauCommonCalcVars = CompFactory.getComp("TauCommonCalcVars")
614  TauCommonCalcVars = TauCommonCalcVars(name = _name)
615 
616  result.setPrivateTools(TauCommonCalcVars)
617  return result
618 

◆ TauDecayModeNNClassifierCfg()

def TauToolHolder.TauDecayModeNNClassifierCfg (   flags)

Definition at line 853 of file TauToolHolder.py.

853 def TauDecayModeNNClassifierCfg(flags):
854  result = ComponentAccumulator()
855  _name = flags.Tau.ActiveConfig.prefix + 'TauDecayModeNNClassifier'
856 
857  TauDecayModeNNClassifier = CompFactory.getComp("TauDecayModeNNClassifier")
858  myTauDecayModeNNClassifier = TauDecayModeNNClassifier(name=_name,
859  WeightFile=flags.Tau.DecayModeNNClassifierConfig)
860 
861  result.setPrivateTools(myTauDecayModeNNClassifier)
862  return result
863 

◆ TauEleOverlapChecker()

def TauToolHolder.TauEleOverlapChecker (   flags)

Definition at line 906 of file TauToolHolder.py.

906 def TauEleOverlapChecker(flags):
907  result = ComponentAccumulator()
908  _name = flags.Tau.ActiveConfig.prefix + 'TauEleOverlapChecker'
909  TauEleOverlapChecker = CompFactory.getComp("TauEleOverlapChecker")
910  myTauEleOverlapChecker = TauEleOverlapChecker(
911  name = _name,
912  Key_RemovedClustersContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
913  Key_RemovedTracksContainer = flags.Tau.ActiveConfig.RemovedElectronTracks,
914  CheckingCone = flags.Tau.ActiveConfig.EleRM_CheckingConeSize,
915  )
916  result.setPrivateTools(myTauEleOverlapChecker)
917  return result

◆ TauEleRNNEvaluatorCfg()

def TauToolHolder.TauEleRNNEvaluatorCfg (   flags,
  applyLooseTrackSel = False 
)

Definition at line 781 of file TauToolHolder.py.

781 def TauEleRNNEvaluatorCfg(flags, applyLooseTrackSel=False):
782  result = ComponentAccumulator()
783  _name = flags.Tau.ActiveConfig.prefix + 'TauEleRNN'
784 
785  TauJetRNNEvaluator = CompFactory.getComp("TauJetRNNEvaluator")
786  RNNConf = flags.Tau.TauEleRNNConfig
787  myTauEleRNNEvaluator = TauJetRNNEvaluator(name = _name,
788  NetworkFile1P = RNNConf[0],
789  NetworkFile3P = RNNConf[1],
790  OutputVarname = "RNNEleScore",
791  MaxTracks = 10,
792  MaxClusters = 6,
793  MaxClusterDR = 1.0,
794  ApplyLooseTrackSel = applyLooseTrackSel,
795  VertexCorrection = flags.Tau.doVertexCorrection,
796  InputLayerScalar = "scalar",
797  InputLayerTracks = "tracks",
798  InputLayerClusters = "clusters",
799  OutputLayer = "rnneveto_output",
800  OutputNode = "sig_prob")
801 
802  result.setPrivateTools(myTauEleRNNEvaluator)
803  return result
804 

◆ TauGNNEvaluatorCfg()

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

Definition at line 732 of file TauToolHolder.py.

732 def TauGNNEvaluatorCfg(flags, version=0, applyLooseTrackSel=False, applyTightTrackSel=False, tauContainerName=""):
733  result = ComponentAccumulator()
734  _name = flags.Tau.ActiveConfig.prefix + 'TauGNN_v' + str(version)
735 
736  TauGNNEvaluator = CompFactory.getComp("TauGNNEvaluator")
737  GNNConf = flags.Tau.TauGNNConfig[version]
738  myTauGNNEvaluator = TauGNNEvaluator(name = _name,
739  NetworkFileInclusive = GNNConf,
740  OutputVarname = flags.Tau.GNTauScoreName[version],
741  OutputPTau = "GNTauProbTau",
742  OutputPJet = "GNTauProbJet",
743  MaxTracks = flags.Tau.GNTauMaxTracks[version],
744  MaxClusters = flags.Tau.GNTauMaxClusters[version],
745  MaxClusterDR = 15.0,
746  MinTauPt = flags.Tau.MinPtDAOD,
747  ApplyLooseTrackSel = applyLooseTrackSel,
748  ApplyTightTrackSel = applyTightTrackSel,
749  VertexCorrection = flags.Tau.doVertexCorrection,
750  InputLayerScalar = "tau_vars",
751  InputLayerTracks = "track_vars",
752  InputLayerClusters = "cluster_vars",
753  NodeNameTau=flags.Tau.GNTauNodeNameTau,
754  NodeNameJet=flags.Tau.GNTauNodeNameJet,
755  TauContainerName = tauContainerName,)
756 
757  result.setPrivateTools(myTauGNNEvaluator)
758  return result
759 

◆ TauIDVarCalculatorCfg()

def TauToolHolder.TauIDVarCalculatorCfg (   flags)

Definition at line 665 of file TauToolHolder.py.

665 def TauIDVarCalculatorCfg(flags):
666  result = ComponentAccumulator()
667  _name = flags.Tau.ActiveConfig.prefix + 'TauIDVarCalculator'
668 
669  TauIDVarCalculator = CompFactory.getComp("TauIDVarCalculator")
670  myTauIDVarCalculator = TauIDVarCalculator(name=_name,
671  VertexCorrection = flags.Tau.doVertexCorrection)
672 
673  result.setPrivateTools(myTauIDVarCalculator)
674  return result
675 

◆ TauJetRNNEvaluatorCfg()

def TauToolHolder.TauJetRNNEvaluatorCfg (   flags,
  applyLooseTrackSel = False 
)

Definition at line 676 of file TauToolHolder.py.

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

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

621 def TauSubstructureCfg(flags):
622  result = ComponentAccumulator()
623  _name = flags.Tau.ActiveConfig.prefix + 'TauSubstructure'
624 
625  TauSubstructureVariables = CompFactory.getComp("TauSubstructureVariables")
626  TauSubstructureVariables = TauSubstructureVariables( name = _name )
627 
628  result.setPrivateTools(TauSubstructureVariables)
629  return result
630 

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

591 def TauVertexVariablesCfg(flags):
592  result = ComponentAccumulator()
593  _name = flags.Tau.ActiveConfig.prefix + 'TauVertexVariables'
594 
595  from TrkConfig.TrkVertexFittersConfig import TauAdaptiveVertexFitterCfg
596  from TrkConfig.TrkVertexSeedFinderToolsConfig import (
597  CrossDistancesSeedFinderCfg)
598 
599  TauVertexVariables = CompFactory.getComp("TauVertexVariables")
600  TauVertexVariables = TauVertexVariables( name = _name,
601  VertexFitter = result.popToolsAndMerge(TauAdaptiveVertexFitterCfg(flags)),
602  SeedFinder = result.popToolsAndMerge(CrossDistancesSeedFinderCfg(flags)) )
603 
604  result.setPrivateTools(TauVertexVariables)
605  return result
606 

◆ TauWPDecoratorEleRNNCfg()

def TauToolHolder.TauWPDecoratorEleRNNCfg (   flags)

Definition at line 805 of file TauToolHolder.py.

805 def TauWPDecoratorEleRNNCfg(flags):
806  import PyUtils.RootUtils as ru
807  ROOT = ru.import_root()
808  import cppyy
809  cppyy.load_library('libxAODTau_cDict')
810 
811  result = ComponentAccumulator()
812  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNN'
813 
814  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
815  WPConf = flags.Tau.TauEleRNNWPConfig
816  myTauEleWPDecorator = TauWPDecorator( name=_name,
817  flatteningFile1Prong = WPConf[0],
818  flatteningFile3Prong = WPConf[1],
819  CutEnumVals =
820  [ ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNLoose,
821  ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNMedium,
822  ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNTight ],
823  SigEff1P = [0.95, 0.90, 0.85],
824  SigEff3P = [0.98, 0.95, 0.90],
825  UseAbsEta = True ,
826  ScoreName = "RNNEleScore",
827  NewScoreName = "RNNEleScoreSigTrans",
828  DefineWPs = True)
829 
830  result.setPrivateTools(myTauEleWPDecorator)
831  return result
832 

◆ TauWPDecoratorEleRNNFixCfg()

def TauToolHolder.TauWPDecoratorEleRNNFixCfg (   flags)

Definition at line 833 of file TauToolHolder.py.

833 def TauWPDecoratorEleRNNFixCfg(flags):
834  result = ComponentAccumulator()
835  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNNFix_v1'
836 
837  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
838  WPConf = flags.Tau.TauEleRNNWPfix
839  myTauEleWPDecorator = TauWPDecorator(name = _name,
840  flatteningFile1Prong = WPConf[0],
841  flatteningFile3Prong = WPConf[1],
842  DecorWPNames = [ "EleRNNLoose_v1", "EleRNNMedium_v1", "EleRNNTight_v1" ],
843  DecorWPCutEffs1P = [0.95, 0.90, 0.85],
844  DecorWPCutEffs3P = [0.98, 0.95, 0.90],
845  UseAbsEta = True,
846  ScoreName = "RNNEleScore",
847  NewScoreName = "RNNEleScoreSigTrans_v1",
848  DefineWPs = True)
849 
850  result.setPrivateTools(myTauEleWPDecorator)
851  return result
852 

◆ TauWPDecoratorGNNCfg()

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

Definition at line 760 of file TauToolHolder.py.

760 def TauWPDecoratorGNNCfg(flags, version, tauContainerName=""):
761  result = ComponentAccumulator()
762  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorGNN_v' + str(version)
763 
764  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
765  WPConf = flags.Tau.TauGNNWP[version]
766  myTauWPDecorator = TauWPDecorator(name=_name,
767  flatteningFile1Prong = WPConf[0],
768  flatteningFile2Prong = WPConf[1],
769  flatteningFile3Prong = WPConf[2],
770  TauContainerName = tauContainerName,
771  DecorWPNames = flags.Tau.GNTauDecorWPNames[version],
772  DecorWPCutEffs1P = [0.95, 0.85, 0.75, 0.60],
773  DecorWPCutEffs2P = [0.95, 0.75, 0.60, 0.45],
774  DecorWPCutEffs3P = [0.95, 0.75, 0.60, 0.45],
775  ScoreName = flags.Tau.GNTauScoreName[version],
776  NewScoreName = flags.Tau.GNTauTransScoreName[version],
777  DefineWPs = True)
778  result.setPrivateTools(myTauWPDecorator)
779  return result
780 

◆ TauWPDecoratorJetRNNCfg()

def TauToolHolder.TauWPDecoratorJetRNNCfg (   flags)

Definition at line 702 of file TauToolHolder.py.

702 def TauWPDecoratorJetRNNCfg(flags):
703  import PyUtils.RootUtils as ru
704  ROOT = ru.import_root()
705  import cppyy
706  cppyy.load_library('libxAODTau_cDict')
707 
708  result = ComponentAccumulator()
709  _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorJetRNN'
710 
711  TauWPDecorator = CompFactory.getComp("TauWPDecorator")
712  WPConf = flags.Tau.TauJetRNNWPConfig
713  myTauWPDecorator = TauWPDecorator( name=_name,
714  flatteningFile1Prong = WPConf[0],
715  flatteningFile2Prong = WPConf[1],
716  flatteningFile3Prong = WPConf[2],
717  CutEnumVals =
718  [ ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigVeryLoose,
719  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigLoose,
720  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigMedium,
721  ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigTight ],
722  SigEff1P = [0.95, 0.85, 0.75, 0.60],
723  SigEff2P = [0.95, 0.75, 0.60, 0.45],
724  SigEff3P = [0.95, 0.75, 0.60, 0.45],
725  ScoreName = "RNNJetScore",
726  NewScoreName = "RNNJetScoreSigTrans",
727  DefineWPs = True )
728 
729  result.setPrivateTools(myTauWPDecorator)
730  return result
731 
TauToolHolder.TauDecayModeNNClassifierCfg
def TauDecayModeNNClassifierCfg(flags)
Definition: TauToolHolder.py:853
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:892
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:563
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:653
TauToolHolder.TauGNNEvaluatorCfg
def TauGNNEvaluatorCfg(flags, version=0, applyLooseTrackSel=False, applyTightTrackSel=False, tauContainerName="")
Definition: TauToolHolder.py:732
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:633
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:760
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:906
TauToolHolder.TauSubstructureCfg
def TauSubstructureCfg(flags)
Tau Variables.
Definition: TauToolHolder.py:621
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:576
TauToolHolder.TauVertexVariablesCfg
def TauVertexVariablesCfg(flags)
Tau Vertex Variables.
Definition: TauToolHolder.py:591
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:864
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:805
TauToolHolder.TauCombinedTESCfg
def TauCombinedTESCfg(flags)
TauCombinedTES.
Definition: TauToolHolder.py:879
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:609
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:833
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:551
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:781
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:702
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:665
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:676
Generated on Thu Sep 4 2025 22:14:18 for ATLAS Offline Software by   doxygen 1.8.18