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 235 of file TauConfig.py.

235 def DiTauOutputCfg(flags):
236 
237  from OutputStreamAthenaPool.OutputStreamConfig import addToESD,addToAOD
238  result=ComponentAccumulator()
239 
240  DiTauOutputList = [ "xAOD::DiTauJetContainer#DiTauJets" ]
241  DiTauOutputList += [ "xAOD::DiTauJetAuxContainer#DiTauJetsAux." ]
242 
243  result.merge(addToESD(flags,DiTauOutputList))
244  result.merge(addToAOD(flags,DiTauOutputList))
245  return result
246 
247 

◆ 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  tools.append( result.popToolsAndMerge(tauTools.TauTrackFinderCfg(flags)) )
34 
35  tools.append( result.popToolsAndMerge(tauTools.TauClusterFinderCfg(flags)) )
36  tools.append( result.popToolsAndMerge(tauTools.TauVertexedClusterDecoratorCfg(flags)) )
37 
38  if flags.Beam.Type is not BeamType.Cosmics:
39  if flags.Tau.doRNNTrackClass:
40  tools.append( result.popToolsAndMerge(tauTools.TauTrackRNNClassifierCfg(flags)) )
41  tools.append( result.popToolsAndMerge(tauTools.EnergyCalibrationLCCfg(flags)) )
42 
43  tools.append( result.popToolsAndMerge(tauTools.CellVariablesCfg(flags)) )
44  tools.append( result.popToolsAndMerge(tauTools.ElectronVetoVarsCfg(flags)) )
45  tools.append( result.popToolsAndMerge(tauTools.TauShotFinderCfg(flags)) )
46 
47  if flags.Tau.doPi0Clus:
48  tools.append( result.popToolsAndMerge(tauTools.Pi0ClusterFinderCfg(flags)) )
49 
50  # TauBuildAlg AKA TauProcessorAlg
51  TauProcessorAlg = CompFactory.getComp("TauProcessorAlg")
52  BuildAlg = TauProcessorAlg(name = flags.Tau.ActiveConfig.prefix+"TauCoreBuilderAlg",
53  Key_jetInputContainer = flags.Tau.ActiveConfig.SeedJetCollection,
54  Key_tauOutputContainer = flags.Tau.ActiveConfig.TauJets_tmp,
55  Key_tauTrackOutputContainer = flags.Tau.ActiveConfig.TauTracks,
56  Key_tauShotClusOutputContainer = flags.Tau.ActiveConfig.TauShotClusters,
57  Key_tauShotClusLinkContainer = flags.Tau.ActiveConfig.TauShotClustersLinks,
58  Key_tauShotPFOOutputContainer = flags.Tau.ActiveConfig.TauShotPFOs,
59  Key_tauPi0CellOutputContainer = flags.Tau.ActiveConfig.TauCommonPi0Cells,
60  MaxEta = flags.Tau.SeedMaxEta,
61  MinPt = flags.Tau.SeedMinPt,
62  MaxNTracks = flags.Tau.MaxNTracks,
63  Tools = tools,
64  CellMakerTool = result.popToolsAndMerge(tauTools.TauCellFinalizerCfg(flags)))
65 
66  if flags.GeoModel.Run is LHCPeriod.Run4:
67  BuildAlg.PixelDetEleCollKey="ITkPixelDetectorElementCollection"
68  BuildAlg.SCTDetEleCollKey="ITkStripDetectorElementCollection"
69  BuildAlg.TRTDetEleContKey=""
70 
71  result.addEventAlgo(BuildAlg)
72  return result
73 
74 

◆ TauCaloAlgCfg()

def TauConfig.TauCaloAlgCfg (   flags)

Definition at line 75 of file TauConfig.py.

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

◆ TauConfigTest()

def TauConfig.TauConfigTest (   flags = None)

Definition at line 400 of file TauConfig.py.

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

◆ TauElecSubtractAlgCfg()

def TauConfig.TauElecSubtractAlgCfg (   flags)

Definition at line 368 of file TauConfig.py.

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

◆ TauOutputCfg()

def TauConfig.TauOutputCfg (   flags)

Definition at line 185 of file TauConfig.py.

