scoop jobs can now be run through SGE

Updated scoop from 0.62 to development version of 0.7RC1. With this new version of scoop you can pass environment variables to workers through bash scripts (prolog.sh).
Fixed the wrong usage of futures.map. Interestingly, older version was working correctly even with this bug. There are many debug loggings that should be deleted.

Author: keceli

prolog.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+#The script that each workers of scoop runs.
+#Should be modified based on user profile.
+source ~/.bashrc
+export RMGQM="/opt/rmgqm"
+#set Gaussian03 environment variables
+g03root=/opt
+GAUSS_SCRDIR=/scratch/$USER
+export g03root GAUSS_SCRDIR
+GAUSS_EXEDIR="$g03root/g03/"
+GAUSS_LEXEDIR="$g03root/g03/linda-exe"
+GAUSS_ARCHDIR="$g03root/g03/arch"
+GMAIN=$GAUSS_EXEDIR/g03
+PATH=$PATH:$GMAIN
+LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$GMAIN
+G03BASIS="$g03root/g03/basis"
+F_ERROPT1="271,271,2,1,2,2,2,2"
+TRAP_FPE="OVERFL=ABORT;DIVZERO=ABORT;INT_OVERFL=ABORT"
+MP_STACK_OVERFLOW="OFF"
+# to partially avoid KAI stupidity
+KMP_DUPLICATE_LIB_OK="TRUE"
+export GAUSS_EXEDIR GAUSS_ARCHDIR PATH GMAIN LD_LIBRARY_PATH F_ERROPT1 TRAP_FPE MP_STACK_OVERFLOW \
+  KMP_DUPLICATE_LIB_OK G03BASIS GAUSS_LEXEDIR
+#set MOPAC
+export MOPAC_LICENSE=/opt/mopac/
+#
+export PYTHONPATH=/home/keceli/RMG/RMG-Py/PyDAS/build/lib.linux-x86_64-2.6:/home/keceli/RMG/RMG-Py/PyDQED:/home/keceli/local/lib/python2.6/site-packages:/opt/rmgqm/RDKit_2013_03_2:/usr/local/lib/python2.6/dist-packages:$PYTHONPATH
+export PATH=/home/keceli/kiler:/home/keceli/bin:/home/keceli/local/bin:/opt/mpich2-1.2.1p1/bin:/opt/intel/Compiler/11.0/074/bin/intel64:/opt/sge/bin/lx24-amd64:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/bin/mh:/opt/g03/g03:$PATH
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/intel/Compiler/11.0/074/ipp/em64t/sharedlib:/opt/intel/Compiler/11.0/074/mkl/lib/em64t:/opt/intel/Compiler/11.0/074/tbb/em64t/cc4.1.0_libc2.4_kernel2.6.16.21/lib:/opt/intel/Compiler/11.0/074/lib/intel64:/opt/g03/g03:/usr/local/lib:/opt/rmgqm/RDKit_2013_03_2/bin:/opt/rmgqm/boost_1_44_0/lib:/opt/rmgqm/RDKit_2013_03_2/lib

rmgpy/qm/main.py

@@ -69,6 +69,7 @@ def checkAllSet(self):
         assert type(self.onlyCyclics) is BooleanType
         assert self.maxRadicalNumber is not None # but it can be 0
         assert type(self.maxRadicalNumber) is IntType
+        logging.debug("QM settings are ok.")
 
 class QMCalculator():
     """
@@ -134,6 +135,7 @@ def checkPaths(self):
             raise Exception("RMG-Py 'bin' directory {0} does not exist.".format(self.settings.RMG_bin_path))
         if not os.path.isdir(self.settings.RMG_bin_path):
             raise Exception("RMG-Py 'bin' directory {0} is not a directory.".format(self.settings.RMG_bin_path))
+        logging.debug("QM paths are ok.")
 
 
     def getThermoData(self, molecule):
@@ -150,15 +152,20 @@ def getThermoData(self, molecule):
         gaussian: Only PM3 is available. 
         """
         if self.settings.software == 'mopac' or self.settings.software == 'mopacPM3':
