ATLAS Offline Software
Loading...
Searching...
No Matches
Functions
TauToolHolder Namespace Reference

Functions

 JetSeedBuilderCfg (flags)
 JetSeedBuilder.
 TauVertexFinderCfg (flags)
 TauAxisCfg (flags)
 Tau energy calibration and tau axis direction.
 getParticleCache (flags)
 TauTrackFinderCfg (flags)
 Tau-Track Association.
 TauTrackCaloExtrapolatorCfg (flags)
 Tau-Track Calo Extrapolator.
 TauClusterFinderCfg (flags)
 Associate the cluster in jet constituents to the tau candidate.
 TauVertexedClusterDecoratorCfg (flags)
 TauTrackRNNCfg (flags)
 TauTrackRNNClassifierCfg (flags)
 EnergyCalibrationLCCfg (flags, force_zero_mass=False)
 Tau energy calibration.
 CellVariablesCfg (flags)
 Tau cell variables calculation.
 ElectronVetoVarsCfg (flags)
 ele veto variables
 TauShotFinderCfg (flags)
 Photon Shot Finder.
 Pi0ClusterFinderCfg (flags)
 Pi0 algo Cluster finder for Pi0 algo.
 TauCellFinalizerCfg (flags)
 Cell finalizer tool for BuildAlg.
 TauCaloLCClassificationCfg (flags)
 Calo Tools.
 TauCaloLCWeightCfg (flags)
 TauCaloLCOutOfClusterCfg (flags)
 TauCaloLCOutPi0Cfg (flags)
 TauCaloLCDeadMaterialCfg (flags)
 TauCaloClusterLocalCalibCfg (flags)
 TauCaloOOCCalibCfg (flags)
 TauCaloDMCalibCfg (flags)
 TauCaloOOCPi0CalibCfg (flags)
 TauCaloTopoClusterMakerCfg (flags)
 TauCaloTopoClusterSplitterCfg (flags)
 TauCaloClusterMomentsMakerCfg (flags)
 TauCaloClusterBadChannelCfg (flags)
 Pi0ClusterCreatorCfg (flags)
 create Pi0 clusters
 Pi0ClusterScalerCfg (flags)
 Set energy of cluster to take care of charged pion energy deposited in the ECAL.
 Pi0ScoreCalculatorCfg (flags)
 calculate MVA scores of pi0 clusters
 Pi0SelectorCfg (flags)
 select pi0 clusters
 TauVertexVariablesCfg (flags)
 Tau Vertex Variables.
 TauCommonCalcVarsCfg (flags)
 Tau Variables.
 TauSubstructureCfg (flags)
 Tau Variables.
 MvaTESVariableDecoratorCfg (flags)
 MvaTESVariableDecorator.
 MvaTESEvaluatorCfg (flags)
 MvaTESEvaluator.
 TauIDVarCalculatorCfg (flags)
 TauJetRNNEvaluatorCfg (flags, applyLooseTrackSel=False)
 TauWPDecoratorJetRNNCfg (flags)
 TauGNNEvaluatorCfg (flags, version=0, applyLooseTrackSel=False, applyTightTrackSel=False, tauContainerName="")
 TausRUsDecorationNames ()
 TausRUsTrackDecorationNames ()
 TausRUsEvaluatorCfg (flags, name="", tauContainerName="", tauTrackContainerName="")
 TauWPDecoratorGNNCfg (flags, version, tauContainerName="")
 TauGNNeVetoEvaluatorCfg (flags, applyLooseTrackSel=False, applyTightTrackSel=False, tauContainerName="")
 TauGNNeVetoWPDecoratorCfg (flags, tauContainerName="")
 TauGNNDisplacedEvaluatorCfg (flags, tauContainerName="")
 TauEleRNNEvaluatorCfg (flags, applyLooseTrackSel=False)
 TauWPDecoratorEleRNNCfg (flags)
 TauDecayModeNNClassifierCfg (flags)
 TauAODSelectorCfg (flags)
 TauCombinedTESCfg (flags, **kwargs)
 TauCombinedTES.
 TauAODMuonRemovalCfg (flags)
 muon removal tool
 TauEleOverlapChecker (flags)

Function Documentation

◆ CellVariablesCfg()

CellVariablesCfg ( flags)

Tau cell variables calculation.

Definition at line 224 of file TauToolHolder.py.

224def CellVariablesCfg(flags):
225 result = ComponentAccumulator()
226 _name = flags.Tau.ActiveConfig.prefix + 'CellVariables'
227
228 TauCellVariables = CompFactory.getComp("TauCellVariables")
229 TauCellVariables = TauCellVariables(name = _name,
230 VertexCorrection = flags.Tau.doVertexCorrection)
231
232 result.setPrivateTools(TauCellVariables)
233 return result
234
TauCellVariables
Calculate tau calorimeter variables from cell information.
Definition TauCellVariables.h:16

◆ ElectronVetoVarsCfg()

ElectronVetoVarsCfg ( flags)

ele veto variables

Definition at line 237 of file TauToolHolder.py.

237def ElectronVetoVarsCfg(flags):
238 result = ComponentAccumulator()
239 _name = flags.Tau.ActiveConfig.prefix + 'TauElectronVetoVars'
240
241 from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg
242
243 TauElectronVetoVariables = CompFactory.getComp("TauElectronVetoVariables")
244 TauElectronVetoVariables = TauElectronVetoVariables(name = _name,
245 VertexCorrection = flags.Tau.doVertexCorrection,
246 ParticleCaloExtensionTool = result.popToolsAndMerge(ParticleCaloExtensionToolCfg(flags)),
247 tauEVParticleCache = getParticleCache(flags))
248
249 result.setPrivateTools(TauElectronVetoVariables)
250 return result
251
TauElectronVetoVariables
Calculate variables sensitive on electrons.
Definition TauElectronVetoVariables.h:27

◆ EnergyCalibrationLCCfg()

EnergyCalibrationLCCfg ( flags,
force_zero_mass = False )

Tau energy calibration.

Definition at line 209 of file TauToolHolder.py.

209def EnergyCalibrationLCCfg(flags, force_zero_mass=False):
210 result = ComponentAccumulator()
211 _name = flags.Tau.ActiveConfig.prefix +'EnergyCalibrationLC'
212
213 TauCalibrateLC = CompFactory.getComp("TauCalibrateLC")
214 TauCalibrateLC = TauCalibrateLC(name = _name,
215 calibrationFile = flags.Tau.CalibrateLCConfig,
216 ForceZeroMass = force_zero_mass,
217 Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection)
218
219 result.setPrivateTools(TauCalibrateLC)
220 return result
221
TauCalibrateLC
Implementation of tau energy scale (TES) with eta and pile-up correction.
Definition TauCalibrateLC.h:25

◆ getParticleCache()

getParticleCache ( flags)

Definition at line 70 of file TauToolHolder.py.

70def 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()

JetSeedBuilderCfg ( flags)

JetSeedBuilder.

Definition at line 20 of file TauToolHolder.py.

20def 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
JetSeedBuilder
Class to build tau jet seed.
Definition JetSeedBuilder.h:17

◆ MvaTESEvaluatorCfg()

MvaTESEvaluatorCfg ( flags)

MvaTESEvaluator.

Definition at line 697 of file TauToolHolder.py.

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

◆ MvaTESVariableDecoratorCfg()

MvaTESVariableDecoratorCfg ( flags)

MvaTESVariableDecorator.

Definition at line 676 of file TauToolHolder.py.

676def MvaTESVariableDecoratorCfg(flags):
677 result = ComponentAccumulator()
678 _name = flags.Tau.ActiveConfig.prefix + 'MvaTESVariableDecorator'
679
680 eventShapeCollection = flags.Tau.ActiveConfig.EventShapeCollection
681 if 'EMPFlow' in flags.Tau.ActiveConfig.SeedJetCollection:
682 eventShapeCollection = "Kt4EMPFlowEventShape"
683 elif 'EMTopo' in flags.Tau.ActiveConfig.SeedJetCollection:
684 eventShapeCollection ="Kt4EMTopoOriginEventShape"
685
686 MvaTESVariableDecorator = CompFactory.getComp("MvaTESVariableDecorator")
687 MvaTESVariableDecorator = MvaTESVariableDecorator(name = _name,
688 Key_vertexInputContainer = flags.Tau.ActiveConfig.VertexCollection,
689 EventShapeKey = eventShapeCollection,
690 VertexCorrection = flags.Tau.doVertexCorrection,
691 SeedJet = flags.Tau.ActiveConfig.SeedJetCollection)
692 result.setPrivateTools(MvaTESVariableDecorator)
693 return result
694