185 def TauOutputCfg(flags):
186 
187  from OutputStreamAthenaPool.OutputStreamConfig import addToESD,addToAOD
188  result=ComponentAccumulator()
189 
190  # common to AOD and ESD
191  TauAODList = []
192  TauAODList += [ f"xAOD::TauJetContainer#{flags.Tau.ActiveConfig.TauJets}" ]
193  TauAODList += [ f"xAOD::TauTrackContainer#{flags.Tau.ActiveConfig.TauTracks}" ]
194  TauAODList += [ f"xAOD::TauTrackAuxContainer#{flags.Tau.ActiveConfig.TauTracks}Aux." ]
195  TauAODList += [ f"xAOD::VertexContainer#{flags.Tau.ActiveConfig.TauSecondaryVertices}" ]
196  TauAODList += [ f"xAOD::VertexAuxContainer#{flags.Tau.ActiveConfig.TauSecondaryVertices}Aux.-vxTrackAtVertex" ]
197  TauAODList += [ f"xAOD::CaloClusterContainer#{flags.Tau.ActiveConfig.TauPi0Clusters}" ]
198  TauAODList += [ f"xAOD::CaloClusterAuxContainer#{flags.Tau.ActiveConfig.TauPi0Clusters}Aux." ]
199  TauAODList += [ f"CaloClusterCellLinkContainer#{flags.Tau.ActiveConfig.TauPi0Clusters}_links" ]
200  TauAODList += [ f"xAOD::CaloClusterContainer#{flags.Tau.ActiveConfig.TauShotClusters}" ]
201  TauAODList += [ f"xAOD::CaloClusterAuxContainer#{flags.Tau.ActiveConfig.TauShotClusters}Aux." ]
202  TauAODList += [ f"CaloClusterCellLinkContainer#{flags.Tau.ActiveConfig.TauShotClusters}_links" ]
203  TauAODList += [ f"xAOD::ParticleContainer#{flags.Tau.ActiveConfig.TauFinalPi0s}" ]
204  TauAODList += [ f"xAOD::ParticleAuxContainer#{flags.Tau.ActiveConfig.TauFinalPi0s}Aux." ]
205  TauAODList += [ f"xAOD::PFOContainer#{flags.Tau.ActiveConfig.TauShotPFOs}" ]
206  TauAODList += [ f"xAOD::PFOAuxContainer#{flags.Tau.ActiveConfig.TauShotPFOs}Aux." ]
207  TauAODList += [ f"xAOD::PFOContainer#{flags.Tau.ActiveConfig.TauNeutralPFOs}" ]
208  TauAODList += [ f"xAOD::PFOAuxContainer#{flags.Tau.ActiveConfig.TauNeutralPFOs}Aux." ]
209  TauAODList += [ f"xAOD::PFOContainer#{flags.Tau.ActiveConfig.TauHadronicPFOs}" ]
210  TauAODList += [ f"xAOD::PFOAuxContainer#{flags.Tau.ActiveConfig.TauHadronicPFOs}Aux." ]
211 
212  # Set common to ESD too
213  TauESDList = list(TauAODList)
214 
215  # AOD specific
216  # 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.
217  removeAODvars = "-VertexedClusters.-mu.-nVtxPU.-ABS_ETA_LEAD_TRACK.-TAU_ABSDELTAPHI.-TAU_ABSDELTAETA.-absipSigLeadTrk.-passThinning.-chargedGlobalFELinks.-neutralGlobalFELinks"
218  if not flags.Tau.ActiveConfig.inTauEleRM:
219  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"
220  TauAODList += [ "xAOD::TauJetAuxContainer#{}Aux.{}".format(flags.Tau.ActiveConfig.TauJets, removeAODvars) ]
221 
222  # ESD specific
223  removeESDvars = "-VertexedClusters.-chargedGlobalFELinks.-neutralGlobalFELinks"
224  if not flags.Tau.ActiveConfig.inTauEleRM:
225  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"
226  TauESDList += [ "xAOD::TauJetAuxContainer#{}Aux.{}".format(flags.Tau.ActiveConfig.TauJets, removeESDvars) ]
227  TauESDList += [ "xAOD::PFOContainer#{}" .format(flags.Tau.ActiveConfig.TauChargedPFOs) ]
228  TauESDList += [ "xAOD::PFOAuxContainer#{}Aux." .format(flags.Tau.ActiveConfig.TauChargedPFOs) ]
229 
230  result.merge(addToESD(flags,TauESDList))
231  result.merge(addToAOD(flags,TauAODList))
232  return result
233 
234 

◆ TauReconstructionCfg()

def TauConfig.TauReconstructionCfg (   flags)

Definition at line 268 of file TauConfig.py.

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

◆ TauRunnerAlgCfg()

def TauConfig.TauRunnerAlgCfg (   flags)

Definition at line 123 of file TauConfig.py.