+            logging.debug("Attempting for a {0} calculation.".format(self.settings.software))
             qm_molecule_calculator = rmgpy.qm.mopac.MopacMolPM3(molecule, self.settings)
             thermo0 = qm_molecule_calculator.generateThermoData()
+            logging.debug("{0} calculation attempted.".format(self.settings.software))
         elif self.settings.software == 'mopacPM6':
+            logging.debug("Attempting for a {0} calculation.".format(self.settings.software))
             qm_molecule_calculator = rmgpy.qm.mopac.MopacMolPM6(molecule, self.settings)
             thermo0 = qm_molecule_calculator.generateThermoData()
         elif self.settings.software == 'mopacPM7':
+            logging.debug("Attempting for a {0} calculation.".format(self.settings.software))
             qm_molecule_calculator = rmgpy.qm.mopac.MopacMolPM7(molecule, self.settings)
             thermo0 = qm_molecule_calculator.generateThermoData()
         elif self.settings.software == 'gaussian':
+            logging.debug("Attempting for a {0} calculation.".format(self.settings.software))
             qm_molecule_calculator = rmgpy.qm.gaussian.GaussianMolPM3(molecule, self.settings)
             thermo0 = qm_molecule_calculator.generateThermoData()
         else:

rmgpy/qm/molecule.py

@@ -204,6 +204,7 @@ def generateQMData(self):
         """
         Calculate the QM data and return a QMData object, or None if it fails.
         """
+        logging.debug("{0} calculation".format(self.__class__.__name__))
         if self.verifyOutputFile():
             logging.info("Found a successful output file already; using that.")
             source = "QM {0} result file found from previous run.".format(self.__class__.__name__)
