GaudiPython::Bindings::AppMgr Class Reference

Inheritance diagram for GaudiPython::Bindings::AppMgr:

Collaboration diagram for GaudiPython::Bindings::AppMgr:

List of all members.

Public Member Functions

def __new__

def __reset__

def __init__

def state

def FSMState

def targetFSMState

def loaddict

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.

Public Attributes

JobOptionsType

OutputLevel

topAlg

Static Public Attributes

evtSvc = evtsvc

histSvc = histsvc

ntupleSvc = ntuplesvc

evtSel = evtsel

detSvc = detsvc

toolSvc = toolsvc

partSvc = partsvc

Detailed Description

Definition at line 656 of file Bindings.py.

Member Function Documentation

def GaudiPython::Bindings::AppMgr::__new__	(	cls,
		args,
		kwargs
	)

Definition at line 657 of file Bindings.py.

00657                                         :
00658         global _gaudi
00659         if not _gaudi :
00660             newobj = object.__new__( cls, *args, **kwargs )
00661             cls.__init__(newobj, *args, **kwargs)
00662             _gaudi = newobj
00663         return _gaudi
    def __reset__(self):

def GaudiPython::Bindings::AppMgr::__reset__ ( self )

Definition at line 664 of file Bindings.py.

00664                        :
00665         global _gaudi
00666         # Stop, Finalize and Terminate the current AppMgr
00667         self.exit()
00668         # release interfaces
00669         self._evtpro.release()
00670         self._svcloc.release()
00671         self._appmgr.release()
00672         # Reset the C++ globals
00673         gbl.Gaudi.setInstance(makeNullPointer('ISvcLocator'))
00674         gbl.Gaudi.setInstance(makeNullPointer('IAppMgrUI'))
00675         # Reset the Python global
00676         _gaudi = None
    def __init__(self, outputlevel = -1, joboptions = None, selfoptions = {},

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

Definition at line 677 of file Bindings.py.

00677                                                                           {},
00678                  dllname = None, factname = None) :
00679         global _gaudi
00680         if _gaudi : return
00681         # Protection against multiple calls to exit() if the finalization fails
00682         self.__dict__['_exit_called'] = False
00683         try:
00684             from GaudiKernel.Proxy.Configurable import expandvars
00685         except ImportError:
00686             # pass-through implementation if expandvars is not defined (AthenaCommon)
00687             expandvars = lambda data : data
00688         if dllname and factname:
00689             self.__dict__['_appmgr'] = gbl.Gaudi.createApplicationMgr(dllname,factname)
00690         elif dllname:
00691             self.__dict__['_appmgr'] = gbl.Gaudi.createApplicationMgr(dllname)
00692         else:
00693             self.__dict__['_appmgr'] = gbl.Gaudi.createApplicationMgr()
00694         self.__dict__['_svcloc'] = gbl.Gaudi.svcLocator()
00695         self.__dict__['_algmgr'] = InterfaceCast(gbl.IAlgManager)(self._appmgr)
00696         self.__dict__['_evtpro'] = InterfaceCast(gbl.IEventProcessor)(self._appmgr)
00697         self.__dict__['_svcmgr'] = InterfaceCast(gbl.ISvcManager)(self._appmgr)
00698         self.__dict__['pyalgorithms'] = []
00699         iService.__init__(self, 'ApplicationMgr', self._appmgr )
00700         #------python specific initialization-------------------------------------
00701         if self.FSMState() < Gaudi.StateMachine.CONFIGURED :  # Not yet configured
00702             self.JobOptionsType = 'NONE'
00703             if joboptions :
00704                 from GaudiKernel.ProcessJobOptions import importOptions
00705                 importOptions(joboptions)
00706             # Ensure that the ConfigurableUser instances have been applied
00707             import GaudiKernel.Proxy.Configurable
00708             if hasattr(GaudiKernel.Proxy.Configurable, "applyConfigurableUsers"):
00709                 GaudiKernel.Proxy.Configurable.applyConfigurableUsers()
00710             # This is the default and could be overridden with "selfopts"
00711             self.OutputLevel = 3
00712             selfprops = Configurable.allConfigurables.get('ApplicationMgr',{})
00713             if selfprops : selfprops = expandvars(selfprops.getValuedProperties())
00714             for p,v in selfprops.items()   : setattr(self, p, v)
00715             for p,v in selfoptions.items() : setattr(self, p, v)
00716             # Override job options
00717             if outputlevel != -1 : self.OutputLevel = outputlevel
00718             self.configure()
00719         #---MessageSvc------------------------------------------------------------
00720         ms = self.service('MessageSvc')
00721         if 'MessageSvc' in Configurable.allConfigurables:
00722             msprops = Configurable.allConfigurables['MessageSvc']
00723             ms = self.service('MessageSvc')
00724             if hasattr(msprops,"getValuedProperties"):
00725                 msprops = expandvars(msprops.getValuedProperties())
00726             for p,v in msprops.items():
00727                 setattr(ms, p, v)
00728         if outputlevel != -1 : ms.OutputLevel = outputlevel
00729         #---JobOptions------------------------------------------------------------
00730         self.__dict__['_optsvc'] = InterfaceCast(gbl.IJobOptionsSvc)(Helper.service(self._svcloc,'JobOptionsSvc'))
00731         #------Configurables initialization (part2)-------------------------------
00732         for n in getNeededConfigurables():
00733             c = Configurable.allConfigurables[n]
00734             if n in ['ApplicationMgr','MessageSvc'] : continue # These are already done---
00735             for p, v in  c.getValuedProperties().items() :
00736                 v = expandvars(v)
00737                 # Note: AthenaCommon.Configurable does not have Configurable.PropertyReference
00738                 if hasattr(Configurable,"PropertyReference") and type(v) == Configurable.PropertyReference:
00739                 # this is done in "getFullName", but the exception is ignored,
00740                 # so we do it again to get it
00741                     v = v.__resolve__()
00742                 if   type(v) == str : v = '"%s"' % v # need double quotes
00743                 elif type(v) == long: v = '%d'   % v # prevent pending 'L'
00744                 self._optsvc.addPropertyToCatalogue(n, StringProperty(p,str(v)))
00745         if hasattr(Configurable,"_configurationLocked"):
00746             Configurable._configurationLocked = True

