Inheritance diagram for python.AppMgr.AthAppMgr:

Collaboration diagram for python.AppMgr.AthAppMgr:

Classes
class	State

Public Member Functions
	__init__ (self, name="ApplicationMgr", **kw)
	__setattr__ (self, name, value)
	__getattribute__ (self, name)
	algorithm (self, name)
	service (self, name)
	setOutputLevel (self, outputLevel)
	addSequence (self, seq)
	removeSequence (self, seq)
	addOutputStream (self, stream)
	getOutputStream (self, stream)
	removeOutputStream (self, stream)
	toolSvc (self, name='ToolSvc')
	serviceMgr (self)
	bootProps (self)
	getHandle (self, selfOptions={})
	setup (self, recursive=False)
	initialize (self)
	reinitialize (self)
	run (self, nEvt=None)
	start (self)
	stop (self)
	finalize (self)
	curEvent (self)
	seekEvent (self, n)
	seek (self, n)
	nextEvent (self, nEvt=None)
	size (self)
	replacePFC (self)
	exit (self, code=None)

Public Attributes
	OutputLevel = outputLevel
str	EventLoop

Static Public Attributes
	toolsvc = toolSvc
	servicemgr = serviceMgr

Protected Member Functions
	_evtSeek (self)
	_evtSize (self)

Protected Attributes
return self._cppApp.service(name)	_cppApp
	_sequences
	_exitstate

Private Member Functions
	__build_master_sequence (self)

Private Attributes
bool	__master_seq_built = True
	__dict__

Detailed Description

Definition at line 103 of file AppMgr.py.

Constructor & Destructor Documentation

◆ init()

python.AppMgr.AthAppMgr.__init__	(		self,
			name = "ApplicationMgr",
		**	kw )

Definition at line 118 of file AppMgr.py.

   def __init__( self, name = "ApplicationMgr", **kw ):
      kw['name'] = name
      if 'outputLevel' not in kw: kw['outputLevel'] = 3
      if 'jobOptions' not in kw : kw['jobOptions']  = None
 
    # some Atlas defaults
      if 'JobOptionsPath' not in kw: kw['JobOptionsPath'] = ""
      if 'JobOptionsType' not in kw: kw['JobOptionsType'] = "NONE"
      if 'EventLoop' not in kw:      kw['EventLoop']="AthenaEventLoopMgr"
      if 'StatusCodeCheck' not in kw: kw['StatusCodeCheck'] = False
 
    # always the case in ATLAS (need early or ExtSvc should be a no-op, too)
      kw['ExtSvcCreates'] = False
 
      super(AthAppMgr,self).__init__( **kw )
      self.__dict__[ '_cppApp' ]    = None        # proxy to C++/App.
      self.__dict__[ '_sequences' ] = []
      self.__dict__[ '_streams' ]   = AlgSequence.AlgSequence( "Streams" )
      self.__dict__[ 'CreateSvc' ]  = []          # block the property
      # TopAlg and OutStream are not user-settable directly (see __setattr__)
      self.__dict__[ 'TopAlg' ] = [ AlgSequence.AthSequencer( "AthMasterSeq" ).getFullName() ]
      self.__dict__[ 'OutStream' ]  = []
      self.__dict__[ '_exitstate' ] = ExitCodes.ALL_OK
 
      self.__dict__['state'] = lambda : AthAppMgr.State.OFFLINE
      self.__dict__['Dlls'] = []
      
    # install services
      svcMgr = self.serviceMgr()  # noqa: F841
 
    # external option (TODO: receive this cleanly; AthOptionsParser doesn't manage results, and
    # can't be called directly due to transforms etc.)
      self.__dict__[ '_opts' ] = None
 
    # figure out which release are we running, for logging purposes
      d = release_metadata()
      msg = Logging.log.info
      msg( 'using release [%(project name)s-%(release)s] [%(platform)s] [%(nightly name)s/%(nightly release)s] -- built on [%(date)s]' % d )
 
      return
 

Member Function Documentation

◆ __build_master_sequence()

python.AppMgr.AthAppMgr.__build_master_sequence ( self )

private

helper method to build the top-level AthSequencer from all bits and
   pieces : AthMasterSeq, AthAlgSeq, AthOutSeq

