ATLAS Offline Software
Functions | Variables
HLTSeedingConfig Namespace Reference

Functions

def mapThresholdToL1DecisionCollection (threshold)
 
def mapThresholdToL1RoICollection (threshold)
 
def createLegacyCaloRoIUnpackers (flags)
 
def createCaloRoIUnpackers (flags)
 
def createLegacyMuonRoIUnpackers (flags)
 
def createMuonRoIUnpackers (flags)
 
def createPrescalingTool (flags)
 
def createKeyWriterTool ()
 
def L1TriggerResultMakerCfg (flags)
 
def HLTSeedingCfg (flags, seqName=None)
 

Variables

 log
 
 _mapL1ThresholdToDecisionCollection
 
 _mapL1ThresholdToRoICollection
 
 flags
 
 forceEnableAllChains
 
 Files
 
 AtlasVersion
 
 acc
 

Function Documentation

◆ createCaloRoIUnpackers()

def HLTSeedingConfig.createCaloRoIUnpackers (   flags)

Definition at line 126 of file HLTSeedingConfig.py.

126 def createCaloRoIUnpackers(flags):
127  from HLTSeeding.HLTSeedingMonitoring import RoIsUnpackingMonitoring
128  tools = []
129 
130  if flags.Trigger.L1.doeFex:
131  maxRoICount_eFex = 150 # used for histogram range, 144 is the hardware limit
132  eFexEMUnpacker = CompFactory.eFexEMRoIsUnpackingTool(
133  Decisions = mapThresholdToL1DecisionCollection("eEM"),
134  DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEeEM"),
135  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("eEM")),
136  RoIHalfWidthEta = 0.2,
137  RoIHalfWidthPhi = 0.2,
138  MonTool = RoIsUnpackingMonitoring(flags, prefix="eEM", maxCount=maxRoICount_eFex, maxEta=2.5))
139  eFexTauUnpacker = CompFactory.eFexTauRoIsUnpackingTool(
140  Decisions = mapThresholdToL1DecisionCollection("eTAU"),
141  DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEeTAU"),
142  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("eTAU")),
143  RoIHalfWidthEta = 0.4,
144  RoIHalfWidthPhi = math.pi/8,
145  MonTool = RoIsUnpackingMonitoring(flags, prefix="eTAU", maxCount=maxRoICount_eFex, maxEta=2.5))
146  tools += [eFexEMUnpacker, eFexTauUnpacker]
147 
148  if flags.Trigger.L1.dojFex:
149  maxRoICount_jFex = 200 # used for histogram range
150  jFexEMUnpacker = CompFactory.jFexFwdElRoIsUnpackingTool(
151  Decisions = mapThresholdToL1DecisionCollection("jEM"),
152  DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEjEM"),
153  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("jEM")),
154  RoIHalfWidthEta = 0.4,
155  RoIHalfWidthPhi = math.pi/8,
156  MonTool = RoIsUnpackingMonitoring(flags, prefix="jEM", maxCount=maxRoICount_jFex))
157  jFexTauUnpacker = CompFactory.jFexTauRoIsUnpackingTool(
158  Decisions = mapThresholdToL1DecisionCollection("jTAU"),
159  DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEjTAU"),
160  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("jTAU")),
161  RoIHalfWidthEta = 0.4,
162  RoIHalfWidthPhi = math.pi/8,
163  MonTool = RoIsUnpackingMonitoring(flags, prefix="jTAU", maxCount=maxRoICount_jFex))
164  jFexSRJetUnpacker = CompFactory.jFexSRJetRoIsUnpackingTool(
165  Decisions = mapThresholdToL1DecisionCollection("jJ"),
166  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("jJ")),
167  RoIHalfWidthEta = 0.1,
168  RoIHalfWidthPhi = 0.1,
169  MonTool = RoIsUnpackingMonitoring(flags, prefix="jJ", maxCount=maxRoICount_jFex, maxEta=5))
170  jFexLRJetUnpacker = CompFactory.jFexLRJetRoIsUnpackingTool(
171  Decisions = mapThresholdToL1DecisionCollection("jLJ"),
172  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("jLJ")),
173  RoIHalfWidthEta = 0.1,
174  RoIHalfWidthPhi = 0.1,
175  MonTool = RoIsUnpackingMonitoring(flags, prefix="jLJ", maxCount=maxRoICount_jFex, maxEta=5))
176  tools += [jFexEMUnpacker, jFexTauUnpacker, jFexSRJetUnpacker, jFexLRJetUnpacker]
177 
178  if flags.Trigger.L1.dogFex:
179  maxRoICount_gFex = 100 # used for histogram range
180  gFexSRJetUnpacker = CompFactory.gFexSRJetRoIsUnpackingTool(
181  Decisions = mapThresholdToL1DecisionCollection("gJ"),
182  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("gJ")),
183  RoIHalfWidthEta = 0.1,
184  RoIHalfWidthPhi = 0.1,
185  MonTool = RoIsUnpackingMonitoring(flags, prefix="gJ", maxCount=maxRoICount_gFex, maxEta=5))
186  gFexLRJetUnpacker = CompFactory.gFexLRJetRoIsUnpackingTool(
187  Decisions = mapThresholdToL1DecisionCollection("gLJ"),
188  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("gLJ")),
189  RoIHalfWidthEta = 0.1,
190  RoIHalfWidthPhi = 0.1,
191  MonTool = RoIsUnpackingMonitoring(flags, prefix="gLJ", maxCount=maxRoICount_gFex, maxEta=5))
192  tools += [gFexSRJetUnpacker, gFexLRJetUnpacker]
193 
194  # Need both eFex and jFex for cTAU
195  if flags.Trigger.L1.doeFex and flags.Trigger.L1.dojFex:
196  maxRoICount_eFex = 150 # used for histogram range
197  cTauUnpacker = CompFactory.cTauRoIsUnpackingTool(
198  Decisions = mapThresholdToL1DecisionCollection("cTAU"),
199  DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEcTAU"),
200  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("cTAU")),
201  RoIHalfWidthEta = 0.4,
202  RoIHalfWidthPhi = math.pi/8,
203  MonTool = RoIsUnpackingMonitoring(flags, prefix="cTAU", maxCount=maxRoICount_eFex))
204  tools += [cTauUnpacker]
205 
206  return tools
207 