def GaudiPython::Bindings::AppMgr::state ( self )

Definition at line 747 of file Bindings.py.

00747 : return self._isvc.FSMState()

def GaudiPython::Bindings::AppMgr::FSMState ( self )

Definition at line 748 of file Bindings.py.

00748 : return self._isvc.FSMState()

def GaudiPython::Bindings::AppMgr::targetFSMState ( self )

Definition at line 749 of file Bindings.py.

00749 : return self._isvc.targetFSMState()

def GaudiPython::Bindings::AppMgr::loaddict	(	self,
		dict
	)

Definition at line 750 of file Bindings.py.

00750                              :
00751         loaddict(dict)
    def service(self, name, interface = None) :

def GaudiPython::Bindings::AppMgr::service	(	self,
		name,
		interface = `None`
	)

Definition at line 752 of file Bindings.py.

00752                                               :
00753         svc = Helper.service( self._svcloc, name )
00754         if interface :
00755             return InterfaceCast(interface)(svc)
00756         else :
00757             return iService(name, svc )
    def declSvcType(self, svcname, svctype ) :

def GaudiPython::Bindings::AppMgr::declSvcType	(	self,
		svcname,
		svctype
	)

Definition at line 758 of file Bindings.py.

00758                                              :
00759         self._svcmgr.declareSvcType(svcname, svctype)
    def createSvc(self, name ) :

def GaudiPython::Bindings::AppMgr::createSvc	(	self,
		name
	)

Definition at line 760 of file Bindings.py.

00760                                :
00761         return Helper.service( self._svcloc, name, True )
    def services(self) :

def GaudiPython::Bindings::AppMgr::services ( self )

Definition at line 762 of file Bindings.py.

00762                        :
00763         l = self._svcloc.getServices()
00764         nl = l.__class__(l)  # get a copy
00765         s = []
00766         for i in range(l.size()) :
00767             s.append(nl.front().name())
00768             nl.pop_front()
00769         return s
    def algorithm(self, name ) :

def GaudiPython::Bindings::AppMgr::algorithm	(	self,
		name
	)

Definition at line 770 of file Bindings.py.

00770                                :
00771         alg = Helper.algorithm( self._algmgr, name )
00772         return iAlgorithm(name, alg )
    def algorithms(self) :

