Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
TauConfig.py
Go to the documentation of this file.
1 # Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
2 
3 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
4 from AthenaConfiguration.ComponentFactory import CompFactory
5 from AthenaConfiguration.Enums import BeamType, LHCPeriod
6 
7 
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 
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 
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 
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 
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 
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 
257 def TauReconstructionCfg(flags):
258 
259  result = ComponentAccumulator()
260 
261  # Schedule the custom jets needed for tau seeding
262  from JetRecConfig.JetRecConfig import JetRecCfg
263  from JetRecConfig.StandardJetConstits import stdConstitDic as cst
264  from JetRecConfig.JetDefinition import JetDefinition
265  from JetRecConfig.StandardSmallRJets import flavourghosts, calibmods_noCut, standardmods, truthmods
266  minimalghosts = ["Track","MuonSegment","Truth"]
267 
268  #Check if the specific jet collection is needed based on flags
269  if flags.Tau.TauRec.SeedJetCollection == "AntiKt4EMPFlow10GeVCutTauSeedJets":
270  AntiKt4EMPFlow10GeVCutTauSeed = JetDefinition("AntiKt",0.4,cst.GPFlow,
271  infix = "10GeVCutTauSeed",
272  ghostdefs = minimalghosts+flavourghosts,
273  modifiers = calibmods_noCut+("Filter:1",)+truthmods+standardmods+("JetPtAssociation","CaloEnergiesClus"),
274  ptmin = 10000.,
275  lock = True)
276  result.merge(JetRecCfg(flags, AntiKt4EMPFlow10GeVCutTauSeed))
277  if flags.Tau.TauRec.SeedJetCollection == "AntiKt4EMPFlow5GeVCutTauSeedJets":
278  AntiKt4EMPFlow5GeVCutTauSeed = JetDefinition("AntiKt",0.4,cst.GPFlow,
279  infix = "5GeVCutTauSeed",
280  ghostdefs = minimalghosts+flavourghosts,
281  modifiers = calibmods_noCut+("Filter:1",)+truthmods+standardmods+("JetPtAssociation","CaloEnergiesClus"),
282  ptmin = 5000.,
283  lock = True)
284  result.merge(JetRecCfg(flags, AntiKt4EMPFlow5GeVCutTauSeed))
285  if flags.Tau.TauRec.SeedJetCollection == "AntiKt4EMPFlowNoPtCutTauSeedJets":
286  AntiKt4EMPFlowNoPtCutTauSeed = JetDefinition("AntiKt",0.4,cst.GPFlow,
287  infix = "NoPtCutTauSeed",
288  ghostdefs = minimalghosts+flavourghosts,
289  modifiers = calibmods_noCut+("Filter:1",)+truthmods+standardmods+("JetPtAssociation","CaloEnergiesClus"),
290  ptmin = 1,
291  lock = True)
292  result.merge(JetRecCfg(flags, AntiKt4EMPFlowNoPtCutTauSeed))
293  # --- > End of Schedule the custom jets needed for tau seeding < ---
294 
295 
296  # standard tau reconstruction
297  flags_TauRec = flags.cloneAndReplace("Tau.ActiveConfig", "Tau.TauRec")
298 
299  result.merge(TauBuildAlgCfg(flags_TauRec))
300 
301  result.merge(TauCaloAlgCfg(flags_TauRec))
302 
303  result.merge(TauRunnerAlgCfg(flags_TauRec))
304 
305  if (flags.Output.doWriteESD or flags.Output.doWriteAOD):
306  result.merge(TauOutputCfg(flags_TauRec))
307 
308  if (flags.Output.doWriteAOD and flags.Tau.ThinTaus):
309  result.merge(TauxAODthinngCfg(flags_TauRec))
310 
311  # electron-subtracted tau reconstruction
312  if flags.Tau.doTauEleRMRec:
313 
314  flags_TauEleRM = flags.cloneAndReplace("Tau.ActiveConfig", "Tau.TauEleRM")
315 
316  result.merge(TauElecSubtractAlgCfg(flags_TauEleRM))
317 
318  # jet reclustering
319  from JetRecConfig.JetRecConfig import JetRecCfg
320  from JetRecConfig.StandardSmallRJets import AntiKt4LCTopo
321  AntiKt4LCTopo_EleRM = AntiKt4LCTopo.clone(suffix="_EleRM")
322  AntiKt4LCTopo_EleRM.inputdef.name = flags_TauEleRM.Tau.ActiveConfig.LCTopoOrigin_EleRM
323  AntiKt4LCTopo_EleRM.inputdef.inputname = flags_TauEleRM.Tau.ActiveConfig.CaloCalTopoClusters_EleRM
324  AntiKt4LCTopo_EleRM.inputdef.containername = flags_TauEleRM.Tau.ActiveConfig.LCOriginTopoClusters_EleRM
325  AntiKt4LCTopo_EleRM.standardRecoMode = True
326  AntiKt4LCTopo_EleRM.context = "EleRM"
327 
328  result.merge(JetRecCfg(flags_TauEleRM, AntiKt4LCTopo_EleRM))
329 
330  result.merge(TauBuildAlgCfg(flags_TauEleRM))
331 
332  result.merge(TauCaloAlgCfg(flags_TauEleRM))
333 
334  result.merge(TauRunnerAlgCfg(flags_TauEleRM))
335 
336  if (flags.Output.doWriteESD or flags.Output.doWriteAOD):
337  result.merge(TauOutputCfg(flags_TauEleRM))
338 
339  if (flags.Output.doWriteAOD and flags.Tau.ThinTaus):
340  result.merge(TauxAODthinngCfg(flags_TauEleRM))
341 
342  # had-had boosted ditaus
343  if flags.Tau.doDiTauRec:
344  from DiTauRec.DiTauBuilderConfig import DiTauBuilderCfg
345  result.merge(DiTauBuilderCfg(flags))
346 
347  if (flags.Output.doWriteESD or flags.Output.doWriteAOD):
348  result.merge(DiTauOutputCfg(flags))
349 
350  return result
351 
352 
353 def TauElecSubtractAlgCfg(flags):
354 
355  result = ComponentAccumulator()
356 
357  from ElectronPhotonSelectorTools.AsgElectronLikelihoodToolsConfig import AsgElectronLikelihoodToolCfg
358  from ElectronPhotonSelectorTools.LikelihoodEnums import LikeEnum
359  from ElectronPhotonSelectorTools.ElectronLikelihoodToolMapping import electronLHmenu
360  ElectronLHSelectorEleRM = result.popToolsAndMerge(
361  AsgElectronLikelihoodToolCfg(
362  flags,
363  name = flags.Tau.ActiveConfig.prefix+"ElectronLHSelector",
364  quality = getattr(LikeEnum, flags.Tau.ActiveConfig.EleRM_ElectronWorkingPoint),
365  menu = electronLHmenu.offlineMC21,
366  )
367  )
368 
369  tauElecSubtractAlg = CompFactory.TauElecSubtractAlg(
370  name = flags.Tau.ActiveConfig.prefix+"TauElecSubtractAlg",
371  Key_ElectronsInput = 'Electrons',
372  Key_ClustersInput = 'CaloCalTopoClusters',
373  Key_ClustersOutput = flags.Tau.ActiveConfig.CaloCalTopoClusters_EleRM,
374  Key_IDTracksInput = 'InDetTrackParticles',
375  Key_IDTracksOutput = flags.Tau.ActiveConfig.TrackCollection,
376  Key_RemovedClustersOutput = flags.Tau.ActiveConfig.RemovedElectronClusters,
377  Key_RemovedTracksOutput = flags.Tau.ActiveConfig.RemovedElectronTracks,
378  ElectronLHTool = ElectronLHSelectorEleRM,
379  doNothing = False,
380  )
381  result.addEventAlgo(tauElecSubtractAlg)
382  return result
383 
384 # Run with python -m tauRec.TauConfig
385 def TauConfigTest(flags=None):
386 
387  if flags is None:
388  from AthenaConfiguration.AllConfigFlags import initConfigFlags
389  from AthenaConfiguration.TestDefaults import defaultTestFiles, defaultConditionsTags
390 
391  flags = initConfigFlags()
392 
393  flags.Input.Files = defaultTestFiles.RDO_RUN3
394  flags.IOVDb.GlobalTag = defaultConditionsTags.RUN3_MC
395 
396  flags.Output.AODFileName = "AOD.pool.root"
397  flags.Exec.MaxEvents = 50
398 
399  flags.Scheduler.ShowDataDeps = True
400  flags.Scheduler.ShowDataFlow = True
401  flags.Scheduler.ShowControlFlow = True
402 
403  flags.Concurrency.NumThreads = 1
404  flags.Concurrency.NumConcurrentEvents = 1
405 
406  from tauRec.ConfigurationHelpers import StandaloneTauRecoFlags
407  StandaloneTauRecoFlags(flags)
408 
409  flags.lock()
410 
411  from RecJobTransforms.RecoSteering import RecoSteering
412  cfg = RecoSteering(flags)
413 
414  from RecJobTransforms.RecoConfigFlags import printRecoFlags
415  printRecoFlags(flags)
416 
417  cfg.run()
418 
419 
420 if __name__=="__main__":
421  TauConfigTest()
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
DiTauBuilderConfig.DiTauBuilderCfg
def DiTauBuilderCfg(flags, name="DiTauBuilder", doLowPt=False, **kwargs)
Definition: DiTauBuilderConfig.py:6
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:353
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:385
TauProcessorAlg
Definition: TauProcessorAlg.h:37
python.AllConfigFlags.initConfigFlags
def initConfigFlags()
Definition: AllConfigFlags.py:19
python.OutputStreamConfig.addToAOD
def addToAOD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:149
Generated on Thu May 22 2025 21:18:59 for ATLAS Offline Software by   doxygen 1.8.18