Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Functions
TauToolHolder Namespace Reference

Functions

def JetSeedBuilderCfg (flags)
 JetSeedBuilder. More...
 
def TauVertexFinderCfg (flags)
 
def TauAxisCfg (flags)
 Tau energy calibration and tau axis direction. More...
 
def getParticleCache (flags)
 
def TauTrackFinderCfg (flags)
 Tau-Track Association. More...
 
def TauClusterFinderCfg (flags)
 Associate the cluster in jet constituents to the tau candidate. More...
 
def TauVertexedClusterDecoratorCfg (flags)
 
def TauTrackRNNCfg (flags)
 
def TauTrackRNNClassifierCfg (flags)
 
def EnergyCalibrationLCCfg (flags)
 Tau energy calibration. More...
 
def CellVariablesCfg (flags)
 Tau cell variables calculation. More...
 
def ElectronVetoVarsCfg (flags)
 ele veto variables More...
 
def 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)
 
def TauWPDecoratorJetRNNCfg (flags)
 
def TauGNNEvaluatorCfg (flags, version=0)
 
def TauWPDecoratorGNNCfg (flags, version)
 
def TauEleRNNEvaluatorCfg (flags)
 
def TauWPDecoratorEleRNNCfg (flags)
 
def TauWPDecoratorEleRNNFixCfg (flags)
 
def TauDecayModeNNClassifierCfg (flags)
 
def TauAODSelectorCfg (flags)
 
def TauCombinedTESCfg (flags)
 TauCombinedTES. More...
 
def TauAODMuonRemovalCfg (flags)
 muon removal tool More...
 
def TauEleOverlapChecker (flags)
 

Function Documentation

◆ CellVariablesCfg()

def TauToolHolder.CellVariablesCfg (   flags)

Tau cell variables calculation.

Definition at line 195 of file TauToolHolder.py.

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

◆ ElectronVetoVarsCfg()

def TauToolHolder.ElectronVetoVarsCfg (   flags)

ele veto variables

Definition at line 208 of file TauToolHolder.py.

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

◆ EnergyCalibrationLCCfg()

def TauToolHolder.EnergyCalibrationLCCfg (   flags)

Tau energy calibration.

Definition at line 181 of file TauToolHolder.py.

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

◆ getParticleCache()

def TauToolHolder.getParticleCache (   flags)

Definition at line 71 of file TauToolHolder.py.

71 def getParticleCache(flags):
72  #If reading from ESD we not create a cache of extrapolations to the calorimeter, so we should signify this by setting the cache key to a null string
73  if flags.Common.ProductionStep is ProductionStep.Reconstruction:
74  ParticleCache = "ParticleCaloExtension"
75  else:
76  ParticleCache = ""
77 
78  return ParticleCache
79 

◆ JetSeedBuilderCfg()

def TauToolHolder.JetSeedBuilderCfg (   flags)

JetSeedBuilder.

Definition at line 21 of file TauToolHolder.py.

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

◆ MvaTESEvaluatorCfg()

def TauToolHolder.MvaTESEvaluatorCfg (   flags)

MvaTESEvaluator.

Definition at line 654 of file TauToolHolder.py.

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

◆ MvaTESVariableDecoratorCfg()

def TauToolHolder.MvaTESVariableDecoratorCfg (   flags)

MvaTESVariableDecorator.

Definition at line 634 of file TauToolHolder.py.

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

◆ Pi0ClusterCreatorCfg()

def TauToolHolder.Pi0ClusterCreatorCfg (   flags)

create Pi0 clusters

Definition at line 540 of file TauToolHolder.py.

540 def Pi0ClusterCreatorCfg(flags):
541  result = ComponentAccumulator()
542  _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterCreator'
543 
544  TauPi0ClusterCreator = CompFactory.getComp("TauPi0ClusterCreator")
545  TauPi0ClusterCreator = TauPi0ClusterCreator(name = _name)
546 
547  result.setPrivateTools(TauPi0ClusterCreator)
548  return result
549 

◆ Pi0ClusterFinderCfg()

def TauToolHolder.Pi0ClusterFinderCfg (   flags)

Pi0 algo Cluster finder for Pi0 algo.

Definition at line 255 of file TauToolHolder.py.

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

◆ Pi0ClusterScalerCfg()

def TauToolHolder.Pi0ClusterScalerCfg (   flags)

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

Definition at line 552 of file TauToolHolder.py.

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

◆ Pi0ScoreCalculatorCfg()

def TauToolHolder.Pi0ScoreCalculatorCfg (   flags)

