Gaudi::Main::gaudimain Class Reference

List of all members.

Public Member Functions
def	__init__
def	setupParallelLogging
def	generatePyOutput
def	generateOptsOutput
def	printconfig
def	writeconfig
def	printsequence
def	run
	Instantiate and run the application.
def	runSerial
def	runParallel
Public Attributes
	log
	g
Private Member Functions
def	_writepickle

---

Detailed Description

Definition at line 8 of file Main.py.

---

Member Function Documentation

def Gaudi::Main::gaudimain::__init__

(

self

)

Definition at line 9 of file Main.py.

                       :
        from Configurables import ApplicationMgr
        appMgr = ApplicationMgr()
        if "GAUDIAPPNAME" in os.environ:
            appMgr.AppName = str(os.environ["GAUDIAPPNAME"])
        if "GAUDIAPPVERSION" in os.environ:
            appMgr.AppVersion = str(os.environ["GAUDIAPPVERSION"])
        self.log = logging.getLogger(__name__)

def Gaudi::Main::gaudimain::_writepickle	(		self,
			filename
	)			[private]

Definition at line 70 of file Main.py.

                                     :
        #--- Lets take the first file input file as the name of the pickle file
        import pickle
        output = open(filename, 'wb')
        # Dump only the the configurables that make sense to dump (not User ones)
        from GaudiKernel.Proxy.Configurable import getNeededConfigurables
        to_dump = {}
        for n in getNeededConfigurables():
            to_dump[n] = Configuration.allConfigurables[n]
        pickle.dump(to_dump, output, -1)
        output.close()

def Gaudi::Main::gaudimain::generateOptsOutput	(		self,
			all = False
	)

Definition at line 57 of file Main.py.

                                             :
        from pprint import pformat
        conf_dict = Configuration.configurationDict(all)
        out = []
        names = conf_dict.keys()
        names.sort()
        for n in names:
            props = conf_dict[n].keys()
            props.sort()
            for p in props:
                out.append('%s.%s = %s;' % (n,p, repr(conf_dict[n][p])))
        return "\n".join(out)

def Gaudi::Main::gaudimain::generatePyOutput	(		self,
			all = False
	)

Definition at line 52 of file Main.py.

                                           :
        from pprint import pformat
        conf_dict = Configuration.configurationDict(all)
        return pformat(conf_dict)

def Gaudi::Main::gaudimain::printconfig	(		self,
			old_format = False,
			all = False
	)

Definition at line 82 of file Main.py.

                                                           :
        msg = 'Dumping all configurables and properties'
        if not all:
            msg += ' (different from default)'
        log.info(msg)
        conf_dict = Configuration.configurationDict(all)
        if old_format:
            print self.generateOptsOutput(all)
        else:
            print self.generatePyOutput(all)

def Gaudi::Main::gaudimain::printsequence

(

self

)

Definition at line 106 of file Main.py.

                           :
        def printAlgo( algName, appMgr, prefix = ' ') :
            print prefix + algName
            alg = appMgr.algorithm( algName.split( "/" )[ -1 ] )
            prop = alg.properties()
            if prop.has_key( "Members" ) :
                subs = prop[ "Members" ].value()
                for i in subs : printAlgo( i.strip( '"' ), appMgr, prefix + "     " )
            elif prop.has_key( "DetectorList" ) :
                subs = prop[ "DetectorList" ].value()
                for i in subs : printAlgo( algName.split( "/" )[ -1 ] + i.strip( '"' ) + "Seq", appMgr, prefix + "     ")
        import GaudiPython
        self.g = GaudiPython.AppMgr()
        mp = self.g.properties()
        print "\n ****************************** Algorithm Sequence **************************** \n"
        for i in mp["TopAlg"].value(): printAlgo( i, self.g )
        print "\n ****************************************************************************** \n"

def Gaudi::Main::gaudimain::run	(		self,
			ncpus = None
	)

Instantiate and run the application.

Depending on the number of CPUs (ncpus) specified, it start

Definition at line 126 of file Main.py.

                               :
        if not ncpus:
            # Standard sequential mode
            result = self.runSerial()
        else:
            # Otherwise, run with the specified number of cpus
            result = self.runParallel(ncpus)
        return result

def Gaudi::Main::gaudimain::runParallel	(		self,
			ncpus
	)

