ATLAS Offline Software
Functions
TauConfig Namespace Reference

Functions

def TauBuildAlgCfg (flags)
 
def TauCaloAlgCfg (flags)
 
def TauRunnerAlgCfg (flags)
 
def TauOutputCfg (flags)
 
def DiTauOutputCfg (flags)
 
def TauxAODthinngCfg (flags)
 
def TauReconstructionCfg (flags)
 
def TauElecSubtractAlgCfg (flags)
 
def TauConfigTest (flags=None)
 

Function Documentation

◆ DiTauOutputCfg()

def TauConfig.DiTauOutputCfg (   flags)

Definition at line 241 of file TauConfig.py.

241 def DiTauOutputCfg(flags):
242 
243  from OutputStreamAthenaPool.OutputStreamConfig import addToESD,addToAOD
244  result=ComponentAccumulator()
245 
246  DiTauOutputList = [ "xAOD::DiTauJetContainer#DiTauJets" ]
247  DiTauOutputList += [ "xAOD::DiTauJetAuxContainer#DiTauJetsAux." ]
248 
249  result.merge(addToESD(flags,DiTauOutputList))
250  result.merge(addToAOD(flags,DiTauOutputList))
251  return result
252 
253 

◆ TauBuildAlgCfg()

def TauConfig.TauBuildAlgCfg (   flags)

Definition at line 8 of file TauConfig.py.

8 def TauBuildAlgCfg(flags):
9 
10  result = ComponentAccumulator()
11 
12  # Schedule total noise cond alg
13  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
14  result.merge(CaloNoiseCondAlgCfg(flags, "totalNoise"))
15  # Schedule electronic noise cond alg (needed for LC weights)
16  result.merge(CaloNoiseCondAlgCfg(flags, "electronicNoise"))
17 
18  # get tools from holder
19  import tauRec.TauToolHolder as tauTools
20 
21  tools = []
22  tools.append( result.popToolsAndMerge(tauTools.JetSeedBuilderCfg(flags)) )
23 
24  # for electron-removed taus, check that seed jets are close to an electron
25  if getattr(flags.Tau.ActiveConfig, 'inTauEleRM', False):
26  tools.append( result.popToolsAndMerge(tauTools.TauEleOverlapChecker(flags)) )
27 
28  # run vertex finder only in case vertexing is available
29  if flags.Tau.isStandalone or flags.Tracking.doVertexFinding:
30  tools.append( result.popToolsAndMerge(tauTools.TauVertexFinderCfg(flags)) )
31 
32  tools.append( result.popToolsAndMerge(tauTools.TauAxisCfg(flags)) )
33 
34  # track classification + association
35  tools.append( result.popToolsAndMerge(tauTools.TauTrackFinderCfg(flags)) )
36  if flags.Beam.Type is not BeamType.Cosmics and flags.Tau.doRNNTrackClass:
37  tools.append( result.popToolsAndMerge(tauTools.TauTrackRNNClassifierCfg(flags)) )
38 
39  # cluster association + vertex correction
40  tools.append( result.popToolsAndMerge(tauTools.TauClusterFinderCfg(flags)) )
41  tools.append( result.popToolsAndMerge(tauTools.TauVertexedClusterDecoratorCfg(flags)) )
42 
43  # this needs to go before the TauCaloAlgCfg
44  if flags.Tau.doPi0Clus:
45  tools.append( result.popToolsAndMerge(tauTools.Pi0ClusterFinderCfg(flags)) )
46 
47  # TauBuildAlg AKA TauProcessorAlg
48  TauProcessorAlg = CompFactory.getComp("TauProcessorAlg")
49  BuildAlg = TauProcessorAlg(name = flags.Tau.ActiveConfig.prefix+"TauCoreBuilderAlg",
50  Key_jetInputContainer = flags.Tau.ActiveConfig.SeedJetCollection,
51  Key_tauOutputContainer = flags.Tau.ActiveConfig.TauJets_tmp,
52  Key_tauTrackOutputContainer = flags.Tau.ActiveConfig.TauTracks,
53  Key_tauPi0CellOutputContainer = flags.Tau.ActiveConfig.TauCommonPi0Cells,
54  MaxEta = flags.Tau.SeedMaxEta,
55  MinPt = flags.Tau.SeedMinPt,
56  MaxNTracks = flags.Tau.MaxNTracks,
57  Tools = tools,
58  CellMakerTool = result.popToolsAndMerge(tauTools.TauCellFinalizerCfg(flags)))
59 
60  if flags.GeoModel.Run is LHCPeriod.Run4:
61  BuildAlg.PixelDetEleCollKey="ITkPixelDetectorElementCollection"
62  BuildAlg.SCTDetEleCollKey="ITkStripDetectorElementCollection"
63  BuildAlg.TRTDetEleContKey=""
64 
65  result.addEventAlgo(BuildAlg)
66  return result
67 
68 

