| # Gaudi Framework, version v25r0 |

Home |  | Generated: Mon Feb 17 2014

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
Public Member Functions | Public Attributes | Static Public Attributes | List of all members
GaudiPython.Bindings.AppMgr Class Reference
Inheritance diagram for GaudiPython.Bindings.AppMgr:
[legend]
Collaboration diagram for GaudiPython.Bindings.AppMgr:
[legend]

## 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.
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.

676
677 dllname = None, factname = None) :
678 global _gaudi
679 if _gaudi : return
680 # Protection against multiple calls to exit() if the finalization fails
681 self.__dict__['_exit_called'] = False
682 # keep the Gaudi namespace around (so it is still available during atexit shutdown)...
683 self.__dict__['_gaudi_ns'] = Gaudi
684 try:
685 from GaudiKernel.Proxy.Configurable import expandvars
686 except ImportError:
687 # pass-through implementation if expandvars is not defined (AthenaCommon)
688 expandvars = lambda data : data
689 if dllname and factname:
690 self.__dict__['_appmgr'] = gbl.Gaudi.createApplicationMgr(dllname,factname)
691 elif dllname:
692 self.__dict__['_appmgr'] = gbl.Gaudi.createApplicationMgr(dllname)
693 else:
694 self.__dict__['_appmgr'] = gbl.Gaudi.createApplicationMgr()
695 self.__dict__['_svcloc'] = gbl.Gaudi.svcLocator()
696 self.__dict__['_algmgr'] = InterfaceCast(gbl.IAlgManager)(self._appmgr)
697 self.__dict__['_evtpro'] = InterfaceCast(gbl.IEventProcessor)(self._appmgr)
698 self.__dict__['_svcmgr'] = InterfaceCast(gbl.ISvcManager)(self._appmgr)
699 self.__dict__['pyalgorithms'] = []
700 iService.__init__(self, 'ApplicationMgr', self._appmgr )
701 #------python specific initialization-------------------------------------
702 if self.FSMState() < Gaudi.StateMachine.CONFIGURED : # Not yet configured
703 self.JobOptionsType = 'NONE'
704 if joboptions :
705 from GaudiKernel.ProcessJobOptions import importOptions
706 importOptions(joboptions)
707 # Ensure that the ConfigurableUser instances have been applied
708 import GaudiKernel.Proxy.Configurable
709 if hasattr(GaudiKernel.Proxy.Configurable, "applyConfigurableUsers"):
710 GaudiKernel.Proxy.Configurable.applyConfigurableUsers()
711 # This is the default and could be overridden with "selfopts"
712 self.OutputLevel = 3
713 selfprops = Configurable.allConfigurables.get('ApplicationMgr',{})
714 if selfprops : selfprops = expandvars(selfprops.getValuedProperties())
715 for p,v in selfprops.items() : setattr(self, p, v)
716 for p,v in selfoptions.items() : setattr(self, p, v)
717 # Override job options
718 if outputlevel != -1 : self.OutputLevel = outputlevel
719 self.configure()
720 #---MessageSvc------------------------------------------------------------
721 ms = self.service('MessageSvc')
722 if 'MessageSvc' in Configurable.allConfigurables:
723 msprops = Configurable.allConfigurables['MessageSvc']
724 ms = self.service('MessageSvc')
725 if hasattr(msprops,"getValuedProperties"):
726 msprops = expandvars(msprops.getValuedProperties())
727 for p,v in msprops.items():
728 setattr(ms, p, v)
729 if outputlevel != -1 : ms.OutputLevel = outputlevel
730 #---JobOptions------------------------------------------------------------
731 self.__dict__['_optsvc'] = InterfaceCast(gbl.IJobOptionsSvc)(Helper.service(self._svcloc,'JobOptionsSvc'))
732 #------Configurables initialization (part2)-------------------------------
733 for n in getNeededConfigurables():
734 c = Configurable.allConfigurables[n]
735 if n in ['ApplicationMgr','MessageSvc'] : continue # These are already done---
736 for p, v in c.getValuedProperties().items() :
737 v = expandvars(v)
738 # Note: AthenaCommon.Configurable does not have Configurable.PropertyReference
739 if hasattr(Configurable,"PropertyReference") and type(v) == Configurable.PropertyReference:
740 # this is done in "getFullName", but the exception is ignored,
741 # so we do it again to get it
742 v = v.__resolve__()
743 if type(v) == str : v = '"%s"' % v # need double quotes
744 elif type(v) == long: v = '%d' % v # prevent pending 'L'
745 self._optsvc.addPropertyToCatalogue(n, StringProperty(p,str(v)))
746 if hasattr(Configurable,"_configurationLocked"):
747 Configurable._configurationLocked = True
748
749 # Ensure that the exit method is called when exiting from Python
750 import atexit
751 atexit.register(self.exit)
752
753 #---Hack to avoid bad interactions with the ROOT exit handler
754 # Look for an exit handler installed by ROOT
755 root_handler_installed = False
756 for h in atexit._exithandlers:
757 func = h[0]
758 if hasattr(func, "__module__") and func.__module__ == "ROOT":
759 root_handler_installed = True
760 break
761
762 # If the handler is not yet installed, let's install our private version
763 # that detects that the ROOT exit handler is installed and add our own
764 # after it to ensure it is called before.
765 if not root_handler_installed:
766 orig_register = atexit.register
767 def register(func, *targs, **kargs):
768 orig_register(func, *targs, **kargs)
769 if hasattr(func, "__module__") and func.__module__ == "ROOT":
770 orig_register(self.exit)
771 # we do not need to remove out handler from the list because
772 # it can be safely called more than once
773 register.__doc__ = (orig_register.__doc__ +
774 "\nNote: version hacked by GaudiPython to work " +
775 "around a problem with the ROOT exit handler")
776 atexit.register = register

