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

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

◆ 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.doCellWeightCalib:
107  CaloTopoForTausMaker.ClusterCorrectionTools += [result.popToolsAndMerge(tauTools.TauCaloClusterCellWeightCalibCfg(flags))]
108 
109  if flags.Calo.TopoCluster.doTopoClusterLocalCalib:
110  CaloTopoForTausMaker.ClusterCorrectionTools += [result.popToolsAndMerge(tauTools.TauCaloClusterLocalCalibCfg(flags)),
111  result.popToolsAndMerge(tauTools.TauCaloOOCCalibCfg(flags)),
112  result.popToolsAndMerge(tauTools.TauCaloOOCPi0CalibCfg(flags)),
113  result.popToolsAndMerge(tauTools.TauCaloDMCalibCfg(flags))]
114 
115  result.addEventAlgo(CaloTopoForTausMaker)
116 
117  relinkAlg = CompFactory.ClusterCellRelinkAlg(name = flags.Tau.ActiveConfig.prefix+'ClusterCellRelinkAlg',
118  Cells = 'AllCalo',
119  ClustersInput = flags.Tau.ActiveConfig.TauPi0Clusters_tmp,
120  ClustersOutput = flags.Tau.ActiveConfig.TauPi0Clusters,
121  CellLinksOutput = flags.Tau.ActiveConfig.TauPi0ClustersLinks)
122  result.addEventAlgo(relinkAlg)
123  return result
124 
125 

◆ TauConfigTest()

def TauConfig.TauConfigTest (   flags = None)

Definition at line 354 of file TauConfig.py.

354 def TauConfigTest(flags=None):
355 
356  if flags is None:
357  from AthenaConfiguration.AllConfigFlags import initConfigFlags
358  flags = initConfigFlags()
359 
360  # Needs to be fixed to use latest ESDs, see ATLASRECTS-8112
361  #from AthenaConfiguration.TestDefaults import defaultTestFiles, defaultConditionsTags
362  #flags.Input.Files = defaultTestFiles.LATEST_ESD_MC
363  #flags.IOVDb.GlobalTag = defaultConditionsTags.LATEST_MC
364 
365  flags.Input.Files = ["/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/RecExRecoTest/mc21_13p6TeV/ESDFiles/mc21_13p6TeV.421450.PhPy8EG_A14_ttbar_hdamp258p75_SingleLep_fct.recon.ESD.e8445_e8447_s3822_r13565/ESD.28877240._000046.pool.root.1"]
366  flags.IOVDb.GlobalTag = "OFLCOND-MC21-SDR-RUN3-10"
367 
368  flags.Output.ESDFileName = "ESD.pool.root"
369  flags.Output.AODFileName = "AOD.pool.root"
370  flags.Exec.MaxEvents = 10
371 
372  flags.Scheduler.ShowDataDeps = True
373  flags.Scheduler.ShowDataFlow = True
374  flags.Scheduler.ShowControlFlow = True
375 
376  #TODO Update once new jet flags are available
377  # from JetRec.JetRecFlags import jetFlags
378  # if not jetFlags.useTracks():
379  # flags.Tau.doTJVA = False # switch off TJVA
380 
381  flags.fillFromArgs()
382 
383  flags.Concurrency.NumThreads = 1
384  flags.Concurrency.NumConcurrentEvents = 1
385 
386  flags.lock()
387 
388  from AthenaConfiguration.MainServicesConfig import MainServicesCfg
389  cfg = MainServicesCfg(flags)
390 
391  from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
392  cfg.merge(PoolReadCfg(flags))
393 
394  # this delcares to the scheduler that EventInfo object comes from the input
395  loadFromSG = [('xAOD::EventInfo', 'StoreGateSvc+EventInfo'),
396  ( 'AthenaAttributeList' , 'StoreGateSvc+Input' ),
397  ( 'CaloCellContainer' , 'StoreGateSvc+AllCalo' )]
398  cfg.addEventAlgo(CompFactory.SGInputLoader(Load=loadFromSG), sequenceName="AthAlgSeq")
399 
400  cfg.merge(TauReconstructionCfg(flags))
401 
402  from SGComps.AddressRemappingConfig import AddressRemappingCfg
403  rename_maps = [ '%s#%s->%s' % ("xAOD::TauJetContainer", "TauJets", "old_TauJets"),
404  '%s#%s->%s' % ("xAOD::TauJetAuxContainer", "TauJetsAux.", "old_TauJetsAux.")]
405  cfg.merge( AddressRemappingCfg(rename_maps) )
406 
407  cfg.run()
408 

