/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Control/BossCommon/BossCommon-01-04-19/share/boss.py

Go to the documentation of this file.

exec env LD_PRELOAD="libGaudiKernel.so libBossServices.so $LD_PRELOAD" python -itx "$0" "$@"

# File: boss.py
# Author: Wim Lavrijsen (Wim.Lavrijsen@cern.ch)

# This script allows you to run Boss from python. It is developed against
# GaudiPython v4r0 and python 2.2.1, but will likely work for older versions
# of GaudiPython and python versions after 2.0.
# A jobOptions.txt file is allowed for backwards compatibility. Debugging is
# supported with the '-d' option.

### load python modules that are used in this script
import sys, os, re

### unhack the hack, such that it doesn't interfere with spawning of processes
if os.environ.has_key( 'LD_PRELOAD' ):
   import string
   ldpreload = string.strip( string.replace(
      os.environ[ 'LD_PRELOAD' ], 'libGaudiKernel.so libBossServices.so', '' ) )

   if len(ldpreload) == 0:
      del os.environ[ 'LD_PRELOAD' ]
   else:
      os.environ[ 'LD_PRELOAD' ] = ldpreload

### readline support
import rlcompleter, readline

# workaround for gcc dynamic loading change, unless GaudiKernel is preloaded
#if sys.platform == 'linux2':
#   import commands
#   stat, out = commands.getstatusoutput( 'gcc -dumpversion' )
#   if 3 <= len(out) and out[:3] == '3.2':
#      sys.setdlopenflags( 0x100 | 0x2 )      # RTLD_GLOBRAL | RTLD_NOW
#   del commands

### feedback to the user that she's running boss
sys.ps1 = 'boss> '

### messaging functions
def AthMessage( descr ):
   print " ==>         : " + descr

def AthWarning( descr ):
   print " ==> WARNING : " + descr

def AthError( descr ):
   print " ==> ERROR   : " + descr + '!'
   sys.exit( -1 )                            # <== Note exit function!

def Usage( prog ):
   print "usage: %s [-d [<debugger>]] [script1.py [script2.py [...]]]" % prog
   sys.exit( -1 )                            # <== Note exit function!

### file inclusion
try:
   optionsPath = os.environ[ 'JOBOPTSEARCHPATH' ]
except:
   optionsPath = os.curdir

optionsPath = re.split( ',|' + os.pathsep, optionsPath )
if '' in optionsPath:
   optionsPath[ optionsPath.index( '' ) ] = str(os.curdir)

def where( filename, pathlist = [] ):
 # special case for those filenames that already contain a path
   if os.path.dirname( filename ):
      if os.access( filename, os.R_OK ):
         return filename

 # test the file name in all possible paths until first found
   for path in pathlist:
      f = os.path.join( path, filename )
      if os.access( f, os.R_OK ):
         return f

 # no such accessible file avalailable
   return ''

def printFile( fn ):
   AthMessage( 'begin listing of "%s"' % fn )

   f = open( fn, 'r' )
   for line in f.readlines():
      print line,
   f.close()

   AthMessage( 'end listing of "%s"' % fn )

def include( fn ):
   name = where( os.path.expanduser( os.path.expandvars( fn ) ), optionsPath )
   if not os.path.exists( name ):
      name = where( os.path.basename( fn ), optionsPath )
      if os.path.exists( name ):
         AthWarning( 'using %s instead of %s' % (name,fn) )
      else:
         AthError( 'include file %s can not be found' % fn )   # exits

   printFile( name )
   execfile( name, globals() )

### check version
if sys.hexversion != 0x020001F0 and not ( 0x20200F0 <= sys.hexversion
      and sys.hexversion <= 0x020203F0 ):
   AthWarning( "script only tested with python 2.0.1, 2.2.[0123]" )

### setup variable name completion
readline.parse_and_bind( 'tab: complete' )
readline.parse_and_bind( 'set show-all-if-ambiguous On' )

### use default 'jobOptions.txt' file for backwards compatibility
argc = len( sys.argv )
jobOptions = ""
if argc == 1 or ( ( argc == 2 or argc == 3 ) and sys.argv[1] == '-d' ):
   if os.path.exists( "jobOptions.txt" ): jobOptions = "jobOptions.txt"

### get user options and store names of any additional scripts
doDebug = ( '', 0 )              # no debugging by default
scripts = []
for arg in sys.argv[1:]:
   if arg == '-d':
      doDebug = ( 'gdb', 1 )     # select debugging, default gdb
      continue
   elif arg[0] == '-':           # unknown option, probably request for help
      Usage( sys.argv[0] )
   elif not ( doDebug[1] or os.path.exists( arg ) ): # expect files or debugger option
      AthError( "file '%s' does not exist" % arg )

   if arg[-3:] == ".py":         # select python scripts
      scripts.append( arg )
   elif arg[-4:] == ".txt":      # allow 1 jobOptions.txt file
      if jobOptions != "":
         AthWarning( "ignoring file '%s'" % arg )
      else:
         jobOptions = arg
   else: # what's the user trying to do?!
      if doDebug[1]: # perhaps user specified a debugger?
         doDebug = ( arg, 0 )    # select arg and (temporarily) deselect debugging
      else: # well, that seems unintelligible
         Usage( sys.argv[0] )