def GaudiPython.Bindings.AppMgr.__del__ | ( |  | self | ) |

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

Definition at line 1007 of file Bindings.py.

1007
1008 def __del__(self):
self.exit()

## Member Function Documentation

def GaudiPython.Bindings.AppMgr.__new__ | ( |  | cls,
|  |  | args,
|  |  | kwargs
| ) |  |

Definition at line 655 of file Bindings.py.

655
656 def __new__ ( cls, *args, **kwargs ):
657 global _gaudi
658 if not _gaudi :
659 newobj = object.__new__( cls )
660 cls.__init__(newobj, *args, **kwargs)
661 _gaudi = newobj
return _gaudi

def GaudiPython.Bindings.AppMgr.__reset__ | ( |  | self | ) |

Definition at line 662 of file Bindings.py.

662
663 def __reset__(self):
664 global _gaudi
665 # Stop, Finalize and Terminate the current AppMgr
666 self.exit()
667 # release interfaces
668 self._evtpro.release()
669 self._svcloc.release()
670 self._appmgr.release()
671 # Reset the C++ globals
672 gbl.Gaudi.setInstance(makeNullPointer('ISvcLocator'))
673 gbl.Gaudi.setInstance(makeNullPointer('IAppMgrUI'))
674 # Reset the Python global
_gaudi = None

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 850 of file Bindings.py.

850
851 def addAlgorithm(self, alg) :
852 """ Add an Algorithm to the list of Top algorithms. It can be either a instance of
853 an Algorithm class or it name """
854 if type(alg) is str :
855 self.topAlg += [alg]
856 else :
857 self.pyalgorithms.append(alg)
858 setOwnership(alg,0)
859 if self.targetFSMState() >= Gaudi.StateMachine.INITIALIZED :
860 alg.sysInitialize()
861 if self.targetFSMState() == Gaudi.StateMachine.RUNNING :
862 alg.sysStart()
self.topAlg += [alg.name()]

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