◆ TauCaloAlgCfg()

def TauConfig.TauCaloAlgCfg (   flags)

Definition at line 69 of file TauConfig.py.

69 def TauCaloAlgCfg(flags):
70 
71  result = ComponentAccumulator()
72 
73  # Schedule total noise cond alg
74  from CaloTools.CaloNoiseCondAlgConfig import CaloNoiseCondAlgCfg
75  result.merge(CaloNoiseCondAlgCfg(flags,"totalNoise"))
76  # Schedule electronic noise cond alg (needed for LC weights)
77  result.merge(CaloNoiseCondAlgCfg(flags,"electronicNoise"))
78 
79  from CaloRec.CaloTopoClusterConfig import caloTopoCoolFolderCfg
80  result.merge(caloTopoCoolFolderCfg(flags))
81 
82  from LArBadChannelTool.LArBadChannelConfig import LArBadChannelCfg
83  result.merge(LArBadChannelCfg(flags))
84 
85  from TileConditions.TileBadChannelsConfig import TileBadChannelsCondAlgCfg
86  result.merge( TileBadChannelsCondAlgCfg(flags) )
87 
88  # get tools from holder
89  import tauRec.TauToolHolder as tauTools
90 
91  CaloClusterMaker = CompFactory.getComp("CaloClusterMaker")
92  CaloTopoForTausMaker = CaloClusterMaker (flags.Tau.ActiveConfig.prefix+"TauPi0SubtractedClusterMaker")
93  CaloTopoForTausMaker.ClustersOutputName = flags.Tau.ActiveConfig.TauPi0Clusters_tmp
94  CaloTopoForTausMaker.ClusterMakerTools = [result.popToolsAndMerge(tauTools.TauCaloTopoClusterMakerCfg(flags)),
95  result.popToolsAndMerge(tauTools.TauCaloTopoClusterSplitterCfg(flags))]
96 
97  CaloTopoForTausMaker.ClusterCorrectionTools += [result.popToolsAndMerge(tauTools.TauCaloClusterBadChannelCfg(flags))]
98  CaloTopoForTausMaker.ClusterCorrectionTools += [result.popToolsAndMerge(tauTools.TauCaloClusterMomentsMakerCfg(flags))]
99 
100  if flags.Calo.TopoCluster.doTopoClusterLocalCalib:
101  CaloTopoForTausMaker.ClusterCorrectionTools += [result.popToolsAndMerge(tauTools.TauCaloClusterLocalCalibCfg(flags)),
102  result.popToolsAndMerge(tauTools.TauCaloOOCCalibCfg(flags)),
103  result.popToolsAndMerge(tauTools.TauCaloOOCPi0CalibCfg(flags)),
104  result.popToolsAndMerge(tauTools.TauCaloDMCalibCfg(flags))]
105 
106  result.addEventAlgo(CaloTopoForTausMaker)
107 
108  relinkAlg = CompFactory.ClusterCellRelinkAlg(name = flags.Tau.ActiveConfig.prefix+'ClusterCellRelinkAlg',
109  Cells = 'AllCalo',
110  ClustersInput = flags.Tau.ActiveConfig.TauPi0Clusters_tmp,
111  ClustersOutput = flags.Tau.ActiveConfig.TauPi0Clusters,
112  CellLinksOutput = flags.Tau.ActiveConfig.TauPi0ClustersLinks)
113  result.addEventAlgo(relinkAlg)
114  return result
115 
116 

◆ TauConfigTest()

def TauConfig.TauConfigTest (   flags = None)

Definition at line 409 of file TauConfig.py.