◆ Pi0ClusterCreatorCfg()

Pi0ClusterCreatorCfg ( flags)

create Pi0 clusters

Definition at line 569 of file TauToolHolder.py.

569def Pi0ClusterCreatorCfg(flags):
570 result = ComponentAccumulator()
571 _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterCreator'
572
573 # TauPi0ClusterCreator accesses cells via links only, which doesn't
574 # make a scheduler dependency. So make additional explicit dependencies
575 # on cells in the input file.
576 extraInputs = []
577 for typ, nam in [i.split('#') for i in flags.Input.TypedCollections]:
578 if typ == 'CaloCellContainer':
579 extraInputs += [('CaloCellContainer', nam)]
580
581 TauPi0ClusterCreator = CompFactory.getComp("TauPi0ClusterCreator")
582 TauPi0ClusterCreator = TauPi0ClusterCreator(name = _name,
583 ExtraInputs = extraInputs,
584 RecoFromAOD = flags.Common.ProductionStep is ProductionStep.Derivation)
585
586 result.setPrivateTools(TauPi0ClusterCreator)
587 return result
588
TauPi0ClusterCreator
Creates Pi0 clusters (Pi0 Finder).
Definition TauPi0ClusterCreator.h:28

◆ Pi0ClusterFinderCfg()

Pi0ClusterFinderCfg ( flags)

Pi0 algo Cluster finder for Pi0 algo.

Definition at line 284 of file TauToolHolder.py.

284def Pi0ClusterFinderCfg(flags):
285 result = ComponentAccumulator()
286 _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterFinder'
287
288 TauPi0CreateROI = CompFactory.getComp("TauPi0CreateROI")
289
290 myTauPi0CreateROI = TauPi0CreateROI(
291 name = _name,
292 Key_caloCellInputContainer = "AllCalo",
293 Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
294 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
295 RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
296 )
297
298 result.setPrivateTools(myTauPi0CreateROI)
299 return result
300
TauPi0CreateROI
Find the cells used to create pi0 cluster.
Definition TauPi0CreateROI.h:30

◆ Pi0ClusterScalerCfg()

Pi0ClusterScalerCfg ( flags)

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

Definition at line 591 of file TauToolHolder.py.

591def Pi0ClusterScalerCfg(flags):
592 result = ComponentAccumulator()
593 _name = flags.Tau.ActiveConfig.prefix + 'Pi0ClusterScaler'
594
595 TauPi0ClusterScaler = CompFactory.getComp("TauPi0ClusterScaler")
596 TauPi0ClusterScaler = TauPi0ClusterScaler(name = _name,
597 MinNeutralPFOPt = flags.Tau.MinNeutralPFOPt)
598
599 result.setPrivateTools(TauPi0ClusterScaler)
600 return result
601
TauPi0ClusterScaler
scale cluster energy to take care of charged pion energy
Definition TauPi0ClusterScaler.h:22

◆ Pi0ScoreCalculatorCfg()

Pi0ScoreCalculatorCfg ( flags)

calculate MVA scores of pi0 clusters

Definition at line 604 of file TauToolHolder.py.

604def Pi0ScoreCalculatorCfg(flags):
605 result = ComponentAccumulator()
606 _name = flags.Tau.ActiveConfig.prefix + 'Pi0ScoreCalculator'
607
608 TauPi0ScoreCalculator = CompFactory.getComp("TauPi0ScoreCalculator")
609 TauPi0ScoreCalculator = TauPi0ScoreCalculator(name = _name,
610 BDTWeightFile = flags.Tau.Pi0ScoreConfig)
611
612 result.setPrivateTools(TauPi0ScoreCalculator)
613 return result
614
TauPi0ScoreCalculator
Selectes pi0Candidates (Pi0 Finder).
Definition TauPi0ScoreCalculator.h:25

◆ Pi0SelectorCfg()

Pi0SelectorCfg ( flags)

select pi0 clusters

Definition at line 617 of file TauToolHolder.py.

617def Pi0SelectorCfg(flags):
618 result = ComponentAccumulator()
619 _name = flags.Tau.ActiveConfig.prefix + 'Pi0Selector'
620
621 TauPi0Selector = CompFactory.getComp("TauPi0Selector")
622 TauPi0Selector = TauPi0Selector(name = _name,
623 Pi0EtCut = flags.Tau.pi0EtCuts,
624 Pi0BDTCut_1prong = flags.Tau.pi0MVACuts_1prong,
625 Pi0BDTCut_mprong = flags.Tau.pi0MVACuts_mprong)
626
627 result.setPrivateTools(TauPi0Selector)
628 return result
629
TauPi0Selector
Apply Et and BDT score cut to pi0s.
Definition TauPi0Selector.h:22

◆ TauAODMuonRemovalCfg()

TauAODMuonRemovalCfg ( flags)

muon removal tool

Definition at line 1070 of file TauToolHolder.py.

1070def TauAODMuonRemovalCfg(flags):
1071 result = ComponentAccumulator()
1072 _name = flags.Tau.ActiveConfig.prefix + 'MuonRemoval'
1073 TauAODMuonRemovalTool = CompFactory.getComp("TauAODMuonRemovalTool")
1074 myMuonRemoval = TauAODMuonRemovalTool( name = _name,
1075 Key_MuonInputContainer = 'Muons',
1076 doMuonTrkRm = True,
1077 doMuonClsRm = True,
1078 muonIDWP = 'Medium'
1079 )
1080 result.setPrivateTools(myMuonRemoval)
1081 return result
1082
1083# electron excluder tool
TauAODMuonRemovalTool
the tool meant to run at AOD level, to remove the muon found inside the TauJet.
Definition TauAODMuonRemovalTool.h:21

◆ TauAODSelectorCfg()

TauAODSelectorCfg ( flags)

Definition at line 1042 of file TauToolHolder.py.

1042def TauAODSelectorCfg(flags):
1043 result = ComponentAccumulator()
1044 _name = flags.Tau.ActiveConfig.prefix + 'TauAODSelector'
1045
1046 TauAODSelector = CompFactory.getComp("TauAODSelector")
1047 myTauAODSelector = TauAODSelector(name=_name,
1048 Min0pTauPt = flags.Tau.MinPt0p,
1049 MinTauPt = flags.Tau.MinPt,
1050 doEarlyStopping = flags.Tau.doEarlyStopping and not flags.Output.doWriteESD)
1051
1052 result.setPrivateTools(myTauAODSelector)
1053 return result
1054

◆ TauAxisCfg()

TauAxisCfg ( flags)

Tau energy calibration and tau axis direction.

Definition at line 56 of file TauToolHolder.py.

56def 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
TauAxisSetter
Set Tau "Detector Axis" and "Intermediate Axis".
Definition TauAxisSetter.h:28

◆ TauCaloClusterBadChannelCfg()

TauCaloClusterBadChannelCfg ( flags)

Definition at line 557 of file TauToolHolder.py.

557def TauCaloClusterBadChannelCfg(flags):
558 result = ComponentAccumulator()
559 _name = flags.Tau.ActiveConfig.prefix + 'CaloClusterBadChannelList'
560
561 CaloClusterBadChannelListCorr = CompFactory.getComp("CaloClusterBadChannelList")
562 BadChannelListCorrForTaus = CaloClusterBadChannelListCorr(_name)
563
564 result.setPrivateTools(BadChannelListCorrForTaus)
565 return result
566

◆ TauCaloClusterLocalCalibCfg()

TauCaloClusterLocalCalibCfg ( flags)

Definition at line 394 of file TauToolHolder.py.

