GaudiPython.Bindings.AppMgr Class Reference

Inheritance diagram for GaudiPython.Bindings.AppMgr:

Collaboration diagram for GaudiPython.Bindings.AppMgr:

Public Member Functions
def	__new__
def	__reset__
def	__init__
def	state
def	FSMState
def	targetFSMState
def	service
def	declSvcType
def	createSvc
def	services
def	algorithm
def	algorithms
def	tool
def	property
def	datasvc
def	evtsvc
def	detsvc
def	filerecordsvc
def	evtsel
def	histsvc
def	ntuplesvc
def	partsvc
def	toolsvc
def	optSvc
def	readOptions
def	addAlgorithm
def	setAlgorithms
def	removeAlgorithm
def	config
def	configure
def	start
def	run
def	executeEvent
def	execute
def	runSelectedEvents
def	exit
def	__del__
	Custom destructor to ensure that the application is correctly finalized when exiting from python. More...
Public Member Functions inherited from GaudiPython.Bindings.iService
def	__init__
def	retrieveInterface
def	isValid
Public Member Functions inherited from GaudiPython.Bindings.iProperty
def	__init__
def	getInterface
def	retrieveInterface
def	__call_interface_method__
def	__setattr__
def	__getattr__
def	properties
def	name

Public Attributes
	JobOptionsType
	OutputLevel
	topAlg

Static Public Attributes
	evtSvc = evtsvc
	histSvc = histsvc
	ntupleSvc = ntuplesvc
	evtSel = evtsel
	detSvc = detsvc
	toolSvc = toolsvc
	partSvc = partsvc
Static Public Attributes inherited from GaudiPython.Bindings.iService
tuple	initialize = lambdaself:self.__call_interface_method__("_isvc","initialize")
tuple	start = lambdaself:self.__call_interface_method__("_isvc","start")
tuple	stop = lambdaself:self.__call_interface_method__("_isvc","stop")
tuple	finalize = lambdaself:self.__call_interface_method__("_isvc","finalize")
tuple	reinitialize = lambdaself:self.__call_interface_method__("_isvc","reinitialize")
tuple	restart = lambdaself:self.__call_interface_method__("_isvc","restart")

Detailed Description

Definition at line 654 of file Bindings.py.

Constructor & Destructor Documentation

def GaudiPython.Bindings.AppMgr.__init__	(		self,
			outputlevel = -1,
			joboptions = None,
			selfoptions = {},
			dllname = None,
			factname = None
	)

Definition at line 676 of file Bindings.py.

                 dllname = None, factname = None) :
        global _gaudi
        if _gaudi : return
        # Protection against multiple calls to exit() if the finalization fails
        self.__dict__['_exit_called'] = False
        # keep the Gaudi namespace around (so it is still available during atexit shutdown)...
        self.__dict__['_gaudi_ns'] = Gaudi
        try:
            from GaudiKernel.Proxy.Configurable import expandvars
        except ImportError:
            # pass-through implementation if expandvars is not defined (AthenaCommon)
            expandvars = lambda data : data
        if dllname and factname:
            self.__dict__['_appmgr'] = gbl.Gaudi.createApplicationMgr(dllname,factname)
        elif dllname:
            self.__dict__['_appmgr'] = gbl.Gaudi.createApplicationMgr(dllname)
        else:
            self.__dict__['_appmgr'] = gbl.Gaudi.createApplicationMgr()
        self.__dict__['_svcloc'] = gbl.Gaudi.svcLocator()
        self.__dict__['_algmgr'] = InterfaceCast(gbl.IAlgManager)(self._appmgr)
        self.__dict__['_evtpro'] = InterfaceCast(gbl.IEventProcessor)(self._appmgr)
        self.__dict__['_svcmgr'] = InterfaceCast(gbl.ISvcManager)(self._appmgr)
        self.__dict__['pyalgorithms'] = []
        iService.__init__(self, 'ApplicationMgr', self._appmgr )
        #------python specific initialization-------------------------------------
        if self.FSMState() < Gaudi.StateMachine.CONFIGURED :  # Not yet configured
            self.JobOptionsType = 'NONE'
            if joboptions :
                from GaudiKernel.ProcessJobOptions import importOptions
                importOptions(joboptions)
            # Ensure that the ConfigurableUser instances have been applied
            import GaudiKernel.Proxy.Configurable
            if hasattr(GaudiKernel.Proxy.Configurable, "applyConfigurableUsers"):
                GaudiKernel.Proxy.Configurable.applyConfigurableUsers()
            # This is the default and could be overridden with "selfopts"
            self.OutputLevel = 3
            selfprops = Configurable.allConfigurables.get('ApplicationMgr',{})
            if selfprops : selfprops = expandvars(selfprops.getValuedProperties())
            for p,v in selfprops.items()   : setattr(self, p, v)
            for p,v in selfoptions.items() : setattr(self, p, v)
            # Override job options
            if outputlevel != -1 : self.OutputLevel = outputlevel
            self.configure()
        #---MessageSvc------------------------------------------------------------
        ms = self.service('MessageSvc')
        if 'MessageSvc' in Configurable.allConfigurables:
            msprops = Configurable.allConfigurables['MessageSvc']
            ms = self.service('MessageSvc')
            if hasattr(msprops,"getValuedProperties"):
                msprops = expandvars(msprops.getValuedProperties())
            for p,v in msprops.items():
                setattr(ms, p, v)
        if outputlevel != -1 : ms.OutputLevel = outputlevel
        #---JobOptions------------------------------------------------------------
        self.__dict__['_optsvc'] = InterfaceCast(gbl.IJobOptionsSvc)(Helper.service(self._svcloc,'JobOptionsSvc'))
        #------Configurables initialization (part2)-------------------------------
        for n in getNeededConfigurables():
            c = Configurable.allConfigurables[n]
            if n in ['ApplicationMgr','MessageSvc'] : continue # These are already done---
            for p, v in  c.getValuedProperties().items() :
                v = expandvars(v)
                # Note: AthenaCommon.Configurable does not have Configurable.PropertyReference
                if hasattr(Configurable,"PropertyReference") and type(v) == Configurable.PropertyReference:
                # this is done in "getFullName", but the exception is ignored,
                # so we do it again to get it
                    v = v.__resolve__()
                if   type(v) == str : v = '"%s"' % v # need double quotes
                elif type(v) == long: v = '%d'   % v # prevent pending 'L'
                self._optsvc.addPropertyToCatalogue(n, StringProperty(p,str(v)))
        if hasattr(Configurable,"_configurationLocked"):
            Configurable._configurationLocked = True

        # Ensure that the exit method is called when exiting from Python
        import atexit
        atexit.register(self.exit)

        #---Hack to avoid bad interactions with the ROOT exit handler
        # Look for an exit handler installed by ROOT
        root_handler_installed = False
        for h in atexit._exithandlers:
            func = h[0]
            if hasattr(func, "__module__") and func.__module__ == "ROOT":
                root_handler_installed = True
                break

        # If the handler is not yet installed, let's install our private version
        # that detects that the ROOT exit handler is installed and add our own
        # after it to ensure it is called before.
        if not root_handler_installed:
            orig_register = atexit.register
            def register(func, *targs, **kargs):
                orig_register(func, *targs, **kargs)
                if hasattr(func, "__module__") and func.__module__ == "ROOT":
                    orig_register(self.exit)
                    # we do not need to remove out handler from the list because
                    # it can be safely called more than once
            register.__doc__ = (orig_register.__doc__ +
                                "\nNote: version hacked by GaudiPython to work " +
                                "around a problem with the ROOT exit handler")
            atexit.register = register