def GaudiPython::Bindings::AppMgr::algorithms ( self )

Definition at line 773 of file Bindings.py.

00773                          :
00774         l = self._algmgr.getAlgorithms()
00775         nl = l.__class__(l)  # get a copy
00776         s = []
00777         for i in range(l.size()) :
00778             s.append(nl.front().name())
00779             nl.pop_front()
00780         return s
    def tool(self, name ) :

def GaudiPython::Bindings::AppMgr::tool	(	self,
		name
	)

Definition at line 781 of file Bindings.py.

00781                           :
00782         return iAlgTool(name)
    def property( self , name ) :

def GaudiPython::Bindings::AppMgr::property	(	self,
		name
	)

Definition at line 783 of file Bindings.py.

00783                                 :
00784         if name in self.algorithms() : return self.algorithm( name )
00785         elif name in self.services() : return self.service(name )
00786         else :                         return iProperty( name )
    def datasvc(self, name) :

def GaudiPython::Bindings::AppMgr::datasvc	(	self,
		name
	)

Definition at line 787 of file Bindings.py.

00787                             :
00788         if self.state() == Gaudi.StateMachine.CONFIGURED :  self.initialize()
00789         svc = Helper.service( self._svcloc, name )
00790         return iDataSvc(name, svc)
    def evtsvc(self) :

def GaudiPython::Bindings::AppMgr::evtsvc ( self )

Definition at line 791 of file Bindings.py.

00791                      :
00792         return self.datasvc('EventDataSvc')
    def detsvc(self) :

def GaudiPython::Bindings::AppMgr::detsvc ( self )

Definition at line 793 of file Bindings.py.

00793                      :
00794         return self.datasvc('DetectorDataSvc')
    def filerecordsvc(self) :

def GaudiPython::Bindings::AppMgr::filerecordsvc ( self )

Definition at line 795 of file Bindings.py.

00795                             :
00796         return self.datasvc('FileRecordDataSvc')
    def evtsel(self):

def GaudiPython::Bindings::AppMgr::evtsel ( self )

Definition at line 797 of file Bindings.py.

00797                     :
00798         if self.state() == Gaudi.StateMachine.CONFIGURED :  self.initialize()
00799         if not hasattr(self,'_evtsel') : self.__dict__['_evtsel'] = iEventSelector()
00800         return self._evtsel
    def histsvc(self, name='HistogramDataSvc') :

def GaudiPython::Bindings::AppMgr::histsvc	(	self,
		name = `'HistogramDataSvc'`
	)

Definition at line 801 of file Bindings.py.

00801                                                :
00802         svc = Helper.service( self._svcloc, name )
00803         return iHistogramSvc(name, svc)
    def ntuplesvc(self, name='NTupleSvc') :

def GaudiPython::Bindings::AppMgr::ntuplesvc	(	self,
		name = `'NTupleSvc'`
	)

Definition at line 804 of file Bindings.py.

00804                                           :
00805         if name not in self.ExtSvc : self.ExtSvc += [name]
00806 #    if self.HistogramPersistency == 'NONE' : self.HistogramPersistency = 'ROOT'
00807         svc = Helper.service( self._svcloc, name, True )
00808         return iNTupleSvc(name, svc)
    def partsvc(self ) :

def GaudiPython::Bindings::AppMgr::partsvc ( self )

Definition at line 809 of file Bindings.py.

00809                        :
00810         if self.FSMState() == Gaudi.StateMachine.CONFIGURED :  self.initialize()
00811         svc = Helper.service( self._svcloc, 'ParticlePropertySvc' )
00812         return InterfaceCast(gbl.IParticlePropertySvc)(svc)
    def toolsvc(self, name='ToolSvc') :

def GaudiPython::Bindings::AppMgr::toolsvc	(	self,
		name = `'ToolSvc'`
	)

Definition at line 813 of file Bindings.py.

00813                                       :
00814         svc = Helper.service( self._svcloc, name, True )
00815         return iToolSvc(name, svc)
    def optSvc (self, name='JobOptionsSvc') :

def GaudiPython::Bindings::AppMgr::optSvc	(	self,
		name = `'JobOptionsSvc'`
	)

Definition at line 816 of file Bindings.py.

