Improved parse_output function

qcengine/programs/gaussian.py

@@ -38,7 +38,6 @@ class GaussianHarness(ProgramHarness):
     class Config(ProgramHarness.Config):
         pass
 
-
     def found(self, raise_error: bool = False) -> bool:
         return which(
             "g09",
@@ -51,6 +50,7 @@ def get_version(self) -> str:
         self.found(raise_error=True)
 
         which_prog = which("g09")
+
         v_input = '''%mem=20MW
 #P HF/sto-3g
 
@@ -102,6 +102,7 @@ def compute(self, input_model: "AtomicInput", config: TaskConfig) -> "AtomicResu
 
             if 'Error termination via ' in outfile:
                 raise InputError(proc['outfiles']['output.log'])
+
             else:
                 # Return UnknownError for error propagation
                 raise UnknownError(proc["outfiles"]["output.log"])
@@ -112,25 +113,31 @@ def build_input(
 
         # Build keywords
         keywords = {k.upper(): v for k, v in input_model.keywords.items()}
-        keywords = {'scf_damp': 'true',
-                    'scf_diis': 'false'
-                    }
+
+        gaussian_kw = []
+
         if input_model.driver == "energy":
-            keywords["JOBTYPE"] = "sp"
+            gaussian_kw.append("sp")
         elif input_model.driver == "gradient":
-            keywords["JOBTYPE"] = "force"
+            gaussian_kw.append("force")
         elif input_model.driver == "hessian":
-            keywords["JOBTYPE"] = "freq"
+            gaussian_kw.append("freq")
         else:
             raise InputError(f"Driver {input_model.driver} not implemented for Gaussian.")
 
-        if input_model.molecule.fix_com or input_model.molecule.fix_orientation:
-            keywords["SYM_IGNORE"] = "TRUE"
-
+        #if input_model.molecule.fix_com or input_model.molecule.fix_orientation:
+        #    keywords["SYM_IGNORE"] = "TRUE"
+        if 'SCF_CONVERGENCE' in keywords:
+           gaussian_kw.append('SCF=' + keywords["SCF_CONVERGENCE"])
+        if 'POPULATION' in keywords:
+           gaussian_kw.append('Pop=' + keywords['POPULATION'])   
+
+        keywords = {'scf_damp': 'true',
+                    'scf_diis': 'false'}
         # Begin input file
         input_file = []
-        input_file.append('%mem={}MW'.format(int(config.memory * 1024 / 100))
-        input_file.append("#P {}/{}".format(input_model.model.method, input_model.model.basis) + '\n')
+        input_file.append('%mem={}MB'.format(int(config.memory * 1024)))
+        input_file.append("#P {}/{}".format(input_model.model.method, input_model.model.basis) + ' ' + ' '.join(gaussian_kw) + '\n')
         input_file.append("write your comment here\n")
 
         # Create a mol object
@@ -147,13 +154,14 @@ def build_input(
         gaussian_ret = {
             'infiles': {'input.inp': '\n'.join(input_file)},
             'commands': [which("g09"),  'input.inp', 'output.log'],
-            'scratch_directory': config.scratch_directory
+            #'scratch_directory': config.scratch_directory
             }
 
         return gaussian_ret
 
     def execute(self,
                 inputs,
+                *,
                 extra_outfiles: Optional[Dict[str, str]] = None,
                 extra_commands: Optional[List[str]] = None,
                 scratch_name = None,
@@ -184,65 +192,42 @@ def parse_output(self, outfiles: Dict[str, str], input_model: AtomicInput) -> At
         data = cclib.io.ccread(tmp_output_file)
 
         last_occupied_energy = data.moenergies[0][data.homos[0]]
-        output_data['HOMO ENERGY'] = last_occupied_energy
-        #print (F'HOMO ENERGY: {last_occupied_energy:2.6f} eV')
+        #output_data['HOMO ENERGY'] = last_occupied_energy
 
-        scf_energy = data.scfenergies[0]
-        output_data['SCF ENERGY'] = scf_energy
-        print (F'SCF ENERGY: {scf_energy:3.6f} eV')
+        scf_energy = data.scfenergies[0] / 27.21138505  # to Hartree
+        #output_data['SCF ENERGY'] = scf_energy
 
-        #if input_model.driver == 'energy':
-           #output_data['return_result'] = 
+        if input_model.driver == 'energy':
+            output_data['return_result'] = scf_energy
         #print (os.system('ccget --list ' + tmp_output_file)) #data available in the output for parsing
-        
+
         #if input_model.driver == 'energy':
-        #   print (cclib.__version__)
+        #   print (cclib.__version__)        
         #   print (output_data)
         #print (input_model)
+
+        properties = {
+            'nuclear_repulsion_energy': Nuclear(data).repulsion_energy(),
+            'scf_total_energy': scf_energy,
+            'return_energy': scf_energy
+            }
 
-        #provenance = Provenance(creator="Gaussian", version=self.get_version(), routine="g09").dict()
-
-        #properties = {
-        #    'nuclear_repulsion_energy': Nuclear(data).repulsion_energy(),
-        #    'scf_total_energy': data.scfenergies[0],
-        #    'return_energy': data.scfenergies[0]
-        #    }
-
-        outtext = ''
-        cnt = 0
-        f = open(os.path.join(tmp_output_path, 'output.log'), 'r')
-        outtext = f.readlines()
-        for num, line in enumerate(outtext, 1):
-           if 'Version=' in line:
-              version_line = line.split('Version=')[-1]
-              version_line = version_line.strip()
-              version_line = version_line.split('\\')[0]
-              print ('version : ', version_line)
-              #cnt = num + 1
-           #if cnt == num:
-              #version_line += line.split("\\")[0]
-              #print ('version is: ', version_line)
-
+        output_data['properties'] = properties
+        output_data['stdout'] = outfiles['outfiles']['output.log']
+        output_data['success'] = True
+        #print ('output_data: ', output_data)
 
         provenance = Provenance(creator="Gaussian 09", version=self.get_version(), routine='g09').dict()
-        print ('we are in mobj')
-        mobj = re.search(r"^Job cpu time:*seconds.$", outfiles['output.log'])
-        print ('we are in mobj')
-        if (mobj):
-           print ('mobj true')
 
         stdout = outfiles.pop('stdout')
         stderr = outfiles.pop('stderr')
         #print("\nPRINT STDOUT: \n", stdout)
 
+
         method = input_model.model.method.lower()
         #method = method[4:] if method.startswith("") else method
-
-        #output_data["stdout"] = stdout
-        output_data["success"] = True
-
+
         merged_data = {**input_model.dict(), **output_data}
 
-        print('\nPRINT MERGED DATA: \n', merged_data)
-
         return AtomicResult(**merged_data)
+