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

Functions

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

Function Documentation

◆ DiTauOutputCfg()

TauConfig.DiTauOutputCfg ( flags)

Definition at line 240 of file TauConfig.py.

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

◆ TauBuildAlgCfg()

TauConfig.TauBuildAlgCfg ( flags)

Definition at line 8 of file TauConfig.py.

8def 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 tools.append( result.popToolsAndMerge(tauTools.Pi0ClusterFinderCfg(flags)) )
45
46 # TauBuilderAlg
47 TauBuilderAlg = CompFactory.getComp("TauBuilderAlg")
48 BuildAlg = TauBuilderAlg(name = flags.Tau.ActiveConfig.prefix+"TauCoreBuilderAlg",
49 Key_jetInputContainer = flags.Tau.ActiveConfig.SeedJetCollection,
50 Key_tauOutputContainer = flags.Tau.ActiveConfig.TauJets_tmp,
51 Key_tauTrackOutputContainer = flags.Tau.ActiveConfig.TauTracks,
52 Key_tauPi0CellOutputContainer = flags.Tau.ActiveConfig.TauCommonPi0Cells,
53 MaxEta = flags.Tau.SeedMaxEta,
54 MinPt = flags.Tau.SeedMinPt,
55 MaxNTracks = flags.Tau.MaxNTracks,
56 Tools = tools,
57 CellMakerTool = result.popToolsAndMerge(tauTools.TauCellFinalizerCfg(flags)))
58
59 if flags.GeoModel.Run is LHCPeriod.Run4:
60 BuildAlg.PixelDetEleCollKey="ITkPixelDetectorElementCollection"
61 BuildAlg.SCTDetEleCollKey="ITkStripDetectorElementCollection"
62 BuildAlg.TRTDetEleContKey=""
63
64 result.addEventAlgo(BuildAlg)
65 return result
66
67

◆ TauCaloAlgCfg()

TauConfig.TauCaloAlgCfg ( flags)

Definition at line 68 of file TauConfig.py.

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

◆ TauConfigTest()

TauConfig.TauConfigTest ( flags = None)

Definition at line 371 of file TauConfig.py.

371def TauConfigTest(flags=None):
372
373 if flags is None:
374 from AthenaConfiguration.AllConfigFlags import initConfigFlags
375 from AthenaConfiguration.TestDefaults import defaultTestFiles, defaultConditionsTags
376
377 flags = initConfigFlags()
378
379 flags.Input.Files = defaultTestFiles.RDO_RUN3
380 flags.IOVDb.GlobalTag = defaultConditionsTags.RUN3_MC
381
382 flags.Output.AODFileName = "AOD.pool.root"
383 flags.Exec.MaxEvents = 50
384
385 flags.Scheduler.ShowDataDeps = True
386 flags.Scheduler.ShowDataFlow = True
387 flags.Scheduler.ShowControlFlow = True
388
389 flags.Concurrency.NumThreads = 1
390 flags.Concurrency.NumConcurrentEvents = 1
391
392 from tauRec.ConfigurationHelpers import StandaloneTauRecoFlags
393 StandaloneTauRecoFlags(flags)
394
395 flags.lock()
396
397 from RecJobTransforms.RecoSteering import RecoSteering
398 cfg = RecoSteering(flags)
399
400 from RecJobTransforms.RecoConfigFlags import printRecoFlags
401 printRecoFlags(flags)
402
403 cfg.run()
404
405

◆ TauElecSubtractAlgCfg()

TauConfig.TauElecSubtractAlgCfg ( flags)

Definition at line 339 of file TauConfig.py.

339def TauElecSubtractAlgCfg(flags):
340
341 result = ComponentAccumulator()
342
343 from ElectronPhotonSelectorTools.AsgElectronLikelihoodToolsConfig import AsgElectronLikelihoodToolCfg
344 from ElectronPhotonSelectorTools.LikelihoodEnums import LikeEnum
345 from ElectronPhotonSelectorTools.ElectronLikelihoodToolMapping import electronLHmenu
346 ElectronLHSelectorEleRM = result.popToolsAndMerge(
347 AsgElectronLikelihoodToolCfg(
348 flags,
349 name = flags.Tau.ActiveConfig.prefix+"ElectronLHSelector",
350 quality = getattr(LikeEnum, flags.Tau.ActiveConfig.EleRM_ElectronWorkingPoint),
351 menu = electronLHmenu.offlineMC21,
352 )
353 )
354
355 tauElecSubtractAlg = CompFactory.TauElecSubtractAlg(
356 name = flags.Tau.ActiveConfig.prefix+"TauElecSubtractAlg",
357 Key_ElectronsInput = 'Electrons',
358 Key_ClustersInput = 'CaloCalTopoClusters',
359 Key_ClustersOutput = flags.Tau.ActiveConfig.CaloCalTopoClusters_EleRM,
360 Key_IDTracksInput = 'InDetTrackParticles',
361 Key_IDTracksOutput = flags.Tau.ActiveConfig.TrackCollection,
362 Key_RemovedClustersOutput = flags.Tau.ActiveConfig.RemovedElectronClusters,
363 Key_RemovedTracksOutput = flags.Tau.ActiveConfig.RemovedElectronTracks,
364 ElectronLHTool = ElectronLHSelectorEleRM,
365 doNothing = False,
366 )
367 result.addEventAlgo(tauElecSubtractAlg)
368 return result
369
370# Run with python -m tauRec.TauConfig