### if a (seemingly valid) debugger was specified, reselect debugging
if len( doDebug[0] ):
   doDebug = ( doDebug[0], 1 )

### debugging helper, hook onto interpreter (ok for gdb/Linux and dbx/Solaris)
def __hookDebugger( prog ):
   if len( prog ):
      pid = os.spawnvp( os.P_NOWAIT, prog, [ prog, 'python', str( os.getpid() ) ] )
    # give debugger some time to attach to the python process
      import time
      time.sleep( 0.500 )

### get Gaudi extension classes
from gaudimodule import *
gaudimodule = sys.modules[ 'gaudimodule' ]
del Algorithm, Service

### event selector constants
NO_EVSEL    = -99
MONTECARLO  = 0
ZEBRA       = 1

### modify the behaviour of the application manager
class AthAppMgr( AppMgr ):
 ## add an initialization guard
   def __init__( self ):
      AppMgr.__init__( self )
      self.__dict__[ "isInitialized" ] = 0

 ## helper for loading the proper libraries for each event selector
   def _selectEventSelector( self, evsel ):
      if evsel == MONTECARLO:
         self.Dlls   += [ "McEventSelector" ]
         self.ExtSvc += [ "McCnvSvc", "McEventSelector/EventSelector" ]
         self.EvtSel  = "Mc"

      elif evsel == ZEBRA:
         self.Dlls   += [ "DetDescrCnvSvc", "ZebraTDRCnv", "HbookCnv" ]
         self.Dlls   += [ "IdDictDetDescrCnv" ] # needed by DetDescrCnvSvc

         self.ExtSvc += [ "DetDescrCnvSvc" ]    # included _before_ event selector
         self.ExtSvc += [ "ZebraTDRCnvSvc", "ZebraTDREventSelector/EventSelector" ]
         self.EvtSel = "ZebraTDR"

      elif evsel == NO_EVSEL:
         pass                      # quiet

      else:
         AthMessage( "unknown event selector, nothing selected" )

 ## helper to load the services during setup
   def _setupServices( self, evsel ):
      global DetectorStore, EventPersistencySvc, EventSelector, MessageSvc, StoreGate

      DetectorStore            = Service( "DetectorStore" )
      EventPersistencySvc      = Service( "EventPersistencySvc" )
      EventSelector            = Service( "EventSelector" )
      MessageSvc               = Service( "MessageSvc" )
      StoreGate                = Service( "StoreGateSvc" )

      if evsel == MONTECARLO:
         global McCnvSvc
         McCnvSvc                 = Service( "McCnvSvc" )
         EventPersistencySvc.CnvServices = [ "McCnvSvc" ]

      elif evsel == ZEBRA:
         global DetDescrCnvSvc, ZebraTDRCnvSvc
         DetDescrCnvSvc           = Service( "DetDescrCnvSvc" )
         ZebraTDRCnvSvc           = Service( "ZebraTDRCnvSvc" )
         EventPersistencySvc.CnvServices = [ "DetDescrCnvSvc", "ZebraTDRCnvSvc" ]

         DetDescrCnvSvc.IdDictName = "BES_IDS.xml"
         DetDescrCnvSvc.CompactIDsOnly = TRUE

      elif evsel == NO_EVSEL:
         pass                      # quiet

      else:
         AthMessage( "unknown event selector, none instantiated" )

      MessageSvc.OutputLevel             = INFO

  ## user  call
   def setup( self, name = NO_EVSEL ):
    # get the proper event selector
      self._selectEventSelector( name )

    # actual loading of all specified dlls and services
      AthMessage( "configuring ... " )
      self.config()

    # add auditor function to the AuditorSvc
      audSvc = AuditorSvc()
      audSvc.__dict__[ 'auditor' ] = theApp.service

    # create views of services for the user
      self._setupServices( name )

 ## redefine run to force initialisation
   def run( self, nEvt = -1 ):
    # get current state (TODO: get state from Boss/C++ side)
      init = self.__dict__[ "isInitialized" ]

    # initialize if needed
      if not init:
         AthMessage( "initializing ... " )
         status = self.initialize()
         if not status.isSuccess():
            raise RuntimeError, "application manager initialization failed"
         self.__dict__[ "isInitialized" ] = 1

    # determine number of events
      if nEvt <= 0:
         if 0 < self.EvtMax:
            nEvt = self.EvtMax
         else:
            nEvt = 1

    # actual run
      AppMgr.execute( self, nEvt )

### get a view of the application manager and start in a non-initialised state
theApp = AthAppMgr()