123 def TauRunnerAlgCfg(flags):
124 
125  result=ComponentAccumulator()
126 
127  # get tools from holder
128  import tauRec.TauToolHolder as tauTools
129 
130  tools = []
131 
132  tools.append( result.popToolsAndMerge(tauTools.Pi0ClusterCreatorCfg(flags)) )
133  tools.append( result.popToolsAndMerge(tauTools.Pi0ClusterScalerCfg(flags)) )
134  tools.append( result.popToolsAndMerge(tauTools.Pi0ScoreCalculatorCfg(flags)) )
135  tools.append( result.popToolsAndMerge(tauTools.Pi0SelectorCfg(flags)) )
136 
137  if flags.Tau.doPanTau:
138  import PanTauAlgs.JobOptions_Main_PanTau as pantau
139  tools.append( result.popToolsAndMerge(pantau.PanTauCfg(flags)) )
140 
141  tools.append(result.popToolsAndMerge(tauTools.TauCombinedTESCfg(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.TauCommonCalcVarsCfg(flags)) )
154  tools.append( result.popToolsAndMerge(tauTools.TauSubstructureCfg(flags)) )
155 
156  if flags.Tau.doTauDiscriminant:
157  tools.append( result.popToolsAndMerge(tauTools.TauIDVarCalculatorCfg(flags)) )
158  tools.append( result.popToolsAndMerge(tauTools.TauJetRNNEvaluatorCfg(flags)) )
159  tools.append( result.popToolsAndMerge(tauTools.TauWPDecoratorJetRNNCfg(flags)) )
160  tools.append( result.popToolsAndMerge(tauTools.TauEleRNNEvaluatorCfg(flags)) )
161  tools.append( result.popToolsAndMerge(tauTools.TauWPDecoratorEleRNNCfg(flags)) )
162  tools.append( result.popToolsAndMerge(tauTools.TauDecayModeNNClassifierCfg(flags)) )
163  # added for offline tau trigger monitoring at T0, not needed for TauJets_EleRM
164  if not flags.Tau.ActiveConfig.inTauEleRM:
165  # only compute GNTau for 1p/3p, as this is internally required by the tau trigger monitoring
166  tools.append( result.popToolsAndMerge(tauTools.TauGNNEvaluatorCfg(flags, version=0, applyTightTrackSel=True)) )
167  tools.append( result.popToolsAndMerge(tauTools.TauWPDecoratorGNNCfg(flags, version=0, tauContainerName=flags.Tau.ActiveConfig.TauJets)) )
168 
169  TauRunnerAlg = CompFactory.getComp("TauRunnerAlg")
170  RunnerAlg = TauRunnerAlg(name = flags.Tau.ActiveConfig.prefix+"TauRecRunnerAlg",
171  Key_tauInputContainer = flags.Tau.ActiveConfig.TauJets_tmp,
172  Key_Pi0ClusterInputContainer = flags.Tau.ActiveConfig.TauPi0Clusters,
173  Key_tauOutputContainer = flags.Tau.ActiveConfig.TauJets,
174  Key_neutralPFOOutputContainer = flags.Tau.ActiveConfig.TauNeutralPFOs,
175  Key_hadronicPFOOutputContainer = flags.Tau.ActiveConfig.TauHadronicPFOs,
176  Key_chargedPFOOutputContainer = flags.Tau.ActiveConfig.TauChargedPFOs,
177  Key_vertexOutputContainer = flags.Tau.ActiveConfig.TauSecondaryVertices,
178  Key_pi0Container = flags.Tau.ActiveConfig.TauFinalPi0s,
179  Tools = tools)
180 
181  result.addEventAlgo(RunnerAlg)
182  return result
183 
184 

◆ TauxAODthinngCfg()

def TauConfig.TauxAODthinngCfg (   flags)

Definition at line 248 of file TauConfig.py.

248 def TauxAODthinngCfg(flags):
249 
250  result = ComponentAccumulator()
251 
252  tauThinAlg = CompFactory.TauThinningAlg(name = flags.Tau.ActiveConfig.prefix+"TauThinningAlg",
253  Taus = flags.Tau.ActiveConfig.TauJets,
254  TauTracks = flags.Tau.ActiveConfig.TauTracks,
255  TauNeutralPFOs = flags.Tau.ActiveConfig.TauNeutralPFOs,
256  TauPi0Clusters = flags.Tau.ActiveConfig.TauPi0Clusters,
257  TauPi0CellLinks = flags.Tau.ActiveConfig.TauPi0ClustersLinks,
258  TauFinalPi0s = flags.Tau.ActiveConfig.TauFinalPi0s,
259  TauShotPFOs = flags.Tau.ActiveConfig.TauShotPFOs,
260  TauShotClusters = flags.Tau.ActiveConfig.TauShotClusters,
261  TauShotCellLinks = flags.Tau.ActiveConfig.TauShotClustersLinks,
262  TauHadronicPFOs = flags.Tau.ActiveConfig.TauHadronicPFOs,
263  TauSecondaryVertices = flags.Tau.ActiveConfig.TauSecondaryVertices)
264  result.addEventAlgo(tauThinAlg)
265  return result
266 
267 
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:302
vtune_athena.format
format
Definition: vtune_athena.py:14
TauConfig.TauOutputCfg
def TauOutputCfg(flags)
Definition: TauConfig.py:185
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:248
TauConfig.TauReconstructionCfg
def TauReconstructionCfg(flags)
Definition: TauConfig.py:268
python.TileBadChannelsConfig.TileBadChannelsCondAlgCfg
def TileBadChannelsCondAlgCfg(flags, **kwargs)
Definition: TileBadChannelsConfig.py:10
TauConfig.TauRunnerAlgCfg
def TauRunnerAlgCfg(flags)
Definition: TauConfig.py:123
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:75
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
TauConfig.TauElecSubtractAlgCfg
def TauElecSubtractAlgCfg(flags)
Definition: TauConfig.py:368
TauConfig.DiTauOutputCfg
def DiTauOutputCfg(flags)
Definition: TauConfig.py:235
python.OutputStreamConfig.addToESD
def addToESD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:187
TauConfig.TauConfigTest
def TauConfigTest(flags=None)
Definition: TauConfig.py:400
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 Tue Oct 28 2025 22:13:51 for ATLAS Offline Software by   doxygen 1.8.18