Definition at line 191 of file AppMgr.py.

   def __build_master_sequence (self):
      """helper method to build the top-level AthSequencer from all bits and
         pieces : AthMasterSeq, AthAlgSeq, AthOutSeq
      """
      from . import AlgSequence as _as
      from AthenaServices.AthenaServicesConf import AthIncFirerAlg as IFA
      from GaudiCoreSvc.GaudiCoreSvcConf import IncidentProcAlg as IPA
 
      def _build():
         Logging.log.debug ("building master sequence...")
         athMasterSeq = _as.AthSequencer ("AthMasterSeq",Sequential = True)
         athBeginSeq  = _as.AthSequencer ("AthBeginSeq",Sequential=True)
         athCondSeq   = _as.AthSequencer ("AthCondSeq", StopOverride=True)
         athAlgSeq    = _as.AthSequencer ("AthAlgSeq",IgnoreFilterPassed=True, StopOverride=True, ProcessDynamicDataDependencies=True, ExtraDataForDynamicConsumers=[])
         athEndSeq    = _as.AthSequencer ("AthEndSeq",Sequential=True)
         athOutSeq    = _as.AthSequencer ("AthOutSeq", StopOverride=True)
         athAllAlgSeq = _as.AthSequencer ("AthAllAlgSeq", StopOverride=True)
         athAlgEvtSeq = _as.AthSequencer ("AthAlgEvtSeq",Sequential = True, StopOverride=True)
 
         #Setup begin and end sequences
         # Begin Sequence
         #   IFA->BeginEvent
         #   IPA
         ifaBeg=IFA("BeginIncFiringAlg")
         ifaBeg.Incidents=["BeginEvent"]
         ifaBeg.FireSerial=False # we want serial incident to be fired as well
         athBeginSeq += ifaBeg
         ipa=IPA("IncidentProcAlg1")
         athBeginSeq += ipa
 
         # EndSequence
         #   IFA->EndEvent
         #   IPA
         ifaEnd=IFA("EndIncFiringAlg")
         ifaEnd.Incidents=["EndEvent"]
         ifaEnd.FireSerial=False # we want serial incident to be fired as well
         athEndSeq += ifaEnd
         ipa2=IPA("IncidentProcAlg2")
         athEndSeq += ipa2
 
         # XXX: should we discard empty sequences ?
         #      might save some CPU and memory...
 
         # ensure that the CondInputLoader gets initialized after all
         # other user Algorithms for MT so that base classes of data deps
         # can be correctly determined. In MT, the order of execution
         # is irrelevant (determined by data deps). But for serial, we 
         # need the CondAlgs to execute first, so the ordering changes.
         from AthenaCommon.ConcurrencyFlags import jobproperties as jp
         if ( jp.ConcurrencyFlags.NumThreads() > 0 ) :
            athAllAlgSeq += athAlgSeq
            athAllAlgSeq += athCondSeq
         else:
            athAllAlgSeq += athCondSeq
            athAllAlgSeq += athAlgSeq
 
         athAlgEvtSeq += athBeginSeq
         athAlgEvtSeq += athAllAlgSeq
         athAlgEvtSeq += athEndSeq
 
         athMasterSeq += athAlgEvtSeq
         athMasterSeq += athOutSeq
         
         # Should be after all other algorithms.
         athMasterSeq += IFA('EndAlgorithmsFiringAlg',
                             Incidents = ['EndAlgorithms'],
                             FireSerial = False)
         athMasterSeq += IPA('IncidentProcAlg3')
 
         if Logging.log.isEnabledFor(Logging.logging.DEBUG):
            from AthenaCommon.AlgSequence import dumpSequence
            dumpSequence(athMasterSeq)
 
         Logging.log.debug ("building master sequence... [done]")
         return athMasterSeq
      # prevent hysteresis effect
      if not hasattr (self, '__master_seq_built'):
         self.__master_seq_built = True
         return _build()
      return _as.AthSequencer ("AthMasterSeq")
   

◆ getattribute()

python.AppMgr.AthAppMgr.__getattribute__	(		self,
			name )

Definition at line 181 of file AppMgr.py.

   def __getattribute__( self, name ):
      if name[0] == '_':
         return object.__getattribute__( self, name )
      if hasattr(self, '_cppApp') and self._cppApp and \
         name in AthAppMgr.__slots__:
         return getattr(self._cppApp, name)
      else:
         if name == "Dlls": return []      # block Dlls calls
         return super( AthAppMgr, self ).__getattribute__(name)
 

◆ setattr()

python.AppMgr.AthAppMgr.__setattr__	(	self,
		name,
		value )

