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 )
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
00747         
00748         # Ensure that the exit method is called when exiting from Python 
00749         import atexit
00750         atexit.register(self.exit)
00751 
00752         #---Hack to avoid bad interactions with the ROOT exit handler
00753         # Look for an exit handler installed by ROOT
00754         root_handler_installed = False
00755         for h in atexit._exithandlers:
00756             func = h[0]
00757             if hasattr(func, "__module__") and func.__module__ == "ROOT":
00758                 root_handler_installed = True
00759                 break
00760         
00761         # If the handler is not yet installed, let's install our private version
00762         # that detects that the ROOT exit handler is installed and add our own
00763         # after it to ensure it is called before. 
00764         if not root_handler_installed:
00765             orig_register = atexit.register
00766             def register(func, *targs, **kargs):
00767                 orig_register(func, *targs, **kargs)
00768                 if hasattr(func, "__module__") and func.__module__ == "ROOT":
00769                     orig_register(self.exit)
00770                     # we do not need to remove out handler from the list because
00771                     # it can be safely called more than once
00772             register.__doc__ = (orig_register.__doc__ +
00773                                 "\nNote: version hacked by GaudiPython to work " +
00774                                 "around a problem with the ROOT exit handler")
00775             atexit.register = register
00776

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

Definition at line 777 of file Bindings.py.

00777 : return self._isvc.FSMState()

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

Definition at line 778 of file Bindings.py.

00778 : return self._isvc.FSMState()

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

Definition at line 779 of file Bindings.py.

00779 : return self._isvc.targetFSMState()

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

Definition at line 780 of file Bindings.py.

00780                              :
00781         loaddict(dict)
    def service(self, name, interface = None) :

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

Definition at line 782 of file Bindings.py.

00782                                               :
00783         svc = Helper.service( self._svcloc, name )
00784         if interface :
00785             return InterfaceCast(interface)(svc)
00786         else :
00787             return iService(name, svc )
    def declSvcType(self, svcname, svctype ) :

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

Definition at line 788 of file Bindings.py.

00788                                              :
00789         self._svcmgr.declareSvcType(svcname, svctype)
    def createSvc(self, name ) :

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

Definition at line 790 of file Bindings.py.

00790                                :
00791         return Helper.service( self._svcloc, name, True )
    def services(self) :

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

Definition at line 792 of file Bindings.py.

00792                        :
00793         l = self._svcloc.getServices()
00794         nl = l.__class__(l)  # get a copy
00795         s = []
00796         for i in range(l.size()) :
00797             s.append(nl.front().name())
00798             nl.pop_front()
00799         return s
    def algorithm(self, name , createIf = False ) :

def GaudiPython::Bindings::AppMgr::algorithm	(	self,
		name,
		createIf = `False`
	)

Definition at line 800 of file Bindings.py.

00800                                                   :
00801         alg = Helper.algorithm( self._algmgr, name , createIf )
00802         if not alg : return iAlgorithm ( name       , alg )
00803         else       : return iAlgorithm ( alg.name() , alg )
    def algorithms(self) :

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

Definition at line 804 of file Bindings.py.

00804                          :
00805         l = self._algmgr.getAlgorithms()
00806         nl = l.__class__(l)  # get a copy
00807         s = []
00808         for i in range(l.size()) :
00809             s.append(nl.front().name())
00810             nl.pop_front()
00811         return s
    def tool(self, name ) :

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

Definition at line 812 of file Bindings.py.

00812                           :
00813         return iAlgTool(name)
    def property( self , name ) :

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

Definition at line 814 of file Bindings.py.

00814                                 :
00815         if name in self.algorithms() : return self.algorithm( name )
00816         elif name in self.services() : return self.service(name )
00817         else :                         return iProperty( name )
    def datasvc(self, name) :

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

Definition at line 818 of file Bindings.py.

00818                             :
00819         if self.state() == Gaudi.StateMachine.CONFIGURED :  self.initialize()
00820         svc = Helper.service( self._svcloc, name )
00821         return iDataSvc(name, svc)
    def evtsvc(self) :

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

Definition at line 822 of file Bindings.py.

00822                      :
00823         return self.datasvc('EventDataSvc')
    def detsvc(self) :

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

Definition at line 824 of file Bindings.py.

00824                      :
00825         return self.datasvc('DetectorDataSvc')
    def filerecordsvc(self) :

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

Definition at line 826 of file Bindings.py.

00826                             :
00827         return self.datasvc('FileRecordDataSvc')
    def evtsel(self):

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

Definition at line 828 of file Bindings.py.

00828                     :
00829         if self.state() == Gaudi.StateMachine.CONFIGURED :  self.initialize()
00830         if not hasattr(self,'_evtsel') : self.__dict__['_evtsel'] = iEventSelector()
00831         return self._evtsel
    def histsvc(self, name='HistogramDataSvc') :

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

Definition at line 832 of file Bindings.py.

00832                                                :
00833         svc = Helper.service( self._svcloc, name )
00834         return iHistogramSvc(name, svc)
    def ntuplesvc(self, name='NTupleSvc') :

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