◆ TauElecSubtractAlgCfg()

def TauConfig.TauElecSubtractAlgCfg (   flags)

Definition at line 322 of file TauConfig.py.

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

◆ TauOutputCfg()

def TauConfig.TauOutputCfg (   flags)

Definition at line 182 of file TauConfig.py.

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

◆ TauReconstructionCfg()

def TauConfig.TauReconstructionCfg (   flags)

Definition at line 261 of file TauConfig.py.

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

◆ TauRunnerAlgCfg()

def TauConfig.TauRunnerAlgCfg (   flags)

Definition at line 126 of file TauConfig.py.

126 def TauRunnerAlgCfg(flags):
127 
128  result=ComponentAccumulator()
129 
130  # get tools from holder
131  import tauRec.TauToolHolder as tauTools
132 
133  tools = []
134 
135  tools.append( result.popToolsAndMerge(tauTools.Pi0ClusterCreatorCfg(flags)) )
136  tools.append( result.popToolsAndMerge(tauTools.Pi0ClusterScalerCfg(flags)) )
137  tools.append( result.popToolsAndMerge(tauTools.Pi0ScoreCalculatorCfg(flags)) )
138  tools.append( result.popToolsAndMerge(tauTools.Pi0SelectorCfg(flags)) )
139 
140  if flags.Tau.isStandalone or flags.Tracking.doVertexFinding:
141  tools.append(result.popToolsAndMerge(tauTools.TauVertexVariablesCfg(flags)) )
142 
143  tools.append( result.popToolsAndMerge(tauTools.TauCommonCalcVarsCfg(flags)) )
144  tools.append( result.popToolsAndMerge(tauTools.TauSubstructureCfg(flags)) )
145 
146  if flags.Tau.doPanTau:
147  import PanTauAlgs.JobOptions_Main_PanTau_New as pantau
148  tools.append( result.popToolsAndMerge(pantau.PanTauCfg(flags)) )
149 
150  tools.append(result.popToolsAndMerge(tauTools.TauCombinedTESCfg(flags)) )
151  # these tools need pantau info
152  if flags.Beam.Type is not BeamType.Cosmics:
153  tools.append( result.popToolsAndMerge(tauTools.MvaTESVariableDecoratorCfg(flags)) )
154  tools.append( result.popToolsAndMerge(tauTools.MvaTESEvaluatorCfg(flags)) )
155 
156  tools.append( result.popToolsAndMerge(tauTools.TauAODSelectorCfg(flags)) )
157 
158  if flags.Tau.doTauDiscriminant:
159  tools.append( result.popToolsAndMerge(tauTools.TauIDVarCalculatorCfg(flags)) )
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 
166  TauRunnerAlg = CompFactory.getComp("TauRunnerAlg")
167  RunnerAlg = TauRunnerAlg(name = flags.Tau.ActiveConfig.prefix+"TauRecRunnerAlg",
168  Key_tauInputContainer = flags.Tau.ActiveConfig.TauJets_tmp,
169  Key_Pi0ClusterInputContainer = flags.Tau.ActiveConfig.TauPi0Clusters,
170  Key_tauOutputContainer = flags.Tau.ActiveConfig.TauJets,
171  Key_neutralPFOOutputContainer = flags.Tau.ActiveConfig.TauNeutralPFOs,
172  Key_hadronicPFOOutputContainer = flags.Tau.ActiveConfig.TauHadronicPFOs,
173  Key_chargedPFOOutputContainer = flags.Tau.ActiveConfig.TauChargedPFOs,
174  Key_vertexOutputContainer = flags.Tau.ActiveConfig.TauSecondaryVertices,
175  Key_pi0Container = flags.Tau.ActiveConfig.TauFinalPi0s,
176  Tools = tools)
177 
178  result.addEventAlgo(RunnerAlg)
179  return result
180 
181 