Definition at line 798 of file Bindings.py.

798
799 def algorithm(self, name , createIf = False ) :
800 alg = Helper.algorithm( self._algmgr, name , createIf )
801 if not alg : return iAlgorithm ( name , alg )
else : return iAlgorithm ( alg.name() , alg )

def GaudiPython.Bindings.AppMgr.algorithms | ( |  | self | ) |

Definition at line 802 of file Bindings.py.

802
803 def algorithms(self) :
804 l = self._algmgr.getAlgorithms()
805 nl = l.__class__(l) # get a copy
806 s = []
807 for i in range(l.size()) :
808 s.append(nl.front().name())
809 nl.pop_front()
return s

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 889 of file Bindings.py.

889
890 def config ( self, **args ):
891 """
892 Simple utility to perform the configuration of Gaudi application.
893 It reads the set of input job-options files, and set few
894 additional parameters 'options' through the usage of temporary *.opts file
895 Usage:
896 gaudi.config( files = [ '$GAUSSOPTS/Gauss.opts' ,
897 '$DECFILESROOT/options/10022_010.0GeV.opts' ] ,
898 options = [ 'EventSelector.PrintFreq = 5 ' ] )
899 """
900 files = args.get('files',[])
901 for file in files :
902 sc = self.readOptions(file)
903 if sc.isFailure() :
904 raise RuntimeError , ' Unable to read file "' + file +'" '
905 options = args.get('options',None)
906 if options :
907 import tempfile
908 tmpfilename = tempfile.mktemp()
909 tmpfile = open( tmpfilename, 'w' )
910 tmpfile.write ( '#pragma print on \n' )
911 tmpfile.write ( '/// File "' + tmpfilename+'" generated by GaudiPython \n\n' )
912 for opt in options :
913 if type(options) is dict :
914 tmpfile.write( ' \t ' + opt + ' = '+ options[opt]+ ' ; // added by GaudiPython \n' )
915 else :
916 tmpfile.write( ' \t ' + opt + ' ; // added by GaudiPython \n' )
917 tmpfile.write ( '/// End of file "' + tmpfilename+'" generated by GaudiPython \n\n' )
918 tmpfile.close()
919 sc = self.readOptions( tmpfilename )
920 if sc.isFailure() :
921 raise RuntimeError , ' Unable to read file "' + tmpfilename +'" '
922 os.remove( tmpfilename )
923 # We need to make sure that the options are taken by the ApplicationMgr
924 if self.FSMState() != Gaudi.StateMachine.OFFLINE : # The state is already configured, so we need to do something....
925
926 ## get job-options-service, @see class iJobOptSvc
927 jos = self.optSvc()
928
929 ## list of all libraries
930 _dlls = jos.getProperty ( self.name() , 'DLLs' )
931 ## take care about libraries : APPEND if not done yet
932 if _dlls :
933 libs = [ l for l in _dlls if not l in self.DLLs ]
934 if libs : self.DLLs += libs
935
936 ## all external services
937 _svcs = jos.getProperty ( self.name() , 'ExtSvc' )
938 ## take care about services : APPEND if not done yet
939 if _svcs :
940 svcs = [ s for s in _svcs if not s in self.ExtSvc ]
941 if svcs : self.ExtSvc += svcs
942
943 ## get all properties
944 props = jos.getProperties ( self.name() )
945 ## finally treat all other properties (presumably scalar properties)
946 for key in props :
947 if 'DLLS' == key or 'EXTSVC' == key : continue
948 self.__setattr__( key , props[key] )
return SUCCESS # RETURN

def GaudiPython.Bindings.AppMgr.configure | ( |  | self | ) |

Definition at line 949 of file Bindings.py.

949
950 def configure(self) :
return self._appmgr.configure()

def GaudiPython.Bindings.AppMgr.createSvc | ( |  | self,
|  |  | name
| ) |  |