calculate MVA scores of pi0 clusters

Definition at line 564 of file TauToolHolder.py.

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

◆ Pi0SelectorCfg()

def TauToolHolder.Pi0SelectorCfg (   flags)

select pi0 clusters

Definition at line 577 of file TauToolHolder.py.

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

◆ TauAODMuonRemovalCfg()

def TauToolHolder.TauAODMuonRemovalCfg (   flags)

muon removal tool

Definition at line 888 of file TauToolHolder.py.

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

◆ TauAODSelectorCfg()

def TauToolHolder.TauAODSelectorCfg (   flags)

Definition at line 860 of file TauToolHolder.py.

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

◆ TauAxisCfg()

def TauToolHolder.TauAxisCfg (   flags)

Tau energy calibration and tau axis direction.

Definition at line 57 of file TauToolHolder.py.

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

◆ TauCaloClusterBadChannelCfg()

def TauToolHolder.TauCaloClusterBadChannelCfg (   flags)

Definition at line 528 of file TauToolHolder.py.

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

◆ TauCaloClusterLocalCalibCfg()

def TauToolHolder.TauCaloClusterLocalCalibCfg (   flags)

Definition at line 365 of file TauToolHolder.py.

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

◆ TauCaloClusterMomentsMakerCfg()

def TauToolHolder.TauCaloClusterMomentsMakerCfg (   flags)

Definition at line 488 of file TauToolHolder.py.

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

◆ TauCaloDMCalibCfg()

def TauToolHolder.TauCaloDMCalibCfg (   flags)

Definition at line 392 of file TauToolHolder.py.

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

◆ TauCaloLCClassificationCfg()

def TauToolHolder.TauCaloLCClassificationCfg (   flags)

Calo Tools.

Definition at line 288 of file TauToolHolder.py.

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

◆ TauCaloLCDeadMaterialCfg()

def TauToolHolder.TauCaloLCDeadMaterialCfg (   flags)

Definition at line 350 of file TauToolHolder.py.

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

◆ TauCaloLCOutOfClusterCfg()

def TauToolHolder.TauCaloLCOutOfClusterCfg (   flags)

Definition at line 324 of file TauToolHolder.py.

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

◆ TauCaloLCOutPi0Cfg()

def TauToolHolder.TauCaloLCOutPi0Cfg (   flags)

Definition at line 337 of file TauToolHolder.py.

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

◆ TauCaloLCWeightCfg()

def TauToolHolder.TauCaloLCWeightCfg (   flags)

Definition at line 305 of file TauToolHolder.py.

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

◆ TauCaloOOCCalibCfg()

def TauToolHolder.TauCaloOOCCalibCfg (   flags)

Definition at line 379 of file TauToolHolder.py.

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

◆ TauCaloOOCPi0CalibCfg()

def TauToolHolder.TauCaloOOCPi0CalibCfg (   flags)

Definition at line 405 of file TauToolHolder.py.

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

◆ TauCaloTopoClusterMakerCfg()

def TauToolHolder.TauCaloTopoClusterMakerCfg (   flags)

Definition at line 418 of file TauToolHolder.py.

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

◆ TauCaloTopoClusterSplitterCfg()

def TauToolHolder.TauCaloTopoClusterSplitterCfg (   flags)

Definition at line 464 of file TauToolHolder.py.

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

◆ TauCellFinalizerCfg()

def TauToolHolder.TauCellFinalizerCfg (   flags)

Cell finalizer tool for BuildAlg.

Definition at line 274 of file TauToolHolder.py.

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

◆ TauClusterFinderCfg()

def TauToolHolder.TauClusterFinderCfg (   flags)

Associate the cluster in jet constituents to the tau candidate.

Definition at line 117 of file TauToolHolder.py.

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

◆ TauCombinedTESCfg()

def TauToolHolder.TauCombinedTESCfg (   flags)

TauCombinedTES.

Definition at line 875 of file TauToolHolder.py.

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

◆ TauCommonCalcVarsCfg()

def TauToolHolder.TauCommonCalcVarsCfg (   flags)

Tau Variables.

Definition at line 610 of file TauToolHolder.py.

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

◆ TauDecayModeNNClassifierCfg()

def TauToolHolder.TauDecayModeNNClassifierCfg (   flags)

Definition at line 849 of file TauToolHolder.py.

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

◆ TauEleOverlapChecker()

def TauToolHolder.TauEleOverlapChecker (   flags)

Definition at line 902 of file TauToolHolder.py.

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

◆ TauEleRNNEvaluatorCfg()