@@ -232,27 +233,32 @@ def generateThermoData(self):
         """
         # First, see if we already have it.
         if self.loadThermoData():
+            logging.debug("Already have thermo data")
             return self.thermo
 
         # If not, generate the QM data
         self.qmData = self.generateQMData()
 
         # If that fails, give up and return None.
         if self.qmData  is None:
+            logging.debug("QM data is not found")
             return None
 
         self.determinePointGroup()
 
         # If that fails, give up and return None.
         if self.pointGroup is None:
+            logging.debug("No point group found")
             return None
 
         self.calculateThermoData()
+        logging.debug("Thermo data calculated")
         Cp0 = self.molecule.calculateCp0()
         CpInf = self.molecule.calculateCpInf()
         self.thermo.Cp0 = (Cp0,"J/(mol*K)")
         self.thermo.CpInf = (CpInf,"J/(mol*K)")
         self.saveThermoData()
+        logging.debug("Thermo data saved")
         return self.thermo
 
     def saveThermoData(self):
@@ -343,6 +349,7 @@ def calculateThermoData(self):
 
         trans = rmgpy.statmech.IdealGasTranslation( mass=self.qmData.molecularMass )
         if self.pointGroup.linear:
+            logging.debug("Linear molecule")
             rot = rmgpy.statmech.LinearRotor(
                                          rotationalConstant = self.qmData.rotationalConstants,
                                          symmetry = self.pointGroup.symmetryNumber,

rmgpy/qm/mopac.py

@@ -20,10 +20,13 @@ class Mopac:
     mopacEnv = os.getenv('MOPAC_DIR', default="/opt/mopac")
     if os.path.exists(os.path.join(mopacEnv , 'MOPAC2012.exe')):
         executablePath = os.path.join(mopacEnv , 'MOPAC2012.exe')
+        logging.debug("{0} is found.".format(executablePath))
     elif os.path.exists(os.path.join(mopacEnv , 'MOPAC2009.exe')):
         executablePath = os.path.join(mopacEnv , 'MOPAC2009.exe')
+        logging.debug("{0} is found.".format(executablePath))
     else:
         executablePath = os.path.join(mopacEnv , '(MOPAC 2009 or 2012)')
+        logging.debug("{0} is found.".format(executablePath))
 
     usePolar = False #use polar keyword in MOPAC
 
@@ -56,6 +59,7 @@ class Mopac:
 
     def testReady(self):
         if not os.path.exists(self.executablePath):
+            logging.debug("{0} is not found.").format(self.executablePath)
             raise Exception("Couldn't find MOPAC executable at {0}. Try setting your MOPAC_DIR environment variable.".format(self.executablePath))
 
     def run(self):

rmgpy/rmg/main.py

@@ -1080,7 +1080,7 @@ def initializeLog(verbose, log_file_name):
     logging.addLevelName(logging.ERROR, 'Error: ')
     logging.addLevelName(logging.WARNING, 'Warning: ')
     logging.addLevelName(logging.INFO, '')
-    logging.addLevelName(logging.DEBUG, '')
+    logging.addLevelName(logging.DEBUG, 'Debug:')
     logging.addLevelName(0, '')
 
     # Create formatter and add to console handler

rmgpy/rmg/model.py

@@ -39,7 +39,7 @@
 import itertools
 
 import scoop
-from scoop import futures
+from scoop import futures,shared
 
 from rmgpy.display import display
 #import rmgpy.chemkin
@@ -64,22 +64,28 @@
 
 __database = None
 
-def makeThermoForSpecies(spec,qmValue=None):
+def makeThermoForSpecies(spec):
     """
     Make thermo for a species.
     """
+    import logging
+    qmValue=shared.getConst('qmValue')
+    if qmValue: logging.debug("qmValue fine @ makeThermoForSpecies")
     global __database
     if __database == None:
         """Load the database from some pickle file"""
-        import cPickle, logging
+        import cPickle
         filename = scoop.shared.getConst('databaseFile')
         database_hash = scoop.shared.getConst('databaseHash')
+        logging.debug('Loading database pickle2 file'.format(filename))
         #logging.info('Loading database pickle2 file from {0!r} on worker {1}'.format(filename, scoop.WORKER_NAME.decode() ))
         f = open(filename, 'rb')
         __database = cPickle.load(f)
         f.close()
         assert __database.hash == database_hash, "Database loaded from {0!r} doesn't match expected hash!".format(filename)
+    logging.debug("Generate thermo data in makeThermoForSpecies")
     spec.generateThermoData(__database,quantumMechanics=qmValue)
+    logging.debug("Thermo generated for {0}".format(spec.label))
     return spec.thermo
 
 ################################################################################
@@ -117,17 +123,18 @@ def generateThermoData(self, database, thermoClass=NASA, quantumMechanics=None):
         from rmgpy.data.thermo import saveEntry
 
         thermo0 = None
-        
         thermo0 = database.thermo.getThermoDataFromLibraries(self)
-        
+        if quantumMechanics is None : logging.debug("qmValue is None at generateThermoData in model.py")
         if thermo0 is not None:
-            logging.info("Found thermo for {0} in thermo library".format(self.label))
+            logging.debug("Found thermo for {0} in thermo library".format(self.label))
             assert len(thermo0) == 3, "thermo0 should be a tuple at this point: (thermoData, library, entry)"
             thermo0 = thermo0[0]
 
         elif quantumMechanics:
+            logging.debug("Generate thermo data with QM")
             molecule = self.molecule[0]
             if quantumMechanics.settings.onlyCyclics and not molecule.isCyclic():
+                logging.debug("Bypassing QM for ".format(self.label))
                 pass
             else: # try a QM calculation
                 if molecule.getRadicalCount() > quantumMechanics.settings.maxRadicalNumber:
@@ -162,10 +169,12 @@ def generateThermoData(self, database, thermoClass=NASA, quantumMechanics=None):
                         f.write('{0}\n'.format(molecule.toSMILES()))
                         f.write('{0}\n\n'.format(molecule.toAdjacencyList(removeH=True)))
                 else: # Not too many radicals: do a direct calculation.
+                    logging.debug("Generate thermo for {0} with QM".format(self.label))
                     thermo0 = quantumMechanics.getThermoData(molecule) # returns None if it fails
-                
+                    if thermo0 is None: logging.debug("QM for {0} failed.".format(self.label))
                 if thermo0 is not None:
                     # Write the QM molecule thermo to a library so that can be used in future RMG jobs.
+                    logging.debug("QM for {0} is successful.".format(self.label))
                     quantumMechanics.database.loadEntry(index = len(quantumMechanics.database.entries) + 1,
                                                         label = molecule.toSMILES(),
                                                         molecule = molecule.toAdjacencyList(),

thermoEstimator.py

@@ -9,12 +9,12 @@
 """
 
 import os.path