394def TauCaloClusterLocalCalibCfg(flags):
395 result = ComponentAccumulator()
396 _name = flags.Tau.ActiveConfig.prefix + 'CaloLocalCalib'
397
398 CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
399 LocalCalib = CaloClusterLocalCalib(_name)
400 LocalCalib.ClusterClassificationTool = [result.popToolsAndMerge(TauCaloLCClassificationCfg(flags))]
401 LocalCalib.ClusterRecoStatus = [1,2]
402 LocalCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCWeightCfg(flags))]
403 LocalCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
404
405 result.setPrivateTools(LocalCalib)
406 return result
407
CaloClusterLocalCalib
Cluster correction tool which applies local hadronic calibration w eights to the cells.
Definition CaloClusterLocalCalib.h:32

◆ TauCaloClusterMomentsMakerCfg()

TauCaloClusterMomentsMakerCfg ( flags)

Definition at line 517 of file TauToolHolder.py.

517def TauCaloClusterMomentsMakerCfg(flags):
518 result = ComponentAccumulator()
519 _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoMoments'
520
521 # Schedule total noise cond alg
522 from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
523 result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
524 # Schedule electronic noise cond alg (needed for LC weights)
525 result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
526
527 CaloClusterMomentsMaker = CompFactory.getComp("CaloClusterMomentsMaker")
528 TopoMomentsForTaus = CaloClusterMomentsMaker(_name)
529 TopoMomentsForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
530 TopoMomentsForTaus.MaxAxisAngle = 20*deg
531 TopoMomentsForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
532 TopoMomentsForTaus.MinBadLArQuality = 4000
533 TopoMomentsForTaus.MomentsNames = ["FIRST_PHI"
534 ,"FIRST_ETA"
535 ,"SECOND_R"
536 ,"SECOND_LAMBDA"
537 ,"DELTA_PHI"
538 ,"DELTA_THETA"
539 ,"DELTA_ALPHA"
540 ,"CENTER_X"
541 ,"CENTER_Y"
542 ,"CENTER_Z"
543 ,"CENTER_MAG"
544 ,"CENTER_LAMBDA"
545 ,"LATERAL"
546 ,"LONGITUDINAL"
547 ,"ENG_FRAC_EM"
548 ,"ENG_FRAC_MAX"
549 ,"ENG_FRAC_CORE"
550 ,"FIRST_ENG_DENS"
551 ,"SECOND_ENG_DENS"
552 ,"ISOLATION"]
553
554 result.setPrivateTools(TopoMomentsForTaus)
555 return result
556
CaloClusterMomentsMaker
Calculate moments for CaloCluster objects.
Definition CaloClusterMomentsMaker.h:50

◆ TauCaloDMCalibCfg()

TauCaloDMCalibCfg ( flags)

Definition at line 421 of file TauToolHolder.py.

421def TauCaloDMCalibCfg(flags):
422 result = ComponentAccumulator()
423 _name = flags.Tau.ActiveConfig.prefix + 'DMCalib'
424
425 CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
426 DMCalib = CaloClusterLocalCalib(_name)
427 DMCalib.ClusterRecoStatus = [1,2]
428 DMCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCDeadMaterialCfg(flags))]
429 DMCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
430
431 result.setPrivateTools(DMCalib)
432 return result
433

◆ TauCaloLCClassificationCfg()

TauCaloLCClassificationCfg ( flags)

Calo Tools.

Definition at line 317 of file TauToolHolder.py.

317def TauCaloLCClassificationCfg(flags):
318 result = ComponentAccumulator()
319 _name = flags.Tau.ActiveConfig.prefix + 'LCClassify'
320
321 CaloLCClassificationTool = CompFactory.getComp("CaloLCClassificationTool")
322 LCClassify = CaloLCClassificationTool(_name)
323 LCClassify.ClassificationKey = "EMFracClassify"
324 LCClassify.UseSpread = False
325 LCClassify.MaxProbability = 0.5
326 # add the moments EM_PROBABILITY, HAD_WEIGHT, OOC_WEIGHT, DM_WEIGHT to the AOD:
327 LCClassify.StoreClassificationProbabilityInAOD = True
328 LCClassify.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
329 LCClassify.UseNormalizedEnergyDensity = True
330
331 result.setPrivateTools(LCClassify)
332 return result
333
CaloLCClassificationTool
classify clusters according to their probability to stem from an em object
Definition CaloLCClassificationTool.h:29

◆ TauCaloLCDeadMaterialCfg()

TauCaloLCDeadMaterialCfg ( flags)

Definition at line 379 of file TauToolHolder.py.

379def TauCaloLCDeadMaterialCfg(flags):
380 result = ComponentAccumulator()
381 _name = flags.Tau.ActiveConfig.prefix + 'CaloLCDeadMaterialTool'
382
383 CaloLCDeadMaterialTool = CompFactory.getComp("CaloLCDeadMaterialTool")
384 LCDeadMaterial = CaloLCDeadMaterialTool(_name)
385 LCDeadMaterial.HadDMCoeffKey = "HadDMCoeff2"
386 LCDeadMaterial.ClusterRecoStatus = 0
387 LCDeadMaterial.WeightModeDM = 2
388 LCDeadMaterial.UseHadProbability = True
389 LCDeadMaterial.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
390
391 result.setPrivateTools(LCDeadMaterial)
392 return result
393
CaloLCDeadMaterialTool
dead material correction tool for local hadronic calibration
Definition CaloLCDeadMaterialTool.h:43

◆ TauCaloLCOutOfClusterCfg()

TauCaloLCOutOfClusterCfg ( flags)

Definition at line 353 of file TauToolHolder.py.

353def TauCaloLCOutOfClusterCfg(flags):
354 result = ComponentAccumulator()
355 _name = flags.Tau.ActiveConfig.prefix + 'CaloLCOutOfClusterTool'
356
357 CaloLCOutOfClusterTool = CompFactory.getComp("CaloLCOutOfClusterTool")
358 LCOut = CaloLCOutOfClusterTool(_name)
359 LCOut.CorrectionKey = "OOCCorrection"
360 LCOut.UseEmProbability = False
361 LCOut.UseHadProbability = True
362
363 result.setPrivateTools(LCOut)
364 return result
365
CaloLCOutOfClusterTool
calculates out-of-cluster corrections based on cluster quantities
Definition CaloLCOutOfClusterTool.h:28

◆ TauCaloLCOutPi0Cfg()

TauCaloLCOutPi0Cfg ( flags)

Definition at line 366 of file TauToolHolder.py.

366def TauCaloLCOutPi0Cfg(flags):
367 result = ComponentAccumulator()
368 _name = flags.Tau.ActiveConfig.prefix + 'LCOutPi0'
369
370 CaloLCOutOfClusterTool = CompFactory.getComp("CaloLCOutOfClusterTool")
371 LCOutPi0 = CaloLCOutOfClusterTool(_name)
372 LCOutPi0.CorrectionKey = "OOCPi0Correction"
373 LCOutPi0.UseEmProbability = True
374 LCOutPi0.UseHadProbability = False
375
376 result.setPrivateTools(LCOutPi0)
377 return result
378

◆ TauCaloLCWeightCfg()

TauCaloLCWeightCfg ( flags)

Definition at line 334 of file TauToolHolder.py.

334def TauCaloLCWeightCfg(flags):
335 result = ComponentAccumulator()
336 _name = flags.Tau.ActiveConfig.prefix + 'CaloLCWeightTool'
337
338 # Schedule total noise cond alg
339 from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
340 result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
341 # Schedule electronic noise cond alg (needed for LC weights)
342 result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
343
344 CaloLCWeightTool = CompFactory.getComp("CaloLCWeightTool")
345 LCWeight = CaloLCWeightTool(_name)
346 LCWeight.CorrectionKey = "H1ClusterCellWeights"
347 LCWeight.SignalOverNoiseCut = 2.0
348 LCWeight.UseHadProbability = True
349
350 result.setPrivateTools(LCWeight)
351 return result
352
CaloLCWeightTool
calculates hadronic cell weights based on cluster and cell quantities
Definition CaloLCWeightTool.h:33