00816                                             :
00817         svc = Helper.service( self._svcloc, name, True )
00818         return iJobOptSvc(name, svc)
    def readOptions(self, file) :

def GaudiPython::Bindings::AppMgr::readOptions	(	self,
		file
	)

Definition at line 819 of file Bindings.py.

00819                                 :
00820         return self._optsvc.readOptions(file)
    def addAlgorithm(self, alg) :

def GaudiPython::Bindings::AppMgr::addAlgorithm	(	self,
		alg
	)

Add an Algorithm to the list of Top algorithms. It can be either a instance of
    an Algorithm class or it name

Definition at line 821 of file Bindings.py.

00821                                 :
00822         """ Add an Algorithm to the list of Top algorithms. It can be either a instance of
00823             an Algorithm class or it name """
00824         if type(alg) is  str :
00825             self.topAlg += [alg]
00826         else :
00827             self.pyalgorithms.append(alg)
00828             setOwnership(alg,0)
00829             if self.targetFSMState() >= Gaudi.StateMachine.INITIALIZED :
00830                 alg.sysInitialize()
00831                 if self.targetFSMState() == Gaudi.StateMachine.RUNNING :
00832                     alg.sysStart()
00833             self.topAlg += [alg.name()]
    def setAlgorithms(self, algs) :

def GaudiPython::Bindings::AppMgr::setAlgorithms	(	self,
		algs
	)

Set the list of Top Algorithms.
    It can be an individual of a list of algorithms names or instances

Definition at line 834 of file Bindings.py.

00834                                   :
00835         """ Set the list of Top Algorithms.
00836             It can be an individual of a list of algorithms names or instances """
00837         if type(algs) is not list : algs = [algs]
00838         names = []
00839         for alg in algs :
00840             if type(alg) is str : names.append(alg)
00841             else :
00842                 self.pyalgorithms.append(alg)
00843                 if self.targetFSMState() >= Gaudi.StateMachine.INITIALIZED :
00844                     alg.sysInitialize()
00845                     if self.targetFSMState() == Gaudi.StateMachine.RUNNING :
00846                         alg.sysStart()
00847                 names.append(alg.name())
00848         self.topAlg = names
    def removeAlgorithm(self, alg) :

def GaudiPython::Bindings::AppMgr::removeAlgorithm	(	self,
		alg
	)

Remove an Algorithm to the list of Top algorithms. It can be either a instance of
    an Algorithm class or it name

Definition at line 849 of file Bindings.py.

00849                                    :
00850         """ Remove an Algorithm to the list of Top algorithms. It can be either a instance of
00851             an Algorithm class or it name """
00852         tmp = self.topAlg
00853         if type(alg) is  str :
00854             tmp.remove(alg)
00855         else :
00856             tmp.remove(alg.name())
00857             self.pyalgorithms.remove(alg)
00858             setOwnership(alg,1)
00859         self.topAlg = tmp
    def config ( self, **args ):

def GaudiPython::Bindings::AppMgr::config	(	self,
		args
	)

Simple utility to perform the configuration of Gaudi application.
It reads the set of input job-options files, and set few
additional parameters 'options' through the usage of temporary *.opts file
Usage:
gaudi.config( files   = [ '$GAUSSOPTS/Gauss.opts'                     ,
                  '$DECFILESROOT/options/10022_010.0GeV.opts' ] ,
      options = [ 'EventSelector.PrintFreq   =   5  '         ] )

Definition at line 860 of file Bindings.py.