-from rmgpy.rmg.main import RMG, processProfileStats, makeProfileGraph
+import logging
+from rmgpy.rmg.main import RMG, initializeLog, processProfileStats, makeProfileGraph
 from rmgpy.data.thermo import ThermoLibrary
 from rmgpy.chemkin import writeThermoEntry
 from rmgpy.rmg.model import makeThermoForSpecies
-import scoop
-from scoop import futures
+from scoop import futures,shared
 ################################################################################
 def chunks(l, n):
     """ Yield successive n-sized chunks from l.
@@ -34,6 +34,7 @@ def runThermoEstimator(inputFile):
     # initialize and load the database as well as any QM settings
     rmg.loadDatabase()
     if rmg.quantumMechanics:
+        logging.debug("Initialize QM")
         rmg.quantumMechanics.initialize()
 
     # Generate the thermo for all the species and write them to chemkin format as well as
@@ -44,9 +45,13 @@ def runThermoEstimator(inputFile):
  #       species.generateThermoData(rmg.database, quantumMechanics=rmg.reactionModel.quantumMechanics)
     listOfSpecies=rmg.initialSpecies
     chunksize=50
+    if rmg.reactionModel.quantumMechanics: logging.debug("qmValue fine @ runThermoEstimator")
+    shared.setConst(qmValue=rmg.reactionModel.quantumMechanics)
     for chunk in list(chunks(listOfSpecies,chunksize)):
-        outputList = futures.map(makeThermoForSpecies, chunk,qmValue=rmg.reactionModel.quantumMechanics)
+        outputList = futures.map(makeThermoForSpecies, chunk)
+        logging.debug("mapped")
         for species, thermo in zip(chunk, outputList):
+            logging.debug("specie {0}".format(species.label))
             species.thermo = thermo   
             library.loadEntry(
                 index = len(library.entries) + 1,
@@ -55,6 +60,7 @@ def runThermoEstimator(inputFile):
                 thermo = species.thermo.toThermoData(),
                 shortDesc = species.thermo.comment,
             )
+            logging.debug("chunk done")
             output.write(writeThermoEntry(species))
             output.write('\n')
 
@@ -69,15 +75,16 @@ def runThermoEstimator(inputFile):
     import argparse
 
     parser = argparse.ArgumentParser()
-    parser.add_argument('input', metavar='INPUT', type=str, nargs=1,
+    parser.add_argument('input', metavar='FILE', type=str, nargs=1,
         help='Thermo input file')
     parser.add_argument('-p', '--profile', action='store_true', help='run under cProfile to gather profiling statistics, and postprocess them if job completes')
     parser.add_argument('-P', '--postprocess', action='store_true', help='postprocess profiling statistics from previous [failed] run; does not run the simulation')
 
     args = parser.parse_args()
 
     inputFile = os.path.abspath(args.input[0])
-   
+    inputDirectory = os.path.abspath(os.path.dirname(args.input[0]))
+    
     if args.postprocess:
         print "Postprocessing the profiler statistics (will be appended to thermo.log)"
         print  "Use `dot -Tpdf thermo_profile.dot -o thermo_profile.pdf`"
@@ -94,9 +101,12 @@ def runThermoEstimator(inputFile):
         # actually run the program!
             cProfile.runctx(command, global_vars, local_vars, stats_file)
         # postprocess the stats
-        log_file = 'thermo.log'
+        log_file = os.path.join(inputDirectory,'RMG.log')
         processProfileStats(stats_file, log_file)
         makeProfileGraph(stats_file)
 
     else:
+        level = logging.DEBUG
+        initializeLog(level, 'thermo.log')
+        logging.debug("runThermoEstimator...")
         runThermoEstimator(inputFile)