◆ TauCaloOOCCalibCfg()

TauCaloOOCCalibCfg ( flags)

Definition at line 408 of file TauToolHolder.py.

408def TauCaloOOCCalibCfg(flags):
409 result = ComponentAccumulator()
410 _name = flags.Tau.ActiveConfig.prefix + 'OOCCalibTool'
411
412 CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
413 OOCCalib = CaloClusterLocalCalib (_name)
414 OOCCalib.ClusterRecoStatus = [1,2]
415 OOCCalib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCOutOfClusterCfg(flags))]
416 OOCCalib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
417
418 result.setPrivateTools(OOCCalib)
419 return result
420

◆ TauCaloOOCPi0CalibCfg()

TauCaloOOCPi0CalibCfg ( flags)

Definition at line 434 of file TauToolHolder.py.

434def TauCaloOOCPi0CalibCfg(flags):
435 result = ComponentAccumulator()
436 _name = flags.Tau.ActiveConfig.prefix + 'OOCPi0CalibTool'
437
438 CaloClusterLocalCalib = CompFactory.getComp("CaloClusterLocalCalib")
439 OOCPi0Calib = CaloClusterLocalCalib (_name)
440 OOCPi0Calib.ClusterRecoStatus = [1,2]
441 OOCPi0Calib.LocalCalibTools = [result.popToolsAndMerge(TauCaloLCOutPi0Cfg(flags))]
442 OOCPi0Calib.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
443
444 result.setPrivateTools(OOCPi0Calib)
445 return result
446

◆ TauCaloTopoClusterMakerCfg()

TauCaloTopoClusterMakerCfg ( flags)

Definition at line 447 of file TauToolHolder.py.

447def TauCaloTopoClusterMakerCfg(flags):
448 result = ComponentAccumulator()
449 _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoClusterMaker'
450
451 # Schedule total noise cond alg
452 from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
453 result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
454 # Schedule electronic noise cond alg (needed for LC weights)
455 result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
456
457 CaloTopoClusterMaker = CompFactory.getComp("CaloTopoClusterMaker")
458 TopoClusterForTaus = CaloTopoClusterMaker(_name)
459
460 TopoClusterForTaus.CellsName = flags.Tau.ActiveConfig.TauCommonPi0Cells
461 TopoClusterForTaus.CalorimeterNames=["LAREM"]
462 TopoClusterForTaus.SeedSamplingNames = ["PreSamplerB", "EMB1", "EMB2", "PreSamplerE", "EME1", "EME2"]
463 TopoClusterForTaus.NeighborOption = "super3D"
464 TopoClusterForTaus.RestrictHECIWandFCalNeighbors = False
465 TopoClusterForTaus.RestrictPSNeighbors = True
466 TopoClusterForTaus.CellThresholdOnEorAbsEinSigma = 0.0
467 TopoClusterForTaus.NeighborThresholdOnEorAbsEinSigma = 2.0
468 TopoClusterForTaus.SeedThresholdOnEorAbsEinSigma = 4.0
469 TopoClusterForTaus.SeedCutsInAbsE = True
470 TopoClusterForTaus.ClusterCutsInAbsEt = True
471 TopoClusterForTaus.ClusterEtorAbsEtCut = 0.5*GeV # 0.0*MeV in standard CaloCalTopoCluster JobOptions!
472 TopoClusterForTaus.TwoGaussianNoise = flags.Calo.TopoCluster.doTwoGaussianNoise
473 # timing cut on seed cell to suppress out-of-time pileup
474 TopoClusterForTaus.SeedCutsInT = flags.Calo.TopoCluster.doTimeCut
475 TopoClusterForTaus.CutOOTseed = flags.Calo.TopoCluster.extendTimeCut and flags.Calo.TopoCluster.doTimeCut
476 TopoClusterForTaus.UseTimeCutUpperLimit = flags.Calo.TopoCluster.useUpperLimitForTimeCut
477 TopoClusterForTaus.TimeCutUpperLimit = flags.Calo.TopoCluster.timeCutUpperLimit
478 TopoClusterForTaus.XTalkEM2 = flags.Calo.TopoCluster.xtalkEM2
479 TopoClusterForTaus.XTalkEM2D = flags.Calo.TopoCluster.xtalkEM2D
480 TopoClusterForTaus.XTalkEM2n = flags.Calo.TopoCluster.xtalkEM2n
481 TopoClusterForTaus.XTalkEM3 = flags.Calo.TopoCluster.xtalkEM3
482 TopoClusterForTaus.XTalkEMEta = flags.Calo.TopoCluster.xtalkEMEta
483 TopoClusterForTaus.XTalkDeltaT = flags.Calo.TopoCluster.xtalkDeltaT
484 TopoClusterForTaus.XTalk2Eratio1 = flags.Calo.TopoCluster.xtalk2Eratio1
485 TopoClusterForTaus.XTalk2Eratio2 = flags.Calo.TopoCluster.xtalk2Eratio2
486 TopoClusterForTaus.XTalk3Eratio = flags.Calo.TopoCluster.xtalk3Eratio
487 TopoClusterForTaus.XTalkEtaEratio = flags.Calo.TopoCluster.xtalkEtaEratio
488 TopoClusterForTaus.XTalk2DEratio = flags.Calo.TopoCluster.xtalk2DEratio
489
490 result.setPrivateTools(TopoClusterForTaus)
491 return result
492
CaloTopoClusterMaker
topological cluster maker.
Definition CaloTopoClusterMaker.h:48

◆ TauCaloTopoClusterSplitterCfg()

TauCaloTopoClusterSplitterCfg ( flags)

Definition at line 493 of file TauToolHolder.py.

493def TauCaloTopoClusterSplitterCfg(flags):
494
495 result = ComponentAccumulator()
496 _name = flags.Tau.ActiveConfig.prefix + 'Pi0TopoClusterSplitter'
497
498 CaloTopoClusterSplitter = CompFactory.getComp("CaloTopoClusterSplitter")
499 TopoSplitterForTaus = CaloTopoClusterSplitter(_name)
500
501 # cells from the following samplings will be able to form local
502 # maxima. The excluded samplings are PreSamplerB, EMB1,
503 # PreSamplerE, EME1, all Tile samplings, all HEC samplings and the
504 # two rear FCal samplings.
505 TopoSplitterForTaus.SamplingNames = ["EMB2","EME2"] # Do we want to use EMB3 and EME3?
506 # cells from the following samplings will also be able to form
507 # local maxima but only if they are not overlapping in eta and phi
508 # with local maxima in previous samplings from the primary list.
509 TopoSplitterForTaus.SecondarySamplingNames = ["EMB1","EME1"]
510 TopoSplitterForTaus.ShareBorderCells = True
511 TopoSplitterForTaus.RestrictHECIWandFCalNeighbors = False
512 TopoSplitterForTaus.WeightingOfNegClusters = flags.Calo.TopoCluster.doTreatEnergyCutAsAbsolute
513
514 result.setPrivateTools(TopoSplitterForTaus)
515 return result
516
CaloTopoClusterSplitter
topological cluster splitter.
Definition CaloTopoClusterSplitter.h:48

◆ TauCellFinalizerCfg()

TauCellFinalizerCfg ( flags)

Cell finalizer tool for BuildAlg.

Definition at line 303 of file TauToolHolder.py.

303def TauCellFinalizerCfg(flags):
304 result = ComponentAccumulator()
305 _name = flags.Tau.ActiveConfig.prefix + 'tauPi0CellContainerFinalizer'
306
307 CaloCellContainerFinalizerTool = CompFactory.getComp("CaloCellContainerFinalizerTool")
308 TauCellContainerFinalizer = CaloCellContainerFinalizerTool(name=_name)
309
310 result.setPrivateTools(TauCellContainerFinalizer)
311 return result
312

◆ TauClusterFinderCfg()

TauClusterFinderCfg ( flags)

Associate the cluster in jet constituents to the tau candidate.

Definition at line 137 of file TauToolHolder.py.