Definition at line 788 of file Bindings.py.

788
789 def createSvc(self, name ) :
return Helper.service( self._svcloc, name, True )

def GaudiPython.Bindings.AppMgr.datasvc | ( |  | self,
|  |  | name
| ) |  |

Definition at line 816 of file Bindings.py.

816
817 def datasvc(self, name) :
818 if self.state() == Gaudi.StateMachine.CONFIGURED : self.initialize()
819 svc = Helper.service( self._svcloc, name )
return iDataSvc(name, svc)

def GaudiPython.Bindings.AppMgr.declSvcType | ( |  | self,
|  |  | svcname,
|  |  | svctype
| ) |  |

Definition at line 786 of file Bindings.py.

786
787 def declSvcType(self, svcname, svctype ) :
self._svcmgr.declareSvcType(svcname, svctype)

def GaudiPython.Bindings.AppMgr.detsvc | ( |  | self | ) |

Definition at line 822 of file Bindings.py.

822
823 def detsvc(self) :
return self.datasvc('DetectorDataSvc')

def GaudiPython.Bindings.AppMgr.evtsel | ( |  | self | ) |

Definition at line 826 of file Bindings.py.

826
827 def evtsel(self):
828 if self.state() == Gaudi.StateMachine.CONFIGURED : self.initialize()
829 if not hasattr(self,'_evtsel') : self.__dict__['_evtsel'] = iEventSelector()
return self._evtsel

def GaudiPython.Bindings.AppMgr.evtsvc | ( |  | self | ) |

Definition at line 820 of file Bindings.py.

820
821 def evtsvc(self) :
return self.datasvc('EventDataSvc')

def GaudiPython.Bindings.AppMgr.execute | ( |  | self | ) |

Definition at line 965 of file Bindings.py.

965
966 def execute(self) :
return self._evtpro.executeEvent()

def GaudiPython.Bindings.AppMgr.executeEvent | ( |  | self | ) |

Definition at line 963 of file Bindings.py.

963
964 def executeEvent(self) :
return self._evtpro.executeEvent()

def GaudiPython.Bindings.AppMgr.exit | ( |  | self | ) |

Definition at line 994 of file Bindings.py.

994
995 def exit(self):
996 # Protection against multiple calls to exit() if the finalization fails
997 if not self._exit_called:
998 self.__dict__['_exit_called'] = True
999 Gaudi = self._gaudi_ns
1000 if self.FSMState() == Gaudi.StateMachine.RUNNING:
1001 self._appmgr.stop().ignore()
1002 if self.FSMState() == Gaudi.StateMachine.INITIALIZED:
1003 self._appmgr.finalize().ignore()
1004 if self.FSMState() == Gaudi.StateMachine.CONFIGURED:
1005 self._appmgr.terminate()
return SUCCESS

def GaudiPython.Bindings.AppMgr.filerecordsvc | ( |  | self | ) |

Definition at line 824 of file Bindings.py.

824
825 def filerecordsvc(self) :
return self.datasvc('FileRecordDataSvc')

def GaudiPython.Bindings.AppMgr.FSMState | ( |  | self | ) |

Definition at line 778 of file Bindings.py.

778
def FSMState(self) : return self._isvc.FSMState()

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

Definition at line 830 of file Bindings.py.

830
831 def histsvc(self, name='HistogramDataSvc') :
832 svc = Helper.service( self._svcloc, name )
return iHistogramSvc(name, svc)

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

Definition at line 833 of file Bindings.py.

833
834 def ntuplesvc(self, name='NTupleSvc') :
835 if name not in self.ExtSvc : self.ExtSvc += [name]
836 # if self.HistogramPersistency == 'NONE' : self.HistogramPersistency = 'ROOT'
837 svc = Helper.service( self._svcloc, name, True )
return iNTupleSvc(name, svc)

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

Definition at line 845 of file Bindings.py.