Definition at line 835 of file Bindings.py.

00835                                           :
00836         if name not in self.ExtSvc : self.ExtSvc += [name]
00837 #    if self.HistogramPersistency == 'NONE' : self.HistogramPersistency = 'ROOT'
00838         svc = Helper.service( self._svcloc, name, True )
00839         return iNTupleSvc(name, svc)
    def partsvc(self ) :

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

Definition at line 840 of file Bindings.py.

00840                        :
00841         if self.FSMState() == Gaudi.StateMachine.CONFIGURED :  self.initialize()
00842         svc = Helper.service( self._svcloc, 'ParticlePropertySvc' )
00843         return InterfaceCast(gbl.IParticlePropertySvc)(svc)
    def toolsvc(self, name='ToolSvc') :

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

Definition at line 844 of file Bindings.py.

00844                                       :
00845         svc = Helper.service( self._svcloc, name, True )
00846         return iToolSvc(name, svc)
    def optSvc (self, name='JobOptionsSvc') :

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

Definition at line 847 of file Bindings.py.

00847                                             :
00848         svc = Helper.service( self._svcloc, name, True )
00849         return iJobOptSvc(name, svc)
    def readOptions(self, file) :

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

Definition at line 850 of file Bindings.py.

00850                                 :
00851         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 852 of file Bindings.py.

00852                                 :
00853         """ Add an Algorithm to the list of Top algorithms. It can be either a instance of
00854             an Algorithm class or it name """
00855         if type(alg) is  str :
00856             self.topAlg += [alg]
00857         else :
00858             self.pyalgorithms.append(alg)
00859             setOwnership(alg,0)
00860             if self.targetFSMState() >= Gaudi.StateMachine.INITIALIZED :
00861                 alg.sysInitialize()
00862                 if self.targetFSMState() == Gaudi.StateMachine.RUNNING :
00863                     alg.sysStart()
00864             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 865 of file Bindings.py.

00865                                   :
00866         """ Set the list of Top Algorithms.
00867             It can be an individual of a list of algorithms names or instances """
00868         if type(algs) is not list : algs = [algs]
00869         names = []
00870         for alg in algs :
00871             if type(alg) is str : names.append(alg)
00872             else :
00873                 self.pyalgorithms.append(alg)
00874                 if self.targetFSMState() >= Gaudi.StateMachine.INITIALIZED :
00875                     alg.sysInitialize()
00876                     if self.targetFSMState() == Gaudi.StateMachine.RUNNING :
00877                         alg.sysStart()
00878                 names.append(alg.name())
00879         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 880 of file Bindings.py.

00880                                    :
00881         """ Remove an Algorithm to the list of Top algorithms. It can be either a instance of
00882             an Algorithm class or it name """
00883         tmp = self.topAlg
00884         if type(alg) is  str :
00885             tmp.remove(alg)
00886         else :
00887             tmp.remove(alg.name())
00888             self.pyalgorithms.remove(alg)
00889             setOwnership(alg,1)
00890         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 891 of file Bindings.py.

00891                                :
00892         """
00893         Simple utility to perform the configuration of Gaudi application.
00894         It reads the set of input job-options files, and set few
00895         additional parameters 'options' through the usage of temporary *.opts file
00896         Usage:
00897         gaudi.config( files   = [ '$GAUSSOPTS/Gauss.opts'                     ,
00898                                   '$DECFILESROOT/options/10022_010.0GeV.opts' ] ,
00899                       options = [ 'EventSelector.PrintFreq   =   5  '         ] )
00900         """
00901         files  = args.get('files',[])
00902         for file in files :
00903             sc = self.readOptions(file)
00904             if sc.isFailure() :
00905                 raise RuntimeError , ' Unable to read file "' + file +'" '
00906         options  = args.get('options',None)
00907         if options :
00908             import tempfile
00909             tmpfilename = tempfile.mktemp()
00910             tmpfile     = open( tmpfilename, 'w' )
00911             tmpfile.write ( '#pragma print on  \n' )
00912             tmpfile.write ( '/// File         "' + tmpfilename+'" generated by GaudiPython \n\n' )
00913             for opt in options :
00914                 if type(options) is dict :
00915                     tmpfile.write( ' \t ' + opt + ' = '+ options[opt]+ ' ;  // added by GaudiPython \n' )
00916                 else :
00917                     tmpfile.write( ' \t ' + opt + ' ;  // added by GaudiPython \n' )
00918             tmpfile.write ( '/// End of  file "' + tmpfilename+'" generated by GaudiPython \n\n' )
00919             tmpfile.close()
00920             sc = self.readOptions( tmpfilename )
00921             if sc.isFailure() :
00922                 raise RuntimeError , ' Unable to read file "' + tmpfilename +'" '
00923             os.remove( tmpfilename )
00924         # We need to make sure that the options are taken by the ApplicationMgr
00925         if self.FSMState() != Gaudi.StateMachine.OFFLINE : # The state is already configured, so we need to do something....
00926 
00927             ## get job-options-service, @see class iJobOptSvc
00928             jos   = self.optSvc()
00929 
00930             ## list of all libraries
00931             _dlls = jos.getProperty   ( self.name() , 'DLLs'   )
00932             ## take care about libraries : APPEND if not done yet
00933             if _dlls :
00934                 libs = [ l for l in _dlls if not l in self.DLLs ]
00935                 if libs : self.DLLs  += libs
00936 
00937             ## all external services
00938             _svcs = jos.getProperty   ( self.name() , 'ExtSvc' )
00939             ## take care about services : APPEND  if not done yet
00940             if _svcs :
00941                 svcs = [ s for s in _svcs if not s in self.ExtSvc ]
00942                 if svcs : self.ExtSvc += svcs
00943 
00944             ## get all properties
00945             props = jos.getProperties ( self.name() )
00946             ## finally treat all other properties (presumably scalar properties)
00947             for key in props :
00948                 if 'DLLS' == key or 'EXTSVC' == key : continue
00949                 self.__setattr__( key , props[key] )
00950         return SUCCESS                                           # RETURN
    def configure(self) :

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

