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)
 TauLRTReconstructionCfg (flags)
 TauElecSubtractAlgCfg (flags)
 TauConfigTest (flags=None)

Function Documentation

◆ DiTauOutputCfg()

DiTauOutputCfg ( flags)

Definition at line 241 of file TauConfig.py.

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

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 # track to calo extrapolation
40 tools.append( result.popToolsAndMerge(tauTools.TauTrackCaloExtrapolatorCfg(flags)) )
41
42 # cluster association + vertex correction
43 tools.append( result.popToolsAndMerge(tauTools.TauClusterFinderCfg(flags)) )
44 tools.append( result.popToolsAndMerge(tauTools.TauVertexedClusterDecoratorCfg(flags)) )
45
46 # this needs to go before the TauCaloAlgCfg
47 tools.append( result.popToolsAndMerge(tauTools.Pi0ClusterFinderCfg(flags)) )
48
49 # TauBuilderAlg
50 TauBuilderAlg = CompFactory.getComp("TauBuilderAlg")
51 BuildAlg = TauBuilderAlg(name = flags.Tau.ActiveConfig.prefix+"TauCoreBuilderAlg",
52 Key_jetInputContainer = flags.Tau.ActiveConfig.SeedJetCollection,
53 Key_tauOutputContainer = flags.Tau.ActiveConfig.TauJets_tmp,
54 Key_tauTrackOutputContainer = flags.Tau.ActiveConfig.TauTracks,
55 Key_tauPi0CellOutputContainer = flags.Tau.ActiveConfig.TauCommonPi0Cells,
56 MaxEta = flags.Tau.SeedMaxEta,
57 MinPt = flags.Tau.SeedMinPt,
58 MaxNTracks = flags.Tau.MaxNTracks,
59 Tools = tools,
60 CellMakerTool = result.popToolsAndMerge(tauTools.TauCellFinalizerCfg(flags)))
61
62 if flags.GeoModel.Run is LHCPeriod.Run4:
63 BuildAlg.PixelDetEleCollKey="ITkPixelDetectorElementCollection"
64 BuildAlg.SCTDetEleCollKey="ITkStripDetectorElementCollection"
65 BuildAlg.TRTDetEleContKey=""
66
67 result.addEventAlgo(BuildAlg)
68 return result
69
70

◆ TauCaloAlgCfg()

TauCaloAlgCfg ( flags)

Definition at line 71 of file TauConfig.py.

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

◆ TauConfigTest()

TauConfigTest ( flags = None)

Definition at line 392 of file TauConfig.py.

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

◆ TauElecSubtractAlgCfg()

TauElecSubtractAlgCfg ( flags)

Definition at line 360 of file TauConfig.py.

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

◆ TauLRTReconstructionCfg()

TauLRTReconstructionCfg ( flags)

Definition at line 340 of file TauConfig.py.

340def TauLRTReconstructionCfg(flags):
341 result = ComponentAccumulator()
342
343 # standard tau reconstruction
344 flags_TauLRT = flags.cloneAndReplace("Tau.ActiveConfig", "Tau.TauLRT")
345
346 result.merge(TauBuildAlgCfg(flags_TauLRT))
347
348 result.merge(TauCaloAlgCfg(flags_TauLRT))
349
350 result.merge(TauRunnerAlgCfg(flags_TauLRT))
351
352 if (flags.Output.doWriteESD or flags.Output.doWriteAOD):
353 result.merge(TauOutputCfg(flags_TauLRT))
354
355 if (flags.Output.doWriteAOD and flags.Tau.ThinTaus):
356 result.merge(TauxAODthinngCfg(flags_TauLRT))
357
358 return result
359

◆ TauOutputCfg()

TauOutputCfg ( flags)

Definition at line 191 of file TauConfig.py.

191def 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.-shotCells.-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.-shotCells.-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()

TauReconstructionCfg ( flags)

Definition at line 275 of file TauConfig.py.

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

◆ TauRunnerAlgCfg()

TauRunnerAlgCfg ( flags)

Definition at line 119 of file TauConfig.py.

119def TauRunnerAlgCfg(flags):
120
121 result=ComponentAccumulator()
122
123 # get tools from holder
124 import tauRec.TauToolHolder as tauTools
125
126 tools = []
127 tools.append( result.popToolsAndMerge(tauTools.TauShotFinderCfg(flags)) )
128 tools.append( result.popToolsAndMerge(tauTools.Pi0ClusterCreatorCfg(flags)) )
129 tools.append( result.popToolsAndMerge(tauTools.Pi0ClusterScalerCfg(flags)) )
130 tools.append( result.popToolsAndMerge(tauTools.Pi0ScoreCalculatorCfg(flags)) )
131 tools.append( result.popToolsAndMerge(tauTools.Pi0SelectorCfg(flags)) )
132
133 if flags.Beam.Type is not BeamType.Cosmics:
134 tools.append( result.popToolsAndMerge(tauTools.EnergyCalibrationLCCfg(flags)) )
135
136 if flags.Tau.doPanTau:
137 import PanTauAlgs.JobOptions_Main_PanTau as pantau
138 tools.append( result.popToolsAndMerge(pantau.PanTauCfg(flags)) )
139
140 tools.append(result.popToolsAndMerge(tauTools.TauCombinedTESCfg(flags)) )
141
142 # this is scheduled here because it provides variables used in the MVATES evaluation
143 tools.append( result.popToolsAndMerge(tauTools.CellVariablesCfg(flags)) )
144 # these tools need pantau info
145 if flags.Beam.Type is not BeamType.Cosmics:
146 tools.append( result.popToolsAndMerge(tauTools.MvaTESVariableDecoratorCfg(flags)) )
147 tools.append( result.popToolsAndMerge(tauTools.MvaTESEvaluatorCfg(flags)) )
148
149 # apply pt cut
150 tools.append( result.popToolsAndMerge(tauTools.TauAODSelectorCfg(flags)) )
151
152 # do some extra variable calculation
153 if flags.Tau.isStandalone or flags.Tracking.doVertexFinding:
154 tools.append(result.popToolsAndMerge(tauTools.TauVertexVariablesCfg(flags)) )
155 tools.append( result.popToolsAndMerge(tauTools.ElectronVetoVarsCfg(flags)) )
156 tools.append( result.popToolsAndMerge(tauTools.TauCommonCalcVarsCfg(flags)) )
157 tools.append( result.popToolsAndMerge(tauTools.TauSubstructureCfg(flags)) )
158
159 if flags.Tau.doTauDiscriminant:
160 tools.append( result.popToolsAndMerge(tauTools.TauIDVarCalculatorCfg(flags)) )
161 # do not schedule eVeto for Run4
162 if flags.GeoModel.Run <= LHCPeriod.Run3:
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
TauRunnerAlg
Main class for tau candidate processing.
Definition TauRunnerAlg.h:31

◆ TauxAODthinngCfg()

TauxAODthinngCfg ( flags)

Definition at line 254 of file TauConfig.py.

254def 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 MinNeutralPFOPt = flags.Tau.MinNeutralPFOPt if flags.GeoModel.Run > LHCPeriod.Run3 else 0,)
271 result.addEventAlgo(tauThinAlg)
272 return result
273
274
Generated on for ATLAS Offline Software by doxygen 1.17.0