Definition at line 155 of file Main.py.

                                 :
        self.setupParallelLogging( )
        from Gaudi.Configuration import Configurable
        import GaudiMP.GMPBase as gpp
        c = Configurable.allConfigurables
        self.log.info('-'*80)
        self.log.info('%s: Parallel Mode : %i '%(__name__, ncpus))
        from commands import getstatusoutput as gso
        metadataCommands = [ 'uname -a',
                             'echo $CMTCONFIG',
                             'echo $GAUDIAPPNAME',
                             'echo $GAUDIAPPVERSION']
        for comm in metadataCommands :
            s, o = gso( comm )
            if s :
                o = "Undetermined"
            string = '%s: %30s : %s '%(__name__, comm, o)
            self.log.info( string )
        try :
            events = str(c['ApplicationMgr'].EvtMax)
        except :
            events = "Undetermined"
        self.log.info('%s: Events Specified : %s '%(__name__,events))
        self.log.info('-'*80)
        # Parall = gpp.Coordinator(ncpus, shared, c, self.log)
        Parall = gpp.Coord( ncpus, c, self.log )
        sysStart = time()
        sc = Parall.Go()
        self.log.info('MAIN.PY : received %s from Coordinator'%(sc))
        if sc.isFailure() :
            return 1
        sysTime = time()-sysStart
        self.log.name = 'Gaudi/Main.py Logger'
        self.log.info('-'*80)
        self.log.info('%s: parallel system finished, time taken: %5.4fs', __name__, sysTime)
        self.log.info('-'*80)
        return 0

def Gaudi::Main::gaudimain::runSerial

(

self

)

Definition at line 136 of file Main.py.

                        :
        #--- Instantiate the ApplicationMgr------------------------------
        import GaudiPython
        self.log.debug('-'*80)
        self.log.debug('%s: running in serial mode', __name__)
        self.log.debug('-'*80)
        sysStart = time()
        self.g = GaudiPython.AppMgr()
        success = self.g.run(self.g.EvtMax).isSuccess()
        success = self.g.exit().isSuccess() and success
        if not success and self.g.ReturnCode == 0:
            # ensure that the return code is correctly set
            self.g.ReturnCode = 1
        sysTime = time()-sysStart
        self.log.debug('-'*80)
        self.log.debug('%s: serial system finished, time taken: %5.4fs', __name__, sysTime)
        self.log.debug('-'*80)
        return self.g.ReturnCode

def Gaudi::Main::gaudimain::setupParallelLogging

(

self

)

Definition at line 18 of file Main.py.

                                     :
        # ---------------------------------------------------
        # set up Logging
        # ----------------
        # from multiprocessing import enableLogging, getLogger
        import multiprocessing
        # preliminaries for handlers/output files, etc.
        from time import ctime
        datetime = ctime()
        datetime = datetime.replace(' ', '_')
        outfile = open( 'gaudirun-%s.log'%(datetime), 'w' )
        # two handlers, one for a log file, one for terminal
        streamhandler = logging.StreamHandler(strm=outfile)
        console       = logging.StreamHandler()
        # create formatter : the params in parentheses are variable names available via logging
        formatter = logging.Formatter( "%(asctime)s - %(name)s - %(levelname)s - %(message)s" )
        # add formatter to Handler
        streamhandler.setFormatter(formatter)
        console.setFormatter(formatter)
        # now, configure the logger
        # enableLogging( level=0 )
        # self.log = getLogger()
        self.log = multiprocessing.log_to_stderr()
        self.log.setLevel( logging.INFO )
        self.log.name = 'Gaudi/Main.py Logger'
        self.log.handlers = []
        # add handlers to logger : one for output to a file, one for console output
        self.log.addHandler(streamhandler)
        self.log.addHandler(console)
        self.log.removeHandler(console)
        # set level!!
        self.log.setLevel = logging.INFO
        # ---------------------------------------------------

def Gaudi::Main::gaudimain::writeconfig	(		self,
			filename,
			all = False
	)

Definition at line 93 of file Main.py.

                                                :
        write = { ".pkl" : lambda filename, all: self._writepickle(filename),
                  ".py"  : lambda filename, all: open(filename,"w").write(self.generatePyOutput(all) + "\n"),
                  ".opts": lambda filename, all: open(filename,"w").write(self.generateOptsOutput(all) + "\n"),
                }
        from os.path import splitext
        ext = splitext(filename)[1]
        if ext in write:
            write[ext](filename, all)
        else:
            log.error("Unknown file type '%s'. Must be any of %r.", ext, write.keys())
            sys.exit(1)

---

Member Data Documentation

Gaudi::Main::gaudimain::g

Definition at line 118 of file Main.py.

Gaudi::Main::gaudimain::log

Definition at line 16 of file Main.py.

---

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

• /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v22r0/Gaudi/python/Gaudi/Main.py