The Gaudi Framework  v36r7 (7f57a304)
Main.py
Go to the documentation of this file.
1 
11 from __future__ import print_function
12 
13 import logging
14 import os
15 import sys
16 from time import time
17 
18 import six
19 
20 from Gaudi import Configuration
21 
22 log = logging.getLogger(__name__)
23 
24 
25 class BootstrapHelper(object):
26  class StatusCode(object):
27  def __init__(self, value):
28  self.value = value
29 
30  def __bool__(self):
31  return self.value
32 
33  __nonzero__ = __bool__
34 
35  def isSuccess(self):
36  return self.value
37 
38  def isFailure(self):
39  return not self.value
40 
41  def ignore(self):
42  pass
43 
44  class Property(object):
45  def __init__(self, value):
46  self.value = value
47 
48  def __str__(self):
49  # TODO why bytes
50  return bytes(self.value).decode("utf-8")
51 
52  toString = __str__
53 
54  class AppMgr(object):
55  def __init__(self, ptr, lib):
56  self.ptr = ptr
57  self.lib = lib
58  self._as_parameter_ = ptr
59 
60  def configure(self):
62  self.lib.py_bootstrap_fsm_configure(self.ptr)
63  )
64 
65  def initialize(self):
67  self.lib.py_bootstrap_fsm_initialize(self.ptr)
68  )
69 
70  def start(self):
71  return BootstrapHelper.StatusCode(self.lib.py_bootstrap_fsm_start(self.ptr))
72 
73  def run(self, nevt):
75  self.lib.py_bootstrap_app_run(self.ptr, nevt)
76  )
77 
78  def stop(self):
79  return BootstrapHelper.StatusCode(self.lib.py_bootstrap_fsm_stop(self.ptr))
80 
81  def finalize(self):
83  self.lib.py_bootstrap_fsm_finalize(self.ptr)
84  )
85 
86  def terminate(self):
88  self.lib.py_bootstrap_fsm_terminate(self.ptr)
89  )
90 
91  def getService(self, name):
92  return self.lib.py_bootstrap_getService(self.ptr, name.encode("ascii"))
93 
94  def setProperty(self, name, value):
96  self.lib.py_bootstrap_setProperty(
97  self.ptr, name.encode("ascii"), value.encode("ascii")
98  )
99  )
100 
101  def getProperty(self, name):
103  self.lib.py_bootstrap_getProperty(self.ptr, name.encode("ascii"))
104  )
105 
107  return self.lib.py_helper_printAlgsSequences(self.ptr)
108 
109  def setOption(self, key, value):
110  self.lib.py_bootstrap_setOption(
111  self.ptr, key.encode("ascii"), value.encode("ascii")
112  )
113 
114  def __init__(self):
115  from ctypes import RTLD_GLOBAL, PyDLL, c_bool, c_char_p, c_int, c_void_p, util
116 
117  # Helper class to avoid void* to int conversion
118  # (see http://stackoverflow.com/questions/17840144)
119 
120  class IInterface_p(c_void_p):
121  def __repr__(self):
122  return "IInterface_p(0x%x)" % (0 if self.value is None else self.value)
123 
124  self.log = logging.getLogger("BootstrapHelper")
125  libname = util.find_library("GaudiKernel") or "libGaudiKernel.so"
126  self.log.debug("loading GaudiKernel (%s)", libname)
127 
128  # FIXME: note that we need PyDLL instead of CDLL if the calls to
129  # Python functions are not protected with the GIL.
130  self.lib = gkl = PyDLL(libname, mode=RTLD_GLOBAL)
131 
132  functions = [
133  ("createApplicationMgr", IInterface_p, []),
134  ("getService", IInterface_p, [IInterface_p, c_char_p]),
135  ("setProperty", c_bool, [IInterface_p, c_char_p, c_char_p]),
136  ("getProperty", c_char_p, [IInterface_p, c_char_p]),
137  ("setOption", None, [IInterface_p, c_char_p, c_char_p]),
138  ("ROOT_VERSION_CODE", c_int, []),
139  ]
140 
141  for name, restype, argtypes in functions:
142  f = getattr(gkl, "py_bootstrap_%s" % name)
143  f.restype, f.argtypes = restype, argtypes
144  # create a delegate method if not already present
145  # (we do not want to use hasattr because it calls "properties")
146  if name not in self.__class__.__dict__:
147  setattr(self, name, f)
148 
149  for name in (
150  "configure",
151  "initialize",
152  "start",
153  "stop",
154  "finalize",
155  "terminate",
156  ):
157  f = getattr(gkl, "py_bootstrap_fsm_%s" % name)
158  f.restype, f.argtypes = c_bool, [IInterface_p]
159  gkl.py_bootstrap_app_run.restype = c_bool
160  gkl.py_bootstrap_app_run.argtypes = [IInterface_p, c_int]
161 
162  gkl.py_helper_printAlgsSequences.restype = None
163  gkl.py_helper_printAlgsSequences.argtypes = [IInterface_p]
164 
166  ptr = self.lib.py_bootstrap_createApplicationMgr()
167  return self.AppMgr(ptr, self.lib)
168 
169  @property
170  def ROOT_VERSION_CODE(self):
171  return self.lib.py_bootstrap_ROOT_VERSION_CODE()
172 
173  @property
174  def ROOT_VERSION(self):
175  root_version_code = self.ROOT_VERSION_CODE
176  a = root_version_code >> 16 & 0xFF
177  b = root_version_code >> 8 & 0xFF
178  c = root_version_code & 0xFF
179  return (a, b, c)
180 
181 
182 def _getAllOpts_old(explicit_defaults=False):
183  """
184  Return all options from the old configuration system as a dictionary.
185 
186  If explicit_defaults is true, include default values of unset properties in the dictionary.
187  """
188  from itertools import chain
189 
190  from GaudiKernel.Proxy.Configurable import Configurable, getNeededConfigurables
191 
192  old_opts = {}
193 
194  # some algorithms may be generater when we call "getValuedProperties"
195  # so we need a few iterations before we get the full list
196  # (see GaudiConfig.ControlFlow)
197  needed_conf = []
198  count = 0
199  new_count = -1
200  while count != new_count:
201  count = new_count
202  needed_conf = getNeededConfigurables()
203  new_count = len(needed_conf)
204  for n in needed_conf:
205  c = Configurable.allConfigurables[n]
206  if hasattr(c, "getValuedProperties"):
207  c.getValuedProperties()
208 
209  for n in needed_conf:
210  c = Configurable.allConfigurables[n]
211  items = (
212  chain(c.getDefaultProperties().items(), c.getValuedProperties().items())
213  if explicit_defaults
214  else c.getValuedProperties().items()
215  )
216  for p, v in items:
217  # Note: AthenaCommon.Configurable does not have Configurable.PropertyReference
218  if (
219  hasattr(Configurable, "PropertyReference")
220  and type(v) == Configurable.PropertyReference
221  ):
222  # this is done in "getFullName", but the exception is ignored,
223  # so we do it again to get it
224  v = v.__resolve__()
225  if isinstance(v, str):
226  # properly escape quotes in the string (see gaudi/Gaudi#78)
227  v = '"%s"' % v.replace('"', '\\"')
228  elif sys.version_info < (3,) and isinstance(v, long):
229  v = "%d" % v # prevent pending 'L'
230  elif hasattr(v, "__opt_value__"):
231  v = v.__opt_value__()
232  old_opts[".".join((n, p))] = str(v)
233 
234  return old_opts
235 
236 
237 def getAllOpts(explicit_defaults=False):
238  """
239  Return all options from the old and new configuration system as a dictionary.
240 
241  If explicit_defaults is true, include default values of unset properties in the dictionary.
242  """
243  import GaudiConfig2
244 
245  # We need to run normal (without defaults) collection first (regardless of explicit_defaults)
246  # as the conflicts detection makes sense only for explicitly set options
247  old_opts = _getAllOpts_old(False)
248  opts = GaudiConfig2.all_options(False)
249 
250  conflicts = [n for n in set(opts).intersection(old_opts) if opts[n] != old_opts[n]]
251  if conflicts:
252  conflicts.sort()
253  log.error("Some properties are set in old and new style configuration")
254  log.warning("name: old -> new")
255  for n in conflicts:
256  log.warning("%s: %s -> %s", n, old_opts[n], opts[n])
257  sys.exit(10)
258 
259  opts.update(old_opts)
260 
261  if explicit_defaults:
262  # If we are asked to print also the defaults, we collect everything
263  # and blindly merge to make sure we have the full set of configurables
264  all_opts = _getAllOpts_old(True)
265  all_opts.update(GaudiConfig2.all_options(True))
266  # the we override the dictionary with the explicitly set options
267  # (that leaves the defaults untouched and the set options with the
268  # correct value)
269  all_opts.update(opts)
270  opts = all_opts
271 
272  return opts
273 
274 
275 def toOpt(value):
276  """
277  Helper to convert values to old .opts format.
278 
279  >>> print(toOpt('some "text"'))
280  "some \\"text\\""
281  >>> print(toOpt('first\\nsecond'))
282  "first
283  second"
284  >>> print(toOpt({'a': [1, 2, '3']}))
285  {"a": [1, 2, "3"]}
286  """
287  if isinstance(value, six.string_types):
288  return '"{0}"'.format(value.replace('"', '\\"'))
289  elif isinstance(value, dict):
290  return "{{{0}}}".format(
291  ", ".join("{0}: {1}".format(toOpt(k), toOpt(v)) for k, v in value.items())
292  )
293  elif hasattr(value, "__iter__"):
294  return "[{0}]".format(", ".join(map(toOpt, value)))
295  else:
296  return repr(value)
297 
298 
299 def parseOpt(s):
300  """
301  Helper to parse option strings to Python values.
302 
303  Ideally it should just be "eval", but the string parser of Gaudi
304  is different from the Python one, so we get string options that
305  cannot be just evaluated.
306 
307  >>> print(parseOpt('123'))
308  123
309  >>> print(parseOpt('"some\\n\\\\"text\\\\""'))
310  some
311  "text"
312  >>> print(parseOpt(''))
313  <BLANKLINE>
314 
315  (see gaudi/Gaudi#78)
316  """
317  import re
318 
319  quoted_string = re.compile(r'^"(.*)"$', re.DOTALL)
320  # FIXME: this is needed because we cannot use repr for strings
321  # (see gaudi/Gaudi#78)
322  if not s: # pass through empty strings
323  return s
324  m = quoted_string.match(s)
325  if m:
326  return m.group(1).replace('\\"', '"')
327  return eval(s)
328 
329 
330 class gaudimain(object):
331  def __init__(self):
332  from Configurables import ApplicationMgr
333 
334  appMgr = ApplicationMgr()
335  if "GAUDIAPPNAME" in os.environ:
336  appMgr.AppName = str(os.environ["GAUDIAPPNAME"])
337  if "GAUDIAPPVERSION" in os.environ:
338  appMgr.AppVersion = str(os.environ["GAUDIAPPVERSION"])
339  self.log = logging.getLogger(__name__)
340  self.printsequence = False
341  self.application = "Gaudi::Application"
342 
344  # ---------------------------------------------------
345  # set up Logging
346  # ----------------
347  # from multiprocessing import enableLogging, getLogger
348  import multiprocessing
349 
350  # preliminaries for handlers/output files, etc.
351  from time import ctime
352 
353  datetime = ctime()
354  datetime = datetime.replace(" ", "_")
355  outfile = open("gaudirun-%s.log" % (datetime), "w")
356  # two handlers, one for a log file, one for terminal
357  streamhandler = logging.StreamHandler(stream=outfile)
358  console = logging.StreamHandler()
359  # create formatter : the params in parentheses are variable names available via logging
360  formatter = logging.Formatter(
361  "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
362  )
363  # add formatter to Handler
364  streamhandler.setFormatter(formatter)
365  console.setFormatter(formatter)
366  # now, configure the logger
367  # enableLogging( level=0 )
368  # self.log = getLogger()
369  self.log = multiprocessing.log_to_stderr()
370  self.log.setLevel(logging.INFO)
371  self.log.name = "Gaudi/Main.py Logger"
372  self.log.handlers = []
373  # add handlers to logger : one for output to a file, one for console output
374  self.log.addHandler(streamhandler)
375  self.log.addHandler(console)
376  self.log.removeHandler(console)
377  # set level!!
378  self.log.setLevel = logging.INFO
379  # ---------------------------------------------------
380 
381  def generatePyOutput(self, all=False):
382  from collections import defaultdict
383  from pprint import pformat
384 
385  optDict = defaultdict(dict)
386  allOpts = getAllOpts(all)
387  for key in allOpts:
388  c, p = key.rsplit(".", 1)
389  optDict[c][p] = parseOpt(allOpts[key])
390  formatted = pformat(dict(optDict))
391  # Python 2 compatibility
392  if six.PY2:
393  return formatted
394  else:
395  # undo splitting of strings on multiple lines
396  import re
397 
398  return re.sub(r'"\n +"', "", formatted, flags=re.MULTILINE)
399 
400  def generateOptsOutput(self, all=False):
401  opts = getAllOpts(all)
402  keys = sorted(opts)
403  return "\n".join(
404  "{} = {};".format(key, toOpt(parseOpt(opts[key]))) for key in keys
405  )
406 
407  def _writepickle(self, filename):
408  # --- Lets take the first file input file as the name of the pickle file
409  import pickle
410 
411  output = open(filename, "wb")
412  # Dump only the the configurables that make sense to dump (not User ones)
413  from GaudiKernel.Proxy.Configurable import getNeededConfigurables
414 
415  to_dump = {}
416  for n in getNeededConfigurables():
417  to_dump[n] = Configuration.allConfigurables[n]
418  pickle.dump(to_dump, output, -1)
419  output.close()
420 
421  def printconfig(self, old_format=False, all=False):
422  msg = "Dumping all configurables and properties"
423  if not all:
424  msg += " (different from default)"
425  log.info(msg)
426  if old_format:
427  print(self.generateOptsOutput(all))
428  else:
429  print(self.generatePyOutput(all))
430  sys.stdout.flush()
431 
432  def writeconfig(self, filename, all=False):
433  import json
434 
435  write = {
436  ".pkl": lambda filename, all: self._writepickle(filename),
437  ".py": lambda filename, all: open(filename, "w").write(
438  self.generatePyOutput(all) + "\n"
439  ),
440  ".opts": lambda filename, all: open(filename, "w").write(
441  self.generateOptsOutput(all) + "\n"
442  ),
443  ".json": lambda filename, all: json.dump(
444  getAllOpts(all), open(filename, "w"), indent=2, sort_keys=True
445  ),
446  }
447  try:
448  import yaml
449 
450  write[".yaml"] = lambda filename, all: yaml.safe_dump(
451  getAllOpts(all), open(filename, "w")
452  )
453  write[".yml"] = write[".yaml"]
454  except ImportError:
455  pass # yaml support is optional
456 
457  from os.path import splitext
458 
459  ext = splitext(filename)[1]
460  if ext in write:
461  write[ext](filename, all)
462  else:
463  log.error(
464  "Unknown file type '%s'. Must be any of %r.", ext, sorted(write.keys())
465  )
466  sys.exit(1)
467 
468  # Instantiate and run the application.
469  # Depending on the number of CPUs (ncpus) specified, it start
470  def run(self, attach_debugger, ncpus=None):
471  if not ncpus:
472  # Standard sequential mode
473  result = self.runSerial(attach_debugger)
474  else:
475  # Otherwise, run with the specified number of cpus
476  result = self.runParallel(ncpus)
477  return result
478 
479  def hookDebugger(self, debugger="gdb"):
480  import os
481 
482  self.log.info("attaching debugger to PID " + str(os.getpid()))
483  pid = os.spawnvp(
484  os.P_NOWAIT, debugger, [debugger, "-q", "python", str(os.getpid())]
485  )
486 
487  # give debugger some time to attach to the python process
488  import time
489 
490  time.sleep(5)
491 
492  # verify the process' existence (will raise OSError if failed)
493  os.waitpid(pid, os.WNOHANG)
494  os.kill(pid, 0)
495  return
496 
497  def runSerial(self, attach_debugger):
498  try:
499  from GaudiKernel.Proxy.Configurable import expandvars
500  except ImportError:
501  # pass-through implementation if expandvars is not defined (AthenaCommon)
502  def expandvars(data):
503  return data
504 
505  from GaudiKernel.Proxy.Configurable import Configurable
506 
507  self.log.debug("runSerial: apply options")
508  conf_dict = expandvars(getAllOpts())
509  conf_dict["ApplicationMgr.JobOptionsType"] = '"NONE"'
510 
511  if self.printsequence:
512  conf_dict["ApplicationMgr.PrintAlgsSequence"] = "true"
513 
514  if hasattr(Configurable, "_configurationLocked"):
515  Configurable._configurationLocked = True
516 
517  if attach_debugger:
518  self.hookDebugger()
519 
520  self.log.debug("-" * 80)
521  self.log.debug("%s: running in serial mode", __name__)
522  self.log.debug("-" * 80)
523  sysStart = time()
524 
525  import Gaudi
526 
527  app = Gaudi.Application.create(self.application, conf_dict)
528  retcode = app.run()
529 
530  sysTime = time() - sysStart
531  self.log.debug("-" * 80)
532  self.log.debug(
533  "%s: serial system finished, time taken: %5.4fs", __name__, sysTime
534  )
535  self.log.debug("-" * 80)
536 
537  return retcode
538 
539  def runParallel(self, ncpus):
540  self.setupParallelLogging()
541  import GaudiMP.GMPBase as gpp
542  from Gaudi.Configuration import Configurable
543 
544  c = Configurable.allConfigurables
545  self.log.info("-" * 80)
546  self.log.info("%s: Parallel Mode : %i ", __name__, ncpus)
547  for name, value in [
548  ("platform", " ".join(os.uname())),
549  ("config", os.environ.get("BINARY_TAG") or os.environ.get("CMTCONFIG")),
550  ("app. name", os.environ.get("GAUDIAPPNAME")),
551  ("app. version", os.environ.get("GAUDIAPPVERSION")),
552  ]:
553  self.log.info("%s: %30s : %s ", __name__, name, value or "Undefined")
554  try:
555  events = str(c["ApplicationMgr"].EvtMax)
556  except:
557  events = "Undetermined"
558  self.log.info("%s: Events Specified : %s ", __name__, events)
559  self.log.info("-" * 80)
560  # Parall = gpp.Coordinator(ncpus, shared, c, self.log)
561  Parall = gpp.Coord(ncpus, c, self.log)
562  sysStart = time()
563  sc = Parall.Go()
564  self.log.info("MAIN.PY : received %s from Coordinator" % (sc))
565  if sc.isFailure():
566  return 1
567  sysTime = time() - sysStart
568  self.log.name = "Gaudi/Main.py Logger"
569  self.log.info("-" * 80)
570  self.log.info(
571  "%s: parallel system finished, time taken: %5.4fs", __name__, sysTime
572  )
573  self.log.info("-" * 80)
574  return 0
Gaudi::Details::PropertyBase
PropertyBase base class allowing PropertyBase* collections to be "homogeneous".
Definition: PropertyBase.h:35
Gaudi.Main.BootstrapHelper.ROOT_VERSION
def ROOT_VERSION(self)
Definition: Main.py:174
Gaudi.Application.create
def create(cls, appType, opts)
Definition: __init__.py:112
Gaudi.Main.BootstrapHelper.AppMgr.finalize
def finalize(self)
Definition: Main.py:81
Gaudi.Main.gaudimain.generatePyOutput
def generatePyOutput(self, all=False)
Definition: Main.py:381
Gaudi.Main.gaudimain.application
application
Definition: Main.py:341
Gaudi.Main.gaudimain.hookDebugger
def hookDebugger(self, debugger="gdb")
Definition: Main.py:479
GaudiMP.GMPBase
Definition: GMPBase.py:1
Gaudi.Main.BootstrapHelper.Property.__init__
def __init__(self, value)
Definition: Main.py:45
Gaudi.Main.BootstrapHelper.lib
lib
Definition: Main.py:130
Gaudi.Main.BootstrapHelper.AppMgr.terminate
def terminate(self)
Definition: Main.py:86
py_bootstrap_app_run
bool py_bootstrap_app_run(IInterface *i, int maxevt)
Definition: Bootstrap.cpp:263
Gaudi.Main.BootstrapHelper.AppMgr.ptr
ptr
Definition: Main.py:56
Gaudi.Main.gaudimain.writeconfig
def writeconfig(self, filename, all=False)
Definition: Main.py:432
Gaudi.Main.BootstrapHelper.AppMgr.run
def run(self, nevt)
Definition: Main.py:73
Containers::map
struct GAUDI_API map
Parametrisation class for map-like implementation.
Definition: KeyedObjectManager.h:35
Gaudi.Main.BootstrapHelper.AppMgr.lib
lib
Definition: Main.py:57
Gaudi.Main.BootstrapHelper.StatusCode.__init__
def __init__(self, value)
Definition: Main.py:27
Gaudi.Main.gaudimain.printconfig
def printconfig(self, old_format=False, all=False)
Definition: Main.py:421
GaudiKernel.Proxy.getNeededConfigurables
getNeededConfigurables
Definition: Proxy.py:30
Gaudi.Main.BootstrapHelper.AppMgr.start
def start(self)
Definition: Main.py:70
Gaudi.Main.BootstrapHelper.__init__
def __init__(self)
Definition: Main.py:114
Gaudi.Main.BootstrapHelper.StatusCode.isSuccess
def isSuccess(self)
Definition: Main.py:35
Gaudi.Main.BootstrapHelper.Property.value
value
Definition: Main.py:46
plotSpeedupsPyRoot.time
def time
Definition: plotSpeedupsPyRoot.py:175
Gaudi.Main.gaudimain.__init__
def __init__(self)
Definition: Main.py:331
Gaudi.Main.parseOpt
def parseOpt(s)
Definition: Main.py:299
Gaudi.Main.BootstrapHelper.AppMgr.setOption
def setOption(self, key, value)
Definition: Main.py:109
Gaudi.Main.BootstrapHelper.AppMgr.initialize
def initialize(self)
Definition: Main.py:65
Gaudi.Main.BootstrapHelper.AppMgr
Definition: Main.py:54
Gaudi.Main.BootstrapHelper.AppMgr.getProperty
def getProperty(self, name)
Definition: Main.py:101
Gaudi.Main.gaudimain.generateOptsOutput
def generateOptsOutput(self, all=False)
Definition: Main.py:400
Gaudi.Configuration
Definition: Configuration.py:1
GaudiPython.HistoUtils.__repr__
__repr__
Definition: HistoUtils.py:536
Gaudi.Main.BootstrapHelper.AppMgr.setProperty
def setProperty(self, name, value)
Definition: Main.py:94
Gaudi.Main.BootstrapHelper.StatusCode
Definition: Main.py:26
Gaudi.Main.gaudimain.runSerial
def runSerial(self, attach_debugger)
Definition: Main.py:497
Gaudi.Main.gaudimain
Definition: Main.py:330
Gaudi.Main.BootstrapHelper.createApplicationMgr
def createApplicationMgr(self)
Definition: Main.py:165
format
GAUDI_API std::string format(const char *,...)
MsgStream format utility "a la sprintf(...)".
Definition: MsgStream.cpp:119
Gaudi.Main.gaudimain.setupParallelLogging
def setupParallelLogging(self)
Definition: Main.py:343
py_helper_printAlgsSequences
void py_helper_printAlgsSequences(IInterface *app)
Helper to call printAlgsSequences from Pyhton ctypes.
Definition: PrintAlgsSequences.cpp:57
Gaudi.Main.gaudimain.log
log
Definition: Main.py:339
gaudirun.type
type
Definition: gaudirun.py:160
Gaudi.Main.gaudimain.run
def run(self, attach_debugger, ncpus=None)
Definition: Main.py:470
Gaudi.Main._getAllOpts_old
def _getAllOpts_old(explicit_defaults=False)
Definition: Main.py:182
Gaudi.Main.BootstrapHelper.StatusCode.__bool__
def __bool__(self)
Definition: Main.py:30
Gaudi.Main.BootstrapHelper.ROOT_VERSION_CODE
def ROOT_VERSION_CODE(self)
Definition: Main.py:170
ApplicationMgr
Definition: ApplicationMgr.h:57
Gaudi.Main.gaudimain._writepickle
def _writepickle(self, filename)
Definition: Main.py:407
Gaudi.Main.BootstrapHelper.log
log
Definition: Main.py:124
Gaudi.Main.BootstrapHelper.Property
Definition: Main.py:44
Gaudi.Main.BootstrapHelper.StatusCode.isFailure
def isFailure(self)
Definition: Main.py:38
Gaudi.Main.gaudimain.printsequence
printsequence
Definition: Main.py:340
Gaudi.Main.toOpt
def toOpt(value)
Definition: Main.py:275
Gaudi.Main.BootstrapHelper.AppMgr.stop
def stop(self)
Definition: Main.py:78
Gaudi.Main.BootstrapHelper.AppMgr._as_parameter_
_as_parameter_
Definition: Main.py:58
Gaudi.Main.BootstrapHelper.StatusCode.value
value
Definition: Main.py:28
Gaudi.Main.BootstrapHelper
Definition: Main.py:25
Gaudi.Main.getAllOpts
def getAllOpts(explicit_defaults=False)
Definition: Main.py:237
Gaudi.Main.BootstrapHelper.StatusCode.ignore
def ignore(self)
Definition: Main.py:41
Gaudi.Main.BootstrapHelper.Property.__str__
def __str__(self)
Definition: Main.py:48
Gaudi.Main.BootstrapHelper.AppMgr.printAlgsSequences
def printAlgsSequences(self)
Definition: Main.py:106
Gaudi.Main.BootstrapHelper.AppMgr.__init__
def __init__(self, ptr, lib)
Definition: Main.py:55
Gaudi.Main.gaudimain.runParallel
def runParallel(self, ncpus)
Definition: Main.py:539
GaudiKernel.Configurable.expandvars
def expandvars(data)
Definition: Configurable.py:73
Gaudi.Main.BootstrapHelper.AppMgr.configure
def configure(self)
Definition: Main.py:60
GaudiPython.Pythonizations.items
items
Definition: Pythonizations.py:546
Gaudi.Main.BootstrapHelper.AppMgr.getService
def getService(self, name)
Definition: Main.py:91