◆ createKeyWriterTool()

def HLTSeedingConfig.createKeyWriterTool ( )

Definition at line 235 of file HLTSeedingConfig.py.

235 def createKeyWriterTool():
236  keyWriter = CompFactory.getComp('TrigConf::KeyWriterTool')('KeyWriterToolOnline')
237  keyWriter.ConfKeys = 'TrigConfKeysOnline'
238  keyWriter.IncludeL1PrescaleKey = False
239  keyWriter.IncludeBunchgroupKey = False
240  return keyWriter
241 

◆ createLegacyCaloRoIUnpackers()

def HLTSeedingConfig.createLegacyCaloRoIUnpackers (   flags)

Definition at line 103 of file HLTSeedingConfig.py.

103 def createLegacyCaloRoIUnpackers(flags):
104  from HLTSeeding.HLTSeedingMonitoring import RoIsUnpackingMonitoring
105  emUnpacker = CompFactory.EMRoIsUnpackingTool(Decisions = mapThresholdToL1DecisionCollection("EM"),
106  DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEEM"),
107  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("EM")),
108  MonTool = RoIsUnpackingMonitoring( flags, prefix="EM", maxCount=30, etaOffset=0.05, phiOffset=math.pi/64., maxEta=2.5 ))
109 
110  metUnpacker = CompFactory.METRoIsUnpackingTool(Decisions = mapThresholdToL1DecisionCollection("XE"))
111 
112 
113  tauUnpacker = CompFactory.TAURoIsUnpackingTool(Decisions = mapThresholdToL1DecisionCollection("TAU"),
114  DecisionsProbe = mapThresholdToL1DecisionCollection("PROBETAU"),
115  OutputTrigRoIs = recordable("HLT_TAURoI"))
116 
117  tauUnpacker.MonTool = RoIsUnpackingMonitoring( flags, prefix="TAU", maxCount=30, etaOffset=0.05, phiOffset=math.pi/64., maxEta=2.5 )
118 
119  jUnpacker = CompFactory.JRoIsUnpackingTool(Decisions = mapThresholdToL1DecisionCollection("J"),
120  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("J")) )
121 
122  jUnpacker.MonTool = RoIsUnpackingMonitoring( flags, prefix="J", maxCount=30, maxEta=5 )
123 
124  return [emUnpacker, metUnpacker, tauUnpacker, jUnpacker ]
125 