137def TauClusterFinderCfg(flags):
138 result = ComponentAccumulator()
139 _name = flags.Tau.ActiveConfig.prefix + 'TauClusterFinder'
140
141
142 TauClusterFinder = CompFactory.getComp("TauClusterFinder")
143 TauClusterFinder = TauClusterFinder(
144 name = _name,
145 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
146 )
147
148
149 result.setPrivateTools(TauClusterFinder)
150 return result
151
TauClusterFinder
Associate the clusters used in the seed jet to the tau candidate.
Definition TauClusterFinder.h:21

◆ TauCombinedTESCfg()

TauCombinedTESCfg ( flags,
** kwargs )

TauCombinedTES.

Definition at line 1057 of file TauToolHolder.py.

1057def TauCombinedTESCfg(flags, **kwargs):
1058 result = ComponentAccumulator()
1059 _name = flags.Tau.ActiveConfig.prefix + 'TauCombinedTES'
1060 kwargs.setdefault("WeightFileName", flags.Tau.CombinedTESConfig)
1061
1062 TauCombinedTES = CompFactory.getComp("TauCombinedTES")
1063 myTauCombinedTES = TauCombinedTES(name = _name, **kwargs)
1064
1065 result.setPrivateTools(myTauCombinedTES)
1066 return result
1067

◆ TauCommonCalcVarsCfg()

TauCommonCalcVarsCfg ( flags)

Tau Variables.

Definition at line 650 of file TauToolHolder.py.

650def TauCommonCalcVarsCfg(flags):
651 result = ComponentAccumulator()
652 _name = flags.Tau.ActiveConfig.prefix + 'TauCommonCalcVars'
653
654 TauCommonCalcVars = CompFactory.getComp("TauCommonCalcVars")
655 TauCommonCalcVars = TauCommonCalcVars(name = _name,
656 doRun4 = flags.GeoModel.Run > LHCPeriod.Run3)
657
658 result.setPrivateTools(TauCommonCalcVars)
659 return result
660
TauCommonCalcVars
Calculate variables which rely on tracks and precalculated cell/cluster information.
Definition TauCommonCalcVars.h:20

◆ TauDecayModeNNClassifierCfg()

TauDecayModeNNClassifierCfg ( flags)

Definition at line 1031 of file TauToolHolder.py.

1031def TauDecayModeNNClassifierCfg(flags):
1032 result = ComponentAccumulator()
1033 _name = flags.Tau.ActiveConfig.prefix + 'TauDecayModeNNClassifier'
1034
1035 TauDecayModeNNClassifier = CompFactory.getComp("TauDecayModeNNClassifier")
1036 myTauDecayModeNNClassifier = TauDecayModeNNClassifier(name=_name,
1037 WeightFile=flags.Tau.DecayModeNNClassifierConfig)
1038
1039 result.setPrivateTools(myTauDecayModeNNClassifier)
1040 return result
1041
TauDecayModeNNClassifier
Tau decay mode classifier using a neural network.
Definition TauDecayModeNNClassifier.h:35

◆ TauEleOverlapChecker()

TauEleOverlapChecker ( flags)

Definition at line 1084 of file TauToolHolder.py.

1084def TauEleOverlapChecker(flags):
1085 result = ComponentAccumulator()
1086 _name = flags.Tau.ActiveConfig.prefix + 'TauEleOverlapChecker'
1087 TauEleOverlapChecker = CompFactory.getComp("TauEleOverlapChecker")
1088 myTauEleOverlapChecker = TauEleOverlapChecker(
1089 name = _name,
1090 Key_RemovedClustersContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
1091 Key_RemovedTracksContainer = flags.Tau.ActiveConfig.RemovedElectronTracks,
1092 CheckingCone = flags.Tau.ActiveConfig.EleRM_CheckingConeSize,
1093 )
1094 result.setPrivateTools(myTauEleOverlapChecker)
1095 return result
TauEleOverlapChecker
Select only the tau within the removal direction.
Definition TauEleOverlapChecker.h:25

◆ TauEleRNNEvaluatorCfg()

TauEleRNNEvaluatorCfg ( flags,
applyLooseTrackSel = False )

Definition at line 953 of file TauToolHolder.py.

953def TauEleRNNEvaluatorCfg(flags, applyLooseTrackSel=False):
954 result = ComponentAccumulator()
955 _name = flags.Tau.ActiveConfig.prefix + 'TauEleRNN'
956
957 TauJetRNNEvaluator = CompFactory.getComp("TauJetRNNEvaluator")
958 RNNConf = flags.Tau.TauEleRNNConfig
959 myTauEleRNNEvaluator = TauJetRNNEvaluator(name = _name,
960 useTRT = flags.Detector.EnableTRT,
961 NetworkFile1P = RNNConf[0],
962 NetworkFile3P = RNNConf[1],
963 OutputVarname = "RNNEleScore",
964 MaxTracks = 10,
965 MaxClusters = 6,
966 MaxClusterDR = 1.0,
967 ApplyLooseTrackSel = applyLooseTrackSel,
968 VertexCorrection = flags.Tau.doVertexCorrection,
969 InputLayerScalar = "scalar",
970 InputLayerTracks = "tracks",
971 InputLayerClusters = "clusters",
972 OutputLayer = "rnneveto_output",
973 OutputNode = "sig_prob")
974
975 result.setPrivateTools(myTauEleRNNEvaluator)
976 return result
977
TauJetRNNEvaluator
Tool to calculate a tau identification score based on neural networks.
Definition TauJetRNNEvaluator.h:28

◆ TauGNNDisplacedEvaluatorCfg()

TauGNNDisplacedEvaluatorCfg ( flags,
tauContainerName = "" )

Definition at line 933 of file TauToolHolder.py.

933def TauGNNDisplacedEvaluatorCfg(flags, tauContainerName=""):
934 # Displaced TauGNNEvaluator tool setup
935 result = ComponentAccumulator()
936
937 TauGNNEvaluator = CompFactory.TauGNNEvaluator(
938 name = flags.Tau.ActiveConfig.prefix + 'TauDisplacedGNN',
939 NetworkFileInclusive = flags.Tau.TauDisplacedGNNConfig[0],
940 OutputVarname = "GNdTauScore",
941 OutputPTau = "GNdTauProbTau",
942 OutputPJet = "GNdTauProbJet",
943 MaxClusterDR = 15.0,
944 MinTauPt = flags.Tau.MinPtDAOD,
945 VertexCorrection = flags.Tau.doVertexCorrection,
946 NodeNameTau="GNdTauv3_pb",
947 NodeNameJet="GNdTauv3_pu",
948 TauContainerName = tauContainerName,
949 )
950 result.setPrivateTools(TauGNNEvaluator)
951 return result
952

◆ TauGNNEvaluatorCfg()

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

Definition at line 777 of file TauToolHolder.py.

777def TauGNNEvaluatorCfg(flags, version=0, applyLooseTrackSel=False, applyTightTrackSel=False, tauContainerName=""):
778 result = ComponentAccumulator()
779 _name = flags.Tau.ActiveConfig.prefix + 'TauGNN_v' + str(version)
780
781 TauGNNEvaluator = CompFactory.getComp("TauGNNEvaluator")
782 GNNConf = flags.Tau.TauGNNConfig[version]
783 myTauGNNEvaluator = TauGNNEvaluator(name = _name,
784 useTRT = flags.Detector.EnableTRT,
785 NetworkFileInclusive = GNNConf,
786 OutputVarname = flags.Tau.GNTauScoreName[version],
787 OutputPTau = "GNTauProbTau",
788 OutputPJet = "GNTauProbJet",
789 MaxTracks = flags.Tau.GNTauMaxTracks[version],
790 MaxClusters = flags.Tau.GNTauMaxClusters[version],
791 MaxClusterDR = 15.0,
792 MinTauPt = flags.Tau.MinPtDAOD,
793 ApplyLooseTrackSel = applyLooseTrackSel,
794 ApplyTightTrackSel = applyTightTrackSel,
795 VertexCorrection = flags.Tau.doVertexCorrection,
796 InputLayerScalar = 'tau_vars',
797 InputLayerTracks = 'track_vars',
798 InputLayerClusters = 'cluster_vars',
799 NodeNameTau=flags.Tau.GNTauNodeNameTau,
800 NodeNameJet=flags.Tau.GNTauNodeNameJet,
801 TauContainerName = tauContainerName,
802 )
803
804 result.setPrivateTools(myTauGNNEvaluator)
805 return result
806
TauGNNEvaluator
Tool to calculate tau identification score from .onnx inputs.
Definition TauGNNEvaluator.h:30