Definition at line 159 of file AppMgr.py.

   def __setattr__( self, name, value ):
    # required b/c the lookup is otherwise intercepted by iProperty
      if name[0] == '_':           # private properties
         return object.__setattr__( self, name, value )
    # in case the C++ app has already been instantiated...
      if hasattr(self, '_cppApp') and self._cppApp and \
         name in AthAppMgr.__slots__:
         handle = self.getHandle()
         return handle.__setattr__(name, value)
      elif name == "TopAlg" and value:
         raise RuntimeError("Setting theApp.TopAlg is not supported. "
                            "Add the algorithm to the default AlgSequence() instead.")
      elif name == "Dlls":         # block Dlls calls
         return
      elif name == "OutStream" and value:
         raise RuntimeError("Setting theApp.OutStream is not supported. "
                            "Use theApp.addOutputStream instead.")
      elif name == "CreateSvc":    # for delaying creation of services
         self.__dict__[ name ] = value
      else:
         return super( AppMgr, self ).__setattr__( name, value )
 

◆ _evtSeek()

python.AppMgr.AthAppMgr._evtSeek ( self )

protected

 retrieve a handle to the IEventSeek interface of the event loop mgr

Definition at line 376 of file AppMgr.py.

   def _evtSeek(self):
      """ retrieve a handle to the IEventSeek interface of the event loop mgr
      """
      import AthenaPython.PyAthena as PyAthena
      return PyAthena.py_svc(self.EventLoop, iface='IEventSeek')
 

◆ _evtSize()

python.AppMgr.AthAppMgr._evtSize ( self )

protected

 retrieve a handle to the ICollectionSize interface of the event loop mgr

Definition at line 383 of file AppMgr.py.

   def _evtSize(self):
      """ retrieve a handle to the ICollectionSize interface of the event loop mgr
      """
      import AthenaPython.PyAthena as PyAthena
      return PyAthena.py_svc(self.EventLoop, iface='ICollectionSize')
 

◆ addOutputStream()

python.AppMgr.AthAppMgr.addOutputStream	(		self,
			stream )

Definition at line 303 of file AppMgr.py.

   def addOutputStream( self, stream ):
      if stream not in self._streams.getChildren():
         self._streams += stream
 

◆ addSequence()

python.AppMgr.AthAppMgr.addSequence	(		self,
			seq )

Definition at line 296 of file AppMgr.py.

   def addSequence( self, seq ):
      if seq not in self._sequences:
         self._sequences.append( seq )
 

◆ algorithm()

python.AppMgr.AthAppMgr.algorithm	(		self,
			name )

Definition at line 272 of file AppMgr.py.

   def algorithm( self, name ):
      if self._cppApp:
         return self.getHandle().algorithm( name )
      # might be lucky...
      return super( AppMgr, self ).algorithm( name )
   

◆ bootProps()

python.AppMgr.AthAppMgr.bootProps ( self )

Definition at line 334 of file AppMgr.py.

   def bootProps(self):
      props = {}
      for k in self.getProperties().keys():
         if k not in [ "Go", "Exit", "AuditInitialize", "AuditFinalize" ]:
            props[k] = self.getDefaultProperty(k)
            if hasattr(self, k):
               props[k] = getattr(self, k)
      props['Dlls'] = []
      props['CreateSvc'] = []
      return props
 

◆ curEvent()

python.AppMgr.AthAppMgr.curEvent ( self )

Definition at line 673 of file AppMgr.py.

   def curEvent( self ):
      try:
         return self._evtSeek.curEvent()
      except AttributeError:
         raise TypeError( '%s does not support IEventSeek' % theApp.EventLoop )
 

◆ exit()

python.AppMgr.AthAppMgr.exit	(		self,
			code = None )

Terminate AppMgr and exit python

