ATLAS Offline Software
Functions | Variables
python.MainServicesConfig Namespace Reference

Functions

def MainServicesMiniCfg (flags, loopMgr='AthenaEventLoopMgr', masterSequence='AthAlgSeq')
 
def AvalancheSchedulerSvcCfg (flags, **kwargs)
 
def OutputUsageIgnoreCfg (flags, algorithm)
 
def AthenaEventLoopMgrCfg (flags)
 
def AthenaHiveEventLoopMgrCfg (flags)
 
def AthenaMpEventLoopMgrCfg (flags)
 
def AthenaMtesEventLoopMgrCfg (flags, mtEs=False, channel='')
 
def MessageSvcCfg (flags)
 
def addMainSequences (flags, cfg)
 
def addEvgenSequences (flags, cfg)
 
def MainServicesCfg (flags, LoopMgr='AthenaEventLoopMgr')
 
def MainEvgenServicesCfg (flags, LoopMgr="AthenaEventLoopMgr", withSequences=True)
 
def JobOptionsDumpCfg (flags, fileName="JobOptsConfig.txt")
 

Variables

 flags
 
 RunNumbers
 
 TimeStamps
 
 cfg
 
 withSequences
 

Function Documentation

◆ addEvgenSequences()

def python.MainServicesConfig.addEvgenSequences (   flags,
  cfg 
)

Definition at line 251 of file MainServicesConfig.py.

251 def addEvgenSequences(flags, cfg):
252  from GeneratorConfig.Sequences import EvgenSequence, EvgenSequenceFactory
253  cfg.addSequence(EvgenSequenceFactory(EvgenSequence.Generator), parentName="AthAlgSeq")
254  cfg.addSequence(EvgenSequenceFactory(EvgenSequence.Fix), parentName="AthAlgSeq")
255  cfg.addSequence(EvgenSequenceFactory(EvgenSequence.PreFilter), parentName="AthAlgSeq")
256  cfg.addSequence(EvgenSequenceFactory(EvgenSequence.Test), parentName="AthAlgSeq")
257  # TODO: needs to setup proper filtering sequence
258  cfg.addSequence(EvgenSequenceFactory(EvgenSequence.Filter), parentName="AthAlgSeq")
259  cfg.addSequence(EvgenSequenceFactory(EvgenSequence.Post), parentName="AthAlgSeq")
260 
261 

◆ addMainSequences()

def python.MainServicesConfig.addMainSequences (   flags,
  cfg 
) 
Add the standard sequences to cfg

Definition at line 194 of file MainServicesConfig.py.