◆ TauGNNeVetoEvaluatorCfg()

TauGNNeVetoEvaluatorCfg ( flags,
applyLooseTrackSel = False,
applyTightTrackSel = False,
tauContainerName = "" )

Definition at line 879 of file TauToolHolder.py.

879def TauGNNeVetoEvaluatorCfg(flags, applyLooseTrackSel=False, applyTightTrackSel=False, tauContainerName=""):
880 result = ComponentAccumulator()
881 _name = flags.Tau.ActiveConfig.prefix + 'TauGNNeVeto'
882
883 TauGNNEvaluator = CompFactory.getComp("TauGNNEvaluator")
884 myTauGNNeVetoEvaluator = TauGNNEvaluator(name = _name,
885 useTRT = flags.Detector.EnableTRT,
886 NetworkFileInclusive = flags.Tau.TauGNNeVetoConfig[0],
887 OutputDiscriminant = flags.Tau.TauGNNeVetoOutputDiscriminant_NeglogPJet_True,
888 OutputVarname = flags.Tau.TauGNNeVetoScoreName,
889 OutputPTau = "GNNeVetoProbTau",
890 OutputPJet = "GNNeVetoProbJet",
891 MaxTracks = flags.Tau.TauGNNeVetoMaxTracks[0],
892 MaxClusters = flags.Tau.TauGNNeVetoMaxClusters[0],
893 MaxClusterDR = 15.0,
894 MinTauPt = flags.Tau.MinPtDAOD,
895 ApplyLooseTrackSel = applyLooseTrackSel,
896 ApplyTightTrackSel = applyTightTrackSel,
897 VertexCorrection = flags.Tau.doVertexCorrection,
898 InputLayerScalar = 'jet_var',
899 InputLayerTracks = 'tracks_r22default_sd0sort',
900 InputLayerClusters = 'cells_var',
901 NodeNameTau=flags.Tau.TauGNNeVetoNodeNameTau,
902 NodeNameJet=flags.Tau.TauGNNeVetoNodeNameJet,
903 TauContainerName = tauContainerName,
904 )
905
906 result.setPrivateTools(myTauGNNeVetoEvaluator)
907 return result
908
909

◆ TauGNNeVetoWPDecoratorCfg()

TauGNNeVetoWPDecoratorCfg ( flags,
tauContainerName = "" )

Definition at line 910 of file TauToolHolder.py.

910def TauGNNeVetoWPDecoratorCfg(flags, tauContainerName=""):
911 result = ComponentAccumulator()
912 _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorGNNeVeto'
913
914 TauWPDecorator = CompFactory.getComp("TauWPDecorator")
915 WPConf = flags.Tau.TauGNNeVetoWP
916 myTauWPDecorator = TauWPDecorator(name=_name,
917 flatteningFile1Prong = WPConf[0],
918 flatteningFile2Prong = WPConf[1],
919 flatteningFile3Prong = WPConf[2],
920 TauContainerName = tauContainerName,
921 DecorWPNames = flags.Tau.TauGNNeVetoDecorWPNames,
922 DecorWPCutEffs1P = [0.95, 0.90, 0.85],
923 DecorWPCutEffs2P = [0.95, 0.90, 0.85],
924 DecorWPCutEffs3P = [0.98, 0.95, 0.90],
925 UseAbsEta = False, # Now for the eVeto algorithm we derive a flattening with respect to mu.
926 ScoreBounds = [-0.01, 14.01],
927 ScoreName = flags.Tau.TauGNNeVetoScoreName,
928 NewScoreName = flags.Tau.TauGNNeVetoTransScoreName,
929 DefineWPs = True)
930 result.setPrivateTools(myTauWPDecorator)
931 return result
932
TauWPDecorator
Implementation of tool to decorate flattened BDT score and working points.
Definition TauWPDecorator.h:36

◆ TauIDVarCalculatorCfg()

TauIDVarCalculatorCfg ( flags)

Definition at line 709 of file TauToolHolder.py.

709def TauIDVarCalculatorCfg(flags):
710 result = ComponentAccumulator()
711 _name = flags.Tau.ActiveConfig.prefix + 'TauIDVarCalculator'
712
713 TauIDVarCalculator = CompFactory.getComp("TauIDVarCalculator")
714 myTauIDVarCalculator = TauIDVarCalculator(name=_name,
715 VertexCorrection = flags.Tau.doVertexCorrection,
716 doRun4 = flags.GeoModel.Run > LHCPeriod.Run3)
717
718 result.setPrivateTools(myTauIDVarCalculator)
719 return result
720
TauIDVarCalculator
This class implements a tool to calculate ID input variables and add them to the tau aux store.
Definition TauIDVarCalculator.h:18

◆ TauJetRNNEvaluatorCfg()

TauJetRNNEvaluatorCfg ( flags,
applyLooseTrackSel = False )

Definition at line 721 of file TauToolHolder.py.

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

◆ TauShotFinderCfg()

TauShotFinderCfg ( flags)

Photon Shot Finder.

Definition at line 254 of file TauToolHolder.py.

254def TauShotFinderCfg(flags):
255 result = ComponentAccumulator()
256 _name = flags.Tau.ActiveConfig.prefix + 'TauShotFinder'
257
258 shotPtCut_1Photon = flags.Tau.shotPtCut_1Photon
259 shotPtCut_2Photons = flags.Tau.shotPtCut_2Photons
260
261
262 from CaloClusterCorrection.StandardCellWeightCalib import getCellWeightTool
263 CaloWeightTool = getCellWeightTool(flags=flags)
264
265
266 TauShotFinder = CompFactory.getComp("TauShotFinder")
267 TauShotFinder = TauShotFinder(
268 name = _name,
269 CaloWeightTool = result.popToolsAndMerge(CaloWeightTool),
270 NCellsInEta = 5,
271 MinPtCut = shotPtCut_1Photon,
272 AutoDoubleShotCut = shotPtCut_2Photons,
273 Key_RemovedClusterInputContainer = flags.Tau.ActiveConfig.RemovedElectronClusters,
274 RemoveElectronCells = flags.Tau.ActiveConfig.RemoveElectronCells,
275 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
276 )
277
278 result.setPrivateTools(TauShotFinder)
279 return result
280

◆ TausRUsDecorationNames()

TausRUsDecorationNames ( ) 
Names of the decorations TausRUs writes on the tau, all of them floats.

Definition at line 807 of file TauToolHolder.py.

807def TausRUsDecorationNames():
808 """Names of the decorations TausRUs writes on the tau, all of them floats."""
809 names = [
810 "TausRUsTauIDScore",
811 "TausRUsEleRejScore",
812 "TausRUsDecayMode",
813 "TausRUsTauCharge",
814 ]
815 # The class counts must match 'num_classes' in the model metadata
816 names += [f"TausRUsDecayModeScore{i}" for i in range(5)]
817 names += [f"TausRUs{particle}P4_{component}"
818 for particle in ("Tau", "ChargedPion", "NeutralPion")
819 for component in ("pt", "eta", "phi", "m")]
820 names += [f"TausRUsVertex_{coordinate}" for coordinate in ("x", "y", "z")]
821 return names
822

◆ TausRUsEvaluatorCfg()

TausRUsEvaluatorCfg ( flags,
name = "",
tauContainerName = "",
tauTrackContainerName = "" ) 
TausRUs multi-output tau network.

Definition at line 827 of file TauToolHolder.py.