00860                                :
00861         """
00862         Simple utility to perform the configuration of Gaudi application.
00863         It reads the set of input job-options files, and set few
00864         additional parameters 'options' through the usage of temporary *.opts file
00865         Usage:
00866         gaudi.config( files   = [ '$GAUSSOPTS/Gauss.opts'                     ,
00867                                   '$DECFILESROOT/options/10022_010.0GeV.opts' ] ,
00868                       options = [ 'EventSelector.PrintFreq   =   5  '         ] )
00869         """
00870         files  = args.get('files',[])
00871         for file in files :
00872             sc = self.readOptions(file)
00873             if sc.isFailure() :
00874                 raise RuntimeError , ' Unable to read file "' + file +'" '
00875         options  = args.get('options',None)
00876         if options :
00877             import tempfile
00878             tmpfilename = tempfile.mktemp()
00879             tmpfile     = open( tmpfilename, 'w' )
00880             tmpfile.write ( '#pragma print on  \n' )
00881             tmpfile.write ( '/// File         "' + tmpfilename+'" generated by GaudiPython \n\n' )
00882             for opt in options :
00883                 if type(options) is dict :
00884                     tmpfile.write( ' \t ' + opt + ' = '+ options[opt]+ ' ;  // added by GaudiPython \n' )
00885                 else :
00886                     tmpfile.write( ' \t ' + opt + ' ;  // added by GaudiPython \n' )
00887             tmpfile.write ( '/// End of  file "' + tmpfilename+'" generated by GaudiPython \n\n' )
00888             tmpfile.close()
00889             sc = self.readOptions( tmpfilename )
00890             if sc.isFailure() :
00891                 raise RuntimeError , ' Unable to read file "' + tmpfilename +'" '
00892             os.remove( tmpfilename )
00893         # We need to make sure that the options are taken by the ApplicationMgr
00894         if self.FSMState() != Gaudi.StateMachine.OFFLINE : # The state is already configured, so we need to do something....
00895 
00896             ## get job-options-service, @see class iJobOptSvc
00897             jos   = self.optSvc()
00898 
00899             ## list of all libraries
00900             _dlls = jos.getProperty   ( self.name() , 'DLLs'   )
00901             ## take care about libraries : APPEND if not done yet
00902             if _dlls :
00903                 libs = [ l for l in _dlls if not l in self.DLLs ]
00904                 if libs : self.DLLs  += libs
00905 
00906             ## all external services
00907             _svcs = jos.getProperty   ( self.name() , 'ExtSvc' )
00908             ## take care about services : APPEND  if not done yet
00909             if _svcs :
00910                 svcs = [ s for s in _svcs if not s in self.ExtSvc ]
00911                 if svcs : self.ExtSvc += svcs
00912 
00913             ## get all properties
00914             props = jos.getProperties ( self.name() )
00915             ## finally treat all other properties (presumably scalar properties)
00916             for key in props :
00917                 if 'DLLS' == key or 'EXTSVC' == key : continue
00918                 self.__setattr__( key , props[key] )
00919         return SUCCESS                                           # RETURN
    def configure(self) :

def GaudiPython::Bindings::AppMgr::configure ( self )

Definition at line 920 of file Bindings.py.

00920                         :
00921         return self._appmgr.configure()
    def start(self) :

def GaudiPython::Bindings::AppMgr::start ( self )

Definition at line 922 of file Bindings.py.

00922                     :
00923         return self._appmgr.start()
    def run(self, n) :

def GaudiPython::Bindings::AppMgr::run	(	self,
		n
	)

Definition at line 924 of file Bindings.py.

00924                      :
00925         if self.FSMState() == Gaudi.StateMachine.CONFIGURED :
00926             sc = self.initialize()
00927             if sc.isFailure(): return sc
00928         if self.FSMState() == Gaudi.StateMachine.INITIALIZED :
00929             sc = self.start()
00930             if sc.isFailure(): return sc
00931         return self._evtpro.executeRun(n)
    def executeEvent(self) :

def GaudiPython::Bindings::AppMgr::executeEvent ( self )

Definition at line 932 of file Bindings.py.

00932                            :
00933         return self._evtpro.executeEvent()
    def execute(self) :

def GaudiPython::Bindings::AppMgr::execute ( self )

Definition at line 934 of file Bindings.py.

00934                       :
00935         return self._evtpro.executeEvent()
    def runSelectedEvents(self, pfn, events):

def GaudiPython::Bindings::AppMgr::runSelectedEvents	(	self,
		pfn,
		events
	)

Definition at line 936 of file Bindings.py.