409 def TauConfigTest(flags=None):
410 
411  if flags is None:
412  from AthenaConfiguration.AllConfigFlags import initConfigFlags
413  from AthenaConfiguration.TestDefaults import defaultTestFiles, defaultConditionsTags
414 
415  flags = initConfigFlags()
416 
417  flags.Input.Files = defaultTestFiles.RDO_RUN3
418  flags.IOVDb.GlobalTag = defaultConditionsTags.RUN3_MC
419 
420  flags.Output.AODFileName = "AOD.pool.root"
421  flags.Exec.MaxEvents = 50
422 
423  flags.Scheduler.ShowDataDeps = True
424  flags.Scheduler.ShowDataFlow = True
425  flags.Scheduler.ShowControlFlow = True
426 
427  flags.Concurrency.NumThreads = 1
428  flags.Concurrency.NumConcurrentEvents = 1
429 
430  from tauRec.ConfigurationHelpers import StandaloneTauRecoFlags
431  StandaloneTauRecoFlags(flags)
432 
433  flags.lock()
434 
435  from RecJobTransforms.RecoSteering import RecoSteering
436  cfg = RecoSteering(flags)
437 
438  from RecJobTransforms.RecoConfigFlags import printRecoFlags
439  printRecoFlags(flags)
440 
441  cfg.run()
442 
443 

◆ TauElecSubtractAlgCfg()

def TauConfig.TauElecSubtractAlgCfg (   flags)

Definition at line 377 of file TauConfig.py.

377 def TauElecSubtractAlgCfg(flags):
378 
379  result = ComponentAccumulator()
380 
381  from ElectronPhotonSelectorTools.AsgElectronLikelihoodToolsConfig import AsgElectronLikelihoodToolCfg
382  from ElectronPhotonSelectorTools.LikelihoodEnums import LikeEnum
383  from ElectronPhotonSelectorTools.ElectronLikelihoodToolMapping import electronLHmenu
384  ElectronLHSelectorEleRM = result.popToolsAndMerge(
385  AsgElectronLikelihoodToolCfg(
386  flags,
387  name = flags.Tau.ActiveConfig.prefix+"ElectronLHSelector",
388  quality = getattr(LikeEnum, flags.Tau.ActiveConfig.EleRM_ElectronWorkingPoint),
389  menu = electronLHmenu.offlineMC21,
390  )
391  )
392 
393  tauElecSubtractAlg = CompFactory.TauElecSubtractAlg(
394  name = flags.Tau.ActiveConfig.prefix+"TauElecSubtractAlg",
395  Key_ElectronsInput = 'Electrons',
396  Key_ClustersInput = 'CaloCalTopoClusters',
397  Key_ClustersOutput = flags.Tau.ActiveConfig.CaloCalTopoClusters_EleRM,
398  Key_IDTracksInput = 'InDetTrackParticles',
399  Key_IDTracksOutput = flags.Tau.ActiveConfig.TrackCollection,
400  Key_RemovedClustersOutput = flags.Tau.ActiveConfig.RemovedElectronClusters,
401  Key_RemovedTracksOutput = flags.Tau.ActiveConfig.RemovedElectronTracks,
402  ElectronLHTool = ElectronLHSelectorEleRM,
403  doNothing = False,
404  )
405  result.addEventAlgo(tauElecSubtractAlg)
406  return result
407 
408 # Run with python -m tauRec.TauConfig

◆ TauOutputCfg()

def TauConfig.TauOutputCfg (   flags)

Definition at line 191 of file TauConfig.py.