◆ createLegacyMuonRoIUnpackers()

def HLTSeedingConfig.createLegacyMuonRoIUnpackers (   flags)

Definition at line 208 of file HLTSeedingConfig.py.

208 def createLegacyMuonRoIUnpackers(flags):
209  from HLTSeeding.HLTSeedingMonitoring import RoIsUnpackingMonitoring
210  muUnpacker = CompFactory.MURoIsUnpackingTool(
211  Decisions = mapThresholdToL1DecisionCollection("MU"),
212  DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEMU"),
213  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("MU")),
214  MonTool = RoIsUnpackingMonitoring(flags, prefix="MU", maxCount=20))
215 
216  return [muUnpacker]
217 

◆ createMuonRoIUnpackers()

def HLTSeedingConfig.createMuonRoIUnpackers (   flags)

Definition at line 218 of file HLTSeedingConfig.py.

218 def createMuonRoIUnpackers(flags):
219  from HLTSeeding.HLTSeedingMonitoring import RoIsUnpackingMonitoring
220  muUnpacker = CompFactory.MuonRoIsUnpackingTool(
221  Decisions = mapThresholdToL1DecisionCollection("MU"),
222  DecisionsProbe = mapThresholdToL1DecisionCollection("PROBEMU"),
223  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("MU")),
224  RoIHalfWidthEta = 0.1,
225  RoIHalfWidthPhi = 0.1,
226  MonTool = RoIsUnpackingMonitoring(flags, prefix="MU", maxCount=20))
227  return [muUnpacker]
228 

◆ createPrescalingTool()

def HLTSeedingConfig.createPrescalingTool (   flags)

Definition at line 229 of file HLTSeedingConfig.py.

229 def createPrescalingTool(flags):
230  from HLTSeeding.HLTSeedingMonitoring import PrescalingMonitoring
231 
232  prescaler = CompFactory.PrescalingTool(MonTool = PrescalingMonitoring(flags))
233  return prescaler
234 

◆ HLTSeedingCfg()

def HLTSeedingConfig.HLTSeedingCfg (   flags,
  seqName = None 
)

Definition at line 309 of file HLTSeedingConfig.py.