845
846 def optSvc (self, name='JobOptionsSvc') :
847 svc = Helper.service( self._svcloc, name, True )
return iJobOptSvc(name, svc)

def GaudiPython.Bindings.AppMgr.partsvc | ( |  | self | ) |

Definition at line 838 of file Bindings.py.

838
839 def partsvc(self ) :
840 if self.FSMState() == Gaudi.StateMachine.CONFIGURED : self.initialize()
841 svc = Helper.service( self._svcloc, 'ParticlePropertySvc' )
return InterfaceCast(gbl.IParticlePropertySvc)(svc)

def GaudiPython.Bindings.AppMgr.property | ( |  | self,
|  |  | name
| ) |  |

Definition at line 812 of file Bindings.py.

812
813 def property( self , name ) :
814 if name in self.algorithms() : return self.algorithm( name )
815 elif name in self.services() : return self.service(name )
else : return iProperty( name )

def GaudiPython.Bindings.AppMgr.readOptions | ( |  | self,
|  |  | file
| ) |  |

Definition at line 848 of file Bindings.py.

848
849 def readOptions(self, file) :
return self._optsvc.readOptions(file)

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 878 of file Bindings.py.

878
879 def removeAlgorithm(self, alg) :
880 """ Remove an Algorithm to the list of Top algorithms. It can be either a instance of
881 an Algorithm class or it name """
882 tmp = self.topAlg
883 if type(alg) is str :
884 tmp.remove(alg)
885 else :
886 tmp.remove(alg.name())
887 self.pyalgorithms.remove(alg)
888 setOwnership(alg,1)
self.topAlg = tmp

def GaudiPython.Bindings.AppMgr.run | ( |  | self,
|  |  | n
| ) |  |

Definition at line 953 of file Bindings.py.

953
954 def run(self, n) :
955 if self.FSMState() == Gaudi.StateMachine.CONFIGURED :
956 sc = self.initialize()
957 if sc.isFailure() or self.ReturnCode != 0:
958 return sc
959 if self.FSMState() == Gaudi.StateMachine.INITIALIZED :
960 sc = self.start()
961 if sc.isFailure() or self.ReturnCode != 0:
962 return sc
return self._evtpro.executeRun(n)

def GaudiPython.Bindings.AppMgr.runSelectedEvents | ( |  | self,
|  |  | pfn,
|  |  | events
| ) |  |

Definition at line 967 of file Bindings.py.

967
968 def runSelectedEvents(self, pfn, events):
969 if self.FSMState() == Gaudi.StateMachine.CONFIGURED :
970 sc = self.initialize()
971 if sc.isFailure(): return sc
972 if self.FSMState() == Gaudi.StateMachine.INITIALIZED :
973 sc = self.start()
974 if sc.isFailure(): return sc
975 #--- Access a number of services ----
976 if not hasattr(self,'_perssvc'): self.__dict__['_perssvc'] = self.service('EventPersistencySvc','IAddressCreator')
977 if not hasattr(self,'_filecat'): self.__dict__['_filecat'] = self.service('FileCatalog','Gaudi::IFileCatalog')
978 if not hasattr(self,'_evtmgr'): self.__dict__['_evtmgr'] = self.service('EventDataSvc','IDataManagerSvc')
979 #--- Get FID from PFN and number of events in file
980 if pfn.find('PFN:') == 0: pfn = pfn[4:]
981 fid, maxevt = _getFIDandEvents(pfn)
982 #--- Add FID into catalog if needed ---
983 if not self._filecat.existsFID(fid) : self._filecat.registerPFN(fid, pfn, '')
984 #--- Loop over events
985 if type(events) is not list : events = (events,)
986 for evt in events :
987 #--- Create POOL Address from Generic Address
988 gadd = gbl.GenericAddress(0x02, 1, fid, '/Event', 0, evt)
989 oadd = makeNullPointer('IOpaqueAddress')
990 self._perssvc.createAddress(gadd.svcType(),gadd.clID(),gadd.par(),gadd.ipar(),oadd)
991 #--- Clear TES, set root and run all algorithms
992 self._evtmgr.clearStore()
993 self._evtmgr.setRoot('/Event',oadd)
self._evtpro.executeEvent()

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