191 def TauOutputCfg(flags):
192 
193  from OutputStreamAthenaPool.OutputStreamConfig import addToESD,addToAOD
194  result=ComponentAccumulator()
195 
196  # common to AOD and ESD
197  TauAODList = []
198  TauAODList += [ f"xAOD::TauJetContainer#{flags.Tau.ActiveConfig.TauJets}" ]
199  TauAODList += [ f"xAOD::TauTrackContainer#{flags.Tau.ActiveConfig.TauTracks}" ]
200  TauAODList += [ f"xAOD::TauTrackAuxContainer#{flags.Tau.ActiveConfig.TauTracks}Aux." ]
201  TauAODList += [ f"xAOD::VertexContainer#{flags.Tau.ActiveConfig.TauSecondaryVertices}" ]
202  TauAODList += [ f"xAOD::VertexAuxContainer#{flags.Tau.ActiveConfig.TauSecondaryVertices}Aux.-vxTrackAtVertex" ]
203  TauAODList += [ f"xAOD::CaloClusterContainer#{flags.Tau.ActiveConfig.TauPi0Clusters}" ]
204  TauAODList += [ f"xAOD::CaloClusterAuxContainer#{flags.Tau.ActiveConfig.TauPi0Clusters}Aux." ]
205  TauAODList += [ f"CaloClusterCellLinkContainer#{flags.Tau.ActiveConfig.TauPi0Clusters}_links" ]
206  TauAODList += [ f"xAOD::CaloClusterContainer#{flags.Tau.ActiveConfig.TauShotClusters}" ]
207  TauAODList += [ f"xAOD::CaloClusterAuxContainer#{flags.Tau.ActiveConfig.TauShotClusters}Aux." ]
208  TauAODList += [ f"CaloClusterCellLinkContainer#{flags.Tau.ActiveConfig.TauShotClusters}_links" ]
209  TauAODList += [ f"xAOD::ParticleContainer#{flags.Tau.ActiveConfig.TauFinalPi0s}" ]
210  TauAODList += [ f"xAOD::ParticleAuxContainer#{flags.Tau.ActiveConfig.TauFinalPi0s}Aux." ]
211  TauAODList += [ f"xAOD::PFOContainer#{flags.Tau.ActiveConfig.TauShotPFOs}" ]
212  TauAODList += [ f"xAOD::PFOAuxContainer#{flags.Tau.ActiveConfig.TauShotPFOs}Aux." ]
213  TauAODList += [ f"xAOD::PFOContainer#{flags.Tau.ActiveConfig.TauNeutralPFOs}" ]
214  TauAODList += [ f"xAOD::PFOAuxContainer#{flags.Tau.ActiveConfig.TauNeutralPFOs}Aux." ]
215  TauAODList += [ f"xAOD::PFOContainer#{flags.Tau.ActiveConfig.TauHadronicPFOs}" ]
216  TauAODList += [ f"xAOD::PFOAuxContainer#{flags.Tau.ActiveConfig.TauHadronicPFOs}Aux." ]
217 
218  # Set common to ESD too
219  TauESDList = list(TauAODList)
220 
221  # AOD specific
222  # remove GlobalFELinks - these are links between FlowElement (FE) containers created in jet finding and taus. Since these transient FE containers are not in the AOD, we should not write out these links.
223  removeAODvars = "-VertexedClusters.-mu.-nVtxPU.-ABS_ETA_LEAD_TRACK.-TAU_ABSDELTAPHI.-TAU_ABSDELTAETA.-absipSigLeadTrk.-passThinning.-chargedGlobalFELinks.-neutralGlobalFELinks"
224  if not flags.Tau.ActiveConfig.inTauEleRM:
225  removeAODvars += f".-{flags.Tau.GNTauScoreName[0]}.-{flags.Tau.GNTauTransScoreName[0]}.-{flags.Tau.GNTauDecorWPNames[0][0]}.-{flags.Tau.GNTauDecorWPNames[0][1]}.-{flags.Tau.GNTauDecorWPNames[0][2]}.-{flags.Tau.GNTauDecorWPNames[0][3]}.-GNTauProbTau.-GNTauProbJet"
226  TauAODList += [ "xAOD::TauJetAuxContainer#{}Aux.{}".format(flags.Tau.ActiveConfig.TauJets, removeAODvars) ]
227 
228  # ESD specific
229  removeESDvars = "-VertexedClusters.-chargedGlobalFELinks.-neutralGlobalFELinks"
230  if not flags.Tau.ActiveConfig.inTauEleRM:
231  removeESDvars += f".-{flags.Tau.GNTauScoreName[0]}.-{flags.Tau.GNTauTransScoreName[0]}.-{flags.Tau.GNTauDecorWPNames[0][0]}.-{flags.Tau.GNTauDecorWPNames[0][1]}.-{flags.Tau.GNTauDecorWPNames[0][2]}.-{flags.Tau.GNTauDecorWPNames[0][3]}.-GNTauProbTau.-GNTauProbJet"
232  TauESDList += [ "xAOD::TauJetAuxContainer#{}Aux.{}".format(flags.Tau.ActiveConfig.TauJets, removeESDvars) ]
233  TauESDList += [ "xAOD::PFOContainer#{}" .format(flags.Tau.ActiveConfig.TauChargedPFOs) ]
234  TauESDList += [ "xAOD::PFOAuxContainer#{}Aux." .format(flags.Tau.ActiveConfig.TauChargedPFOs) ]
235 
236  result.merge(addToESD(flags,TauESDList))
237  result.merge(addToAOD(flags,TauAODList))
238  return result
239 
240 