309 def HLTSeedingCfg(flags, seqName = None):
310  if seqName:
311  from AthenaCommon.CFElements import parOR
312  acc = ComponentAccumulator(sequence=parOR(seqName)) # TODO - once rec-ex-common JO are phased out this can also be dropped
313  else:
314  acc = ComponentAccumulator()
315 
316  from HLTSeeding.HLTSeedingMonitoring import CTPUnpackingMonitoring, L1DataConsistencyMonitoring
317  decoderAlg = CompFactory.HLTSeeding(
318  RoIBResult = "RoIBResult" if flags.Trigger.enableL1CaloLegacy or not flags.Trigger.enableL1MuonPhase1 else "",
319  L1TriggerResult = "L1TriggerResult" if flags.Trigger.enableL1MuonPhase1 or flags.Trigger.enableL1CaloPhase1 else "",
320  HLTSeedingSummaryKey = "HLTSeedingSummary", # Transient, consumed by DecisionSummaryMakerAlg
321  ctpUnpacker = CompFactory.CTPUnpackingTool( ForceEnableAllChains = flags.Trigger.forceEnableAllChains,
322  MonTool = CTPUnpackingMonitoring(flags, 512, 400) )
323  )
324 
325  # Add L1DataConsistencyChecker unless we forceEnableAllChains which always results in missing TOBs
326  if not flags.Trigger.forceEnableAllChains:
327  def checkConsistency(thrName):
328  '''Filter out threshold types for which HLT doesn't read TOBs from L1 readout'''
329  return thrName not in ['FSNOSEED','TE','XE','XS'] and not thrName.startswith('PROBE')
330 
331  decoderAlg.L1DataConsistencyChecker = CompFactory.L1DataConsistencyChecker(
332  ThresholdToDecisionMap = dict([(k,v) for k,v in _mapL1ThresholdToDecisionCollection.items() if checkConsistency(k)]),
333  MonTool = L1DataConsistencyMonitoring(flags),
334  ErrorOnMissingTOB = flags.Trigger.L1.errorOnMissingTOB )
335 
336  #Transient bytestream
337  from AthenaConfiguration.Enums import Format
338  if flags.Input.Format is Format.POOL:
339  transTypeKey = ("TransientBSOutType","StoreGateSvc+TransientBSOutKey")
340  decoderAlg.ExtraInputs.add(transTypeKey)
341 
342  decoderAlg.RoIBRoIUnpackers += [
343  CompFactory.FSRoIsUnpackingTool("FSRoIsUnpackingTool", Decisions=mapThresholdToL1DecisionCollection("FSNOSEED"),
344  OutputTrigRoIs = recordable(mapThresholdToL1RoICollection("FSNOSEED")) ) ]
345 
346  if flags.Trigger.L1.doCalo:
347  if flags.Trigger.enableL1CaloPhase1:
348  decoderAlg.xAODRoIUnpackers += createCaloRoIUnpackers(flags)
349  if flags.Trigger.enableL1CaloLegacy:
350  decoderAlg.RoIBRoIUnpackers += createLegacyCaloRoIUnpackers(flags)
351 
352  if flags.Trigger.L1.doMuon:
353  if flags.Trigger.enableL1MuonPhase1:
354  decoderAlg.xAODRoIUnpackers += createMuonRoIUnpackers(flags)
355  else:
356  decoderAlg.RoIBRoIUnpackers += createLegacyMuonRoIUnpackers(flags)
357 
358  decoderAlg.prescaler = createPrescalingTool(flags)
359  decoderAlg.KeyWriterTool = createKeyWriterTool()
360  decoderAlg.DoCostMonitoring = flags.Trigger.CostMonitoring.doCostMonitoring
361  decoderAlg.CostMonitoringChain = flags.Trigger.CostMonitoring.chain
362  decoderAlg.RoiZedWidthDefault = flags.Trigger.InDetTracking.RoiZedWidthDefault
363 
364  if flags.Input.Format is Format.BS and not flags.Trigger.doLVL1:
365  # Add the algorithm decoding ByteStream into xAOD (Run-3 L1) and/or RoIBResult (legacy L1)
366  from TrigT1ResultByteStream.TrigT1ResultByteStreamConfig import L1TriggerByteStreamDecoderCfg
367  acc.merge( L1TriggerByteStreamDecoderCfg(flags), sequenceName = seqName )
368 
369  # Add the algorithm creating L1TriggerResult which is the input to HLTSeeding (Run-3 L1)
370  if flags.Trigger.enableL1MuonPhase1 or flags.Trigger.enableL1CaloPhase1:
371  acc.merge( L1TriggerResultMakerCfg(flags), sequenceName = seqName )
372 
373  acc.addEventAlgo( decoderAlg, sequenceName = seqName )
374 
375  from TrigConfigSvc.TrigConfigSvcCfg import TrigConfigSvcCfg, HLTPrescaleCondAlgCfg
376  acc.merge( TrigConfigSvcCfg( flags ) )
377  acc.merge( HLTPrescaleCondAlgCfg( flags ) )
378 
379  # Configure ROB prefetching from initial RoIs
380  from TriggerJobOpts.TriggerConfigFlags import ROBPrefetching
381  if ROBPrefetching.InitialRoI in flags.Trigger.ROBPrefetchingOptions:
382  allDecisionsSet = set()
383  for roiUnpacker in decoderAlg.RoIBRoIUnpackers + decoderAlg.xAODRoIUnpackers:
384  dec = str(roiUnpacker.Decisions)
385  if dec:
386  allDecisionsSet.add(dec)
387  allDecisions = sorted(list(allDecisionsSet))
388  from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Si, ROBPrefetchingAlgCfg_Calo, ROBPrefetchingAlgCfg_Muon
389  acc.merge(ROBPrefetchingAlgCfg_Si(flags, "initialRoI", RoILinkName="initialRoI", ROBPrefetchingInputDecisions=allDecisions), sequenceName=seqName)
390  acc.merge(ROBPrefetchingAlgCfg_Calo(flags,"initialRoI", RoILinkName="initialRoI", ROBPrefetchingInputDecisions=allDecisions), sequenceName=seqName)
391  acc.merge(ROBPrefetchingAlgCfg_Muon(flags,"initialRoI", RoILinkName="initialRoI", ROBPrefetchingInputDecisions=allDecisions), sequenceName=seqName)
392 
393  return acc
394 
395 