Definition at line 737 of file AppMgr.py.

   def exit( self, code = None ):
      """Terminate AppMgr and exit python"""
      try:
         if self.state() > AthAppMgr.State.CONFIGURED:
            sc1 = self.finalize()
            self.replacePFC() #only for AthenaMP -> replace pfc by mp version
            sc2 = self.getHandle()._appmgr.terminate()
            if ( sc1.isFailure() or sc2.isFailure() ) and not self._exitstate:
               self._exitstate = ExitCodes.FIN_ALG_FAILURE
      except Exception:
         if not self._exitstate:
            self._exitstate = ExitCodes.FIN_ALG_EXCEPTION
         import traceback
         traceback.print_exc()     # no re-raise to allow sys.exit next
 
      if self._opts.profile_python:
         from AthenaCommon.Debugging import dumpPythonProfile
         dumpPythonProfile(self._opts.profile_python)
 
      if code is None:
         code = self._exitstate
 
      # In interactive mode, where this functions is called within an atexit handler,
      # we cannot call sys.exit as this raises SystemExit, which is not allowed in
      # exit handlers. Unfortunately, this also means we cannot set an exit code.
      # See also: https://bugs.python.org/issue27035
      #           https://github.com/python/cpython/issues/103512
      if not os.environ.get('PYTHONINSPECT', ''):
         Logging.log.info( 'leaving with code %d: "%s"', code, ExitCodes.what( code ) )
         sys.exit( code )
 
 

◆ finalize()

python.AppMgr.AthAppMgr.finalize ( self )

Definition at line 652 of file AppMgr.py.

   def finalize( self ): 
      #stop theApp if not already done
      sc = theApp.stop()
      if sc.isFailure() and not self._exitstate:
         self._exitstate = ExitCodes.FIN_ALG_FAILURE
      try:
         if not self._cppApp:
            raise RuntimeError("C++ application not instantiated : Nothing to finalize !")
         # Set threaded flag to release the GIL when finalizing in the c++
         from AthenaCommon.ConcurrencyFlags import jobproperties as jp
         finalizeMethod = self.getHandle()._appmgr.finalize
         finalizeMethod.__release_gil__ = jp.ConcurrencyFlags.NumThreads() > 0
         sc = finalizeMethod()
         if sc.isFailure():
            self._exitstate = ExitCodes.FIN_ALG_FAILURE
      except Exception:
         self._exitstate = ExitCodes.FIN_ALG_EXCEPTION
         raise
      return sc
 

◆ getHandle()

python.AppMgr.AthAppMgr.getHandle	(		self,
			selfOptions = {} )

Definition at line 345 of file AppMgr.py.

   def getHandle( self, selfOptions = {} ):
      if not self._cppApp:
       # temporarily store this list as it will be touched by the C++ app
       # through the __getattribute__ method
         _createSvc = self.__dict__['CreateSvc']
         if not selfOptions:
            selfOptions = self.bootProps()
            for k,v in selfOptions.items(): setattr(self, k, v)
         svcMgr = self.serviceMgr()
       # prevent the loading of ConfigurableDb when no configuration is done
         if self._opts and not self._opts.fromdb:
            from AthenaCommon.ConfigurableDb import getConfigurable
            if not hasattr(svcMgr, 'JobOptionsSvc'):
               svcMgr += getConfigurable(self.JobOptionsSvcType)("JobOptionsSvc")
            if not hasattr(svcMgr, 'MessageSvc'):
               svcMgr += getConfigurable(self.MessageSvcType)("MessageSvc")
 
         from GaudiPython import AppMgr as GaudiAppMgr
         self._cppApp = GaudiAppMgr( outputlevel = self.outputLevel,
                                     joboptions  = None,
                                     selfoptions = selfOptions )
         self.__dict__['state'] = self._cppApp.state
         for k,v in selfOptions.items():
            setattr(self._cppApp,k,v)
         self.__dict__['CreateSvc'] = _createSvc
         del _createSvc
 
      import GaudiPython # this module might have disappeared b/c of cleansing # noqa: F401
      return self._cppApp
   

◆ getOutputStream()

python.AppMgr.AthAppMgr.getOutputStream	(		self,
			stream )

Definition at line 307 of file AppMgr.py.

   def getOutputStream( self, stream ):
      athOutSeq    = AlgSequence.AthSequencer( "AthOutSeq" )
      for o in athOutSeq.getChildren():
         if o.name() == stream:
            return o
      for o in self._streams.getChildren():
         if o.name() == stream:
            return o
      return None
 

◆ initialize()

python.AppMgr.AthAppMgr.initialize ( self )