◆ TauReconstructionCfg()

def TauConfig.TauReconstructionCfg (   flags)

Definition at line 274 of file TauConfig.py.

274 def TauReconstructionCfg(flags):
275 
276  result = ComponentAccumulator()
277 
278  # Schedule the custom jets needed for tau seeding
279  from JetRecConfig.JetRecConfig import JetRecCfg
280  from JetRecConfig.StandardJetConstits import stdConstitDic as cst
281  from JetRecConfig.JetDefinition import JetDefinition
282  from JetRecConfig.StandardSmallRJets import flavourghosts, calibmods_noCut, standardmods, truthmods
283  minimalghosts = ["Track","MuonSegment","Truth"]
284 
285  #Check if the specific jet collection is needed based on flags
286  if flags.Tau.TauRec.SeedJetCollection == "AntiKt4EMPFlowMLJets":
287  from JetRecConfig.StandardSmallRJets import AntiKt4EMPFlowML
288  result.merge(JetRecCfg(flags, AntiKt4EMPFlowML))
289  if flags.Tau.TauRec.SeedJetCollection == "AntiKt4EMPFlow10GeVCutTauSeedJets":
290  AntiKt4EMPFlow10GeVCutTauSeed = JetDefinition("AntiKt",0.4,cst.GPFlow,
291  infix = "10GeVCutTauSeed",
292  ghostdefs = minimalghosts+flavourghosts,
293  modifiers = calibmods_noCut+("Filter:1",)+truthmods+standardmods+("JetPtAssociation","CaloEnergiesClus"),
294  ptmin = 10000.,
295  lock = True)
296  result.merge(JetRecCfg(flags, AntiKt4EMPFlow10GeVCutTauSeed))
297  if flags.Tau.TauRec.SeedJetCollection == "AntiKt4EMPFlow5GeVCutTauSeedJets":
298  AntiKt4EMPFlow5GeVCutTauSeed = JetDefinition("AntiKt",0.4,cst.GPFlow,
299  infix = "5GeVCutTauSeed",
300  ghostdefs = minimalghosts+flavourghosts,
301  modifiers = calibmods_noCut+("Filter:1",)+truthmods+standardmods+("JetPtAssociation","CaloEnergiesClus"),
302  ptmin = 5000.,
303  lock = True)
304  result.merge(JetRecCfg(flags, AntiKt4EMPFlow5GeVCutTauSeed))
305  if flags.Tau.TauRec.SeedJetCollection == "AntiKt4EMPFlowNoPtCutTauSeedJets":
306  AntiKt4EMPFlowNoPtCutTauSeed = JetDefinition("AntiKt",0.4,cst.GPFlow,
307  infix = "NoPtCutTauSeed",
308  ghostdefs = minimalghosts+flavourghosts,
309  modifiers = calibmods_noCut+("Filter:1",)+truthmods+standardmods+("JetPtAssociation","CaloEnergiesClus"),
310  ptmin = 1,
311  lock = True)
312  result.merge(JetRecCfg(flags, AntiKt4EMPFlowNoPtCutTauSeed))
313  # --- > End of Schedule the custom jets needed for tau seeding < ---
314 
315 
316  # standard tau reconstruction
317  flags_TauRec = flags.cloneAndReplace("Tau.ActiveConfig", "Tau.TauRec")
318 
319  result.merge(TauBuildAlgCfg(flags_TauRec))
320 
321  result.merge(TauCaloAlgCfg(flags_TauRec))
322 
323  result.merge(TauRunnerAlgCfg(flags_TauRec))
324 
325  if (flags.Output.doWriteESD or flags.Output.doWriteAOD):
326  result.merge(TauOutputCfg(flags_TauRec))
327 
328  if (flags.Output.doWriteAOD and flags.Tau.ThinTaus):
329  result.merge(TauxAODthinngCfg(flags_TauRec))
330 
331  # electron-subtracted tau reconstruction
332  if flags.Tau.doTauEleRMRec:
333 
334  flags_TauEleRM = flags.cloneAndReplace("Tau.ActiveConfig", "Tau.TauEleRM")
335 
336  result.merge(TauElecSubtractAlgCfg(flags_TauEleRM))
337 
338  # jet reclustering
339  from JetRecConfig.JetRecConfig import JetRecCfg
340  if 'PFlow' in flags.Tau.TauRec.SeedJetCollection:
341  from JetRecConfig.JetRecConfig import JetRecCfg
342  from JetRecConfig.StandardSmallRJets import AntiKt4EMPFlow_tauSeedEleRM
343  result.merge( JetRecCfg(flags_TauEleRM,AntiKt4EMPFlow_tauSeedEleRM ))
344  else:
345  from JetRecConfig.StandardSmallRJets import AntiKt4LCTopo
346  AntiKt4LCTopo_EleRM = AntiKt4LCTopo.clone(suffix="_EleRM")
347  AntiKt4LCTopo_EleRM.inputdef.name = flags_TauEleRM.Tau.ActiveConfig.LCTopoOrigin_EleRM
348  AntiKt4LCTopo_EleRM.inputdef.inputname = flags_TauEleRM.Tau.ActiveConfig.CaloCalTopoClusters_EleRM
349  AntiKt4LCTopo_EleRM.inputdef.containername = flags_TauEleRM.Tau.ActiveConfig.LCOriginTopoClusters_EleRM
350  AntiKt4LCTopo_EleRM.standardRecoMode = True
351  AntiKt4LCTopo_EleRM.context = "EleRM"
352  result.merge(JetRecCfg(flags_TauEleRM, AntiKt4LCTopo_EleRM))
353 
354  result.merge(TauBuildAlgCfg(flags_TauEleRM))
355 
356  result.merge(TauCaloAlgCfg(flags_TauEleRM))
357 
358  result.merge(TauRunnerAlgCfg(flags_TauEleRM))
359 
360  if (flags.Output.doWriteESD or flags.Output.doWriteAOD):
361  result.merge(TauOutputCfg(flags_TauEleRM))
362 
363  if (flags.Output.doWriteAOD and flags.Tau.ThinTaus):
364  result.merge(TauxAODthinngCfg(flags_TauEleRM))
365 
366  # had-had boosted ditaus
367  if flags.DiTau.doDiTauRec:
368  from DiTauRec.DiTauBuilderConfig import DiTauBuilderCfg
369  result.merge(DiTauBuilderCfg(flags))
370 
371  if (flags.Output.doWriteESD or flags.Output.doWriteAOD):
372  result.merge(DiTauOutputCfg(flags))
373 
374  return result
375 
376 