def TauToolHolder.TauEleRNNEvaluatorCfg (   flags)

Definition at line 778 of file TauToolHolder.py.

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

◆ TauGNNEvaluatorCfg()

def TauToolHolder.TauGNNEvaluatorCfg (   flags,
  version = 0 
)

Definition at line 732 of file TauToolHolder.py.

732 def TauGNNEvaluatorCfg(flags, version=0):
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  VertexCorrection = flags.Tau.doVertexCorrection,
748  DecorateTracks = False,
749  InputLayerScalar = "tau_vars",
750  InputLayerTracks = "track_vars",
751  InputLayerClusters = "cluster_vars",
752  NodeNameTau=flags.Tau.GNTauNodeNameTau,
753  NodeNameJet=flags.Tau.GNTauNodeNameJet)
754 
755  result.setPrivateTools(myTauGNNEvaluator)
756  return result
757 

◆ TauIDVarCalculatorCfg()

def TauToolHolder.TauIDVarCalculatorCfg (   flags)

Definition at line 666 of file TauToolHolder.py.

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

◆ TauJetRNNEvaluatorCfg()

def TauToolHolder.TauJetRNNEvaluatorCfg (   flags)

Definition at line 677 of file TauToolHolder.py.

677 def TauJetRNNEvaluatorCfg(flags):
678  result = ComponentAccumulator()
679  _name = flags.Tau.ActiveConfig.prefix + 'TauJetRNN'
680 
681  TauJetRNNEvaluator = CompFactory.getComp("TauJetRNNEvaluator")
682  RNNConf = flags.Tau.TauJetRNNConfig
683  myTauJetRNNEvaluator = TauJetRNNEvaluator(name = _name,
684  NetworkFile0P = "",
685  NetworkFile1P = RNNConf[0],
686  NetworkFile2P = RNNConf[1],
687  NetworkFile3P = RNNConf[2],
688  OutputVarname = "RNNJetScore",
689  MaxTracks = 10,
690  MaxClusters = 6,
691  MaxClusterDR = 1.0,
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 225 of file TauToolHolder.py.

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

◆ TauSubstructureCfg()

def TauToolHolder.TauSubstructureCfg (   flags)

Tau Variables.

Definition at line 622 of file TauToolHolder.py.

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

◆ TauTrackFinderCfg()

def TauToolHolder.TauTrackFinderCfg (   flags)

Tau-Track Association.

Definition at line 82 of file TauToolHolder.py.

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

◆ TauTrackRNNCfg()

def TauToolHolder.TauTrackRNNCfg (   flags)

Definition at line 145 of file TauToolHolder.py.

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

◆ TauTrackRNNClassifierCfg()

def TauToolHolder.TauTrackRNNClassifierCfg (   flags)

Definition at line 158 of file TauToolHolder.py.

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

◆ TauVertexedClusterDecoratorCfg()

def TauToolHolder.TauVertexedClusterDecoratorCfg (   flags)

Definition at line 133 of file TauToolHolder.py.

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

◆ TauVertexFinderCfg()

def TauToolHolder.TauVertexFinderCfg (   flags)

Definition at line 32 of file TauToolHolder.py.

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

◆ TauVertexVariablesCfg()

def TauToolHolder.TauVertexVariablesCfg (   flags)

Tau Vertex Variables.

Definition at line 592 of file TauToolHolder.py.

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

◆ TauWPDecoratorEleRNNCfg()

def TauToolHolder.TauWPDecoratorEleRNNCfg (   flags)

Definition at line 801 of file TauToolHolder.py.

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

◆ TauWPDecoratorEleRNNFixCfg()

def TauToolHolder.TauWPDecoratorEleRNNFixCfg (   flags)

Definition at line 829 of file TauToolHolder.py.

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

◆ TauWPDecoratorGNNCfg()

def TauToolHolder.TauWPDecoratorGNNCfg (   flags,
  version 
)

Definition at line 758 of file TauToolHolder.py.

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

◆ 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:849
TauWPDecorator
Implementation of tool to decorate flattened BDT score and working points.
Definition: TauWPDecorator.h:35
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:145
TauToolHolder.TauClusterFinderCfg
def TauClusterFinderCfg(flags)
Associate the cluster in jet constituents to the tau candidate.
Definition: TauToolHolder.py:117
TauToolHolder.TauVertexedClusterDecoratorCfg
def TauVertexedClusterDecoratorCfg(flags)
Definition: TauToolHolder.py:133
TauPi0CreateROI
Find the cells used to create pi0 cluster.
Definition: TauPi0CreateROI.h:30
TauToolHolder.TauAODMuonRemovalCfg
def TauAODMuonRemovalCfg(flags)
muon removal tool
Definition: TauToolHolder.py:888
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:564
TauToolHolder.TauCaloClusterBadChannelCfg
def TauCaloClusterBadChannelCfg(flags)
Definition: TauToolHolder.py:528
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:654
TauToolHolder.TauEleRNNEvaluatorCfg
def TauEleRNNEvaluatorCfg(flags)
Definition: TauToolHolder.py:778
CaloCellContainerFinalizerTool
Definition: CaloCellContainerFinalizerTool.h:20
TauToolHolder.TauAxisCfg
def TauAxisCfg(flags)
Tau energy calibration and tau axis direction.
Definition: TauToolHolder.py:57
python.InDetTrackSelectorToolConfig.TauRecInDetTrackSelectorToolCfg
def TauRecInDetTrackSelectorToolCfg(flags, name='tauRec_InDetTrackSelectorTool', **kwargs)
Definition: InDetTrackSelectorToolConfig.py:197
TauCombinedTES
Definition: TauCombinedTES.h:21
TauToolHolder.TauCaloDMCalibCfg
def TauCaloDMCalibCfg(flags)
Definition: TauToolHolder.py:392
TrackVertexAssociationToolConfig.TauTTVAToolCfg
def TauTTVAToolCfg(flags, name="TVATool", **kwargs)
Definition: TrackVertexAssociationToolConfig.py:42
TauToolHolder.TauTrackRNNClassifierCfg
def TauTrackRNNClassifierCfg(flags)
Definition: TauToolHolder.py:158
TauToolHolder.TauJetRNNEvaluatorCfg
def TauJetRNNEvaluatorCfg(flags)
Definition: TauToolHolder.py:677
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:464
TauToolHolder.Pi0ClusterCreatorCfg
def Pi0ClusterCreatorCfg(flags)
create Pi0 clusters
Definition: TauToolHolder.py:540
CaloTopoClusterSplitter
topological cluster splitter.
Definition: CaloTopoClusterSplitter.h:48
TauToolHolder.MvaTESVariableDecoratorCfg
def MvaTESVariableDecoratorCfg(flags)
MvaTESVariableDecorator.
Definition: TauToolHolder.py:634
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:288
TauToolHolder.TauCaloClusterMomentsMakerCfg
def TauCaloClusterMomentsMakerCfg(flags)
Definition: TauToolHolder.py:488
TauToolHolder.ElectronVetoVarsCfg
def ElectronVetoVarsCfg(flags)
ele veto variables
Definition: TauToolHolder.py:208
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:418
TauToolHolder.TauGNNEvaluatorCfg
def TauGNNEvaluatorCfg(flags, version=0)
Definition: TauToolHolder.py:732
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:71
TauToolHolder.TauEleOverlapChecker
def TauEleOverlapChecker(flags)
Definition: TauToolHolder.py:902
TauToolHolder.TauSubstructureCfg
def TauSubstructureCfg(flags)
Tau Variables.
Definition: TauToolHolder.py:622
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:32
TauPi0ClusterScaler
scale cluster energy to take care of charged pion energy
Definition: TauPi0ClusterScaler.h:22
TauDecayModeNNClassifier
Tau decay mode classifier using a neural network.
Definition: TauDecayModeNNClassifier.h:35
TauToolHolder.TauCaloOOCCalibCfg
def TauCaloOOCCalibCfg(flags)
Definition: TauToolHolder.py:379
TauToolHolder.TauCaloLCDeadMaterialCfg
def TauCaloLCDeadMaterialCfg(flags)
Definition: TauToolHolder.py:350
TauToolHolder.TauCaloOOCPi0CalibCfg
def TauCaloOOCPi0CalibCfg(flags)
Definition: TauToolHolder.py:405
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:162
TauIDVarCalculator
This class implements a tool to calculate ID input variables and add them to the tau aux store.
Definition: TauIDVarCalculator.h:18
TauToolHolder.Pi0SelectorCfg
def Pi0SelectorCfg(flags)
select pi0 clusters
Definition: TauToolHolder.py:577
TauToolHolder.TauVertexVariablesCfg
def TauVertexVariablesCfg(flags)
Tau Vertex Variables.
Definition: TauToolHolder.py:592
TauToolHolder.CellVariablesCfg
def CellVariablesCfg(flags)
Tau cell variables calculation.
Definition: TauToolHolder.py:195
TauToolHolder.EnergyCalibrationLCCfg
def EnergyCalibrationLCCfg(flags)
Tau energy calibration.
Definition: TauToolHolder.py:181
TauElectronVetoVariables
Calculate variables sensitive on electrons.
Definition: TauElectronVetoVariables.h:27
TauToolHolder.TauWPDecoratorGNNCfg
def TauWPDecoratorGNNCfg(flags, version)
Definition: TauToolHolder.py:758
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:337
TauToolHolder.TauAODSelectorCfg
def TauAODSelectorCfg(flags)
Definition: TauToolHolder.py:860
TauToolHolder.TauCaloClusterLocalCalibCfg
def TauCaloClusterLocalCalibCfg(flags)
Definition: TauToolHolder.py:365
TauVertexFinder
Associate a vertex (origin) to the tau candidate.
Definition: TauVertexFinder.h:29
CaloLCOutOfClusterTool
calculates out-of-cluster corrections based on cluster quantities
Definition: CaloLCOutOfClusterTool.h:28
JetSeedBuilder
Class to build tau jet seed.
Definition: JetSeedBuilder.h:17
TauTrackFinder
Associate tracks to the tau candidate.
Definition: TauTrackFinder.h:39
TauAODMuonRemovalTool
the tool meant to run at AOD level, to remove the muon found inside the TauJet.
Definition: TauAODMuonRemovalTool.h:21
TauToolHolder.JetSeedBuilderCfg
def JetSeedBuilderCfg(flags)
JetSeedBuilder.
Definition: TauToolHolder.py:21
TauToolHolder.TauWPDecoratorEleRNNCfg
def TauWPDecoratorEleRNNCfg(flags)
Definition: TauToolHolder.py:801
TauToolHolder.TauCombinedTESCfg
def TauCombinedTESCfg(flags)
TauCombinedTES.
Definition: TauToolHolder.py:875
CaloClusterMomentsMaker
Calculate moments for CaloCluster objects.
Definition: CaloClusterMomentsMaker.h:50
TauToolHolder.TauCellFinalizerCfg
def TauCellFinalizerCfg(flags)
Cell finalizer tool for BuildAlg.
Definition: TauToolHolder.py:274
TauToolHolder.TauCommonCalcVarsCfg
def TauCommonCalcVarsCfg(flags)
Tau Variables.
Definition: TauToolHolder.py:610
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:28
TauToolHolder.TauWPDecoratorEleRNNFixCfg
def TauWPDecoratorEleRNNFixCfg(flags)
Definition: TauToolHolder.py:829
TauToolHolder.TauCaloLCWeightCfg
def TauCaloLCWeightCfg(flags)
Definition: TauToolHolder.py:305
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:225
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:552
TauShotFinder
Definition: TauShotFinder.h:30
python.TrkVertexSeedFinderToolsConfig.CrossDistancesSeedFinderCfg
def CrossDistancesSeedFinderCfg(flags, name="CrossDistancesSeedFinder", **kwargs)
Definition: TrkVertexSeedFinderToolsConfig.py:33
CaloLCDeadMaterialTool
dead material correction tool for local hadronic calibration
Definition: CaloLCDeadMaterialTool.h:40
TauToolHolder.TauCaloLCOutOfClusterCfg
def TauCaloLCOutOfClusterCfg(flags)
Definition: TauToolHolder.py:324
TauToolHolder.TauTrackFinderCfg
def TauTrackFinderCfg(flags)
Tau-Track Association.
Definition: TauToolHolder.py:82
TauToolHolder.TauWPDecoratorJetRNNCfg
def TauWPDecoratorJetRNNCfg(flags)
Definition: TauToolHolder.py:702
TauToolHolder.Pi0ClusterFinderCfg
def Pi0ClusterFinderCfg(flags)
Pi0 algo Cluster finder for Pi0 algo.
Definition: TauToolHolder.py:255
TauJetRNNEvaluator
Tool to calculate a tau identification score based on neural networks.
Definition: TauJetRNNEvaluator.h:28
TauToolHolder.TauIDVarCalculatorCfg
def TauIDVarCalculatorCfg(flags)
Definition: TauToolHolder.py:666
CaloTopoClusterMaker
topological cluster maker.
Definition: CaloTopoClusterMaker.h:48
TrackToCaloConfig.ParticleCaloExtensionToolCfg
def ParticleCaloExtensionToolCfg(flags, name='ParticleCaloExtensionTool', **kwargs)
Definition: TrackToCaloConfig.py:10
Generated on Sat Apr 19 2025 22:07:38 for ATLAS Offline Software by   doxygen 1.8.18