Definition at line 951 of file Bindings.py.

00951                         :
00952         return self._appmgr.configure()
    def start(self) :

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

Definition at line 953 of file Bindings.py.

00953                     :
00954         return self._appmgr.start()
    def run(self, n) :

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

Definition at line 955 of file Bindings.py.

00955                      :
00956         if self.FSMState() == Gaudi.StateMachine.CONFIGURED :
00957             sc = self.initialize()
00958             if sc.isFailure(): return sc
00959         if self.FSMState() == Gaudi.StateMachine.INITIALIZED :
00960             sc = self.start()
00961             if sc.isFailure(): return sc
00962         return self._evtpro.executeRun(n)
    def executeEvent(self) :

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

Definition at line 963 of file Bindings.py.

00963                            :
00964         return self._evtpro.executeEvent()
    def execute(self) :

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

Definition at line 965 of file Bindings.py.

00965                       :
00966         return self._evtpro.executeEvent()
    def runSelectedEvents(self, pfn, events):

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

Definition at line 967 of file Bindings.py.

00967                                             :
00968         if self.FSMState() == Gaudi.StateMachine.CONFIGURED :
00969             sc = self.initialize()
00970             if sc.isFailure(): return sc
00971         if self.FSMState() == Gaudi.StateMachine.INITIALIZED :
00972             sc = self.start()
00973             if sc.isFailure(): return sc
00974         #--- Access a number of services ----
00975         if not hasattr(self,'_perssvc'): self.__dict__['_perssvc'] = self.service('EventPersistencySvc','IAddressCreator')
00976         if not hasattr(self,'_filecat'): self.__dict__['_filecat'] = self.service('FileCatalog','Gaudi::IFileCatalog')
00977         if not hasattr(self,'_evtmgr'):  self.__dict__['_evtmgr']  = self.service('EventDataSvc','IDataManagerSvc')
00978         #--- Get FID from PFN and number of events in file
00979         if pfn.find('PFN:') == 0: pfn = pfn[4:]
00980         fid, maxevt = _getFIDandEvents(pfn)
00981         #--- Add FID into catalog if needed ---
00982         if not self._filecat.existsFID(fid) : self._filecat.registerPFN(fid, pfn, '')
00983         #--- Loop over events
00984         if type(events) is not list : events = (events,)
00985         for evt in events :
00986             #--- Create POOL Address from Generic Address
00987             gadd = gbl.GenericAddress(0x202, 1, fid, '/Event', 0, evt)
00988             oadd = makeNullPointer('IOpaqueAddress')
00989             self._perssvc.createAddress(gadd.svcType(),gadd.clID(),gadd.par(),gadd.ipar(),oadd)
00990             #--- Clear TES, set root and run all algorithms
00991             self._evtmgr.clearStore()
00992             self._evtmgr.setRoot('/Event',oadd)
00993             self._evtpro.executeEvent()
    def exit(self):

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

Definition at line 994 of file Bindings.py.

00994                   :
00995         # Protection against multiple calls to exit() if the finalization fails
00996         if not self._exit_called:
00997             self.__dict__['_exit_called'] = True
00998             if self.FSMState() == Gaudi.StateMachine.RUNNING:
00999                 self._appmgr.stop().ignore()
01000             if self.FSMState() == Gaudi.StateMachine.INITIALIZED:
01001                 self._appmgr.finalize().ignore()
01002             if self.FSMState() == Gaudi.StateMachine.CONFIGURED:
01003                 self._appmgr.terminate()
01004         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 1006 of file Bindings.py.

01006                      :
01007         self.exit()
    evtSvc  = evtsvc

Member Data Documentation

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

Definition at line 1008 of file Bindings.py.

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

Definition at line 1009 of file Bindings.py.

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

Definition at line 1010 of file Bindings.py.

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

Definition at line 1011 of file Bindings.py.

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

Definition at line 1012 of file Bindings.py.

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

Definition at line 1013 of file Bindings.py.

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

Definition at line 1014 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 879 of file Bindings.py.

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

/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r11/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 v21r11

GaudiPython::Bindings::AppMgr Class Reference

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Member Function Documentation

Member Data Documentation