◆ TauRunnerAlgCfg()

def TauConfig.TauRunnerAlgCfg (   flags)

Definition at line 117 of file TauConfig.py.

117 def TauRunnerAlgCfg(flags):
118 
119  result=ComponentAccumulator()
120 
121  # get tools from holder
122  import tauRec.TauToolHolder as tauTools
123 
124  tools = []
125  tools.append( result.popToolsAndMerge(tauTools.TauShotFinderCfg(flags)) )
126  tools.append( result.popToolsAndMerge(tauTools.Pi0ClusterCreatorCfg(flags)) )
127  tools.append( result.popToolsAndMerge(tauTools.Pi0ClusterScalerCfg(flags)) )
128  tools.append( result.popToolsAndMerge(tauTools.Pi0ScoreCalculatorCfg(flags)) )
129  tools.append( result.popToolsAndMerge(tauTools.Pi0SelectorCfg(flags)) )
130 
131  if flags.Beam.Type is not BeamType.Cosmics:
132  tools.append( result.popToolsAndMerge(tauTools.EnergyCalibrationLCCfg(flags)) )
133 
134  if flags.Tau.doPanTau:
135  import PanTauAlgs.JobOptions_Main_PanTau as pantau
136  tools.append( result.popToolsAndMerge(pantau.PanTauCfg(flags)) )
137 
138  tools.append(result.popToolsAndMerge(tauTools.TauCombinedTESCfg(flags)) )
139 
140  # this is scheduled here because it provides variables used in the MVATES evaluation
141  tools.append( result.popToolsAndMerge(tauTools.CellVariablesCfg(flags)) )
142  # these tools need pantau info
143  if flags.Beam.Type is not BeamType.Cosmics:
144  tools.append( result.popToolsAndMerge(tauTools.MvaTESVariableDecoratorCfg(flags)) )
145  tools.append( result.popToolsAndMerge(tauTools.MvaTESEvaluatorCfg(flags)) )
146 
147  # apply pt cut
148  tools.append( result.popToolsAndMerge(tauTools.TauAODSelectorCfg(flags)) )
149 
150  # do some extra variable calculation
151  if flags.Tau.isStandalone or flags.Tracking.doVertexFinding:
152  tools.append(result.popToolsAndMerge(tauTools.TauVertexVariablesCfg(flags)) )
153  tools.append( result.popToolsAndMerge(tauTools.ElectronVetoVarsCfg(flags)) )
154  tools.append( result.popToolsAndMerge(tauTools.TauCommonCalcVarsCfg(flags)) )
155  tools.append( result.popToolsAndMerge(tauTools.TauSubstructureCfg(flags)) )
156 
157  if flags.Tau.doTauDiscriminant:
158  tools.append( result.popToolsAndMerge(tauTools.TauIDVarCalculatorCfg(flags)) )
159  # do not schedule RNNID and eVeto for Run4
160  if flags.GeoModel.Run <= LHCPeriod.Run3:
161  tools.append( result.popToolsAndMerge(tauTools.TauJetRNNEvaluatorCfg(flags)) )
162  tools.append( result.popToolsAndMerge(tauTools.TauWPDecoratorJetRNNCfg(flags)) )
163  tools.append( result.popToolsAndMerge(tauTools.TauEleRNNEvaluatorCfg(flags)) )
164  tools.append( result.popToolsAndMerge(tauTools.TauWPDecoratorEleRNNCfg(flags)) )
165  tools.append( result.popToolsAndMerge(tauTools.TauDecayModeNNClassifierCfg(flags)) )
166  # added for offline tau trigger monitoring at T0, not needed for TauJets_EleRM
167  if not flags.Tau.ActiveConfig.inTauEleRM:
168  # only compute GNTau for 1p/3p, as this is internally required by the tau trigger monitoring
169  tools.append( result.popToolsAndMerge(tauTools.TauGNNEvaluatorCfg(flags, version=0, applyTightTrackSel=True)) )
170  tools.append( result.popToolsAndMerge(tauTools.TauWPDecoratorGNNCfg(flags, version=0, tauContainerName=flags.Tau.ActiveConfig.TauJets)) )
171 
172  TauRunnerAlg = CompFactory.getComp("TauRunnerAlg")
173  RunnerAlg = TauRunnerAlg(name = flags.Tau.ActiveConfig.prefix+"TauRecRunnerAlg",
174  Key_tauInputContainer = flags.Tau.ActiveConfig.TauJets_tmp,
175  Key_Pi0ClusterInputContainer = flags.Tau.ActiveConfig.TauPi0Clusters,
176  Key_tauOutputContainer = flags.Tau.ActiveConfig.TauJets,
177  Key_neutralPFOOutputContainer = flags.Tau.ActiveConfig.TauNeutralPFOs,
178  Key_hadronicPFOOutputContainer = flags.Tau.ActiveConfig.TauHadronicPFOs,
179  Key_chargedPFOOutputContainer = flags.Tau.ActiveConfig.TauChargedPFOs,
180  Key_vertexOutputContainer = flags.Tau.ActiveConfig.TauSecondaryVertices,
181  Key_pi0Container = flags.Tau.ActiveConfig.TauFinalPi0s,
182  Key_tauShotClusOutputContainer = flags.Tau.ActiveConfig.TauShotClusters,
183  Key_tauShotClusLinkContainer = flags.Tau.ActiveConfig.TauShotClustersLinks,
184  Key_tauShotPFOOutputContainer = flags.Tau.ActiveConfig.TauShotPFOs,
185  Tools = tools)
186 
187  result.addEventAlgo(RunnerAlg)
188  return result
189 
190 

