ATLAS Offline Software
MainServicesConfig.py
Go to the documentation of this file.
1 # Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
2 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
3 from AthenaConfiguration.ComponentFactory import CompFactory
4 from AthenaCommon.Constants import INFO
5 
6 
7 def MainServicesMiniCfg(flags, loopMgr='AthenaEventLoopMgr', masterSequence='AthAlgSeq'):
8  """Mininmal basic config, just good enough for HelloWorld and alike"""
9  cfg = ComponentAccumulator(CompFactory.AthSequencer(masterSequence,
10  Sequential=True,
11  TimeOut=flags.Exec.EventTimeOut))
12  cfg.setAsTopLevel()
13  cfg.setAppProperty('TopAlg',['AthSequencer/'+masterSequence])
14  cfg.setAppProperty('MessageSvcType', 'MessageSvc')
15  cfg.setAppProperty('EventLoop', loopMgr)
16  cfg.setAppProperty('ExtSvcCreates', 'False')
17  cfg.setAppProperty('JobOptionsSvcType', 'JobOptionsSvc')
18  cfg.setAppProperty('JobOptionsType', 'NONE')
19  cfg.setAppProperty('JobOptionsPostAction', '')
20  cfg.setAppProperty('JobOptionsPreAction', '')
21  cfg.setAppProperty('PrintAlgsSequence', flags.Exec.PrintAlgsSequence)
22  if flags.Debug.NameAuditor:
23  cfg.addAuditor(CompFactory.NameAuditor())
24  return cfg
25 
26 
27 def AvalancheSchedulerSvcCfg(flags, **kwargs):
28  kwargs.setdefault("CheckDependencies", flags.Scheduler.CheckDependencies)
29  kwargs.setdefault("CheckOutputUsage", flags.Scheduler.CheckOutputUsage)
30  kwargs.setdefault("ShowDataDependencies", flags.Scheduler.ShowDataDeps)
31  kwargs.setdefault("ShowDataFlow", flags.Scheduler.ShowDataFlow)
32  kwargs.setdefault("ShowControlFlow", flags.Scheduler.ShowControlFlow)
33  kwargs.setdefault("VerboseSubSlots", flags.Scheduler.EnableVerboseViews)
34  kwargs.setdefault("ThreadPoolSize", flags.Concurrency.NumThreads)
35  kwargs.setdefault("DataDepsGraphFile", flags.Scheduler.DataDepsGraphFile)
36  kwargs.setdefault("DataDepsGraphAlgPattern", flags.Scheduler.DataDepsGraphAlgPattern)
37  kwargs.setdefault("DataDepsGraphObjectPattern", flags.Scheduler.DataDepsGraphObjectPattern)
38  kwargs.setdefault("NumOffloadThreads", flags.Concurrency.NumOffloadThreads)
39 
40  cfg = ComponentAccumulator()
41  scheduler = CompFactory.AvalancheSchedulerSvc(**kwargs)
42  cfg.addService(scheduler, primary=True)
43 
44  from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
45  # FailIfNoProxy=False makes it a warning, not an error, if unmet data
46  # dependencies are not found in the store. It should probably be changed
47  # to True eventually.
48  inputloader_ca = SGInputLoaderCfg(flags, FailIfNoProxy=flags.Input.FailOnUnknownCollections)
49  cfg.merge(inputloader_ca, sequenceName="AthAlgSeq")
50 
51  # Specifying DataLoaderAlg makes the Scheduler automatically assign
52  # all unmet data dependencies to that algorithm.
53  if flags.Scheduler.AutoLoadUnmetDependencies:
54  scheduler.DataLoaderAlg = inputloader_ca.getPrimary().getName()
55 
56  return cfg
57 
58 
59 def OutputUsageIgnoreCfg(flags, algorithm):
60  cfg = ComponentAccumulator()
61  if flags.Concurrency.NumThreads > 0 and flags.Scheduler.CheckOutputUsage:
62  cfg.merge(AvalancheSchedulerSvcCfg(flags, CheckOutputUsageIgnoreList=[algorithm]))
63  return cfg
64 
65 
67  cfg = ComponentAccumulator()
68  elmgr = CompFactory.AthenaEventLoopMgr(EventPrintoutInterval = flags.Exec.EventPrintoutInterval)
69  if flags.Input.OverrideRunNumber:
70  from AthenaKernel.EventIdOverrideConfig import EvtIdModifierSvcCfg
71  elmgr.EvtIdModifierSvc = cfg.getPrimaryAndMerge( EvtIdModifierSvcCfg(flags) )
72 
73  if flags.Common.isOverlay:
74  if not flags.Overlay.DataOverlay:
75  elmgr.RequireInputAttributeList = True
76  elmgr.UseSecondaryEventNumber = True
77 
78  cfg.addService( elmgr )
79 
80  return cfg
81 
82 
84  """Sets up an MPIHive EventLoopMgr along with it's dependencies"""
85  from SQLiteDBSvc.SQLiteDBSvcConfig import SQLiteDBSvcCfg
86  cfg = ComponentAccumulator()
87  nConcurrentEvents = flags.Concurrency.NumConcurrentEvents
88  nThreads = flags.Concurrency.NumThreads
89 
90  hivesvc = CompFactory.SG.HiveMgrSvc("EventDataSvc", NSlots=nConcurrentEvents)
91  cfg.addService(hivesvc)
92 
93  arp = CompFactory.AlgResourcePool(
94  TopAlg=["AthMasterSeq"]
95  ) # this should enable control flow
96  cfg.addService(arp)
97 
98  scheduler = cfg.getPrimaryAndMerge(
99  AvalancheSchedulerSvcCfg(flags, ThreadPoolSize=nThreads)
100  )
101 
102  cfg.merge(SQLiteDBSvcCfg(flags, name="LogDBSvc", dbPath="mpilog.db"))
103  cfg.addService(CompFactory.MPIClusterSvc("ClusterSvc", LogDatabaseSvc="LogDBSvc"))
104  elmgr = CompFactory.MPIHiveEventLoopMgr(
105  MPIClusterSvc="ClusterSvc",
106  WhiteboardSvc="EventDataSvc",
107  SchedulerSvc=scheduler.getName(),
108  FirstEventIndex=flags.Exec.SkipEvents,
109  )
110 
111  from AthenaServices.OutputStreamSequencerSvcConfig import (
112  OutputStreamSequencerSvcCfg,
113  )
114 
115  cfg.merge(
117  flags, incidentName="BeginInputFile", reportingOn=False, replaceRangeMode=True
118  )
119  )
120  if flags.Input.OverrideRunNumber:
121  from AthenaKernel.EventIdOverrideConfig import EvtIdModifierSvcCfg
122 
123  elmgr.EvtIdModifierSvc = cfg.getPrimaryAndMerge(EvtIdModifierSvcCfg(flags)).name
124 
125  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
126  elmgr.RequireInputAttributeList = True
127  elmgr.UseSecondaryEventNumber = True
128 
129  cfg.addService(elmgr)
130 
131  return cfg
132 
134  cfg = ComponentAccumulator()
135  hivesvc = CompFactory.SG.HiveMgrSvc("EventDataSvc",
136  NSlots = flags.Concurrency.NumConcurrentEvents)
137  cfg.addService( hivesvc )
138 
139  arp = CompFactory.AlgResourcePool(TopAlg = ["AthMasterSeq"]) #this should enable control flow
140  cfg.addService( arp )
141 
142  scheduler = cfg.getPrimaryAndMerge(AvalancheSchedulerSvcCfg(flags))
143 
144  elmgr = CompFactory.AthenaHiveEventLoopMgr(
145  WhiteboardSvc = "EventDataSvc",
146  SchedulerSvc = scheduler.getName(),
147  EventPrintoutInterval = flags.Exec.EventPrintoutInterval)
148 
149  if flags.Input.OverrideRunNumber:
150  from AthenaKernel.EventIdOverrideConfig import EvtIdModifierSvcCfg
151  elmgr.EvtIdModifierSvc = cfg.getPrimaryAndMerge(EvtIdModifierSvcCfg(flags))
152 
153  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
154  elmgr.RequireInputAttributeList = True
155  elmgr.UseSecondaryEventNumber = True
156 
157  cfg.addService( elmgr )
158 
159  return cfg
160 
162  cfg = ComponentAccumulator()
163  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
164  elmgr = CompFactory.AthenaEventLoopMgr(EventPrintoutInterval = flags.Exec.EventPrintoutInterval)
165  elmgr.RequireInputAttributeList = True
166  elmgr.UseSecondaryEventNumber = True
167  cfg.addService( elmgr )
168 
169  from AthenaMP.AthenaMPConfig import AthenaMPCfg
170  mploop = AthenaMPCfg(flags)
171  cfg.merge( mploop )
172 
173  return cfg
174 
175 
176 def AthenaMtesEventLoopMgrCfg(flags, mtEs=False, channel=''):
177  cfg = ComponentAccumulator()
178 
179  hivesvc = CompFactory.SG.HiveMgrSvc("EventDataSvc",
180  NSlots = flags.Concurrency.NumConcurrentEvents)
181  cfg.addService( hivesvc )
182 
183  arp = CompFactory.AlgResourcePool(TopAlg = ["AthMasterSeq"]) #this should enable control flow
184  cfg.addService( arp )
185 
186  scheduler = cfg.getPrimaryAndMerge(AvalancheSchedulerSvcCfg(flags))
187 
188  elmgr = CompFactory.AthenaMtesEventLoopMgr(
189  WhiteboardSvc = "EventDataSvc",
190  SchedulerSvc = scheduler.getName(),
191  EventRangeChannel = channel,
192  EventPrintoutInterval = flags.Exec.EventPrintoutInterval)
193 
194  if flags.Input.OverrideRunNumber:
195  from AthenaKernel.EventIdOverrideConfig import EvtIdModifierSvcCfg
196  elmgr.EvtIdModifierSvc = cfg.getPrimaryAndMerge(EvtIdModifierSvcCfg(flags))
197 
198  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
199  elmgr.RequireInputAttributeList = True
200  elmgr.UseSecondaryEventNumber = True
201 
202  if mtEs:
203  from AthenaServices.OutputStreamSequencerSvcConfig import OutputStreamSequencerSvcCfg
204  cfg.merge(OutputStreamSequencerSvcCfg(flags,
205  incidentName="NextEventRange",
206  reportingOn = True))
207 
208  cfg.addService( elmgr )
209 
210  return cfg
211 
212 
213 def MessageSvcCfg(flags):
214  cfg = ComponentAccumulator()
215  msgsvc = CompFactory.MessageSvc()
216  msgsvc.OutputLevel = flags.Exec.OutputLevel
217  msgsvc.Format = "% F%{:d}W%C%7W%R%T %0W%M".format(flags.Common.MsgSourceLength)
218  msgsvc.enableSuppression = flags.Common.MsgSuppression
219  if flags.Common.ShowMsgStats:
220  msgsvc.showStats = True
221  from AthenaCommon.Constants import WARNING
222  msgsvc.statLevel = WARNING
223 
224  from AthenaConfiguration.Enums import ProductionStep
225  if flags.Common.ProductionStep not in [ProductionStep.Default, ProductionStep.Reconstruction, ProductionStep.Derivation]:
226  msgsvc.Format = "% F%18W%S%7W%R%T %0W%M" # Temporary to match legacy configuration for serial simulation/digitization/overlay jobs
227  if flags.Concurrency.NumThreads>0:
228  msgsvc.Format = "% F%{:d}W%C%6W%R%e%s%8W%R%T %0W%M".format(flags.Common.MsgSourceLength)
229  if flags.Exec.VerboseMessageComponents:
230  msgsvc.verboseLimit=0
231  if flags.Exec.DebugMessageComponents:
232  msgsvc.debugLimit=0
233  if flags.Exec.InfoMessageComponents:
234  msgsvc.infoLimit=0
235  if flags.Exec.WarningMessageComponents:
236  msgsvc.warningLimit=0
237  if flags.Exec.ErrorMessageComponents:
238  msgsvc.errorLimit=0
239 
240  cfg.addService(msgsvc)
241  return cfg
242 
243 
244 def addMainSequences(flags, cfg):
245  """Add the standard sequences to cfg"""
246 
247  # Build standard sequences:
248  AthSequencer = CompFactory.AthSequencer
249  cfg.addSequence(AthSequencer('AthAlgEvtSeq', Sequential=True, StopOverride=True), parentName='AthMasterSeq')
250  cfg.addSequence(AthSequencer('AthOutSeq', StopOverride=True), parentName='AthMasterSeq')
251 
252  cfg.addSequence(AthSequencer('AthBeginSeq', Sequential=True), parentName='AthAlgEvtSeq')
253  cfg.addSequence(AthSequencer('AthAllAlgSeq', StopOverride=True), parentName='AthAlgEvtSeq')
254 
255  athAlgSeq = AthSequencer('AthAlgSeq', IgnoreFilterPassed=True, StopOverride=True, ProcessDynamicDataDependencies=True, ExtraDataForDynamicConsumers=[])
256  athCondSeq = AthSequencer('AthCondSeq',StopOverride=True)
257 
258  if flags.Concurrency.NumThreads==0:
259  # For serial execution, we need the CondAlgs to execute first.
260  cfg.addSequence(athCondSeq, parentName='AthAllAlgSeq')
261  cfg.addSequence(athAlgSeq, parentName='AthAllAlgSeq')
262  else:
263  # In MT, the order of execution is irrelevant (determined by data deps).
264  # We add the conditions sequence later such that the CondInputLoader gets
265  # initialized after all other user Algorithms for MT, so the base classes
266  # of data deps can be correctly determined.
267  cfg.addSequence(athAlgSeq, parentName='AthAllAlgSeq')
268  cfg.addSequence(athCondSeq, parentName='AthAllAlgSeq')
269 
270  cfg.addSequence(AthSequencer('AthEndSeq', Sequential=True), parentName='AthAlgEvtSeq')
271 
272  # Set up incident firing:
273  AthIncFirerAlg = CompFactory.AthIncFirerAlg
274  IncidentProcAlg = CompFactory.IncidentProcAlg
275 
276  previousPerfmonDomain = cfg.getCurrentPerfmonDomain()
277  cfg.flagPerfmonDomain('Incidents')
278 
279  cfg.addEventAlgo(AthIncFirerAlg("BeginIncFiringAlg", FireSerial=False, Incidents=['BeginEvent']),
280  sequenceName='AthBeginSeq')
281 
282  cfg.addEventAlgo(IncidentProcAlg('IncidentProcAlg1'),
283  sequenceName='AthBeginSeq')
284 
285  cfg.addEventAlgo(AthIncFirerAlg('EndIncFiringAlg', FireSerial=False, Incidents=['EndEvent']),
286  sequenceName="AthEndSeq")
287 
288  cfg.addEventAlgo(IncidentProcAlg('IncidentProcAlg2'),
289  sequenceName="AthEndSeq")
290 
291  # Should be after all other algorithms:
292  cfg.addEventAlgo(AthIncFirerAlg('EndAlgorithmsFiringAlg', FireSerial=False, Incidents=['EndAlgorithms']),
293  sequenceName="AthMasterSeq")
294 
295  cfg.addEventAlgo(IncidentProcAlg('IncidentProcAlg3'),
296  sequenceName="AthMasterSeq")
297 
298  cfg.flagPerfmonDomain(previousPerfmonDomain)
299 
300 
301 def addEvgenSequences(flags, cfg):
302  from GeneratorConfig.Sequences import EvgenSequence, EvgenSequenceFactory
303  cfg.addSequence(EvgenSequenceFactory(EvgenSequence.Generator), parentName="AthAlgSeq")
304  cfg.addSequence(EvgenSequenceFactory(EvgenSequence.Fix), parentName="AthAlgSeq")
305  cfg.addSequence(EvgenSequenceFactory(EvgenSequence.PreFilter), parentName="AthAlgSeq")
306  cfg.addSequence(EvgenSequenceFactory(EvgenSequence.Test), parentName="AthAlgSeq")
307  # TODO: needs to setup proper filtering sequence
308  cfg.addSequence(EvgenSequenceFactory(EvgenSequence.Filter), parentName="AthAlgSeq")
309  cfg.addSequence(EvgenSequenceFactory(EvgenSequence.Post), parentName="AthAlgSeq")
310 
311 
312 def MainServicesCfg(flags, LoopMgr='AthenaEventLoopMgr'):
313  # Set the Python OutputLevel on the root logger
314  from AthenaCommon.Logging import log
315  log.setLevel(flags.Exec.OutputLevel)
316 
317  if flags.Exec.Interactive == "run":
318  LoopMgr="PyAthenaEventLoopMgr"
319  log.info("Interactive mode, switching to %s", LoopMgr)
320  else:
321  # Run a serial job for threads=0
322  if flags.Concurrency.NumThreads > 0:
323  if flags.Concurrency.NumConcurrentEvents==0:
324  raise Exception("Requested Concurrency.NumThreads>0 and Concurrency.NumConcurrentEvents==0, "
325  "which will not process events!")
326  if flags.Exec.MTEventService:
327  LoopMgr = "AthenaMtesEventLoopMgr"
328  elif flags.Exec.MPI:
329  LoopMgr = "MPIHiveEventLoopMgr"
330  else:
331  LoopMgr = "AthenaHiveEventLoopMgr"
332 
333  if flags.Concurrency.NumProcs > 0:
334  LoopMgr = "AthMpEvtLoopMgr"
335 
336  # Core components needed for serial and threaded jobs:
337  cfg = MainServicesMiniCfg(flags, loopMgr=LoopMgr, masterSequence='AthMasterSeq')
338 
339  # Main sequences and incident handling:
340  addMainSequences(flags, cfg)
341 
342  # Basic services:
343  cfg.addService(CompFactory.ClassIDSvc(CLIDDBFiles = ['clid.db','Gaudi_clid.db']))
344 
345  cfg.addService(CompFactory.AlgContextSvc(BypassIncidents=True))
346  cfg.addAuditor(CompFactory.AlgContextAuditor())
347 
348  cfg.addService(CompFactory.StoreGateSvc(Dump=flags.Debug.DumpEvtStore))
349  cfg.addService(CompFactory.StoreGateSvc("DetectorStore",Dump=flags.Debug.DumpDetStore))
350  cfg.addService(CompFactory.StoreGateSvc("HistoryStore"))
351  cfg.addService(CompFactory.StoreGateSvc("ConditionStore",Dump=flags.Debug.DumpCondStore))
352 
353  cfg.merge(MessageSvcCfg(flags))
354 
355  from AthenaConfiguration.FPEAndCoreDumpConfig import FPEAndCoreDumpCfg
356  cfg.merge(FPEAndCoreDumpCfg(flags))
357 
358  # Avoid stack traces to the exception handler. These traces
359  # aren't very useful since they just point to the handler, not
360  # the original bug.
361  cfg.addService(CompFactory.ExceptionSvc(Catch="NONE"))
362 
363  # ApplicationMgr properties:
364  cfg.setAppProperty('AuditAlgorithms', True)
365  cfg.setAppProperty('InitializationLoopCheck', False)
366  cfg.setAppProperty('EvtMax', flags.Exec.MaxEvents)
367  if flags.Exec.OutputLevel > INFO:
368  # this turns off the appMgr spalsh
369  cfg.setAppProperty('AppName', '')
370  cfg.setAppProperty('OutputLevel', flags.Exec.OutputLevel)
371 
372  if flags.Exec.DebugStage != "":
373  cfg.setDebugStage(flags.Exec.DebugStage)
374 
375  cfg.interactive=flags.Exec.Interactive
376 
377  if flags.Concurrency.NumProcs > 0:
378  cfg.merge(AthenaMpEventLoopMgrCfg(flags))
379 
380  # Additional components needed for threaded jobs only:
381  if flags.Concurrency.NumThreads > 0:
382  if flags.Exec.MTEventService:
383  cfg.merge(AthenaMtesEventLoopMgrCfg(flags,True,flags.Exec.MTEventServiceChannel))
384  elif flags.Exec.MPI:
385  cfg.merge(MPIHiveEventLoopMgrCfg(flags))
386  else:
387  cfg.merge(AthenaHiveEventLoopMgrCfg(flags))
388  # Setup SGCommitAuditor to sweep new DataObjects at end of Alg execute
389  cfg.addAuditor( CompFactory.SGCommitAuditor() )
390  elif LoopMgr == 'AthenaEventLoopMgr':
391  cfg.merge(AthenaEventLoopMgrCfg(flags))
392 
393  # Performance monitoring and profiling:
394  if flags.PerfMon.doFastMonMT or flags.PerfMon.doFullMonMT:
395  from PerfMonComps.PerfMonCompsConfig import PerfMonMTSvcCfg
396  cfg.merge(PerfMonMTSvcCfg(flags))
397 
398  if flags.PerfMon.doGPerfProf:
399  from PerfMonGPerfTools.GPT_ProfilerServiceConfig import GPT_ProfilerServiceCfg
400  cfg.merge(GPT_ProfilerServiceCfg(flags))
401 
402  if len(flags.PerfMon.Valgrind.ProfiledAlgs)>0:
403  from Valkyrie.ValkyrieConfig import ValgrindServiceCfg
404  cfg.merge(ValgrindServiceCfg(flags))
405 
406  return cfg
407 
408 
409 def MainEvgenServicesCfg(flags, LoopMgr="AthenaEventLoopMgr", withSequences=True):
410  """ComponentAccumulator-based equivalent of:
411  import AthenaCommon.AtlasUnixGeneratorJob
412 
413  NB Must have set flags.Input.RunNumbers and
414  flags.Input.TimeStamps before calling to avoid
415  attempted auto-configuration from an input file.
416  """
417  cfg = MainServicesCfg(flags, LoopMgr)
418  from McEventSelector.McEventSelectorConfig import McEventSelectorCfg
419  cfg.merge(McEventSelectorCfg(flags))
420 
421  if withSequences:
422  addEvgenSequences(flags, cfg)
423 
424  return cfg
425 
426 
427 def JobOptionsDumpCfg(flags, fileName="JobOptsConfig.txt"):
428  """Job options service configuration - mainly to dump the config."""
429  acc = ComponentAccumulator()
430  acc.addService(CompFactory.JobOptionsSvc(DUMPFILE=fileName))
431  return acc
432 
433 
434 if __name__=="__main__":
435  from AthenaConfiguration.AllConfigFlags import initConfigFlags
436  flags = initConfigFlags()
437  try:
438  flags.Input.RunNumbers = [284500] # Set to either MC DSID or MC Run Number
439  flags.Input.TimeStamps = [1] # dummy value
440  cfg = MainEvgenServicesCfg(flags, withSequences=True)
441  except ModuleNotFoundError:
442  # The McEventSelector package required by MainEvgenServicesCfg is not part of the AthAnalysis project
443  cfg = MainServicesCfg(flags)
444  cfg.wasMerged() # to avoid errror that CA was not merged
python.AthenaMPConfig.AthenaMPCfg
def AthenaMPCfg(flags)
Definition: AthenaMPConfig.py:49
python.Sequences.EvgenSequenceFactory
def EvgenSequenceFactory(sequence)
Definition: Sequences.py:17
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
AthSequencer
ClassName: AthSequencer.
Definition: AthSequencer.h:40
vtune_athena.format
format
Definition: vtune_athena.py:14
python.MainServicesConfig.OutputUsageIgnoreCfg
def OutputUsageIgnoreCfg(flags, algorithm)
Definition: MainServicesConfig.py:59
python.FPEAndCoreDumpConfig.FPEAndCoreDumpCfg
def FPEAndCoreDumpCfg(flags)
Definition: FPEAndCoreDumpConfig.py:11
python.PerfMonCompsConfig.PerfMonMTSvcCfg
def PerfMonMTSvcCfg(flags, **kwargs)
A minimal new-style configuration for PerfMonMTSvc.
Definition: PerfMonCompsConfig.py:10
dumpTruth.getName
getName
Definition: dumpTruth.py:34
python.MainServicesConfig.MessageSvcCfg
def MessageSvcCfg(flags)
Definition: MainServicesConfig.py:213
python.MainServicesConfig.MainEvgenServicesCfg
def MainEvgenServicesCfg(flags, LoopMgr="AthenaEventLoopMgr", withSequences=True)
Definition: MainServicesConfig.py:409
SGInputLoaderConfig.SGInputLoaderCfg
def SGInputLoaderCfg(flags, Load=None, **kwargs)
Definition: SGInputLoaderConfig.py:7
python.MainServicesConfig.addMainSequences
def addMainSequences(flags, cfg)
Definition: MainServicesConfig.py:244
python.MainServicesConfig.AthenaEventLoopMgrCfg
def AthenaEventLoopMgrCfg(flags)
Definition: MainServicesConfig.py:66
python.MainServicesConfig.addEvgenSequences
def addEvgenSequences(flags, cfg)
Definition: MainServicesConfig.py:301
GPT_ProfilerServiceConfig.GPT_ProfilerServiceCfg
def GPT_ProfilerServiceCfg(flags, **kwargs)
Definition: GPT_ProfilerServiceConfig.py:10
SQLiteDBSvcConfig.SQLiteDBSvcCfg
def SQLiteDBSvcCfg(flags, name="SQLiteDBSvc", dbPath=":memory:", **kwargs)
Definition: SQLiteDBSvcConfig.py:8
python.MainServicesConfig.MainServicesCfg
def MainServicesCfg(flags, LoopMgr='AthenaEventLoopMgr')
Definition: MainServicesConfig.py:312
Constants
some useful constants -------------------------------------------------—
python.McEventSelectorConfig.McEventSelectorCfg
def McEventSelectorCfg(flags, **kwargs)
Definition: McEventSelectorConfig.py:5
python.MainServicesConfig.AvalancheSchedulerSvcCfg
def AvalancheSchedulerSvcCfg(flags, **kwargs)
Definition: MainServicesConfig.py:27
python.MainServicesConfig.MPIHiveEventLoopMgrCfg
def MPIHiveEventLoopMgrCfg(flags)
Definition: MainServicesConfig.py:83
AthIncFirerAlg
Algorithm to fire given list of incidents on execute.
Definition: AthIncFirerAlg.h:23
python.ValkyrieConfig.ValgrindServiceCfg
def ValgrindServiceCfg(flags, **kwargs)
Definition: ValkyrieConfig.py:7
python.AllConfigFlags.initConfigFlags
def initConfigFlags()
Definition: AllConfigFlags.py:19
python.MainServicesConfig.AthenaMpEventLoopMgrCfg
def AthenaMpEventLoopMgrCfg(flags)
Definition: MainServicesConfig.py:161
python.OutputStreamSequencerSvcConfig.OutputStreamSequencerSvcCfg
def OutputStreamSequencerSvcCfg(flags, incidentName='', reportingOn=False, replaceRangeMode=False)
Definition: OutputStreamSequencerSvcConfig.py:6
python.MainServicesConfig.JobOptionsDumpCfg
def JobOptionsDumpCfg(flags, fileName="JobOptsConfig.txt")
Definition: MainServicesConfig.py:427
python.EventIdOverrideConfig.EvtIdModifierSvcCfg
def EvtIdModifierSvcCfg(flags, name="EvtIdModifierSvc", **kwargs)
Definition: EventIdOverrideConfig.py:140
python.MainServicesConfig.AthenaHiveEventLoopMgrCfg
def AthenaHiveEventLoopMgrCfg(flags)
Definition: MainServicesConfig.py:133
python.MainServicesConfig.AthenaMtesEventLoopMgrCfg
def AthenaMtesEventLoopMgrCfg(flags, mtEs=False, channel='')
Definition: MainServicesConfig.py:176
python.MainServicesConfig.MainServicesMiniCfg
def MainServicesMiniCfg(flags, loopMgr='AthenaEventLoopMgr', masterSequence='AthAlgSeq')
Definition: MainServicesConfig.py:7