Definition at line 536 of file AppMgr.py.

   def initialize( self ):
      # Touch these types early, before dictionaries are loaded,
      # to prevent spurious error messages from ROOT.
      # See ATLASRECTS-3486.
      from os import environ
      environ['CLING_STANDARD_PCH'] = 'none' #See bug ROOT-10789
      import cppyy
      getattr(cppyy.gbl, 'vector<bool>')
      getattr(cppyy.gbl, 'vector<float>')
      getattr(cppyy.gbl, 'vector<unsigned short>')
      getattr(cppyy.gbl, 'vector<short>')
      getattr(cppyy.gbl, 'vector<unsigned long>')
      getattr(cppyy.gbl, 'vector<ULong64_t>')
      getattr(cppyy.gbl, 'map<string,string>')
 
    # build configuration
      self.setup()
 
    # create C++-side AppMgr
      from AthenaCommon.ConcurrencyFlags import jobproperties as jp
      try:
         # Set threaded flag to release the python GIL when we're in C++
         is_threaded = jp.ConcurrencyFlags.NumThreads() > 0
         self.getHandle()._appmgr.initialize.__release_gil__ = is_threaded
         sc = self.getHandle().initialize()
         if sc.isFailure():
            self._exitstate = ExitCodes.INI_ALG_FAILURE
      except Exception:
         self._exitstate = ExitCodes.INI_ALG_EXCEPTION
         raise
      return sc
 

◆ nextEvent()

python.AppMgr.AthAppMgr.nextEvent	(		self,
			nEvt = None )

Definition at line 703 of file AppMgr.py.

   def nextEvent( self, nEvt = None ):
      #start theApp if not already done
      sc = theApp.start()
      if sc.isFailure() and not self._exitstate:
         self._exitstate = ExitCodes.INI_ALG_FAILURE
 
      if nEvt is None:
         nEvt = self.curEvent() + 1
 
      try:
         sc = self.getHandle()._evtpro.nextEvent( nEvt )
         if sc.isFailure() and not self._exitstate:
            self._exitstate = ExitCodes.EXE_ALG_FAILURE
      except Exception:
         self._exitstate = ExitCodes.EXE_ALG_EXCEPTION
         raise
 
      return sc
 

◆ reinitialize()

python.AppMgr.AthAppMgr.reinitialize ( self )

Definition at line 568 of file AppMgr.py.

   def reinitialize( self ):
    # since we're going to run python again, may have to re-enable to profiler
      if self._opts and self._opts.profile_python:
         import cProfile
         cProfile._athena_python_profiler.enable()
 
    # first, rebuild configuration
      self.setup()
 
    # ApplicationMgr::reinitialize does not reinit algorithms ...
      for name in self.getHandle().TopAlg:
         try:
            parts = name.split('/')
            algname = len(parts) == 2 and parts[1] or parts[0]
            sc = self.algorithm( algname )._ialg.reinitialize()
            if sc.isFailure() and not self._exitstate:
               return sc
         except AttributeError:
            pass
 
    # normal reinitialize kicks services, tools left out ...
      return self.getHandle().reinitialize()
 

◆ removeOutputStream()

python.AppMgr.AthAppMgr.removeOutputStream	(		self,
			stream )

Definition at line 317 of file AppMgr.py.

   def removeOutputStream( self, stream ):
      self._streams.remove( stream )
         

◆ removeSequence()

python.AppMgr.AthAppMgr.removeSequence	(		self,
			seq )

Definition at line 300 of file AppMgr.py.

   def removeSequence( self, seq ):
      self._sequences.remove( seq )
 

◆ replacePFC()

python.AppMgr.AthAppMgr.replacePFC ( self )

if we have MP version of EventLoopMgr 
replace PoolFileCatalog.xml by MP version

Definition at line 728 of file AppMgr.py.

   def replacePFC(self):
     """ if we have MP version of EventLoopMgr 
      replace PoolFileCatalog.xml by MP version"""
     if (self.EventLoop == 'AthMpEventLoopMgr/EventLoopMgr'):
         if os.path.exists("MP_PoolFileCatalog.xml"):
             Logging.log.info ("replacing PoolFileCataloG.xml by MP version")
             import shutil
             shutil.copy2("MP_PoolFileCatalog.xml", "PoolFileCatalog.xml")
 

◆ run()

python.AppMgr.AthAppMgr.run	(		self,
			nEvt = None )