194 def addMainSequences(flags, cfg):
195  """Add the standard sequences to cfg"""
196 
197  # Build standard sequences:
198  AthSequencer = CompFactory.AthSequencer
199  cfg.addSequence(AthSequencer('AthAlgEvtSeq', Sequential=True, StopOverride=True), parentName='AthMasterSeq')
200  cfg.addSequence(AthSequencer('AthOutSeq', StopOverride=True), parentName='AthMasterSeq')
201 
202  cfg.addSequence(AthSequencer('AthBeginSeq', Sequential=True), parentName='AthAlgEvtSeq')
203  cfg.addSequence(AthSequencer('AthAllAlgSeq', StopOverride=True), parentName='AthAlgEvtSeq')
204 
205  athAlgSeq = AthSequencer('AthAlgSeq', IgnoreFilterPassed=True, StopOverride=True, ProcessDynamicDataDependencies=True, ExtraDataForDynamicConsumers=[])
206  athCondSeq = AthSequencer('AthCondSeq',StopOverride=True)
207 
208  if flags.Concurrency.NumThreads==0:
209  # For serial execution, we need the CondAlgs to execute first.
210  cfg.addSequence(athCondSeq, parentName='AthAllAlgSeq')
211  cfg.addSequence(athAlgSeq, parentName='AthAllAlgSeq')
212  else:
213  # In MT, the order of execution is irrelevant (determined by data deps).
214  # We add the conditions sequence later such that the CondInputLoader gets
215  # initialized after all other user Algorithms for MT, so the base classes
216  # of data deps can be correctly determined.
217  cfg.addSequence(athAlgSeq, parentName='AthAllAlgSeq')
218  cfg.addSequence(athCondSeq, parentName='AthAllAlgSeq')
219 
220  cfg.addSequence(AthSequencer('AthEndSeq', Sequential=True), parentName='AthAlgEvtSeq')
221 
222  # Set up incident firing:
223  AthIncFirerAlg = CompFactory.AthIncFirerAlg
224  IncidentProcAlg = CompFactory.IncidentProcAlg
225 
226  previousPerfmonDomain = cfg.getCurrentPerfmonDomain()
227  cfg.flagPerfmonDomain('Incidents')
228 
229  cfg.addEventAlgo(AthIncFirerAlg("BeginIncFiringAlg", FireSerial=False, Incidents=['BeginEvent']),
230  sequenceName='AthBeginSeq')
231 
232  cfg.addEventAlgo(IncidentProcAlg('IncidentProcAlg1'),
233  sequenceName='AthBeginSeq')
234 
235  cfg.addEventAlgo(AthIncFirerAlg('EndIncFiringAlg', FireSerial=False, Incidents=['EndEvent']),
236  sequenceName="AthEndSeq")
237 
238  cfg.addEventAlgo(IncidentProcAlg('IncidentProcAlg2'),
239  sequenceName="AthEndSeq")
240 
241  # Should be after all other algorithms:
242  cfg.addEventAlgo(AthIncFirerAlg('EndAlgorithmsFiringAlg', FireSerial=False, Incidents=['EndAlgorithms']),
243  sequenceName="AthMasterSeq")
244 
245  cfg.addEventAlgo(IncidentProcAlg('IncidentProcAlg3'),
246  sequenceName="AthMasterSeq")
247 
248  cfg.flagPerfmonDomain(previousPerfmonDomain)
249 
250 

◆ AthenaEventLoopMgrCfg()

def python.MainServicesConfig.AthenaEventLoopMgrCfg (   flags)

Definition at line 66 of file MainServicesConfig.py.

66 def AthenaEventLoopMgrCfg(flags):
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 

◆ AthenaHiveEventLoopMgrCfg()

def python.MainServicesConfig.AthenaHiveEventLoopMgrCfg (   flags)

Definition at line 83 of file MainServicesConfig.py.

83 def AthenaHiveEventLoopMgrCfg(flags):
84  cfg = ComponentAccumulator()
85  hivesvc = CompFactory.SG.HiveMgrSvc("EventDataSvc",
86  NSlots = flags.Concurrency.NumConcurrentEvents)
87  cfg.addService( hivesvc )
88 
89  arp = CompFactory.AlgResourcePool(TopAlg = ["AthMasterSeq"]) #this should enable control flow
90  cfg.addService( arp )
91 
92  scheduler = cfg.getPrimaryAndMerge(AvalancheSchedulerSvcCfg(flags))
93 
94  elmgr = CompFactory.AthenaHiveEventLoopMgr(
95  WhiteboardSvc = "EventDataSvc",
96  SchedulerSvc = scheduler.getName(),
97  EventPrintoutInterval = flags.Exec.EventPrintoutInterval)
98 
99  if flags.Input.OverrideRunNumber:
100  from AthenaKernel.EventIdOverrideConfig import EvtIdModifierSvcCfg
101  elmgr.EvtIdModifierSvc = cfg.getPrimaryAndMerge(EvtIdModifierSvcCfg(flags))
102 
103  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
104  elmgr.RequireInputAttributeList = True
105  elmgr.UseSecondaryEventNumber = True
106 
107  cfg.addService( elmgr )
108 
109  return cfg
110 

◆ AthenaMpEventLoopMgrCfg()

def python.MainServicesConfig.AthenaMpEventLoopMgrCfg (   flags)