00936                                             :
00937         if self.FSMState() == Gaudi.StateMachine.CONFIGURED :
00938             sc = self.initialize()
00939             if sc.isFailure(): return sc
00940         if self.FSMState() == Gaudi.StateMachine.INITIALIZED :
00941             sc = self.start()
00942             if sc.isFailure(): return sc
00943         #--- Access a number of services ----
00944         if not hasattr(self,'_perssvc'): self.__dict__['_perssvc'] = self.service('EventPersistencySvc','IAddressCreator')
00945         if not hasattr(self,'_filecat'): self.__dict__['_filecat'] = self.service('FileCatalog','Gaudi::IFileCatalog')
00946         if not hasattr(self,'_evtmgr'):  self.__dict__['_evtmgr']  = self.service('EventDataSvc','IDataManagerSvc')
00947         #--- Get FID from PFN and number of events in file
00948         if pfn.find('PFN:') == 0: pfn = pfn[4:]
00949         fid, maxevt = _getFIDandEvents(pfn)
00950         #--- Add FID into catalog if needed ---
00951         if not self._filecat.existsFID(fid) : self._filecat.registerPFN(fid, pfn, '')
00952         #--- Loop over events
00953         if type(events) is not list : events = (events,)
00954         for evt in events :
00955             #--- Create POOL Address from Generic Address
00956             gadd = gbl.GenericAddress(0x202, 1, fid, '/Event', 0, evt)
00957             oadd = makeNullPointer('IOpaqueAddress')
00958             self._perssvc.createAddress(gadd.svcType(),gadd.clID(),gadd.par(),gadd.ipar(),oadd)
00959             #--- Clear TES, set root and run all algorithms
00960             self._evtmgr.clearStore()
00961             self._evtmgr.setRoot('/Event',oadd)
00962             self._evtpro.executeEvent()
    def exit(self):

def GaudiPython::Bindings::AppMgr::exit ( self )

Definition at line 963 of file Bindings.py.

00963                   :
00964         # Protection against multiple calls to exit() if the finalization fails
00965         if not self._exit_called:
00966             self.__dict__['_exit_called'] = True
00967             if self.FSMState() == Gaudi.StateMachine.RUNNING:
00968                 self._appmgr.stop().ignore()
00969             if self.FSMState() == Gaudi.StateMachine.INITIALIZED:
00970                 self._appmgr.finalize().ignore()
00971             if self.FSMState() == Gaudi.StateMachine.CONFIGURED:
00972                 self._appmgr.terminate()
00973         return SUCCESS
    ## Custom destructor to ensure that the application is correctly finalized when exiting from python.

def GaudiPython::Bindings::AppMgr::__del__ ( self )

Custom destructor to ensure that the application is correctly finalized when exiting from python.

Definition at line 975 of file Bindings.py.

00975                      :
00976         self.exit()
    evtSvc  = evtsvc

Member Data Documentation

GaudiPython::Bindings::AppMgr::evtSvc = evtsvc [static]

Definition at line 977 of file Bindings.py.

GaudiPython::Bindings::AppMgr::histSvc = histsvc [static]

Definition at line 978 of file Bindings.py.

GaudiPython::Bindings::AppMgr::ntupleSvc = ntuplesvc [static]

Definition at line 979 of file Bindings.py.

GaudiPython::Bindings::AppMgr::evtSel = evtsel [static]

Definition at line 980 of file Bindings.py.

GaudiPython::Bindings::AppMgr::detSvc = detsvc [static]

Definition at line 981 of file Bindings.py.

GaudiPython::Bindings::AppMgr::toolSvc = toolsvc [static]

Definition at line 982 of file Bindings.py.

GaudiPython::Bindings::AppMgr::partSvc = partsvc [static]

Definition at line 983 of file Bindings.py.

GaudiPython::Bindings::AppMgr::JobOptionsType

Definition at line 701 of file Bindings.py.

GaudiPython::Bindings::AppMgr::OutputLevel

Definition at line 710 of file Bindings.py.

GaudiPython::Bindings::AppMgr::topAlg

Definition at line 848 of file Bindings.py.

The documentation for this class was generated from the following file:

/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r8/GaudiPython/python/GaudiPython/Bindings.py


Public Member Functions
def	__new__
def	__reset__
def	__init__
def	state
def	FSMState
def	targetFSMState
def	loaddict
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.
Public Attributes
	JobOptionsType
	OutputLevel
	topAlg
Static Public Attributes
	evtSvc = evtsvc
	histSvc = histsvc
	ntupleSvc = ntuplesvc
	evtSel = evtsel
	detSvc = detsvc
	toolSvc = toolsvc
	partSvc = partsvc

Gaudi Framework, version v21r8

GaudiPython::Bindings::AppMgr Class Reference

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Member Function Documentation

Member Data Documentation