Definition at line 592 of file AppMgr.py.

   def run( self, nEvt = None ):
    # initialize as appropriate
      if self.state() in ( AthAppMgr.State.OFFLINE,
                           AthAppMgr.State.CONFIGURED, ):
         Logging.log.debug( 'Initializing application manager' )
         sc = self.initialize()
      else:
         Logging.log.debug( 'Re-initializing application manager' )
         sc = self.reinitialize()
 
      if sc.isFailure():
         return sc
 
      sc = self.start()
      if sc.isFailure():
         return sc
 
    # determine number of events
      if nEvt is None:
         nEvt = self.EvtMax            # late, as sequences may have changed it
 
      from AthenaCommon.Debugging import DbgStage
      if DbgStage.value == "exec":
         from .Debugging import hookDebugger
         hookDebugger()
 
    # actual run (FIXME: capture beginRun() exceptions and failures, which is
    #               not currently supported by IEventProcessor interface)
      from AthenaCommon.ConcurrencyFlags import jobproperties as jp
      try:
         # Set threaded flag to release the GIL on execution
         executeRunMethod = self.getHandle()._evtpro.executeRun
         executeRunMethod.__release_gil__ = jp.ConcurrencyFlags.NumThreads() > 0
         sc = executeRunMethod(nEvt)
         if sc.isFailure() and not self._exitstate:
            self._exitstate = ExitCodes.EXE_ALG_FAILURE   # likely, no guarantee
      except Exception:
         self._exitstate = ExitCodes.EXE_ALG_EXCEPTION    # idem
         raise
 
      sc = self.stop()
      return sc
 

◆ seek()

python.AppMgr.AthAppMgr.seek	(		self,
			n )

Definition at line 693 of file AppMgr.py.

   def seek( self, n ):
      try:
         sc = self._evtSeek.seek( n )
         # prevents any unchecked statuscode leftover
         if not sc.isSuccess():
            return sc
         return sc
      except AttributeError:
         raise TypeError( '%s does not support IEventSeek' % theApp.EventLoop )
 

◆ seekEvent()

python.AppMgr.AthAppMgr.seekEvent	(		self,
			n )

Definition at line 679 of file AppMgr.py.

   def seekEvent( self, n ):
      try:
         sc = self._evtSeek.seek( n )
         # prevents any unchecked statuscode leftover
         if not sc.isSuccess():
            return sc
         sc = self.nextEvent()
         # prevents any unchecked statuscode leftover
         if not sc.isSuccess():
            return sc
         return sc
      except AttributeError:
         raise TypeError( '%s does not support IEventSeek' % theApp.EventLoop )
 

◆ service()

python.AppMgr.AthAppMgr.service	(		self,
			name )

Definition at line 278 of file AppMgr.py.

   def service( self, name ):
      if self._cppApp: return self._cppApp.service(name)
      svcMgr = self.serviceMgr()
      if not hasattr( svcMgr, name ):
         from AthenaCommon import CfgMgr
         svcMgr += getattr( CfgMgr, name )()
      return getattr( svcMgr, name )
   

◆ serviceMgr()

python.AppMgr.AthAppMgr.serviceMgr ( self )

Definition at line 328 of file AppMgr.py.

   def serviceMgr( self ):
      if '_servicemgr' not in self.__dict__:
         self.__dict__[ '_servicemgr' ] = AthServiceManager( 'ServiceManager' )
      return self._servicemgr

◆ setOutputLevel()

python.AppMgr.AthAppMgr.setOutputLevel	(		self,
			outputLevel )

Definition at line 286 of file AppMgr.py.

   def setOutputLevel( self, outputLevel ):
      if outputLevel != -1 :
         if self.state() == AthAppMgr.State.OFFLINE :    # not yet configured
            self.OutputLevel = outputLevel
         svcMgr = self.serviceMgr()
         if not hasattr( svcMgr, 'MessageSvc' ):
            svcMgr += GaudiCoreSvcConf.MessageSvc()
         svcMgr.MessageSvc.OutputLevel = outputLevel
 

◆ setup()

python.AppMgr.AthAppMgr.setup	(		self,
			recursive = False )