Definition at line 111 of file MainServicesConfig.py.

111 def AthenaMpEventLoopMgrCfg(flags):
112  cfg = ComponentAccumulator()
113  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
114  elmgr = CompFactory.AthenaEventLoopMgr(EventPrintoutInterval = flags.Exec.EventPrintoutInterval)
115  elmgr.RequireInputAttributeList = True
116  elmgr.UseSecondaryEventNumber = True
117  cfg.addService( elmgr )
118 
119  from AthenaMP.AthenaMPConfig import AthenaMPCfg
120  mploop = AthenaMPCfg(flags)
121  cfg.merge( mploop )
122 
123  return cfg
124 
125 

◆ AthenaMtesEventLoopMgrCfg()

def python.MainServicesConfig.AthenaMtesEventLoopMgrCfg (   flags,
  mtEs = False,
  channel = '' 
)

Definition at line 126 of file MainServicesConfig.py.

126 def AthenaMtesEventLoopMgrCfg(flags, mtEs=False, channel=''):
127  cfg = ComponentAccumulator()
128 
129  hivesvc = CompFactory.SG.HiveMgrSvc("EventDataSvc",
130  NSlots = flags.Concurrency.NumConcurrentEvents)
131  cfg.addService( hivesvc )
132 
133  arp = CompFactory.AlgResourcePool(TopAlg = ["AthMasterSeq"]) #this should enable control flow
134  cfg.addService( arp )
135 
136  scheduler = cfg.getPrimaryAndMerge(AvalancheSchedulerSvcCfg(flags))
137 
138  elmgr = CompFactory.AthenaMtesEventLoopMgr(
139  WhiteboardSvc = "EventDataSvc",
140  SchedulerSvc = scheduler.getName(),
141  EventRangeChannel = channel,
142  EventPrintoutInterval = flags.Exec.EventPrintoutInterval)
143 
144  if flags.Input.OverrideRunNumber:
145  from AthenaKernel.EventIdOverrideConfig import EvtIdModifierSvcCfg
146  elmgr.EvtIdModifierSvc = cfg.getPrimaryAndMerge(EvtIdModifierSvcCfg(flags))
147 
148  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
149  elmgr.RequireInputAttributeList = True
150  elmgr.UseSecondaryEventNumber = True
151 
152  if mtEs:
153  from AthenaServices.OutputStreamSequencerSvcConfig import OutputStreamSequencerSvcCfg
154  cfg.merge(OutputStreamSequencerSvcCfg(flags,
155  incidentName="NextEventRange",
156  reportingOn = True))
157 
158  cfg.addService( elmgr )
159 
160  return cfg
161 
162 

◆ AvalancheSchedulerSvcCfg()

def python.MainServicesConfig.AvalancheSchedulerSvcCfg (   flags,
**  kwargs 
)

Definition at line 27 of file MainServicesConfig.py.

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 

◆ JobOptionsDumpCfg()

def python.MainServicesConfig.JobOptionsDumpCfg (   flags,
  fileName = "JobOptsConfig.txt" 
) 
Job options service configuration - mainly to dump the config.

Definition at line 373 of file MainServicesConfig.py.

373 def JobOptionsDumpCfg(flags, fileName="JobOptsConfig.txt"):
374  """Job options service configuration - mainly to dump the config."""
375  acc = ComponentAccumulator()
376  acc.addService(CompFactory.JobOptionsSvc(DUMPFILE=fileName))
377  return acc
378 
379 

◆ MainEvgenServicesCfg()

def python.MainServicesConfig.MainEvgenServicesCfg (   flags,
  LoopMgr = "AthenaEventLoopMgr",
  withSequences = True 
) 
ComponentAccumulator-based equivalent of:
import AthenaCommon.AtlasUnixGeneratorJob

NB Must have set flags.Input.RunNumbers and
flags.Input.TimeStamps before calling to avoid
attempted auto-configuration from an input file.

