| # Gaudi Framework, version v21r8 |

Home |  | Generated: 17 Mar 2010

# Main.py

Go to the documentation of this file.

    00001 import sys, os
    00002 from time import time
    00003 from Gaudi import Configuration
    00004 import logging
    00005
    00006 log = logging.getLogger(__name__)
    00007
    00008 class gaudimain(object) :
    00009     def __init__(self) :
    00010         from Configurables import ApplicationMgr
    00011         appMgr = ApplicationMgr()
    00012         if "GAUDIAPPNAME" in os.environ:
    00013             appMgr.AppName = str(os.environ["GAUDIAPPNAME"])
    00014         if "GAUDIAPPVERSION" in os.environ:
    00015             appMgr.AppVersion = str(os.environ["GAUDIAPPVERSION"])
    00016
    00017     def generatePyOutput(self, all = False):
    00018         from pprint import pformat
    00019         conf_dict = Configuration.configurationDict(all)
    00020         return pformat(conf_dict)
    00021
    00022     def generateOptsOutput(self, all = False):
    00023         from pprint import pformat
    00024         conf_dict = Configuration.configurationDict(all)
    00025         out = []
    00026         names = conf_dict.keys()
    00027         names.sort()
    00028         for n in names:
    00029             props = conf_dict[n].keys()
    00030             props.sort()
    00031             for p in props:
    00032                 out.append('%s.%s = %s;' % (n,p, repr(conf_dict[n][p])))
    00033         return "\n".join(out)
    00034
    00035     def _writepickle(self, filename) :
    00036         #--- Lets take the first file input file as the name of the pickle file
    00037         import pickle
    00038         output = open(filename, 'wb')
    00039         # Dump only the the configurables that make sense to dump (not User ones)
    00040         from GaudiKernel.Proxy.Configurable import getNeededConfigurables
    00041         to_dump = {}
    00042         for n in getNeededConfigurables():
    00043             to_dump[n] = Configuration.allConfigurables[n]
    00044         pickle.dump(to_dump, output, -1)
    00045         output.close()
    00046
    00047     def printconfig(self, old_format = False, all = False) :
    00048         msg = 'Dumping all configurables and properties'
    00049         if not all:
    00050             msg += ' (different from default)'
    00051         log.info(msg)
    00052         conf_dict = Configuration.configurationDict(all)
    00053         if old_format:
    00054             print self.generateOptsOutput(all)
    00055         else:
    00056             print self.generatePyOutput(all)
    00057
    00058     def writeconfig(self, filename, all = False):
    00059         write = { ".pkl" : lambda filename, all: self._writepickle(filename),
    00060                   ".py"  : lambda filename, all: open(filename,"w").write(self.generatePyOutput(all) + "\n"),
    00061                   ".opts": lambda filename, all: open(filename,"w").write(self.generateOptsOutput(all) + "\n"),
    00062                 }
    00063         from os.path import splitext
    00064         ext = splitext(filename)[1]
    00065         if ext in write:
    00066             write[ext](filename, all)
    00067         else:
    00068             log.error("Unknown file type '%s'. Must be any of %r.", ext, write.keys())
    00069             sys.exit(1)
    00070
    00071     def printsequence(self):
    00072         def printAlgo( algName, appMgr, prefix = ' ') :
    00073             print prefix + algName
    00074             alg = appMgr.algorithm( algName.split( "/" )[ -1 ] )
    00075             prop = alg.properties()
    00076             if prop.has_key( "Members" ) :
    00077                 subs = prop[ "Members" ].value()
    00078                 for i in subs : printAlgo( i.strip( '"' ), appMgr, prefix + "     " )
    00079             elif prop.has_key( "DetectorList" ) :
    00080                 subs = prop[ "DetectorList" ].value()
    00081                 for i in subs : printAlgo( algName.split( "/" )[ -1 ] + i.strip( '"' ) + "Seq", appMgr, prefix + "     ")
    00082         import GaudiPython
    00083         self.g = GaudiPython.AppMgr()
    00084         mp = self.g.properties()
    00085         print "\n ****************************** Algorithm Sequence **************************** \n"
    00086         for i in mp["TopAlg"].value(): printAlgo( i, self.g )
    00087         print "\n ****************************************************************************** \n"
    00088
    00089     ## Instantiate and run the application.
    00090     #  Depending on the number of CPUs (ncpus) specified, it start
    00091     def run(self, ncpus = None):
    00092         if not ncpus:
    00093             # Standard sequential mode
    00094             result = self.runSerial()
    00095         else:
    00096             # Doing the checking here because it is not done in runParallel
    00097             ncpus = int(ncpus)
    00098             assert(ncpus > 0)
    00099             # Parallel mode
    00100             result = self.runParallel(ncpus)
    00101         return result
    00102
    00103     def runSerial(self) :
    00104         #--- Instantiate the ApplicationMgr------------------------------
    00105         import GaudiPython
    00106         log.debug('-'*80)
    00107         log.debug('%s: running in serial mode', __name__)
    00108         log.debug('-'*80)
    00109         sysStart = time()
    00110         self.g = GaudiPython.AppMgr()
    00111         success = self.g.run(self.g.EvtMax).isSuccess()
    00112         success = self.g.exit().isSuccess() and success
    00113         if not success:
    00114             return 1
    00115         sysTime = time()-sysStart
    00116         log.debug('-'*80)
    00117         log.debug('%s: serial system finished, time taken: %5.4fs', __name__, sysTime)
    00118         log.debug('-'*80)
    00119         return 0
    00120
    00121     def runParallel(self, ncpus) :
    00122         from Gaudi.Configuration import Configurable
    00123         import GaudiPython.Parallel as gpp
    00124         c = Configurable.allConfigurables
    00125         log.info('-'*80)
    00126         log.info('%s: running in parallel mode', __name__)
    00127         log.info('-'*80)
    00128         sysStart = time()
    00129         sc = gpp.setupSystem(ncpus, c)
    00130         if not sc:
    00131             return 1
    00132         sysTime = time()-sysStart
    00133         log.info('-'*80)
    00134         log.info('%s: parallel system finished, time taken: %5.4fs', __name__, sysTime)
    00135         log.info('-'*80)
    00136         return 0