Definition at line 780 of file Bindings.py.

780
781 def service(self, name, interface = None) :
782 svc = Helper.service( self._svcloc, name )
783 if interface :
784 return InterfaceCast(interface)(svc)
785 else :
return iService(name, svc )

def GaudiPython.Bindings.AppMgr.services | ( |  | self | ) |

Definition at line 790 of file Bindings.py.

790
791 def services(self) :
792 l = self._svcloc.getServices()
793 nl = l.__class__(l) # get a copy
794 s = []
795 for i in range(l.size()) :
796 s.append(nl.front().name())
797 nl.pop_front()
return s

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 863 of file Bindings.py.

863
864 def setAlgorithms(self, algs) :
865 """ Set the list of Top Algorithms.
866 It can be an individual of a list of algorithms names or instances """
867 if type(algs) is not list : algs = [algs]
868 names = []
869 for alg in algs :
870 if type(alg) is str : names.append(alg)
871 else :
872 self.pyalgorithms.append(alg)
873 if self.targetFSMState() >= Gaudi.StateMachine.INITIALIZED :
874 alg.sysInitialize()
875 if self.targetFSMState() == Gaudi.StateMachine.RUNNING :
876 alg.sysStart()
877 names.append(alg.name())
self.topAlg = names

def GaudiPython.Bindings.AppMgr.start | ( |  | self | ) |

Definition at line 951 of file Bindings.py.

951
952 def start(self) :
return self._appmgr.start()

def GaudiPython.Bindings.AppMgr.state | ( |  | self | ) |

Definition at line 777 of file Bindings.py.

777
def state(self) : return self._isvc.FSMState()

def GaudiPython.Bindings.AppMgr.targetFSMState | ( |  | self | ) |

Definition at line 779 of file Bindings.py.

779
def targetFSMState(self) : return self._isvc.targetFSMState()

def GaudiPython.Bindings.AppMgr.tool | ( |  | self,
|  |  | name
| ) |  |

Definition at line 810 of file Bindings.py.

810
811 def tool(self, name ) :
return iAlgTool(name)

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

Definition at line 842 of file Bindings.py.

842
843 def toolsvc(self, name='ToolSvc') :
844 svc = Helper.service( self._svcloc, name, True )
return iToolSvc(name, svc)

## Member Data Documentation

GaudiPython.Bindings.AppMgr.detSvc detsvc
| static

Definition at line 1013 of file Bindings.py.

GaudiPython.Bindings.AppMgr.evtSel evtsel
| static

Definition at line 1012 of file Bindings.py.

GaudiPython.Bindings.AppMgr.evtSvc evtsvc
| static

Definition at line 1009 of file Bindings.py.

GaudiPython.Bindings.AppMgr.histSvc histsvc
| static

Definition at line 1010 of file Bindings.py.

GaudiPython.Bindings.AppMgr.JobOptionsType

Definition at line 702 of file Bindings.py.

GaudiPython.Bindings.AppMgr.ntupleSvc ntuplesvc
| static

Definition at line 1011 of file Bindings.py.

GaudiPython.Bindings.AppMgr.OutputLevel

Definition at line 711 of file Bindings.py.

GaudiPython.Bindings.AppMgr.partSvc partsvc
| static

Definition at line 1015 of file Bindings.py.

GaudiPython.Bindings.AppMgr.toolSvc toolsvc
| static

Definition at line 1014 of file Bindings.py.

GaudiPython.Bindings.AppMgr.topAlg

Definition at line 877 of file Bindings.py.

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

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