Definition at line 355 of file MainServicesConfig.py.

355 def MainEvgenServicesCfg(flags, LoopMgr="AthenaEventLoopMgr", withSequences=True):
356  """ComponentAccumulator-based equivalent of:
357  import AthenaCommon.AtlasUnixGeneratorJob
358 
359  NB Must have set flags.Input.RunNumbers and
360  flags.Input.TimeStamps before calling to avoid
361  attempted auto-configuration from an input file.
362  """
363  cfg = MainServicesCfg(flags, LoopMgr)
364  from McEventSelector.McEventSelectorConfig import McEventSelectorCfg
365  cfg.merge(McEventSelectorCfg(flags))
366 
367  if withSequences:
368  addEvgenSequences(flags, cfg)
369 
370  return cfg
371 
372 

◆ MainServicesCfg()

def python.MainServicesConfig.MainServicesCfg (   flags,
  LoopMgr = 'AthenaEventLoopMgr' 
)

Definition at line 262 of file MainServicesConfig.py.

262 def MainServicesCfg(flags, LoopMgr='AthenaEventLoopMgr'):
263  # Set the Python OutputLevel on the root logger
264  from AthenaCommon.Logging import log
265  log.setLevel(flags.Exec.OutputLevel)
266 
267  if flags.Exec.Interactive == "run":
268  LoopMgr="PyAthenaEventLoopMgr"
269  log.info("Interactive mode, switching to %s", LoopMgr)
270  else:
271  # Run a serial job for threads=0
272  if flags.Concurrency.NumThreads > 0:
273  if flags.Concurrency.NumConcurrentEvents==0:
274  raise Exception("Requested Concurrency.NumThreads>0 and Concurrency.NumConcurrentEvents==0, "
275  "which will not process events!")
276  if flags.Exec.MTEventService:
277  LoopMgr = "AthenaMtesEventLoopMgr"
278  else:
279  LoopMgr = "AthenaHiveEventLoopMgr"
280 
281  if flags.Concurrency.NumProcs > 0:
282  LoopMgr = "AthMpEvtLoopMgr"
283 
284  # Core components needed for serial and threaded jobs:
285  cfg = MainServicesMiniCfg(flags, loopMgr=LoopMgr, masterSequence='AthMasterSeq')
286 
287  # Main sequences and incident handling:
288  addMainSequences(flags, cfg)
289 
290  # Basic services:
291  cfg.addService(CompFactory.ClassIDSvc(CLIDDBFiles = ['clid.db','Gaudi_clid.db']))
292 
293  cfg.addService(CompFactory.AlgContextSvc(BypassIncidents=True))
294  cfg.addAuditor(CompFactory.AlgContextAuditor())
295 
296  cfg.addService(CompFactory.StoreGateSvc(Dump=flags.Debug.DumpEvtStore))
297  cfg.addService(CompFactory.StoreGateSvc("DetectorStore",Dump=flags.Debug.DumpDetStore))
298  cfg.addService(CompFactory.StoreGateSvc("HistoryStore"))
299  cfg.addService(CompFactory.StoreGateSvc("ConditionStore",Dump=flags.Debug.DumpCondStore))
300 
301  cfg.merge(MessageSvcCfg(flags))
302 
303  from AthenaConfiguration.FPEAndCoreDumpConfig import FPEAndCoreDumpCfg
304  cfg.merge(FPEAndCoreDumpCfg(flags))
305 
306  # Avoid stack traces to the exception handler. These traces
307  # aren't very useful since they just point to the handler, not
308  # the original bug.
309  cfg.addService(CompFactory.ExceptionSvc(Catch="NONE"))
310 
311  # ApplicationMgr properties:
312  cfg.setAppProperty('AuditAlgorithms', True)
313  cfg.setAppProperty('InitializationLoopCheck', False)
314  cfg.setAppProperty('EvtMax', flags.Exec.MaxEvents)
315  if flags.Exec.OutputLevel > INFO:
316  # this turns off the appMgr spalsh
317  cfg.setAppProperty('AppName', '')
318  cfg.setAppProperty('OutputLevel', flags.Exec.OutputLevel)
319 
320  if flags.Exec.DebugStage != "":
321  cfg.setDebugStage(flags.Exec.DebugStage)
322 
323  cfg.interactive=flags.Exec.Interactive
324 
325  if flags.Concurrency.NumProcs > 0:
326  cfg.merge(AthenaMpEventLoopMgrCfg(flags))
327 
328  # Additional components needed for threaded jobs only:
329  if flags.Concurrency.NumThreads > 0:
330  if flags.Exec.MTEventService:
331  cfg.merge(AthenaMtesEventLoopMgrCfg(flags,True,flags.Exec.MTEventServiceChannel))
332  else:
333  cfg.merge(AthenaHiveEventLoopMgrCfg(flags))
334  # Setup SGCommitAuditor to sweep new DataObjects at end of Alg execute
335  cfg.addAuditor( CompFactory.SGCommitAuditor() )
336  elif LoopMgr == 'AthenaEventLoopMgr':
337  cfg.merge(AthenaEventLoopMgrCfg(flags))
338 
339  # Performance monitoring and profiling:
340  if flags.PerfMon.doFastMonMT or flags.PerfMon.doFullMonMT:
341  from PerfMonComps.PerfMonCompsConfig import PerfMonMTSvcCfg
342  cfg.merge(PerfMonMTSvcCfg(flags))
343 
344  if flags.PerfMon.doGPerfProf:
345  from PerfMonGPerfTools.GPT_ProfilerServiceConfig import GPT_ProfilerServiceCfg
346  cfg.merge(GPT_ProfilerServiceCfg(flags))
347 
348  if len(flags.PerfMon.Valgrind.ProfiledAlgs)>0:
349  from Valkyrie.ValkyrieConfig import ValgrindServiceCfg
350  cfg.merge(ValgrindServiceCfg(flags))
351 
352  return cfg
353 
354 

