Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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 224 of file TauConfig.py.

224 def DiTauOutputCfg(flags):
225 
226  from OutputStreamAthenaPool.OutputStreamConfig import addToESD,addToAOD
227  result=ComponentAccumulator()
228 
229  DiTauOutputList = [ "xAOD::DiTauJetContainer#DiTauJets" ]
230  DiTauOutputList += [ "xAOD::DiTauJetAuxContainer#DiTauJetsAux." ]
231 
232  result.merge(addToESD(flags,DiTauOutputList))
233  result.merge(addToAOD(flags,DiTauOutputList))
234  return result
235 
236 

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

350 def TauConfigTest(flags=None):
351 
352  if flags is None:
353  from AthenaConfiguration.AllConfigFlags import initConfigFlags
354  from AthenaConfiguration.TestDefaults import defaultTestFiles, defaultConditionsTags
355 
356  flags = initConfigFlags()
357 
358  flags.Input.Files = defaultTestFiles.RDO_RUN3
359  flags.IOVDb.GlobalTag = defaultConditionsTags.RUN3_MC
360 
361  flags.Output.AODFileName = "AOD.pool.root"
362  flags.Exec.MaxEvents = 50
363 
364  flags.Scheduler.ShowDataDeps = True
365  flags.Scheduler.ShowDataFlow = True
366  flags.Scheduler.ShowControlFlow = True
367 
368  flags.Concurrency.NumThreads = 1
369  flags.Concurrency.NumConcurrentEvents = 1
370 
371  from tauRec.ConfigurationHelpers import StandaloneTauRecoFlags
372  StandaloneTauRecoFlags(flags)
373 
374  flags.lock()
375 
376  from RecJobTransforms.RecoSteering import RecoSteering
377  cfg = RecoSteering(flags)
378 
379  from RecJobTransforms.RecoConfigFlags import printRecoFlags
380  printRecoFlags(flags)
381 
382  cfg.run()
383 

◆ TauElecSubtractAlgCfg()

def TauConfig.TauElecSubtractAlgCfg (   flags)

Definition at line 318 of file TauConfig.py.

318 def TauElecSubtractAlgCfg(flags):
319 
320  result = ComponentAccumulator()
321 
322  from ElectronPhotonSelectorTools.AsgElectronLikelihoodToolsConfig import AsgElectronLikelihoodToolCfg
323  from ElectronPhotonSelectorTools.LikelihoodEnums import LikeEnum
324  from ElectronPhotonSelectorTools.ElectronLikelihoodToolMapping import electronLHmenu
325  ElectronLHSelectorEleRM = result.popToolsAndMerge(
326  AsgElectronLikelihoodToolCfg(
327  flags,
328  name = flags.Tau.ActiveConfig.prefix+"ElectronLHSelector",
329  quality = getattr(LikeEnum, flags.Tau.ActiveConfig.EleRM_ElectronWorkingPoint),
330  menu = electronLHmenu.offlineMC21,
331  )
332  )
333 
334  tauElecSubtractAlg = CompFactory.TauElecSubtractAlg(
335  name = flags.Tau.ActiveConfig.prefix+"TauElecSubtractAlg",
336  Key_ElectronsInput = 'Electrons',
337  Key_ClustersInput = 'CaloCalTopoClusters',
338  Key_ClustersOutput = flags.Tau.ActiveConfig.CaloCalTopoClusters_EleRM,
339  Key_IDTracksInput = 'InDetTrackParticles',
340  Key_IDTracksOutput = flags.Tau.ActiveConfig.TrackCollection,
341  Key_RemovedClustersOutput = flags.Tau.ActiveConfig.RemovedElectronClusters,
342  Key_RemovedTracksOutput = flags.Tau.ActiveConfig.RemovedElectronTracks,
343  ElectronLHTool = ElectronLHSelectorEleRM,
344  doNothing = False,
345  )
346  result.addEventAlgo(tauElecSubtractAlg)
347  return result
348 
349 # Run with python -m tauRec.TauConfig

◆ TauOutputCfg()

def TauConfig.TauOutputCfg (   flags)

Definition at line 179 of file TauConfig.py.

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

◆ TauReconstructionCfg()

def TauConfig.TauReconstructionCfg (   flags)

Definition at line 257 of file TauConfig.py.