◆ TauxAODthinngCfg()

def TauConfig.TauxAODthinngCfg (   flags)

Definition at line 241 of file TauConfig.py.

241 def TauxAODthinngCfg(flags):
242 
243  result = ComponentAccumulator()
244 
245  tauThinAlg = CompFactory.TauThinningAlg(name = flags.Tau.ActiveConfig.prefix+"TauThinningAlg",
246  Taus = flags.Tau.ActiveConfig.TauJets,
247  TauTracks = flags.Tau.ActiveConfig.TauTracks,
248  TauNeutralPFOs = flags.Tau.ActiveConfig.TauNeutralPFOs,
249  TauPi0Clusters = flags.Tau.ActiveConfig.TauPi0Clusters,
250  TauPi0CellLinks = flags.Tau.ActiveConfig.TauPi0ClustersLinks,
251  TauFinalPi0s = flags.Tau.ActiveConfig.TauFinalPi0s,
252  TauShotPFOs = flags.Tau.ActiveConfig.TauShotPFOs,
253  TauShotClusters = flags.Tau.ActiveConfig.TauShotClusters,
254  TauShotCellLinks = flags.Tau.ActiveConfig.TauShotClustersLinks,
255  TauHadronicPFOs = flags.Tau.ActiveConfig.TauHadronicPFOs,
256  TauSecondaryVertices = flags.Tau.ActiveConfig.TauSecondaryVertices)
257  result.addEventAlgo(tauThinAlg)
258  return result
259 
260 
python.CaloTopoClusterConfig.caloTopoCoolFolderCfg
def caloTopoCoolFolderCfg(flags)
Definition: CaloTopoClusterConfig.py:7
AddressRemappingConfig.AddressRemappingCfg
def AddressRemappingCfg(renameMaps=[], overwriteMaps=[])
Definition: AddressRemappingConfig.py:10
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:182
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
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:241
TauConfig.TauReconstructionCfg
def TauReconstructionCfg(flags)
Definition: TauConfig.py:261
python.TileBadChannelsConfig.TileBadChannelsCondAlgCfg
def TileBadChannelsCondAlgCfg(flags, **kwargs)
Definition: TileBadChannelsConfig.py:10
TauConfig.TauRunnerAlgCfg
def TauRunnerAlgCfg(flags)
Definition: TauConfig.py:126
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
python.MainServicesConfig.MainServicesCfg
def MainServicesCfg(flags, LoopMgr='AthenaEventLoopMgr')
Definition: MainServicesConfig.py:260
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
TauConfig.TauElecSubtractAlgCfg
def TauElecSubtractAlgCfg(flags)
Definition: TauConfig.py:322
TauConfig.DiTauOutputCfg
def DiTauOutputCfg(flags)
Definition: TauConfig.py:228
python.OutputStreamConfig.addToESD
def addToESD(flags, itemOrList, **kwargs)
Definition: OutputStreamConfig.py:127
TauConfig.TauConfigTest
def TauConfigTest(flags=None)
Definition: TauConfig.py:354
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:142
python.PoolReadConfig.PoolReadCfg
def PoolReadCfg(flags)
Definition: PoolReadConfig.py:69
Generated on Thu Nov 7 2024 22:26:17 for ATLAS Offline Software by   doxygen 1.8.18