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

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

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

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

◆ TauElecSubtractAlgCfg()

def TauConfig.TauElecSubtractAlgCfg (   flags)

Definition at line 367 of file TauConfig.py.

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

◆ TauOutputCfg()

def TauConfig.TauOutputCfg (   flags)

Definition at line 184 of file TauConfig.py.

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

◆ TauReconstructionCfg()

def TauConfig.TauReconstructionCfg (   flags)

Definition at line 267 of file TauConfig.py.

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

◆ 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.isStandalone or flags.Tracking.doVertexFinding:
138  tools.append(result.popToolsAndMerge(tauTools.TauVertexVariablesCfg(flags)) )
139 
140  tools.append( result.popToolsAndMerge(tauTools.TauCommonCalcVarsCfg(flags)) )
141  tools.append( result.popToolsAndMerge(tauTools.TauSubstructureCfg(flags)) )
142 
143  if flags.Tau.doPanTau:
144  import PanTauAlgs.JobOptions_Main_PanTau as pantau
145  tools.append( result.popToolsAndMerge(pantau.PanTauCfg(flags)) )
146 
147  tools.append(result.popToolsAndMerge(tauTools.TauCombinedTESCfg(flags)) )
148  # these tools need pantau info
149  if flags.Beam.Type is not BeamType.Cosmics:
150  tools.append( result.popToolsAndMerge(tauTools.MvaTESVariableDecoratorCfg(flags)) )
151  tools.append( result.popToolsAndMerge(tauTools.MvaTESEvaluatorCfg(flags)) )
152 
153  tools.append( result.popToolsAndMerge(tauTools.TauAODSelectorCfg(flags)) )
154 
155  if flags.Tau.doTauDiscriminant:
156  tools.append( result.popToolsAndMerge(tauTools.TauIDVarCalculatorCfg(flags)) )
157  tools.append( result.popToolsAndMerge(tauTools.TauJetRNNEvaluatorCfg(flags)) )
158  tools.append( result.popToolsAndMerge(tauTools.TauWPDecoratorJetRNNCfg(flags)) )
159  tools.append( result.popToolsAndMerge(tauTools.TauEleRNNEvaluatorCfg(flags)) )
160  tools.append( result.popToolsAndMerge(tauTools.TauWPDecoratorEleRNNCfg(flags)) )
161  tools.append( result.popToolsAndMerge(tauTools.TauDecayModeNNClassifierCfg(flags)) )
162  # added for offline tau trigger monitoring at T0, not needed for TauJets_EleRM
163  if not flags.Tau.ActiveConfig.inTauEleRM:
164  # only compute GNTau for 1p/3p, as this is internally required by the tau trigger monitoring
165  tools.append( result.popToolsAndMerge(tauTools.TauGNNEvaluatorCfg(flags, version=0, applyTightTrackSel=True)) )
166  tools.append( result.popToolsAndMerge(tauTools.TauWPDecoratorGNNCfg(flags, version=0, tauContainerName=flags.Tau.ActiveConfig.TauJets)) )
167 
168  TauRunnerAlg = CompFactory.getComp("TauRunnerAlg")
169  RunnerAlg = TauRunnerAlg(name = flags.Tau.ActiveConfig.prefix+"TauRecRunnerAlg",
170  Key_tauInputContainer = flags.Tau.ActiveConfig.TauJets_tmp,
171  Key_Pi0ClusterInputContainer = flags.Tau.ActiveConfig.TauPi0Clusters,
172  Key_tauOutputContainer = flags.Tau.ActiveConfig.TauJets,
173  Key_neutralPFOOutputContainer = flags.Tau.ActiveConfig.TauNeutralPFOs,
174  Key_hadronicPFOOutputContainer = flags.Tau.ActiveConfig.TauHadronicPFOs,
175  Key_chargedPFOOutputContainer = flags.Tau.ActiveConfig.TauChargedPFOs,
176  Key_vertexOutputContainer = flags.Tau.ActiveConfig.TauSecondaryVertices,
177  Key_pi0Container = flags.Tau.ActiveConfig.TauFinalPi0s,
178  Tools = tools)
179 
180  result.addEventAlgo(RunnerAlg)
181  return result
182 
183 

◆ TauxAODthinngCfg()

def TauConfig.TauxAODthinngCfg (   flags)

Definition at line 247 of file TauConfig.py.

247 def TauxAODthinngCfg(flags):
248 
249  result = ComponentAccumulator()
250 
251  tauThinAlg = CompFactory.TauThinningAlg(name = flags.Tau.ActiveConfig.prefix+"TauThinningAlg",
252  Taus = flags.Tau.ActiveConfig.TauJets,
253  TauTracks = flags.Tau.ActiveConfig.TauTracks,
254  TauNeutralPFOs = flags.Tau.ActiveConfig.TauNeutralPFOs,
255  TauPi0Clusters = flags.Tau.ActiveConfig.TauPi0Clusters,
256  TauPi0CellLinks = flags.Tau.ActiveConfig.TauPi0ClustersLinks,
257  TauFinalPi0s = flags.Tau.ActiveConfig.TauFinalPi0s,
258  TauShotPFOs = flags.Tau.ActiveConfig.TauShotPFOs,
259  TauShotClusters = flags.Tau.ActiveConfig.TauShotClusters,
260  TauShotCellLinks = flags.Tau.ActiveConfig.TauShotClustersLinks,
261  TauHadronicPFOs = flags.Tau.ActiveConfig.TauHadronicPFOs,
262  TauSecondaryVertices = flags.Tau.ActiveConfig.TauSecondaryVertices)
263  result.addEventAlgo(tauThinAlg)
264  return result
265 
266 
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:184
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:247
TauConfig.TauReconstructionCfg
def TauReconstructionCfg(flags)
Definition: TauConfig.py:267
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:367
TauConfig.DiTauOutputCfg
def DiTauOutputCfg(flags)
Definition: TauConfig.py:234
python.OutputStreamConfig.addToESD
def addToESD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:135
TauConfig.TauConfigTest
def TauConfigTest(flags=None)
Definition: TauConfig.py:399
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:150
Generated on Tue Sep 2 2025 22:24:37 for ATLAS Offline Software by   doxygen 1.8.18