◆ TauOutputCfg()

TauConfig.TauOutputCfg ( flags)

Definition at line 190 of file TauConfig.py.

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

◆ TauReconstructionCfg()

TauConfig.TauReconstructionCfg ( flags)

Definition at line 273 of file TauConfig.py.

273def TauReconstructionCfg(flags):
274
275 result = ComponentAccumulator()
276
277 #Check if the specific jet collection is needed based on flags
278 if flags.Tau.TauRec.SeedJetCollection in ["AntiKt4MLTopoJets",
279 "AntiKt4EMPFlowMLJets",
280 "AntiKt4EMPFlow10GeVCutTauSeedJets",
281 "AntiKt4EMPFlow5GeVCutTauSeedJets",
282 "AntiKt4EMPFlowNoPtCutTauSeedJets"]:
283 from JetRecConfig.JetRecConfig import JetRecCfg
284 from tauRec.ConfigurationHelpers import GetSeedCollection
285 seedJet = GetSeedCollection(flags)
286 result.merge(JetRecCfg(flags, seedJet))
287
288 # standard tau reconstruction
289 flags_TauRec = flags.cloneAndReplace("Tau.ActiveConfig", "Tau.TauRec")
290
291 result.merge(TauBuildAlgCfg(flags_TauRec))
292
293 result.merge(TauCaloAlgCfg(flags_TauRec))
294
295 result.merge(TauRunnerAlgCfg(flags_TauRec))
296
297 if (flags.Output.doWriteESD or flags.Output.doWriteAOD):
298 result.merge(TauOutputCfg(flags_TauRec))
299
300 if (flags.Output.doWriteAOD and flags.Tau.ThinTaus):
301 result.merge(TauxAODthinngCfg(flags_TauRec))
302
303 # electron-subtracted tau reconstruction
304 if flags.Tau.doTauEleRMRec:
305
306 flags_TauEleRM = flags.cloneAndReplace("Tau.ActiveConfig", "Tau.TauEleRM")
307
308 result.merge(TauElecSubtractAlgCfg(flags_TauEleRM))
309
310 # jet reclustering
311 from JetRecConfig.JetRecConfig import JetRecCfg
312 from tauRec.ConfigurationHelpers import GetEleRMSeedCollection
313 eleRMSeedJetCollection = GetEleRMSeedCollection(flags_TauEleRM)
314 result.merge( JetRecCfg(flags_TauEleRM, eleRMSeedJetCollection ))
315
316 result.merge(TauBuildAlgCfg(flags_TauEleRM))
317
318 result.merge(TauCaloAlgCfg(flags_TauEleRM))
319
320 result.merge(TauRunnerAlgCfg(flags_TauEleRM))
321
322 if (flags.Output.doWriteESD or flags.Output.doWriteAOD):
323 result.merge(TauOutputCfg(flags_TauEleRM))
324
325 if (flags.Output.doWriteAOD and flags.Tau.ThinTaus):
326 result.merge(TauxAODthinngCfg(flags_TauEleRM))
327
328 # had-had boosted ditaus
329 if flags.DiTau.doDiTauRec:
330 from DiTauRec.DiTauBuilderConfig import DiTauBuilderCfg
331 result.merge(DiTauBuilderCfg(flags))
332
333 if (flags.Output.doWriteESD or flags.Output.doWriteAOD):
334 result.merge(DiTauOutputCfg(flags))
335
336 return result
337
338

◆ TauRunnerAlgCfg()

TauConfig.TauRunnerAlgCfg ( flags)

Definition at line 116 of file TauConfig.py.

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

◆ TauxAODthinngCfg()

TauConfig.TauxAODthinngCfg ( flags)

Definition at line 253 of file TauConfig.py.

253def TauxAODthinngCfg(flags):
254
255 result = ComponentAccumulator()
256
257 tauThinAlg = CompFactory.TauThinningAlg(name = flags.Tau.ActiveConfig.prefix+"TauThinningAlg",
258 Taus = flags.Tau.ActiveConfig.TauJets,
259 TauTracks = flags.Tau.ActiveConfig.TauTracks,
260 TauNeutralPFOs = flags.Tau.ActiveConfig.TauNeutralPFOs,
261 TauPi0Clusters = flags.Tau.ActiveConfig.TauPi0Clusters,
262 TauPi0CellLinks = flags.Tau.ActiveConfig.TauPi0ClustersLinks,
263 TauFinalPi0s = flags.Tau.ActiveConfig.TauFinalPi0s,
264 TauShotPFOs = flags.Tau.ActiveConfig.TauShotPFOs,
265 TauShotClusters = flags.Tau.ActiveConfig.TauShotClusters,
266 TauShotCellLinks = flags.Tau.ActiveConfig.TauShotClustersLinks,
267 TauHadronicPFOs = flags.Tau.ActiveConfig.TauHadronicPFOs,
268 TauSecondaryVertices = flags.Tau.ActiveConfig.TauSecondaryVertices)
269 result.addEventAlgo(tauThinAlg)
270 return result
271
272
Generated on for ATLAS Offline Software by doxygen 1.14.0