257 def TauReconstructionCfg(flags):
258 
259  result = ComponentAccumulator()
260 
261  # standard tau reconstruction
262  flags_TauRec = flags.cloneAndReplace("Tau.ActiveConfig", "Tau.TauRec")
263 
264  result.merge(TauBuildAlgCfg(flags_TauRec))
265 
266  result.merge(TauCaloAlgCfg(flags_TauRec))
267 
268  result.merge(TauRunnerAlgCfg(flags_TauRec))
269 
270  if (flags.Output.doWriteESD or flags.Output.doWriteAOD):
271  result.merge(TauOutputCfg(flags_TauRec))
272 
273  if (flags.Output.doWriteAOD and flags.Tau.ThinTaus):
274  result.merge(TauxAODthinngCfg(flags_TauRec))
275 
276  # electron-subtracted tau reconstruction
277  if flags.Tau.doTauEleRMRec:
278 
279  flags_TauEleRM = flags.cloneAndReplace("Tau.ActiveConfig", "Tau.TauEleRM")
280 
281  result.merge(TauElecSubtractAlgCfg(flags_TauEleRM))
282 
283  # jet reclustering
284  from JetRecConfig.JetRecConfig import JetRecCfg
285  from JetRecConfig.StandardSmallRJets import AntiKt4LCTopo
286  AntiKt4LCTopo_EleRM = AntiKt4LCTopo.clone(suffix="_EleRM")
287  AntiKt4LCTopo_EleRM.inputdef.name = flags_TauEleRM.Tau.ActiveConfig.LCTopoOrigin_EleRM
288  AntiKt4LCTopo_EleRM.inputdef.inputname = flags_TauEleRM.Tau.ActiveConfig.CaloCalTopoClusters_EleRM
289  AntiKt4LCTopo_EleRM.inputdef.containername = flags_TauEleRM.Tau.ActiveConfig.LCOriginTopoClusters_EleRM
290  AntiKt4LCTopo_EleRM.standardRecoMode = True
291  AntiKt4LCTopo_EleRM.context = "EleRM"
292 
293  result.merge(JetRecCfg(flags_TauEleRM, AntiKt4LCTopo_EleRM))
294 
295  result.merge(TauBuildAlgCfg(flags_TauEleRM))
296 
297  result.merge(TauCaloAlgCfg(flags_TauEleRM))
298 
299  result.merge(TauRunnerAlgCfg(flags_TauEleRM))
300 
301  if (flags.Output.doWriteESD or flags.Output.doWriteAOD):
302  result.merge(TauOutputCfg(flags_TauEleRM))
303 
304  if (flags.Output.doWriteAOD and flags.Tau.ThinTaus):
305  result.merge(TauxAODthinngCfg(flags_TauEleRM))
306 
307  # had-had boosted ditaus
308  if flags.Tau.doDiTauRec:
309  from DiTauRec.DiTauBuilderConfig import DiTauBuilderCfg
310  result.merge(DiTauBuilderCfg(flags))
311 
312  if (flags.Output.doWriteESD or flags.Output.doWriteAOD):
313  result.merge(DiTauOutputCfg(flags))
314 
315  return result
316 
317 

◆ 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 
163  TauRunnerAlg = CompFactory.getComp("TauRunnerAlg")
164  RunnerAlg = TauRunnerAlg(name = flags.Tau.ActiveConfig.prefix+"TauRecRunnerAlg",
165  Key_tauInputContainer = flags.Tau.ActiveConfig.TauJets_tmp,
166  Key_Pi0ClusterInputContainer = flags.Tau.ActiveConfig.TauPi0Clusters,
167  Key_tauOutputContainer = flags.Tau.ActiveConfig.TauJets,
168  Key_neutralPFOOutputContainer = flags.Tau.ActiveConfig.TauNeutralPFOs,
169  Key_hadronicPFOOutputContainer = flags.Tau.ActiveConfig.TauHadronicPFOs,
170  Key_chargedPFOOutputContainer = flags.Tau.ActiveConfig.TauChargedPFOs,
171  Key_vertexOutputContainer = flags.Tau.ActiveConfig.TauSecondaryVertices,
172  Key_pi0Container = flags.Tau.ActiveConfig.TauFinalPi0s,
173  Tools = tools)
174 
175  result.addEventAlgo(RunnerAlg)
176  return result
177 
178 

◆ TauxAODthinngCfg()

def TauConfig.TauxAODthinngCfg (   flags)

Definition at line 237 of file TauConfig.py.

237 def TauxAODthinngCfg(flags):
238 
239  result = ComponentAccumulator()
240 
241  tauThinAlg = CompFactory.TauThinningAlg(name = flags.Tau.ActiveConfig.prefix+"TauThinningAlg",
242  Taus = flags.Tau.ActiveConfig.TauJets,
243  TauTracks = flags.Tau.ActiveConfig.TauTracks,
244  TauNeutralPFOs = flags.Tau.ActiveConfig.TauNeutralPFOs,
245  TauPi0Clusters = flags.Tau.ActiveConfig.TauPi0Clusters,
246  TauPi0CellLinks = flags.Tau.ActiveConfig.TauPi0ClustersLinks,
247  TauFinalPi0s = flags.Tau.ActiveConfig.TauFinalPi0s,
248  TauShotPFOs = flags.Tau.ActiveConfig.TauShotPFOs,
249  TauShotClusters = flags.Tau.ActiveConfig.TauShotClusters,
250  TauShotCellLinks = flags.Tau.ActiveConfig.TauShotClustersLinks,
251  TauHadronicPFOs = flags.Tau.ActiveConfig.TauHadronicPFOs,
252  TauSecondaryVertices = flags.Tau.ActiveConfig.TauSecondaryVertices)
253  result.addEventAlgo(tauThinAlg)
254  return result
255 
256 
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
TauConfig.TauOutputCfg
def TauOutputCfg(flags)
Definition: TauConfig.py:179
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:237
TauConfig.TauReconstructionCfg
def TauReconstructionCfg(flags)
Definition: TauConfig.py:257
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:318
TauConfig.DiTauOutputCfg
def DiTauOutputCfg(flags)
Definition: TauConfig.py:224
python.OutputStreamConfig.addToESD
def addToESD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:134
TauConfig.TauConfigTest
def TauConfigTest(flags=None)
Definition: TauConfig.py:350
TauProcessorAlg
Definition: TauProcessorAlg.h:37
DiTauBuilderConfig.DiTauBuilderCfg
def DiTauBuilderCfg(flags, name="DiTauBuilder", **kwargs)
Definition: DiTauBuilderConfig.py:6
python.AllConfigFlags.initConfigFlags
def initConfigFlags()
Definition: AllConfigFlags.py:19
python.OutputStreamConfig.addToAOD
def addToAOD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:149
Generated on Thu Apr 17 2025 22:01:59 for ATLAS Offline Software by   doxygen 1.8.18