827def TausRUsEvaluatorCfg(flags, name="", tauContainerName="", tauTrackContainerName=""):
828 """TausRUs multi-output tau network."""
829
830 result = ComponentAccumulator()
831 _name = name or flags.Tau.ActiveConfig.prefix + 'TausRUs'
832
833 if flags.Tau.TausRUsUseTriton:
834 from AthTritonComps.TritonToolConfig import TritonToolCfg
835 inferenceTool = result.popToolsAndMerge(TritonToolCfg(
836 flags,
837 model_name = flags.Tau.TausRUsTritonModel,
838 url = flags.Tau.TausRUsTritonUrl,
839 port = flags.Tau.TausRUsTritonPort,
840 name = _name + '_TritonTool'))
841 else:
842 from AthOnnxComps.OnnxRuntimeInferenceConfig import OnnxRuntimeInferenceToolCfg
843 inferenceTool = result.popToolsAndMerge(OnnxRuntimeInferenceToolCfg(
844 flags,
845 flags.Tau.TausRUsModelFile,
846 name = _name + '_ORTTool'))
847
848 TausRUsEvaluator = CompFactory.getComp("TausRUsEvaluator")
849 result.setPrivateTools(TausRUsEvaluator(
850 name = _name,
851 InferenceTool = inferenceTool,
852 ModelFile = flags.Tau.TausRUsModelFile,
853 MinTauPt = flags.Tau.TausRUsMinPt,
854 TauContainerName = tauContainerName,
855 TauTrackContainerName = tauTrackContainerName))
856 return result
857
TausRUsEvaluator
Evaluates the TausRUs network and decorates its predictions on the tau and on its tracks.
Definition TausRUsEvaluator.h:60

◆ TausRUsTrackDecorationNames()

TausRUsTrackDecorationNames ( ) 
Decorations TausRUs writes on each of the tau's xAOD::TauTrack.

Definition at line 823 of file TauToolHolder.py.

823def TausRUsTrackDecorationNames():
824 """Decorations TausRUs writes on each of the tau's xAOD::TauTrack."""
825 return ["TausRUsTrackClass"] + [f"TausRUsTrackScore{i}" for i in range(4)]
826

◆ TauSubstructureCfg()

TauSubstructureCfg ( flags)

Tau Variables.

Definition at line 663 of file TauToolHolder.py.

663def TauSubstructureCfg(flags):
664 result = ComponentAccumulator()
665 _name = flags.Tau.ActiveConfig.prefix + 'TauSubstructure'
666
667 TauSubstructureVariables = CompFactory.getComp("TauSubstructureVariables")
668 TauSubstructureVariables = TauSubstructureVariables( name = _name,
669 doRun4 = flags.GeoModel.Run > LHCPeriod.Run3)
670
671 result.setPrivateTools(TauSubstructureVariables)
672 return result
673
TauSubstructureVariables
Calculate variables from the tau substructure.
Definition TauSubstructureVariables.h:21

◆ TauTrackCaloExtrapolatorCfg()

TauTrackCaloExtrapolatorCfg ( flags)

Tau-Track Calo Extrapolator.

Definition at line 118 of file TauToolHolder.py.

118def TauTrackCaloExtrapolatorCfg(flags):
119 result = ComponentAccumulator()
120 _name = flags.Tau.ActiveConfig.prefix + 'TauTrackCaloExtrapolator'
121
122 from TrackToCalo.TrackToCaloConfig import ParticleCaloExtensionToolCfg
123
124 TauTrackCaloExtrapolator = CompFactory.getComp("TauTrackCaloExtrapolator")
125 TauTrackCaloExtrapolator = TauTrackCaloExtrapolator(name = _name,
126 ParticleCaloExtensionTool = result.popToolsAndMerge(ParticleCaloExtensionToolCfg(flags)),
127 tauParticleCache = getParticleCache(flags), # only returns a string
128 ExtrapOnlyChargedTracks = False if flags.GeoModel.Run <= LHCPeriod.Run3 else True,
129 )
130 result.setPrivateTools(TauTrackCaloExtrapolator)
131 return result
132
133
134
TauTrackCaloExtrapolator
Tau Tracks to Calo extrapolation.
Definition TauTrackCaloExtrapolator.h:27

◆ TauTrackFinderCfg()

TauTrackFinderCfg ( flags)

Tau-Track Association.

Definition at line 81 of file TauToolHolder.py.

81def 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 TrkConfig.TrkVertexFitterUtilsConfig import AtlasTrackToVertexIPEstimatorCfg
90 from InDetConfig.InDetTrackSelectorToolConfig import TauRecInDetTrackSelectorToolCfg
91
92 _LargeD0TrackInputContainer = (flags.Tau.ActiveConfig.LargeD0TrackCollection if flags.Tau.associateLRT else "")
93
94 # Manually setting for TauLRT reco
95 if flags.Tau.ActiveConfig.inTauLRT:
96 _LargeD0TrackInputContainer = flags.Tau.ActiveConfig.LargeD0TrackCollection
97
98 TauTrackFinder = CompFactory.getComp("TauTrackFinder")
99 TauTrackFinder = TauTrackFinder(name = _name,
100 MaxJetDrTau = 0.2,
101 MaxJetDrWide = 0.4,
102 TrackSelectorToolTau = result.popToolsAndMerge(TauRecInDetTrackSelectorToolCfg(flags)),
103 TrackToVertexTool = "",
104 removeDuplicateCoreTracks = flags.Tau.RemoveDupeCoreTracks,
105 useGhostTracks = flags.Tau.useGhostTracks,
106 ghostTrackDR = flags.Tau.ghostTrackDR,
107 Key_jetContainer = (flags.Tau.ActiveConfig.SeedJetCollection if flags.Tau.useGhostTracks else ""),
108 Key_trackPartInputContainer = flags.Tau.ActiveConfig.TrackCollection,
109 Key_LargeD0TrackInputContainer = _LargeD0TrackInputContainer,
110 TrackToVertexIPEstimator = result.popToolsAndMerge(AtlasTrackToVertexIPEstimatorCfg(flags)),
111 inEleRM = flags.Tau.ActiveConfig.inTauEleRM,
112 )
113 result.setPrivateTools(TauTrackFinder)
114 return result
115
TauTrackFinder
Associate tracks to the tau candidate.
Definition TauTrackFinder.h:38

◆ TauTrackRNNCfg()

TauTrackRNNCfg ( flags)

Definition at line 165 of file TauToolHolder.py.

165def TauTrackRNNCfg(flags):
166 result = ComponentAccumulator()
167 _name = flags.Tau.ActiveConfig.prefix + 'TauTrackRNNClassifier'
168
169 TrackRNN = CompFactory.tauRecTools.TrackRNN
170 _RNN = TrackRNN(name = _name + "_TrackRNN",
171 InputWeightsPath = flags.Tau.tauRNNTrackClassConfig,
172 calibFolder = flags.Tau.tauRecToolsCVMFSPath )
173
174 result.setPrivateTools(_RNN)
175 return result
176

◆ TauTrackRNNClassifierCfg()

TauTrackRNNClassifierCfg ( flags)

Definition at line 178 of file TauToolHolder.py.

178def TauTrackRNNClassifierCfg(flags):
179 result = ComponentAccumulator()
180 _name = flags.Tau.ActiveConfig.prefix + 'TauTrackRNNClassifier'
181
182 # create tool alg
183 TauTrackRNNClassifier = CompFactory.tauRecTools.TauTrackRNNClassifier
184
185 import cppyy
186 cppyy.load_library('libxAODTau_cDict')
187
188 _classifyLRT = True
189 _classifyLRTWithDedicated = flags.Tau.classifyLRTWithDedicated
190 if flags.Tau.associateLRT and not flags.Tau.classifyLRT:
191 _classifyLRT = False
192
193 # Manually setting for TauLRT reco
194 if flags.Tau.ActiveConfig.inTauLRT:
195 _classifyLRT = True
196 _classifyLRTWithDedicated = True
197
198
199 myTauTrackClassifier = TauTrackRNNClassifier( name = _name,
200 Classifiers = [ result.popToolsAndMerge(TauTrackRNNCfg(flags)) ],
201 classifyLRT = _classifyLRT,
202 classifyLRTWithDedicated = _classifyLRTWithDedicated)
203
204 result.setPrivateTools(myTauTrackClassifier)
205 return result
206