◆ TauxAODthinngCfg()

def TauConfig.TauxAODthinngCfg (   flags)

Definition at line 254 of file TauConfig.py.

254 def TauxAODthinngCfg(flags):
255 
256  result = ComponentAccumulator()
257 
258  tauThinAlg = CompFactory.TauThinningAlg(name = flags.Tau.ActiveConfig.prefix+"TauThinningAlg",
259  Taus = flags.Tau.ActiveConfig.TauJets,
260  TauTracks = flags.Tau.ActiveConfig.TauTracks,
261  TauNeutralPFOs = flags.Tau.ActiveConfig.TauNeutralPFOs,
262  TauPi0Clusters = flags.Tau.ActiveConfig.TauPi0Clusters,
263  TauPi0CellLinks = flags.Tau.ActiveConfig.TauPi0ClustersLinks,
264  TauFinalPi0s = flags.Tau.ActiveConfig.TauFinalPi0s,
265  TauShotPFOs = flags.Tau.ActiveConfig.TauShotPFOs,
266  TauShotClusters = flags.Tau.ActiveConfig.TauShotClusters,
267  TauShotCellLinks = flags.Tau.ActiveConfig.TauShotClustersLinks,
268  TauHadronicPFOs = flags.Tau.ActiveConfig.TauHadronicPFOs,
269  TauSecondaryVertices = flags.Tau.ActiveConfig.TauSecondaryVertices)
270  result.addEventAlgo(tauThinAlg)
271  return result
272 
273 
python.RecoSteering.RecoSteering
def RecoSteering(flags)
Definition: RecoSteering.py:6
python.CaloTopoClusterConfig.caloTopoCoolFolderCfg
def caloTopoCoolFolderCfg(flags)
Definition: CaloTopoClusterConfig.py:7
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:342
vtune_athena.format
format
Definition: vtune_athena.py:14
TauConfig.TauOutputCfg
def TauOutputCfg(flags)
Definition: TauConfig.py:191
ConfigurationHelpers.StandaloneTauRecoFlags
def StandaloneTauRecoFlags(flags)
Definition: Reconstruction/tauRec/python/ConfigurationHelpers.py:6
python.AsgElectronLikelihoodToolsConfig.AsgElectronLikelihoodToolCfg
def AsgElectronLikelihoodToolCfg(flag, name, quality, menu=electronLHmenu.offlineMC21)
Definition: AsgElectronLikelihoodToolsConfig.py:13
python.LArBadChannelConfig.LArBadChannelCfg
def LArBadChannelCfg(configFlags, tag=None, isSC=False)
Definition: LArBadChannelConfig.py:8
python.RecoConfigFlags.printRecoFlags
def printRecoFlags(flags)
Definition: RecoConfigFlags.py:155
TauConfig.TauBuildAlgCfg
def TauBuildAlgCfg(flags)
Definition: TauConfig.py:8
TauRunnerAlg
Main class for tau candidate processing.
Definition: TauRunnerAlg.h:31
TauConfig.TauxAODthinngCfg
def TauxAODthinngCfg(flags)
Definition: TauConfig.py:254
TauConfig.TauReconstructionCfg
def TauReconstructionCfg(flags)
Definition: TauConfig.py:274
python.TileBadChannelsConfig.TileBadChannelsCondAlgCfg
def TileBadChannelsCondAlgCfg(flags, **kwargs)
Definition: TileBadChannelsConfig.py:10
TauConfig.TauRunnerAlgCfg
def TauRunnerAlgCfg(flags)
Definition: TauConfig.py:117
python.JetRecConfig.JetRecCfg
def JetRecCfg(flags, jetdef, returnConfiguredDef=False)
Top level functions returning ComponentAccumulator out of JetDefinition.
Definition: JetRecConfig.py:36
python.CaloNoiseCondAlgConfig.CaloNoiseCondAlgCfg
def CaloNoiseCondAlgCfg(flags, noisetype="totalNoise")
Definition: CaloNoiseCondAlgConfig.py:11
TauConfig.TauCaloAlgCfg
def TauCaloAlgCfg(flags)
Definition: TauConfig.py:69
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
TauConfig.TauElecSubtractAlgCfg
def TauElecSubtractAlgCfg(flags)
Definition: TauConfig.py:377
TauConfig.DiTauOutputCfg
def DiTauOutputCfg(flags)
Definition: TauConfig.py:241
python.OutputStreamConfig.addToESD
def addToESD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:187
TauConfig.TauConfigTest
def TauConfigTest(flags=None)
Definition: TauConfig.py:409
TauProcessorAlg
Definition: TauProcessorAlg.h:37
DiTauBuilderConfig.DiTauBuilderCfg
def DiTauBuilderCfg(flags, name="DiTauBuilder", doLowPt=False)
Definition: DiTauBuilderConfig.py:16
python.AllConfigFlags.initConfigFlags
def initConfigFlags()
Definition: AllConfigFlags.py:19
python.OutputStreamConfig.addToAOD
def addToAOD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:202
Generated on Fri Nov 21 2025 22:06:36 for ATLAS Offline Software by   doxygen 1.8.18