◆ L1TriggerResultMakerCfg()

def HLTSeedingConfig.L1TriggerResultMakerCfg (   flags)

Definition at line 242 of file HLTSeedingConfig.py.

242 def L1TriggerResultMakerCfg(flags):
243  acc = ComponentAccumulator()
244 
245  # Reset properties to empty by default and fill based on flags below
246  l1trMaker = CompFactory.L1TriggerResultMaker(
247  MuRoIKey = "",
248  eFexEMRoIKey = "",
249  eFexTauRoIKey = "",
250  jFexFwdElRoIKey = "",
251  jFexTauRoIKey = "",
252  jFexSRJetRoIKey = "",
253  jFexLRJetRoIKey = "",
254  gFexSRJetRoIKey = "",
255  gFexLRJetRoIKey = "",
256  cTauRoIKey = "",
257  cjTauLinkKey = "",
258  ThresholdPatternTools = [] )
259 
260  # Muon RoIs
261  if flags.Trigger.L1.doMuon and flags.Trigger.enableL1MuonPhase1:
262  l1trMaker.MuRoIKey = "LVL1MuonRoIs"
263  from TrigT1MuctpiPhase1.TrigT1MuctpiPhase1Config import TrigThresholdDecisionToolCfg
264  l1trMaker.ThresholdPatternTools += [acc.popToolsAndMerge(TrigThresholdDecisionToolCfg(flags))]
265 
266  # L1Calo RoIs
267  if flags.Trigger.L1.doCalo and flags.Trigger.enableL1CaloPhase1:
268  if flags.Trigger.L1.doeFex:
269  l1trMaker.eFexEMRoIKey = "L1_eEMRoI"
270  l1trMaker.eFexTauRoIKey = "L1_eTauRoI"
271  l1trMaker.ThresholdPatternTools += [
272  CompFactory.eFexEMRoIThresholdsTool(),
273  CompFactory.eFexTauRoIThresholdsTool(),
274  ]
275  if flags.Trigger.L1.dojFex:
276  l1trMaker.jFexFwdElRoIKey = "L1_jFexFwdElRoI"
277  l1trMaker.jFexTauRoIKey = "L1_jFexTauRoI"
278  l1trMaker.jFexSRJetRoIKey = "L1_jFexSRJetRoI"
279  l1trMaker.jFexLRJetRoIKey = "L1_jFexLRJetRoI"
280  l1trMaker.ThresholdPatternTools += [
281  CompFactory.jFexFwdElRoIThresholdsTool(),
282  CompFactory.jFexTauRoIThresholdsTool(),
283  CompFactory.jFexSRJetRoIThresholdsTool(),
284  CompFactory.jFexLRJetRoIThresholdsTool(),
285  ]
286  if flags.Trigger.L1.dogFex:
287  l1trMaker.gFexSRJetRoIKey = "L1_gFexSRJetRoI"
288  l1trMaker.gFexLRJetRoIKey = "L1_gFexLRJetRoI"
289  l1trMaker.ThresholdPatternTools += [
290  CompFactory.gFexSRJetRoIThresholdsTool(),
291  CompFactory.gFexLRJetRoIThresholdsTool(),
292  ]
293  # Need both eFex and jFex for cTAU
294  if flags.Trigger.L1.doeFex and flags.Trigger.L1.dojFex:
295  l1trMaker.cTauRoIKey = "L1_cTauRoI" # Note: WriteHandle
296  l1trMaker.cjTauLinkKey = "L1_cTauRoI.jTauLink" # Note: WriteDecorHandle
297  l1trMaker.ThresholdPatternTools += [
298  CompFactory.cTauRoIThresholdsTool(),
299  ]
300 
301  # Placeholder for other L1 xAOD outputs:
302  # - CTP result
303  # - L1Topo result
304 
305  acc.addEventAlgo(l1trMaker, primary=True)
306  return acc
307 
308 