◆ MainServicesMiniCfg()

def python.MainServicesConfig.MainServicesMiniCfg (   flags,
  loopMgr = 'AthenaEventLoopMgr',
  masterSequence = 'AthAlgSeq' 
) 
Mininmal basic config, just good enough for HelloWorld and alike

Definition at line 7 of file MainServicesConfig.py.

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 

◆ MessageSvcCfg()

def python.MainServicesConfig.MessageSvcCfg (   flags)

Definition at line 163 of file MainServicesConfig.py.

163 def MessageSvcCfg(flags):
164  cfg = ComponentAccumulator()
165  msgsvc = CompFactory.MessageSvc()
166  msgsvc.OutputLevel = flags.Exec.OutputLevel
167  msgsvc.Format = "% F%{:d}W%C%7W%R%T %0W%M".format(flags.Common.MsgSourceLength)
168  msgsvc.enableSuppression = flags.Common.MsgSuppression
169  if flags.Common.ShowMsgStats:
170  msgsvc.showStats = True
171  from AthenaCommon.Constants import WARNING
172  msgsvc.statLevel = WARNING
173 
174  from AthenaConfiguration.Enums import ProductionStep
175  if flags.Common.ProductionStep not in [ProductionStep.Default, ProductionStep.Reconstruction, ProductionStep.Derivation]:
176  msgsvc.Format = "% F%18W%S%7W%R%T %0W%M" # Temporary to match legacy configuration for serial simulation/digitization/overlay jobs
177  if flags.Concurrency.NumThreads>0:
178  msgsvc.Format = "% F%{:d}W%C%6W%R%e%s%8W%R%T %0W%M".format(flags.Common.MsgSourceLength)
179  if flags.Exec.VerboseMessageComponents:
180  msgsvc.verboseLimit=0
181  if flags.Exec.DebugMessageComponents:
182  msgsvc.debugLimit=0
183  if flags.Exec.InfoMessageComponents:
184  msgsvc.infoLimit=0
185  if flags.Exec.WarningMessageComponents:
186  msgsvc.warningLimit=0
187  if flags.Exec.ErrorMessageComponents:
188  msgsvc.errorLimit=0
189 
190  cfg.addService(msgsvc)
191  return cfg
192 
193 