Definition at line 390 of file AppMgr.py.

   def setup( self, recursive = False ):
      if not recursive and (self._opts and (self._opts.drop_reload or self._opts.config_only)):
       # store configuration on disk
         if self._opts.config_only is True:  # config-only but not storing to file
            fn = None
         elif self._opts.config_only:
            fn = self._opts.config_only
         else:
            fn = 'TempAthenaConfig.' + str(os.getpid()) + '.pkl'
 
         if fn is not None:
            Logging.log.info( "storing configuration in %s", fn )
            from AthenaCommon import ConfigurationShelve
            ConfigurationShelve.storeJobOptionsCatalogue( fn )
            del ConfigurationShelve
 
         if self._opts.drop_reload:
          # build the new set of options; replace the .py by the .pkl,
          # and remove '-c arg'
            del sys.argv[ sys.argv.index( '--drop-and-reload' ) ]
            for arg in sys.argv[1:]:
               if arg[-3:] == '.py':
                  del sys.argv[ sys.argv.index( arg ) ]
 
               elif arg == '-c':
                  idx = sys.argv.index( arg )
                  del sys.argv[ idx : idx + 2 ]
 
          # dump profiling
            if self._opts.profile_python:
               i = sys.argv.index( '--profile-python' )
               del sys.argv[i:i+2]  # delete argument and its value
               from AthenaCommon.Debugging import dumpPythonProfile
               dumpPythonProfile(self._opts.profile_python)
 
          # fire ourselves up anew
            Logging.log.info( 'restarting athena.py from %s ... ', fn )
            sys.argv.insert( 1, fn )
            os.execvp( sys.argv[0], sys.argv )
 
         else:
          # running config-only, so we're done
            if self._opts.profile_python:
               from AthenaCommon.Debugging import dumpPythonProfile
               dumpPythonProfile(self._opts.profile_python)
            Logging.log.info( "configuration complete, now exiting ... " )
            os._exit( self._exitstate )
 
    # normal setup() (non drop-and-reload) continues here:
 
    # first we bring the real C++ application to life...
      handle = self.getHandle()
 
    # temporarily disable GaudiAppMgr.Dlls and .CreateSvc calls
      handle.__dict__['CreateSvc'] = self.__dict__.get('CreateSvc',
                                                       handle.CreateSvc)
      
      from GaudiPython import AppMgr as GaudiAppMgr
 
    # Likely the first (or at least the first important) place if we're
    # running in compatibility mode where gaudimodule will be loaded. And
    # even if not, still ok. Remove the GaudiPython exit handlers as to
    # prevent them from clobbering Athena ones.
    # Don't remove exit handlers for GaudiConfig2, or we can get spurious
    # errors on exit.
      import atexit
      handler = None
      if hasattr(atexit, '_exithandlers'):
         for handler in atexit._exithandlers[:]:
            if hasattr(handler[0], '__module__') and handler[0].__module__:
               if 'audiPython' in handler[0].__module__:  # removes GaudiPython handlers
                  #print ("removed ", handler[0].__module__)
                  atexit._exithandlers.remove( handler )
      del handler, atexit
 
      def _setattr( self, n, v ):
         if n == 'CreateSvc':
            self.__dict__[n] = v
            return
         if n == 'Dlls':
            return
         return super( GaudiAppMgr, self ).__setattr__( n, v )
      GaudiAppMgr_old_setattr = GaudiAppMgr.__setattr__
      GaudiAppMgr.__setattr__ = _setattr
      del _setattr
      
      def _getattr( self, n ):
         if n == 'CreateSvc':
            return self.__dict__[n]
         return super( GaudiAppMgr, self ).__getattr__( n )
      GaudiAppMgr_old_getattr = GaudiAppMgr.__getattr__
      GaudiAppMgr.__getattr__ = _getattr
      del _getattr
      
    # public tools (they're less likely to be instantiated early, and
    # thus rely on job options load order)
      self.toolSvc().setup()
 
    # new-style services (also sets up AuditorSvc)
      self.serviceMgr().setup()
 
    # setup top-level job seq
      master_seq = self.__build_master_sequence()
      master_seq.setup()
 
    # tell self about the algs
      handle.TopAlg = [ master_seq.getFullName() ]
                           
    # setup output streams, and tell self about them
      streams = self.__dict__[ '_streams' ]
      streams.setup()
      handle.OutStream = list(map( lambda x: x.getFullName(), streams.getChildren() ))
 
    # synchronize 'Dlls'
    # note: we synchronize in the opposite direction wrt CreateSvc
      super(AppMgr,self).__setattr__('Dlls', handle.Dlls)
 
    # synchronize 'CreateSvc'  
      svcMgr = self.serviceMgr()
      _createSvc = handle.__dict__['CreateSvc']
      if len(_createSvc) > 0 and \
         _createSvc[0] != svcMgr.ToolSvc.getFullName():
         _createSvc = [ svcMgr.ToolSvc.getFullName() ] + _createSvc
 
      if 'CreateSvc' in self.__dict__:
         del self.__dict__['CreateSvc']
      handle.__dict__['CreateSvc'] = [ s for s in _createSvc ]
      
    # reinstall old __?etattr__
      del handle.__dict__['CreateSvc']
      GaudiAppMgr.__getattr__ = GaudiAppMgr_old_getattr
      GaudiAppMgr.__setattr__ = GaudiAppMgr_old_setattr
      
    # only now allow CreateSvc, so that there are no ordering problems
      Logging.log.debug( 'Updating (C++) "CreateSvc" property...' )
      handle.CreateSvc = _createSvc
      Logging.log.debug( 'Updating (C++) "CreateSvc" property... [ok]' )
      
    # if requested, dump the current state of the configuration to an ASCII file
      if self._opts and self._opts.config_dump_file:
         import AthenaCommon.ConfigurationShelve as cs
         cs.saveToAscii(self._opts.config_dump_file)
 
      return
   