◆ mapThresholdToL1DecisionCollection()

def HLTSeedingConfig.mapThresholdToL1DecisionCollection (   threshold) 
Translates L1 threshold  name of the DecisionsContainer name in the HLTSeeding unpacking tools

Definition at line 79 of file HLTSeedingConfig.py.

79 def mapThresholdToL1DecisionCollection(threshold):
80  """
81  Translates L1 threshold name of the DecisionsContainer name in the HLTSeeding unpacking tools
82  """
83  # remove actual threshold value from L1 threshold string
84  for (thresholdType, l1Collection) in _mapL1ThresholdToDecisionCollection.items():
85  if threshold.startswith( thresholdType ):
86  return l1Collection
87 
88  log.error("Threshold \""+ threshold + "\" not mapped to any Decision collection! Available are: " + str(_mapL1ThresholdToDecisionCollection.values()))
89 
90 

◆ mapThresholdToL1RoICollection()

def HLTSeedingConfig.mapThresholdToL1RoICollection (   threshold) 
Translates L1 threshold  name of the RoIDescriptor name in the HLTSeeding unpacking tools

Definition at line 91 of file HLTSeedingConfig.py.

91 def mapThresholdToL1RoICollection(threshold):
92  """
93  Translates L1 threshold name of the RoIDescriptor name in the HLTSeeding unpacking tools
94  """
95  # remove actual threshold value from L1 threshold string
96  for (thresholdType, l1Collection) in _mapL1ThresholdToRoICollection.items():
97  if threshold.startswith( thresholdType ):
98  return l1Collection
99 
100  log.error("Threshold \""+ threshold + "\" not mapped to any ROI collection! Available are: " + str(_mapL1ThresholdToRoICollection.values()))
101 
102 

Variable Documentation

◆ _mapL1ThresholdToDecisionCollection

HLTSeedingConfig._mapL1ThresholdToDecisionCollection
private

Definition at line 14 of file HLTSeedingConfig.py.

◆ _mapL1ThresholdToRoICollection

HLTSeedingConfig._mapL1ThresholdToRoICollection
private

Definition at line 46 of file HLTSeedingConfig.py.

◆ acc

HLTSeedingConfig.acc

Definition at line 405 of file HLTSeedingConfig.py.

◆ AtlasVersion

HLTSeedingConfig.AtlasVersion

Definition at line 403 of file HLTSeedingConfig.py.

◆ Files

HLTSeedingConfig.Files

Definition at line 401 of file HLTSeedingConfig.py.

◆ flags

HLTSeedingConfig.flags

Definition at line 399 of file HLTSeedingConfig.py.

◆ forceEnableAllChains

HLTSeedingConfig.forceEnableAllChains

Definition at line 400 of file HLTSeedingConfig.py.

◆ log

HLTSeedingConfig.log

Definition at line 12 of file HLTSeedingConfig.py.