### rebind globals to call directly into the application manager view
def _cachedLookup( name, cache, func ):
   try:
      res = cache[ name ]
   except KeyError:
      res = func( name )
      cache[ name ] = res
   return res

_algorithms, _services = {}, {}
Algorithm  = lambda name : _cachedLookup( name, _algorithms, theApp.algorithm )
Service    = lambda name : _cachedLookup( name, _services,   theApp.service   )
AuditorSvc = lambda : _cachedLookup( 'AuditorSvc', _services, theApp.service )

### hacks to allow assignment to non-existent lists ...
class _AlgSvcMemberProxy:
   def __init__( self, name, owner ):
      self.__dict__[ 'name' ] = name
      self.__dict__[ 'owner' ] = owner
      self.owner.__dict__[ self.name ] = self

   def __iadd__( self, what ):
      del self.owner.__dict__[ self.name ]                            # Python
      self.owner.__class__.__setattr__( self.owner, self.name, what ) # C++
      return getattr( self.owner, self.name )

   def __setattr__( self, attr, value ):
      fullname = self.owner.name() + '.' + self.name
      if type( self.owner ) == type( gaudimodule.Algorithm ):
         newself = Algorithm( fullname )
      else:
         newself = Service( fullname )
      self.owner.__dict__[ self.name ] = newself
      setattr( newself, attr, value )

class _AlgSvcRedirect:
   def __init__( self, func ):
      self.func = func

   def __call__( self, what, name ):
      try:
         return self.func( what, name )
      except ( TypeError, RuntimeError ):
         return _AlgSvcMemberProxy( name, what )

gaudimodule.Algorithm.__getattr__ = _AlgSvcRedirect( gaudimodule.Algorithm.__getattr__ )
gaudimodule.Service.__getattr__   = _AlgSvcRedirect( gaudimodule.Service.__getattr__ )


### take care of job options legacy
theApp.JobOptionsPath = jobOptions
if jobOptions != "":
   AthWarning( "using job options file '%s'" % jobOptions )
   theApp.JobOptionsType    = "FILE"
else:
   theApp.JobOptionsType    = "NONE"

### specify the required dlls and start the required services

# BossServices is not needed if it is preloaded, which is currently the case
#theApp.Dlls    = [ "BossServices" ]

theApp.ExtSvc  = [ "IncidentSvc/IncidentSvc",
                   "EvtPersistencySvc/EventPersistencySvc",
                   "HistogramSvc/HistogramDataSvc",
                   "NTupleSvc/NTupleSvc",
                   "ToolSvc/ToolSvc",
                   "AuditorSvc/AuditorSvc",
                   "RndmGenSvc/RndmGenSvc",
                   "ChronoStatSvc/ChronoStatSvc" ]

### specify StoreGate dlls and services
try:
   sgfile = os.path.join( os.environ[ 'STOREGATEROOT' ], 'share', 'StoreGate.py' )
   include( sgfile )
except (KeyError, IOError, OSError):
   AthWarning( "StoreGate.py not found, selecting defaults" )
   theApp.Dlls   += [ 'StoreGate', 'CLIDSvc' ]
   theApp.ExtSvc += [ 'ClassIDSvc' ]
   theApp.ExtSvc += [ 'StoreGateSvc', 'StoreGateSvc/DetectorStore', 'StoreGateSvc/ConditionsStore' ]
   theApp.ExtSvc += [ 'ActiveStoreSvc' ]

### Bes specific event loop and output stream
theApp.EventLoop         = "BossEventLoopMgr"
theApp.OutStreamType     = "BossOutputStream"

### some useful constants
ALL     = 0
VERBOSE = 1
DEBUG   = 2
INFO    = 3
WARNING = 4
ERROR   = 5
FATAL   = 6

TRUE    = 1
FALSE   = 0

### from this point, user code with algorithms can take over
if len( scripts ):
 # simplistic sanity check
   doesSetup = 0
   scrfile = open( scripts[ 0 ], 'r' )
   for line in scrfile.readlines():
      pos = line.find( "theApp.setup" )
      if 0 <= pos and line[:pos].find( '#' ) < 0:
         doesSetup = 1
         break
   del scrfile

   if not doesSetup:
      AthWarning( "missing call to 'theApp.setup()' in first script" )

 # ready for execution, set the exit handler
   import atexit
   atexit.register( theApp.exit )

 # process all user provided scripts
   for script in scripts:
      include( script )

 # start debugging after all user provided scripts
   if doDebug[1]:
      __hookDebugger( doDebug[0] )

elif jobOptions != "":   # run in batch mode
 # actual run, note that this is fully batch if we're not debugging
   theApp.config()
   theApp.initialize()

 # all symbols have been loaded, but nothing has been run, good time for debug
   if doDebug[1]:
      __hookDebugger( doDebug[0] )

 # resume batch mode
   theApp.run( theApp.EvtMax )
   theApp.exit()

# still here? Ok, go interactive
AthMessage( 'entered interactive mode' )

---