◆ size()

python.AppMgr.AthAppMgr.size ( self )

Definition at line 722 of file AppMgr.py.

   def size( self ):
      try:
         return self._evtSize.size()
      except AttributeError:
         raise TypeError( '%s does not support ICollectionSize' % theApp.EventLoop )
     

◆ start()

python.AppMgr.AthAppMgr.start ( self )

Definition at line 635 of file AppMgr.py.

   def start( self ):
      import GaudiPython
      sc = GaudiPython.SUCCESS
      if self.State.INITIALIZED == self.getHandle().FSMState():
         Logging.log.debug( 'Starting application manager' )
         sc = self.getHandle().start()
      return sc
 

◆ stop()

python.AppMgr.AthAppMgr.stop ( self )

Definition at line 643 of file AppMgr.py.

   def stop( self ):
      import GaudiPython
      sc = GaudiPython.SUCCESS
      if self.State.RUNNING == self.getHandle().FSMState():
         Logging.log.debug( 'Stopping application manager' )
         sc = self.getHandle().stop()
      return sc
 

◆ toolSvc()

python.AppMgr.AthAppMgr.toolSvc	(		self,
			name = 'ToolSvc' )

Definition at line 321 of file AppMgr.py.

   def toolSvc( self, name='ToolSvc' ):
      if '_toolsvc' not in self.__dict__:
         self.__dict__[ '_toolsvc' ] = GaudiCoreSvcConf.ToolSvc( name )
      return self._toolsvc

Member Data Documentation

◆ dict

python.AppMgr.AthAppMgr.__dict__

private

Definition at line 322 of file AppMgr.py.

◆ __master_seq_built

bool python.AppMgr.AthAppMgr.__master_seq_built = True

private

Definition at line 268 of file AppMgr.py.

◆ _cppApp

python.AppMgr.AthAppMgr._cppApp

protected

Definition at line 186 of file AppMgr.py.

◆ _exitstate

python.AppMgr.AthAppMgr._exitstate

protected

Definition at line 436 of file AppMgr.py.

◆ _sequences

python.AppMgr.AthAppMgr._sequences

protected

Definition at line 297 of file AppMgr.py.

◆ EventLoop

python.AppMgr.AthAppMgr.EventLoop

Definition at line 380 of file AppMgr.py.

◆ OutputLevel

python.AppMgr.AthAppMgr.OutputLevel = outputLevel

Definition at line 289 of file AppMgr.py.

◆ servicemgr

python.AppMgr.AthAppMgr.servicemgr = serviceMgr

static

Definition at line 332 of file AppMgr.py.

◆ toolsvc

python.AppMgr.AthAppMgr.toolsvc = toolSvc

static

Definition at line 325 of file AppMgr.py.

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

AppMgr.py

Classes

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __build_master_sequence()

◆ __getattribute__()

◆ __setattr__()

◆ _evtSeek()

◆ _evtSize()

◆ addOutputStream()

◆ addSequence()

◆ algorithm()

◆ bootProps()

◆ curEvent()

◆ exit()

◆ finalize()

◆ getHandle()

◆ getOutputStream()

◆ initialize()

◆ nextEvent()

◆ reinitialize()

◆ removeOutputStream()

◆ removeSequence()

◆ replacePFC()

◆ run()

◆ seek()

◆ seekEvent()

◆ service()

◆ serviceMgr()

◆ setOutputLevel()

◆ setup()

◆ size()

◆ start()

◆ stop()

◆ toolSvc()

Member Data Documentation

◆ __dict__

◆ __master_seq_built

◆ _cppApp

◆ _exitstate

◆ _sequences

◆ EventLoop

◆ OutputLevel

◆ servicemgr

◆ toolsvc

◆ init()

◆ getattribute()

◆ setattr()

◆ dict