HLTSeedingConfig.createCaloRoIUnpackers
def createCaloRoIUnpackers(flags)
Definition: HLTSeedingConfig.py:126
python.TrigConfigSvcCfg.TrigConfigSvcCfg
def TrigConfigSvcCfg(flags)
Definition: TrigConfigSvcCfg.py:263
python.TrigT1MuctpiPhase1Config.TrigThresholdDecisionToolCfg
def TrigThresholdDecisionToolCfg(flags, name="TrigThresholdDecisionTool")
Definition: TrigT1MuctpiPhase1Config.py:9
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
HLTSeedingMonitoring.RoIsUnpackingMonitoring
def RoIsUnpackingMonitoring(flags, prefix, maxCount, maxEta=3., phiOffset=0., etaOffset=0.)
Definition: HLTSeedingMonitoring.py:18
python.TrigGenericAlgsConfig.ROBPrefetchingAlgCfg_Muon
def ROBPrefetchingAlgCfg_Muon(flags, nameSuffix, **kwargs)
Definition: TrigGenericAlgsConfig.py:63
HLTSeedingMonitoring.L1DataConsistencyMonitoring
def L1DataConsistencyMonitoring(flags)
Definition: HLTSeedingMonitoring.py:46
HLTSeedingMonitoring.PrescalingMonitoring
def PrescalingMonitoring(flags)
Definition: HLTSeedingMonitoring.py:34
python.TrigGenericAlgsConfig.ROBPrefetchingAlgCfg_Calo
def ROBPrefetchingAlgCfg_Calo(flags, nameSuffix, **kwargs)
Definition: TrigGenericAlgsConfig.py:60
python.TrigConfigSvcCfg.HLTPrescaleCondAlgCfg
def HLTPrescaleCondAlgCfg(flags)
Definition: TrigConfigSvcCfg.py:329
python.JetAnalysisCommon.parOR
parOR
Definition: JetAnalysisCommon.py:271
HLTSeedingConfig.createLegacyCaloRoIUnpackers
def createLegacyCaloRoIUnpackers(flags)
Definition: HLTSeedingConfig.py:103
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
DerivationFramework::TriggerMatchingUtils::sorted
std::vector< typename T::value_type > sorted(T begin, T end)
Helper function to create a sorted vector from an unsorted one.
HLTSeedingConfig.createLegacyMuonRoIUnpackers
def createLegacyMuonRoIUnpackers(flags)
Definition: HLTSeedingConfig.py:208
CxxUtils::set
constexpr std::enable_if_t< is_bitmask_v< E >, E & > set(E &lhs, E rhs)
Convenience function to set bits in a class enum bitmask.
Definition: bitmask.h:232
HLTSeedingMonitoring.CTPUnpackingMonitoring
def CTPUnpackingMonitoring(flags, maxItems, maxChains)
Definition: HLTSeedingMonitoring.py:8
python.TrigGenericAlgsConfig.ROBPrefetchingAlgCfg_Si
def ROBPrefetchingAlgCfg_Si(flags, nameSuffix, **kwargs)
Definition: TrigGenericAlgsConfig.py:57
HLTSeedingConfig.L1TriggerResultMakerCfg
def L1TriggerResultMakerCfg(flags)
Definition: HLTSeedingConfig.py:242
HLTSeedingConfig.createKeyWriterTool
def createKeyWriterTool()
Definition: HLTSeedingConfig.py:235
HLTSeedingConfig.createMuonRoIUnpackers
def createMuonRoIUnpackers(flags)
Definition: HLTSeedingConfig.py:218
HLTSeedingConfig.mapThresholdToL1RoICollection
def mapThresholdToL1RoICollection(threshold)
Definition: HLTSeedingConfig.py:91
python.TriggerEDM.recordable
def recordable(arg, runVersion=3)
Definition: TriggerEDM.py:34
str
Definition: BTagTrackIpAccessor.cxx:11
TrigT1ResultByteStreamConfig.L1TriggerByteStreamDecoderCfg
def L1TriggerByteStreamDecoderCfg(flags, returnEDM=False)
Definition: TrigT1ResultByteStreamConfig.py:132
HLTSeedingConfig.createPrescalingTool
def createPrescalingTool(flags)
Definition: HLTSeedingConfig.py:229
HLTSeedingConfig.mapThresholdToL1DecisionCollection
def mapThresholdToL1DecisionCollection(threshold)
Definition: HLTSeedingConfig.py:79
HLTSeedingConfig.HLTSeedingCfg
def HLTSeedingCfg(flags, seqName=None)
Definition: HLTSeedingConfig.py:309
Generated on Sun Dec 22 2024 22:00:12 for ATLAS Offline Software by   doxygen 1.8.18