◆ TauVertexedClusterDecoratorCfg()

TauVertexedClusterDecoratorCfg ( flags)

Definition at line 153 of file TauToolHolder.py.

153def TauVertexedClusterDecoratorCfg(flags):
154 result = ComponentAccumulator()
155 _name = flags.Tau.ActiveConfig.prefix + 'TauVertexedClusterDecorator'
156
157 TauVertexedClusterDecorator = CompFactory.getComp("TauVertexedClusterDecorator")
158 myTauVertexedClusterDecorator = TauVertexedClusterDecorator(name = _name,
159 SeedJet = flags.Tau.ActiveConfig.SeedJetCollection)
160
161 result.setPrivateTools(myTauVertexedClusterDecorator)
162 return result
163
TauVertexedClusterDecorator
Decorate CaloVertexedTopoCluster to the tau candidate.
Definition TauVertexedClusterDecorator.h:19

◆ TauVertexFinderCfg()

TauVertexFinderCfg ( flags)

Definition at line 31 of file TauToolHolder.py.

31def TauVertexFinderCfg(flags):
32 result = ComponentAccumulator()
33 _name = flags.Tau.ActiveConfig.prefix + 'TauVertexFinder'
34
35 from InDetTrackSelectionTool.InDetTrackSelectionToolConfig import (
36 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_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
TauVertexFinder
Associate a vertex (origin) to the tau candidate.
Definition TauVertexFinder.h:29

◆ TauVertexVariablesCfg()

TauVertexVariablesCfg ( flags)

Tau Vertex Variables.

Definition at line 632 of file TauToolHolder.py.

632def TauVertexVariablesCfg(flags):
633 result = ComponentAccumulator()
634 _name = flags.Tau.ActiveConfig.prefix + 'TauVertexVariables'
635
636 from TrkConfig.TrkVertexFittersConfig import TauAdaptiveVertexFitterCfg
637 from TrkConfig.TrkVertexSeedFinderToolsConfig import (
638 CrossDistancesSeedFinderCfg)
639
640 TauVertexVariables = CompFactory.getComp("TauVertexVariables")
641 TauVertexVariables = TauVertexVariables( name = _name,
642 VertexFitter = result.popToolsAndMerge(TauAdaptiveVertexFitterCfg(flags)),
643 SeedFinder = result.popToolsAndMerge(CrossDistancesSeedFinderCfg(flags)) )
644
645 result.setPrivateTools(TauVertexVariables)
646 return result
647
TauVertexVariables
Class for calculating vertex variables.
Definition TauVertexVariables.h:23

◆ TauWPDecoratorEleRNNCfg()

TauWPDecoratorEleRNNCfg ( flags)

Definition at line 978 of file TauToolHolder.py.

978def TauWPDecoratorEleRNNCfg(flags):
979
980 result = ComponentAccumulator()
981
982 WPConf = flags.Tau.TauEleRNNWPConfig
983
984 from AthenaConfiguration.Enums import ProductionStep
985 # set the instance to run at derivation level
986 if flags.Common.ProductionStep is ProductionStep.Derivation:
987 _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNNFix_v1'
988 NewScoreName = "RNNEleScoreSigTrans_v1"
989 CutEnumVals = []
990 SigEff1P = []
991 SigEff3P = []
992 DecorWPNames = [ "EleRNNLoose_v1", "EleRNNMedium_v1", "EleRNNTight_v1" ]
993 DecorWPCutEffs1P = [0.95, 0.90, 0.85]
994 DecorWPCutEffs3P = [0.98, 0.95, 0.90]
995 else:
996 #this is the instance running in reconstruction level
997 import PyUtils.RootUtils as ru
998 ROOT = ru.import_root()
999 import cppyy
1000 cppyy.load_library('libxAODTau_cDict')
1001
1002 _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorEleRNN'
1003 NewScoreName = "RNNEleScoreSigTrans"
1004 SigEff1P = [0.95, 0.90, 0.85]
1005 SigEff3P = [0.98, 0.95, 0.90]
1006 CutEnumVals = [ ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNLoose,
1007 ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNMedium,
1008 ROOT.xAOD.TauJetParameters.IsTauFlag.EleRNNTight ]
1009 DecorWPNames = []
1010 DecorWPCutEffs1P = []
1011 DecorWPCutEffs3P = []
1012
1013 TauWPDecorator = CompFactory.getComp("TauWPDecorator")
1014 myTauEleWPDecorator = TauWPDecorator( name=_name,
1015 flatteningFile1Prong = WPConf[0],
1016 flatteningFile3Prong = WPConf[1],
1017 CutEnumVals = CutEnumVals,
1018 DecorWPNames = DecorWPNames,
1019 SigEff1P = SigEff1P,
1020 SigEff3P = SigEff3P,
1021 DecorWPCutEffs1P = DecorWPCutEffs1P,
1022 DecorWPCutEffs3P = DecorWPCutEffs3P,
1023 UseAbsEta = True ,
1024 ScoreName = "RNNEleScore",
1025 NewScoreName = NewScoreName,
1026 DefineWPs = True)
1027
1028 result.setPrivateTools(myTauEleWPDecorator)
1029 return result
1030

◆ TauWPDecoratorGNNCfg()

TauWPDecoratorGNNCfg ( flags,
version,
tauContainerName = "" )

Definition at line 858 of file TauToolHolder.py.

858def TauWPDecoratorGNNCfg(flags, version, tauContainerName=""):
859 result = ComponentAccumulator()
860 _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorGNN_v' + str(version)
861
862 TauWPDecorator = CompFactory.getComp("TauWPDecorator")
863 WPConf = flags.Tau.TauGNNWP[version]
864 myTauWPDecorator = TauWPDecorator(name=_name,
865 flatteningFile1Prong = WPConf[0],
866 flatteningFile2Prong = WPConf[1],
867 flatteningFile3Prong = WPConf[2],
868 TauContainerName = tauContainerName,
869 DecorWPNames = flags.Tau.GNTauDecorWPNames[version],
870 DecorWPCutEffs1P = [0.95, 0.85, 0.75, 0.60],
871 DecorWPCutEffs2P = [0.95, 0.75, 0.60, 0.45],
872 DecorWPCutEffs3P = [0.95, 0.75, 0.60, 0.45],
873 ScoreName = flags.Tau.GNTauScoreName[version],
874 NewScoreName = flags.Tau.GNTauTransScoreName[version],
875 DefineWPs = True)
876 result.setPrivateTools(myTauWPDecorator)
877 return result
878

◆ TauWPDecoratorJetRNNCfg()

TauWPDecoratorJetRNNCfg ( flags)

Definition at line 747 of file TauToolHolder.py.

747def TauWPDecoratorJetRNNCfg(flags):
748 import PyUtils.RootUtils as ru
749 ROOT = ru.import_root()
750 import cppyy
751 cppyy.load_library('libxAODTau_cDict')
752
753 result = ComponentAccumulator()
754 _name = flags.Tau.ActiveConfig.prefix + 'TauWPDecoratorJetRNN'
755
756 TauWPDecorator = CompFactory.getComp("TauWPDecorator")
757 WPConf = flags.Tau.TauJetRNNWPConfig
758 myTauWPDecorator = TauWPDecorator( name=_name,
759 flatteningFile1Prong = WPConf[0],
760 flatteningFile2Prong = WPConf[1],
761 flatteningFile3Prong = WPConf[2],
762 CutEnumVals =
763 [ ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigVeryLoose,
764 ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigLoose,
765 ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigMedium,
766 ROOT.xAOD.TauJetParameters.IsTauFlag.JetRNNSigTight ],
767 SigEff1P = [0.95, 0.85, 0.75, 0.60],
768 SigEff2P = [0.95, 0.75, 0.60, 0.45],
769 SigEff3P = [0.95, 0.75, 0.60, 0.45],
770 ScoreName = "RNNJetScore",
771 NewScoreName = "RNNJetScoreSigTrans",
772 DefineWPs = True )
773
774 result.setPrivateTools(myTauWPDecorator)
775 return result
776
Generated on for ATLAS Offline Software by doxygen 1.17.0