◆ OutputUsageIgnoreCfg()

def python.MainServicesConfig.OutputUsageIgnoreCfg (   flags,
  algorithm 
)

Definition at line 59 of file MainServicesConfig.py.

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 

Variable Documentation

◆ cfg

python.MainServicesConfig.cfg

Definition at line 386 of file MainServicesConfig.py.

◆ flags

python.MainServicesConfig.flags

Definition at line 382 of file MainServicesConfig.py.

◆ RunNumbers

python.MainServicesConfig.RunNumbers

Definition at line 384 of file MainServicesConfig.py.

◆ TimeStamps

python.MainServicesConfig.TimeStamps

Definition at line 385 of file MainServicesConfig.py.

◆ withSequences

python.MainServicesConfig.withSequences

Definition at line 386 of file MainServicesConfig.py.

python.OutputStreamSequencerSvcConfig.OutputStreamSequencerSvcCfg
def OutputStreamSequencerSvcCfg(flags, incidentName='', reportingOn=False)
Definition: OutputStreamSequencerSvcConfig.py:6
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:163
python.MainServicesConfig.MainEvgenServicesCfg
def MainEvgenServicesCfg(flags, LoopMgr="AthenaEventLoopMgr", withSequences=True)
Definition: MainServicesConfig.py:355
SGInputLoaderConfig.SGInputLoaderCfg
def SGInputLoaderCfg(flags, Load=None, **kwargs)
Definition: SGInputLoaderConfig.py:7
python.MainServicesConfig.addMainSequences
def addMainSequences(flags, cfg)
Definition: MainServicesConfig.py:194
python.MainServicesConfig.AthenaEventLoopMgrCfg
def AthenaEventLoopMgrCfg(flags)
Definition: MainServicesConfig.py:66
python.MainServicesConfig.addEvgenSequences
def addEvgenSequences(flags, cfg)
Definition: MainServicesConfig.py:251
GPT_ProfilerServiceConfig.GPT_ProfilerServiceCfg
def GPT_ProfilerServiceCfg(flags, **kwargs)
Definition: GPT_ProfilerServiceConfig.py:10
python.MainServicesConfig.MainServicesCfg
def MainServicesCfg(flags, LoopMgr='AthenaEventLoopMgr')
Definition: MainServicesConfig.py:262
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
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.MainServicesConfig.AthenaMpEventLoopMgrCfg
def AthenaMpEventLoopMgrCfg(flags)
Definition: MainServicesConfig.py:111
python.MainServicesConfig.JobOptionsDumpCfg
def JobOptionsDumpCfg(flags, fileName="JobOptsConfig.txt")
Definition: MainServicesConfig.py:373
python.EventIdOverrideConfig.EvtIdModifierSvcCfg
def EvtIdModifierSvcCfg(flags, name="EvtIdModifierSvc", **kwargs)
Definition: EventIdOverrideConfig.py:140
python.MainServicesConfig.AthenaHiveEventLoopMgrCfg
def AthenaHiveEventLoopMgrCfg(flags)
Definition: MainServicesConfig.py:83
python.MainServicesConfig.AthenaMtesEventLoopMgrCfg
def AthenaMtesEventLoopMgrCfg(flags, mtEs=False, channel='')
Definition: MainServicesConfig.py:126
python.MainServicesConfig.MainServicesMiniCfg
def MainServicesMiniCfg(flags, loopMgr='AthenaEventLoopMgr', masterSequence='AthAlgSeq')
Definition: MainServicesConfig.py:7
Generated on Sat Jun 21 2025 22:09:04 for ATLAS Offline Software by   doxygen 1.8.18