Initial repository

Makefile

@@ -0,0 +1,7 @@
+VERSION=1.1
+default:
+	- rm -rf build dist
+	- export VERSION=$(VERSION) ;\
+	  ./setup.py --quiet bdist_rpm  
+	- sudo rpm -e resultsFile
+	- sudo rpm -hiv dist/resultsFile*.noarch.rpm

resultsFile/Modules/__init__.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+#   resultsFile is a library which allows to read output files of quantum 
+#   chemistry codes and write input files.
+#   Copyright (C) 2007 Anthony SCEMAMA 
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program; if not, write to the Free Software Foundation, Inc.,
+#   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+#   Anthony Scemama
+#   LCPQ - IRSAMC        
+#   Universite Paul Sabatier
+#   118, route de Narbonne      
+#   31062 Toulouse Cedex 4      
+#   scemama@irsamc.ups-tlse.fr 
+
+
+
+"""resultsFile library."""
+
+__author__ = "Anthony SCEMAMA <scemama@irsamc.ups-tlse.fr>"
+__date__   = "25 Oct 2007"
+
+import os
+
+wd = os.path.dirname(__file__)
+all = [ i[:-3] for i in os.listdir(wd) if i.endswith("File.py") ]
+if "q5CostFile" in all:
+  all.remove("q5CostFile")
+  all += [ "q5CostFile" ]
+
+for mod in all:
+   try:
+     exec 'from '+mod+' import *'
+   except:
+     print "Error importing module", mod
+     pass
+
+

resultsFile/Modules/include.py

@@ -0,0 +1,39 @@
+
+#   resultsFile is a library which allows to read output files of quantum 
+#   chemistry codes and write input files.
+#   Copyright (C) 2007 Anthony SCEMAMA 
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program; if not, write to the Free Software Foundation, Inc.,
+#   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+#   Anthony Scemama
+#   LCPQ - IRSAMC        
+#   Universite Paul Sabatier
+#   118, route de Narbonne      
+#   31062 Toulouse Cedex 4      
+#   scemama@irsamc.ups-tlse.fr 
+
+
+code = compile("""
+try:
+  from resultsFile import *
+except ImportError: 
+  import os
+  import sys
+  wd = os.path.dirname(__file__)
+  wd = '/'.join ( wd.split('/')[:-1] )
+  sys.path += [ wd ]
+  from resultsFile import *
+""", 'include.py','single')
+

resultsFile/Modules/molproFile.py

@@ -0,0 +1,938 @@
+#!/usr/bin/python
+#   resultsFile is a library which allows to read output files of quantum 
+#   chemistry codes and write input files.
+#   Copyright (C) 2007 Anthony SCEMAMA 
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program; if not, write to the Free Software Foundation, Inc.,
+#   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+#   Anthony Scemama
+#   LCPQ - IRSAMC        
+#   Universite Paul Sabatier
+#   118, route de Narbonne      
+#   31062 Toulouse Cedex 4      
+#   scemama@irsamc.ups-tlse.fr 
+
+
+
+import include
+eval(include.code)
+
+import struct
+import re
+
+molproFile_defined_vars = [ "date", "version", "machine", "memory", "disk",\
+                "cpu_time", "author", "title", "units", "methods", \
+                "spin_restrict", "conv_threshs", "energies", \
+                "one_e_energies", "two_e_energies", \
+                "kin_energies", "virials", "point_group", "num_elec", \
+                "charge", "multiplicity","nuclear_energy","dipole","geometry",\
+                "basis","mo_sets","mo_types",\
+                "determinants", "num_alpha", "num_beta",\
+                "closed_mos", "active_mos", "virtual_mos", \
+                "determinants_mo_type", "det_coefficients", \
+                "csf_mo_type", "csf_coefficients", "symmetries", "occ_num", \
+                "csf", "num_states", "num_orb_sym" ]
+
+methods_with_orbitals = ['RHF-SCF', 'MULTI']
+
+class molproFile(resultsFile):
+   """ Class defining the molpro file.
+   """
+
+   local_vars = list(local_vars)
+   defined_vars = list(molproFile_defined_vars)
+
+   exec get_data('date',"DATE: ",'-3:-2') in locals()
+   exec get_data('point_group',"Point group",'2:') in locals()
+   exec get_data('version',"    Version",'1:2') in locals()
+   exec get_data('nuclear_energy',"NUCLEAR REPULSION ENERGY", '3:4',"float") in locals()
+
+   def get_num_elec(self):
+     if self._num_elec is None:
+       self._num_elec = self.num_alpha + self.num_beta
+     return self._num_elec 
+
+   def get_charge(self):
+     if self._charge is None:
+       self._charge = 0.
+       for a in self.geometry:
+         self._charge += a.charge
+       self._charge -= self.num_elec
+     return self._charge
+
+   def get_multiplicity(self):
+     if self._multiplicity is None:
+       self._multiplicity = self.num_alpha - self.num_beta + 1
+     return self._multiplicity
+
+   def get_author(self):
+     if self._author is None:
+       buffer = ' '.join(self.text[-10:])
+       regexp = re.compile(r"user=(.+),")
+       matches = regexp.findall(buffer)
+       if matches != []:
+         self._author = matches[0]
+     return self._author
+
+   def get_machine(self):
+     if self._machine is None:
+       regexp = re.compile(r"[^/]+/([^\(]+).+DATE:")
+       for line in self.text:
+         matches = regexp.findall(line)
+         if matches != []:
+           self._machine = matches[0]
+           return self._machine
+     return self._machine
+
+   def get_disk(self):
+     if self._disk is None:
+       buffer = ' '.join(self.text[-100:])
+       regexp = re.compile(r"DISK USED +\* +([0-9]+\.[0-9]* +[^ \n]+)")
+       matches = regexp.findall(buffer)
+       try:
+         self._disk = matches[-1].title()
+       except IndexError:
+         return None
+     return self._disk
+
+   def get_cpu_time(self):
+     if self._cpu_time is None:
+       buffer = ' '.join(self.text[-100:])
+       regexp = re.compile(r"CPU TIMES +\* +([0-9]+\.[0-9]*) +[^ \n]+")
+       matches = regexp.findall(buffer)
+       try:
+         self._cpu_time = matches[-1] + " s"
+       except IndexError:
+         return None
+     return self._cpu_time
+
+   def get_memory(self):
+     if self._memory is None:
+       buffer = ' '.join(self.text[-100:])
+       regexp = re.compile(r"SF USED +\* +([0-9]+\.[0-9]* +[^ \n]+)")
+       matches = regexp.findall(buffer)
+       try:
+         self._memory = matches[-1].title()
+       except IndexError:
+         return None
+     return self._memory
+
+   def get_title(self):
+     if self._title is None:
+       try:
+         self.find_string("LABEL")
+       except IndexError:
+         return None
+       pos = self._pos
+       self._title = ' '.join(self.text[pos].split()[2:]).strip()
+     return self._title
+
+   def get_symmetries(self):
+     if self._symmetries is None:
+       try:
+         self.find_string("NUMBER OF CONTRACTIONS")
+       except IndexError:
+         return None
+       pos = self._pos
+       regexp = re.compile(r" +([0-9]+)([A-Z][^ ]*) +")
+       self._symmetries = [ [j,int(i)] for i,j in regexp.findall(self.text[pos]) ]
+     return self._symmetries
+
+   def get_units(self):
+     if self._units is None:
+       self._units = "BOHR"
+     return self._units
+
+   def get_methods(self):
+     if self._methods is None:
+        regexp = re.compile(r"^1PROGRAM *\* *([^ ]+)")
+        methods = []
+        for line in self.text:
+          program = regexp.findall(line)
+          if program != []:
+           if program[0] in methods_with_orbitals:
+            methods += program
+        self._methods = methods
+     return self._methods
+
+   def get_occ_num(self):
+     if self._occ_num is None:
+        occ = {}
+        program = []
+        progFound=False
+        doRead=False
+        regexp  = re.compile(r"^1PROGRAM *\* *([^ ]+)")
+        regexp2 = re.compile(r"^ +Orb +Occ +")
+        regexp3 = re.compile(r"^ +[0-9]*\.[0-9]+ +([0-2]*\.[0-9]+|[0-2]|\+|\-) +[^ ]")
+        for line in self.text:
+          if not progFound:
+            program = regexp.findall(line)
+            if program != []:
+             if program[0] in methods_with_orbitals:
+              while program[0] in occ.keys():
+                program[0] += 'x'
+              occ[program[0]] = []
+              progFound=True
+          else:
+            buffer = line[:25]
+            if doRead:
+              if buffer.strip() != "":
+                matches = regexp3.findall(buffer)
+                if matches != []:
+                  if matches[0] == '+':
+                    res = 1.
+                  else:
+                    res = float(matches[0])
+                  occ[program[0]].append(res)
+                else:
+                  doRead = False 
+                  progFound = False 
+            elif regexp2.match(buffer):
+              doRead = True
+        if occ != {}:
+          self._occ_num = occ
+     return self._occ_num 
+
+   def get_spin_restrict(self):
+       if self._spin_restrict is None:
+          self._spin_restrict = True
+          for m in self.methods:
+             if "U" in m:
+                self._spin_restrict = False
+       return self._spin_restrict
+
+
+   def get_conv_threshs(self):
+       if self._conv_threshs is None:
+          self._conv_threshs = []
+          regexp = \
+            re.compile(r" conv.* thre.* +.*([0-9]+\.[0-9]*[^ ]*) *\(energy\)",
+                            re.I)
+          for line in self.text:
+            matches = regexp.findall(line)
+            if matches != []:
+               self._conv_threshs += [float(matches[0])]
+       return self._conv_threshs
+
+   def get_energies(self):
+       if self._energies is None:
+          self._energies = []
+          self._one_e_energies = []
+          self._two_e_energies = []
+          self._ee_pot_energies = []
+          self._Ne_pot_energies = []
+          self._pot_energies = []
+          self._kin_energies = []
+          self._virials = []
+       pos = len(self.text)-1
+       while not self.text[pos].startswith(" PROGRAMS") and pos>0:
+          pos -=1
+       while not self.text[pos].startswith(" ****"):
+          pos += 1
+       pos +=1 
+       regexp = re.compile(r"^\s+([|\-][0-9]+\.[0-9]+\s*)+")
+       found = False
+       while not found:
+          result = regexp.match(self.text[pos])
+          if result != None: 
+             found = True
+             buffer = self.text[pos].split()
+             for e in buffer:
+               self._energies.insert(0,float(e))
+          pos += 1
+       program = []
+       progFound=False
+       regexp  = re.compile(r"^1PROGRAM *\* *([^ ]+)")
+       regexp2 = re.compile(r"^ (Virial|One.elec|Two.elec|Kinetic)[^ ]* +[^ ]+ +(.+)")
+       progindex = -1
+       for line in self.text:
+         if not progFound:
+           program = regexp.findall(line)
+           if program != []:
+            if program[0] in methods_with_orbitals:
+             progindex += 1
+             progFound=True
+         else:
+           try:
+             quantity, value = regexp2.findall(line)[0]
+             if quantity == "Virial":
+                quantity = self._virials
+                progFound=False
+             elif quantity[0:3] == "One":
+                quantity = self._one_e_energies
+             elif quantity[0:3] == "Two":
+                quantity = self._two_e_energies
+             elif quantity == "Kinetic":
+                quantity = self._kin_energies
+             while len(quantity) <= progindex:
+                quantity.append(None)
+             quantity[progindex] = float(value)
+           except:
+             pass
+       return self._energies
+
+   def get_one_e_energies(self):
+     if self._one_e_energies is None:
+        self.get_energies()
+     return self._one_e_energies
+
+   def get_two_e_energies(self):
+     if self._two_e_energies is None:
+        self.get_energies()
+     return self._two_e_energies
+
+   def get_kin_energies(self):
+     if self._kin_energies is None:
+        self.get_energies()
+     return self._kin_energies
+
+   def get_virials(self):
+     if self._virials is None:
+        self.get_energies()
+     return self._virials
+
+   def get_num_alpha(self):
+     if self._num_alpha is None:
+        try:
+           self.find_string(" NUMBER OF ELECTRONS")
+           pos = self._pos
+           buffer = self.text[pos].split()
+           self._num_alpha = int(buffer[3][:-1])
+           self._num_beta = int(buffer[4][:-1])
+        except IndexError:
+           pass
+     return self._num_alpha
+
+   def get_num_beta(self):
+     if self._num_beta is None:
+       self.get_num_alpha()
+     return self._num_beta
+
+   def get_geometry(self):
+     if self._geometry is None:
+        try:
+           self.find_string(" ATOMIC COORDINATES")
+           pos = self._pos
+           pos += 4
+           self._geometry = []
+           buffer = self.text[pos].split()
+           while len(buffer) > 1:
+              temp = atom()
+              temp.name   = buffer[1]
+              temp.charge = float(buffer[2])
+              temp.coord  = (float(buffer[3]), float(buffer[4]), float(buffer[5]))
+              temp.basis  = []
+              self._geometry.append(temp)
+              pos += 1
+              buffer = self.text[pos].split()
+        except IndexError:
+           pass
+     return self._geometry
+
+   def get_dipole(self):
+     if self._dipole is None:
+        try:
+           self.find_last_string("DIPOLE MOMENTS:")
+           pos = self._pos
+           self._dipole = []
+           buffer = self.text[pos].split(':')[1]
+           for d in buffer.split()[:3]:
+             self._dipole.append( float(d) )
+        except IndexError:
+           pass
+     return self._dipole
+   
+   def get_num_orb_sym(self):
+     try:
+       if self._num_orb_sym is None:
+         self.get_basis()
+     except:
+       self._num_orb_sym = None
+       self.get_basis()
+     return self._num_orb_sym
+
+   def get_basis(self):
+     if self._basis is None:
+        try:
+           self.find_string("BASIS DATA")
+        except IndexError:
+           return None
+        pos = self._pos
+        try:
+           self.find_next_string("NUCLEAR CHARGE")
+        except IndexError:
+           return None
+        end = self._pos-1
+        num_orb_sym = []
+        for k in self.symmetries:
+           num_orb_sym.append([0,0])
+        pos += 4
+        basis_read = []
+        index, sym, nuc, type, expo, coef = "", "", "", "", "", ""
+        basis = []
+        currfunc = 0
+        salcao2mo = []
+        contrmax=0
+        buffer = self.text[pos:end+1]
+        text = []
+        for line in buffer:
+          if line[:41].strip() == "":
+            text[-1] = text[-1][:-1] + line[41:]
+          else:
+            text.append(line)
+        pos=0
+        end = len(text)
+        text.append(80*" ")
+        while pos < end:
+           begin = pos
+           line = text[begin]
+           nfunc = len( line[41:].split() )
+           nuc = []
+           try:
+              idx4 = line.find('.')
+              idx5 = idx4+1
+              idx6 = idx4+2
+              currfunc = int(line[:idx4])
+              geom = int( line[idx5:idx6] )
+           except:
+             line = str(currfunc)+'.'+str(geom)+line[8:]
+           end2 = pos
+           while end2<end and int( line[:idx4] ) < currfunc+nfunc and \
+             int( line[idx5:idx6] ) == geom:
+             if  line[11:15].strip() != '':
+               nuc.append( (int(line[11:15])-1, line[15:22].strip() ) )
+             end2 += 1
+             line = text[end2]
+             if line[:idx4] == '    ':
+               line = "%4d.%d  "%(currfunc,geom)+line[8:]
+           line = text[begin]
+
+           
+           contr = []
+           for k in range(nfunc):
+             for NucType in nuc:
+               c = contraction()
+               contr.append(c)
+
+           thiscontr=0
+           if nfunc > contrmax: contrmax = nfunc
+           for k in range(nfunc):
+             smo = []
+             num_orb_sym[geom-1][0] += 1
+             num_orb_sym[geom-1][1] += len(nuc)
+             for NucType in nuc:
+               c = contr[thiscontr]
+               thiscontr += 1
+               sign=1.
+               pos = begin
+               line = text[pos]
+               atom = self.geometry[NucType[0]]
+               type = str(NucType[1])
+               if type[0] == '-':
+                 type = type[1:]
+                 sign = -1.
+               if type[0].isdigit():
+                  type = type[1:]
+               try:
+                 if not type[1].isdigit() :
+                   if type[0].lower() in "pdfghi": type = type[1:]
+               except:
+                 if type[0].lower() in "pdfghi": type = type[1:]
+               smo.append(sign/sqrt(float(len(nuc))))
+               c.center = atom.coord
+               type = normalize_basis_name(type)
+               c.sym = type
+               while pos<end2:
+                 expo = line[24:40].strip()
+                 coef = line[41:].split()
+                 if expo == '':
+                   pos = end2
+                   break
+                 gauss = gaussian()
+                 gauss.center = atom.coord
+                 gauss.expo = float(expo)
+                 gauss.sym  = type
+                 if float(coef[k]) != 0.:
+                   c.append(float(coef[k]),gauss)
+                 pos += 1
+                 line = text[pos]
+             salcao2mo.append( smo )
+           for c in contr:
+  #          c.normalize()
+             basis.append(c)
+        self._num_orb_sym = num_orb_sym
+        self._basis = basis
+        self.salcao2mo = salcao2mo
+        for f in basis:
+          for at in self.geometry:
+            if f.center is at.coord:
+              at.basis.append(f)
+        if (len(self.symmetries)>1) and contrmax > 1:
+          file = open('basis.molpro','w')
+          molpro_write_input(self,file)
+          file.close()
+          print >>sys.stderr, """
+Warning: there is a bug in the molpro output. Run the 'basis.molpro'
+input file with molpro to generate a correct output for the basis set.
+"""
+     return self._basis
+
+   def get_mo_types(self):
+      if self._mo_types is None:
+        self.get_mo_sets()
+      return self._mo_types 
+
+
+   def get_mo_sets(self):
+      if self._mo_sets is None:
+        global methods_with_orbitals
+        self._mo_sets = {}
+        self._mo_types = []
+        doRead=False
+        regexp  = re.compile(r"^1PROGRAM *\* *([^ ]+)")
+        regexp2 = re.compile(r"^ +Orb +Occ +")
+        rstring  = r"^ {,4}([0-9]+\.[0-9]+) +"             # Orb
+        rstring += r"([0-2| ]\.[0-9]{,5}|[0-2]|\+|\-) *" # Occ
+        rstring += r"(-*[0-9|-]*\.[0-9]+) +" # Energy
+        regexp3 = re.compile(rstring)
+        rstring = r"(([0-9|\-]*\.[0-9]{6} *)+)" # Coefs
+        regexp4 = re.compile(rstring)
+        rstring = r"(^ {30,}([0-9] [123456789xyzspdfghijk\+\-]+ *)+)" # Labels
+        regexp5 = re.compile(rstring)
+        rstring = r"(^ \*{10,}|orbital dump)" # *********
+        regexp6 = re.compile(rstring)
+        rstring = " +[0-9|-]*\.[0-9]+\.[0-9]*"
+        regexp7 = re.compile(rstring)
+        text = list(self.text)
+        curr_sym = self.basis[0].sym
+        v=None
+        ReadingLabels = False
+        PreviousBlank = False
+        for iline, line in enumerate(text):
+          buffer = regexp7.findall(line)
+          while buffer != []:  # Insert spaces in "7851.548715699.7413"
+             if ":" in line:
+               break
+             begin = line.find(buffer[0])
+             end = begin+len(buffer[0])
+             line = line[0:end-10]+" "+line[end-10:]
+             buffer = regexp7.findall(line)
+          line = line[:11]+line[11:32].replace ("**********"," 999999.9999") \
+                          +line[32:].replace('-',' -')
+          # Find method
+          program = regexp.findall(line)
+          if program != []:
+           if program[0] in methods_with_orbitals:
+            add_method = False
+            while program[0] in self._mo_sets:
+              program[0] += 'x'
+              add_method = True
+            if add_method and program[0] not in methods_with_orbitals:
+              methods_with_orbitals += [program[0]]
+            index = program[0]
+            self._mo_types.append(index)
+            self._mo_sets[index] = []
+          if doRead:
+            # Find labels
+            buffer = regexp6.findall(line)
+            if buffer != []:
+              doRead=False
+            elif line.strip() == "":
+              if symcount == len(self.symmetries):
+                if PreviousBlank:
+                  doRead = False
+                  PreviousBlank = False
+                else:
+                  if not ReadingLabels:
+                    PreviousBlank = True
+              if v is not None:
+                for l,s in enumerate(self.num_orb_sym):
+                   if l > symcount-1 :
+                     for k in range(s[1]):
+                       v.vector.append(0.)
+                self._mo_sets[index].append(v)
+                v = None
+            elif line.strip() != "":
+              buffer = regexp5.findall(line)
+              PreviousBlank = False
+              if buffer != []:
+                if not ReadingLabels:
+                  ReadingLabels = True
+              else:
+                ReadingLabels = False
+              # Find "Orb Occ Energy" values to initiate a new orbital
+              buffer = regexp3.findall(line)
+              if buffer != []:
+                buffer = buffer[0]
+                symcount = int(buffer[0].split('.')[1])
+                bf = 0
+                v = orbital()
+                v.set = index
+                v.basis = self.basis
+                v.sym = self.symmetries[ int(buffer[0].split('.')[1])-1 ][0]
+                v.eigenvalue = float(buffer[2])
+                if v.eigenvalue == 999999.9999:
+                  print "Warning line", iline+1, ": '**********' in orbital eigenvalues"
+                for l,s in enumerate(self.num_orb_sym):
+                  if l < symcount-1 :
+                    bf += s[0]
+                    for k in range(0,s[1]):
+                      v.vector.append(0.)
+              # Find coefficient values to continue the orbital
+              buffer = regexp7.findall(line[30:])
+              while buffer != []:  # Insert spaces in "7851.548715699.7413"
+                 begin = line[0:].find(buffer[0])
+                 end = begin+len(buffer[0])
+                 line = line[0:end-10]+" "+line[end-10:]
+                 buffer = regexp7.findall(line)
+              buffer = regexp4.findall(line[30:])
+              if buffer != []:
+                for x in buffer[0][0].split():
+                  for k in self.salcao2mo[bf]:
+                    try:
+                      x2 = k*float(x)
+                    except ValueError:
+                      print "Error line", iline+1, ": orbital coefficients"
+                      sys.exit(1)
+                    v.vector.append(x2)
+                  bf+=1
+          elif regexp2.match(line):
+            if self._mo_sets[index] == []:
+              doRead = True
+            symcount=0
+      return self._mo_sets
+
+   def get_determinants_mo_type(self):
+      if self._determinants_mo_type is None:
+        self._determinants_mo_type = self.mo_types[-1]
+      return self._determinants_mo_type
+
+   def get_csf_mo_type(self):
+      if self._csf_mo_type is None:
+        self._csf_mo_type = self.determinants_mo_type
+      return self._determinants_mo_type
+
+   def get_determinants(self):
+      if self._determinants is None:
+        determinants = []
+        if self.csf is not None:
+           for csf in self.csf:
+              for new_det in csf.determinants:
+                 determinants.append(new_det)
+        else:
+           pass
+        if determinants != []:
+          self._determinants_mo_type = self.mo_types[-1]
+          self._determinants = determinants
+      return self._determinants
+
+   def get_csf(self):
+      if self._csf is None:
+        csf = []
+        csfcoef = [[]]
+        index = len(self.methods)-1
+        while self.mo_types[index] not in methods_with_orbitals and index >0:
+           index -= 1
+        # Mono-determinant case
+        if self.mo_types[index].startswith("RHF-SCF"):
+           new_csf = CSF()
+           new_spin_det_a = []
+           new_spin_det_b = []
+           occ = self.occ_num[self.determinants_mo_type]
+           for i,v in enumerate(occ):
+                   if v == 1.:
+                           new_spin_det_a.append(i)
+                   elif v == 2.:
+                           new_spin_det_a.append(i)
+                           new_spin_det_b.append(i)
+                   else:
+                           assert v == 0.
+           new_csf.append(1.,new_spin_det_a,new_spin_det_b)
+           csf.append(new_csf)
+           csfcoef[0].append(1.)
+           self._determinants_mo_type = self.mo_types[index]
+
+        # Multi-determinant case
+        elif self.mo_types[index].startswith("MULTI"):
+             try:
+               self.find_last_string('Number of closed-shell orbitals')
+               pos = self._pos
+               buffer = self.text[pos].split()
+               ncore0 = [ int(a) for a in buffer[6:-1] ]
+             except IndexError:
+               ncore0 = [ 0 for a in self.symmetries ]
+
+             self.find_last_string('Number of active')
+             pos = self._pos
+             buffer = self.text[pos].split()
+             nact0  = [ int(a) for a in buffer[6:-1] ]
+
+             self.find_next_string('Number of external')
+             mo_count = [ 0 for i in self.num_orb_sym ] 
+             j = 0
+#            curr_sym = self.mo_sets[self.determinants_mo_type][0].sym[0]
+             curr_sym = self.mo_sets[self.determinants_mo_type][0].sym
+             for i in self.mo_sets[self.determinants_mo_type]:
+              if i.sym is not None:
+               if i.sym != curr_sym:
+                 curr_sym = i.sym
+#              if i.sym[0] != curr_sym:
+#                curr_sym = i.sym[0]
+                 j+=1
+               mo_count[j] += 1
+             next0  = [ mo_count[i] - nact0[i] - ncore0[i] for i in range(len(self.num_orb_sym)) ]
+             self.find_next_string('TOTAL ENERGIES')
+             end = self._pos -2
+             self.find_prev_string('CI vector')
+             pos = self._pos +2
+             while pos < end:
+              pos += 1
+              this_csf = CSF()
+              tempcsf_a = []
+              tempcsf_b = []
+              buffer = [ ''.join(self.text[pos].split()[:-1]),self.text[pos].split()[-1]]
+              mo, coef = buffer
+              coef = float(coef)
+              ncoreold=0
+              nactold=0
+              mo2=""
+              for ((ncore,nact),next) in zip(zip(ncore0,nact0),next0):
+               for i in range(ncore):
+                 tempcsf_a.append(ncoreold+i)
+                 tempcsf_b.append(ncoreold+i)
+                 mo2+="2"
+               ncoreold += ncore
+               for k,i in enumerate(mo[nactold:nactold+nact]):
+                 if i in "2a+/":
+                   tempcsf_a.append(ncoreold+k)
+                 if i in "2b-\\":
+                   tempcsf_b.append(ncoreold+k)
+                 mo2 += i
+               ncoreold += nact+next
+               nactold  += nact
+
+# Correction de la phase due au changement d'ordre des orbitales
+              p_count=0
+              for k,i in enumerate(mo2):
+                if i in "2b-\\":
+                  for j in mo2[k+1:]:
+                    if j in "2a+/":
+                      p_count+=1
+              this_csf.append((-1.0)**p_count,tempcsf_a,tempcsf_b)
+
+              csf.append(this_csf)
+              csfcoef[0].append(coef)
+        if csf != []:
+           self._csf = csf
+           self._csf_coefficients = csfcoef
+      return self._csf
+
+
+   def get_csf_coefficients(self):
+      if self._csf_coefficients is None:
+         self.get_csf()
+      return self._csf_coefficients
+
+   def get_closed_mos(self):
+      if self._closed_mos is None:
+         result = []
+         occ = filter(lambda x: x>0., self.occ_num[self.determinants_mo_type])
+         maxmo = len(occ)
+         for orb in range(maxmo):
+           present = True
+           for det in self.determinants:
+               if present:
+                 for spin_det in det:
+                   if orb not in det[spin_det]: present = False
+               else:
+                 break
+           if present: result.append(orb)
+         self._closed_mos = result
+      return self._closed_mos
+
+   def get_virtual_mos(self):
+      if self._virtual_mos is None:
+         result = []
+         occ = filter(lambda x: x>0., self.occ_num[self.determinants_mo_type])
+         maxmo = len(self.mo_sets[self.determinants_mo_type])
+         for orb in range(maxmo):
+           present = False
+           for det in self.determinants:
+             if not present:
+               for spin_det in det:
+                   if orb in det[spin_det]: present = True
+             else:
+               break
+           if not present: result.append(orb)
+           self._virtual_mos = result
+         self._virtual_mos = result
+      return self._virtual_mos
+
+   def get_active_mos(self):
+      if self._active_mos is None:
+         cl = self.closed_mos
+         vi = self.virtual_mos
+         maxmo = len(self.mo_sets[self.determinants_mo_type])
+         result = []
+         for i in range(maxmo):
+           present = i in cl or i in vi
+           if not present:
+             result.append(i)
+         self._active_mos = result
+      return self._active_mos
+
+   def get_det_coefficients(self):
+      if self._det_coefficients is None:
+        index = len(self.methods)-1
+        while self.mo_types[index] not in methods_with_orbitals and index >0:
+           index -= 1
+        # Mono-determinant case
+        if self.mo_types[index].startswith("RHF-SCF"):
+           self._det_coefficients = [ [1.] ]
+        # Multi-determinant case
+        if self.mo_types[index].startswith("MULTI"):
+         if self.csf is not None:
+           self._det_coefficients = []
+           csf = self.csf
+           for state_coef in self.csf_coefficients:
+              vector = []
+              for i,c in enumerate(state_coef):
+                 for d in csf[i].coefficients:
+                    vector.append(c*d)
+              self._det_coefficients.append(vector)
+      return self._det_coefficients
+
+   def get_num_states(self):
+      if self._num_states is None:
+        self._num_states=1
+      return self._num_states
+
+# Properties
+# ----------
+   exec build_property("num_orb_sym","Number of SALCAO/sym") in locals()
+   to_remove = []
+   for i, j in local_vars:
+     if i in resultsFile_defined_vars:
+        to_remove.append( (i,j) )
+   for i in to_remove:
+      local_vars.remove(i)
+
+   for i, j in local_vars:
+     if i not in defined_vars:
+        exec build_get_funcs(i) in locals()
+     exec build_property(i,j) in locals()
+   del to_remove, i, j
+
+# Output Routines
+# ---------------
+
+def molpro_write_input(res,file):
+
+  print >>file, " ***,", res.title
+  geom = res.geometry
+  print >>file, """
+ print,basis;
+ print,orbitals;
+ gprint,civector;
+ gthresh,printci=0.;
+
+ geomtyp=xyz
+ geometry={
+ """, len(geom)
+  print >>file, res.title
+  i=1
+  for at in geom:
+    coord = []
+    for x in at.coord: coord.append(x*a0)
+    print >>file, "%10s  %15.8f %15.8f %15.8f" % tuple( \
+     [(at.name+str(i)).ljust(10) ]+coord )
+    i+=1
+  print >>file, "}\n"
+  print >>file, "basis={"
+  lines = []
+  for idx,at in enumerate(geom):
+    # Find atom
+    doPrint = True
+    for contr in at.basis:
+         line = ""
+         # Find Sym
+         sym = contr.sym
+         if sym == 's' :
+            sym = 's'
+            doPrint = True
+         elif sym == 'x' :
+            sym = 'p'
+            doPrint = True
+         elif sym == 'd+0' :
+            sym = 'd'
+            doPrint = True
+         elif sym == 'xx' :
+            sym = 'd'
+            doPrint = True
+         elif sym == 'f+0' :
+            sym = 'f'
+            doPrint = True
+         elif sym == 'xxx' :
+            sym = 'f'
+            doPrint = True
+         elif sym == 'g+0' :
+            sym = 'g'
+            doPrint = True
+         elif sym == 'xxxx' :
+            sym = 'g'
+            doPrint = True
+         elif sym == 'h+0' :
+            sym = 'h'
+            doPrint = True
+         elif sym == 'xxxxx' :
+            sym = 'h'
+            doPrint = True
+         elif sym == 'i+0' :
+            sym = 'i'
+            doPrint = True
+         elif sym == 'xxxxxx' :
+            sym = 'i'
+            doPrint = True
+         elif sym == 'xxxxxxx' :
+            sym = 'j'
+            doPrint = True
+         else:
+            doPrint = False
+         if doPrint:
+           # Find exponents
+           line += "%1s,%s%d"%(sym, at.name, idx+1)
+           for i, p in enumerate(contr.prim):
+              if not isinstance(p,gaussian):
+                 raise TypeError("Basis function is not a gaussian")
+              line += ",%f"%(float(p.expo))
+           line += "\n"
+           # Find coefs
+           line += "c,1."+str(len(contr.prim))
+           for c in contr.coef:
+              line += ",%g"%(c)
+           if line not in lines:
+             lines.append(line)
+  for line in lines:
+    print >>file, line
+  print >>file, "}\n",
+
+  print >>file, "rhf;"
+  print >>file, "---"
+  
+fileTypes.append(molproFile)
+
+if __name__ == '__main__':
+   main(molproFile)
+

resultsFile/Modules/qmcchem_newFile.py

@@ -0,0 +1,297 @@
+#!/usr/bin/python
+#   resultsFile is a library which allows to read output files of quantum 
+#   chemistry codes and write input files.
+#   Copyright (C) 2007 Anthony SCEMAMA 
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program; if not, write to the Free Software Foundation, Inc.,
+#   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+#   Anthony Scemama
+#   LCPQ - IRSAMC        
+#   Universite Paul Sabatier
+#   118, route de Narbonne      
+#   31062 Toulouse Cedex 4      
+#   scemama@irsamc.ups-tlse.fr 
+
+
+
+import include
+eval(include.code)
+
+import struct
+import re
+
+import os
+QMCCHEM_PATH = os.getenv("QMCCHEM_PATH",default="")
+if QMCCHEM_PATH == "":
+ print "QmcChem new files are not handled."
+ class qmcchem_newFile(resultsFile):
+   pass
+else:
+ sys.path = [ QMCCHEM_PATH+"/scripts" ]+sys.path
+ from ezfio import ezfio
+
+ qmcchem_newFile_defined_vars = [ "date", "version", \
+                "title", "units", "methods", \
+                "point_group", "num_elec", \
+                "charge", "multiplicity","geometry",\
+                "basis","mo_sets","mo_types",\
+                "determinants", "num_alpha", "num_beta",\
+                "closed_mos", "active_mos", "virtual_mos", \
+                "determinants_mo_type", "det_coefficients", \
+                "csf_mo_type", "csf_coefficients", "occ_num", \
+                "csf" ]
+
+ class qmcchem_newFile(resultsFile):
+   """ Class defining the qmcchem_new file.
+   """
+
+   local_vars = list(local_vars)
+   defined_vars = list(qmcchem_newFile_defined_vars)
+
+   def __init__(self,name):
+     resultsFile.__init__(self,name)
+     ezfio.set_filename(self.filename)
+
+   def get_version(self):
+     if self._version is None:
+       self._version = ezfio.get_version()
+     return self._version
+
+   def get_date(self):
+     if self._date is None:
+       self._date = ezfio.get_ezfio_creation()
+     return self._date
+
+   def get_num_elec(self):
+     if self._num_elec is None:
+       self._num_elec = self.num_alpha + self.num_beta
+     return self._num_elec
+
+   def get_multiplicity(self):
+     if self._multiplicity is None:
+       self._multiplicity = self.num_alpha - self.num_beta + 1
+     return self._multiplicity
+
+   def get_charge(self):
+     if self._charge is None:
+       self._charge = sum(ezfio.get_nuclei_nucl_charge())-float(self.num_elec)
+     return self._charge
+
+   def get_title(self):
+     if self._title is None:
+       self._title = self.filename
+     return self._title
+
+   def get_units(self):
+     if self._units is None:
+       self._units = 'BOHR'
+       #for a gamess use the units is give by an option on gamess_write_contrl
+     return self._units
+
+   def get_methods(self):
+     if self._methods is None:
+        self._methods = ['QMC']
+     return self._methods
+
+   def get_point_group(self):
+     if self._point_group is None:
+        self._point_group = "C1"
+     return self._point_group 
+
+   def get_geometry(self):
+     if self._geometry is None:
+       self.get_geometryX()
+       self.get_basisX()
+     return self._geometry
+
+   def get_basis(self):
+     if self._basis is None:
+       self.get_geometry()
+     return self._basis
+
+   def get_geometryX(self):
+     self._geometry = []
+     charge = ezfio.get_nuclei_nucl_charge()
+     coord  = ezfio.get_nuclei_nucl_coord()
+     num    = ezfio.get_nuclei_nucl_num()
+     for i in range(num):
+        temp = atom()
+        temp.charge = charge[i]
+        temp.coord  = (coord[0][i], coord[1][i], coord[2][i])
+        temp.name   = 'X'
+        temp.basis  = []
+        self._geometry.append(temp)
+
+   def get_basisX(self):
+        coef = ezfio.get_ao_basis_ao_coef()
+        expo = ezfio.get_ao_basis_ao_expo()
+        nucl = ezfio.get_ao_basis_ao_nucl()
+        num  = ezfio.get_ao_basis_ao_num()
+        power= ezfio.get_ao_basis_ao_power()
+        prim_num= ezfio.get_ao_basis_ao_prim_num()
+
+        self._basis = []
+        for i in range(num):
+            contr = contraction()
+            for j in range(prim_num[i]):
+              gauss = gaussian()
+              atom = self._geometry[nucl[i]-1]
+              gauss.center = atom.coord
+              gauss.expo = expo[j][i]
+              name = normalize_basis_name('x'*power[0][i]+'y'*power[1][i]+'z'*power[2][i])
+              if name == '': name = 's'
+              gauss.sym  = name
+              contr.append(coef[j][i],gauss)
+            self._geometry[nucl[i]-1].basis.append(contr)
+            self._basis.append(contr)
+
+
+   def get_mo_types(self):
+      if self._mo_types is None:
+        self._mo_types = ['QMC']
+      return self._mo_types 
+
+   def get_mo_sets(self):
+      if self._mo_sets is None:
+         self._mo_sets = {}
+         self._mo_sets['QMC'] = []
+         coef = ezfio.get_mo_basis_mo_coef()
+         energy = ezfio.get_mo_basis_mo_energy()
+         num = ezfio.get_mo_basis_mo_tot_num()
+         for i in range(num):
+           v = orbital()
+           v.basis = self.basis
+           v.set = 'QMC'
+           v.eigenvalue = energy[i]
+           v.vector = coef[i]
+           self.mo_sets['QMC'].append(v)
+      return self._mo_sets
+         
+   def get_num_alpha(self):
+      if self._num_alpha is None:
+        self._num_alpha = ezfio.get_electrons_elec_alpha_num()
+      return self._num_alpha 
+
+   def get_num_beta(self):
+      if self._num_beta is None:
+        self._num_beta = ezfio.get_electrons_elec_beta_num()
+      return self._num_beta 
+
+   def get_determinants_mo_type(self):
+      if self._determinants_mo_type is None:
+         self._determinants_mo_type = 'QMC'
+      return self._determinants_mo_type
+
+   def get_csf_mo_type(self):
+      if self._csf_mo_type is None:
+         self._csf_mo_type = 'QMC'
+      return self._csf_mo_type
+
+   def get_determinants(self):
+      if self._determinants is None:
+        determinants = []
+        if self.csf is not None:
+           for csf in self.csf:
+              for new_det in csf.determinants:
+                 determinants.append(new_det)
+        else:
+           pass
+        if determinants != []:
+          self._determinants_mo_type = self.mo_types[-1]
+          self._determinants = determinants
+      return self._determinants
+
+   def get_csf(self):
+      method = self.methods[0]
+      if self._csf is None:
+        csf = []
+        ncore = ezfio.get_mo_basis_mo_closed_num()
+        nact  = ezfio.get_mo_basis_mo_active_num()
+        core_a = []
+        core_b = []
+        for i in range(ncore):
+           core_a.append(i)
+           core_b.append(i)
+        num = ezfio.get_determinants_det_num()
+        occ = ezfio.get_determinants_det_occ()
+        if occ == []:
+          occ = [[[0]],[[0]]]
+        for i in range(num):
+          this_csf = CSF()
+          tempcsf_a = core_a + map(lambda x: x-1, occ[0][i])
+          tempcsf_b = core_b + map(lambda x: x-1, occ[1][i])
+          this_csf.append(1.,tempcsf_a,tempcsf_b)
+          csf.append(this_csf)
+        if csf != []:
+           self._csf = csf
+      return self._csf
+
+
+   def get_closed_mos(self):
+      if self._closed_mos is None:
+         cls = ezfio.get_mo_basis_mo_classif()
+         self._closed_mos = []
+         self._virtual_mos = []
+         self._active_mos = []
+         for i in range(len(cls)):
+           if cls[i] == 'c':
+             self._closed_mos.append(i)
+           elif cls[i] == 'a':
+             self._active_mos.append(i)
+           elif cls[i] == 'v':
+             self._virtual_mos.append(i)
+      return self._closed_mos
+
+   def get_virtual_mos(self):
+      if self._virtual_mos is None:
+        self.get_closed_mos()
+      return self._virtual_mos
+
+   def get_active_mos(self):
+      if self._active_mos is None:
+        self.get_closed_mos()
+      return self._active_mos
+
+   def get_det_coefficients(self):
+      if self._det_coefficients is None:
+        self._det_coefficients = []
+        csf = self.csf
+        for state_coef in self.csf_coefficients:
+           vector = []
+           for i,c in enumerate(state_coef):
+              for d in csf[i].coefficients:
+                 vector.append(c*d)
+           self._det_coefficients.append(vector)
+      return self._det_coefficients
+
+   def get_csf_coefficients(self):
+      if self._csf_coefficients is None:
+           self._csf_coefficients = [ [] ]
+           self._csf_coefficients[0] = ezfio.get_determinants_det_coef()
+      return self._csf_coefficients
+
+   def get_occ_num(self):
+     if self._occ_num is None:
+      self._occ_num = {}
+      motype = 'QMC'
+      self._occ_num[motype] = ezfio.get_mo_basis_mo_occ()
+     return self._occ_num 
+
+      
+fileTypes.append(qmcchem_newFile)
+  
+if __name__ == '__main__':
+   main(qmcchem_newFile)
+

resultsFile/Modules/wfnFile.py

@@ -0,0 +1,487 @@
+#!/usr/bin/python
+#   resultsFile is a library which allows to read output files of quantum 
+#   chemistry codes and write input files.
+#   Copyright (C) 2007 Anthony SCEMAMA 
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program; if not, write to the Free Software Foundation, Inc.,
+#   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+#   Anthony Scemama
+#   LCPQ - IRSAMC        
+#   Universite Paul Sabatier
+#   118, route de Narbonne      
+#   31062 Toulouse Cedex 4      
+#   scemama@irsamc.ups-tlse.fr 
+
+
+
+import include
+eval(include.code)
+
+import struct
+
+wfnFile_defined_vars = [ 
+                "energies", "title", "units",\
+                "virials", "num_elec", \
+                "charge", "geometry",\
+                "basis","mo_sets","mo_types", \
+                "num_alpha", "num_beta",\
+                "closed_mos", "active_mos", "virtual_mos", \
+                "determinants",
+                "determinants_mo_type", "det_coefficients", \
+                "csf_mo_type", "csf_coefficients", "occ_num", \
+                "csf", "num_states"] 
+
+class wfnFile(resultsFile):
+   """ Class defining the wfn file.
+   """
+
+   local_vars = list(local_vars)
+   defined_vars = list(wfnFile_defined_vars)
+
+   def get_title(self):
+     if self._title is None:
+       self._title = self.text[0].strip()
+     return self._title
+
+   def get_units(self):
+     if self._units is None:
+       self._units = "BOHR"
+     return self._units
+
+   def get_num_elec(self):
+     if self._num_elec is None:
+       self._num_elec = int(sum(self.occ_num["Wfn"]))
+     return self._num_elec
+
+   def get_occ_num(self):
+     if self._occ_num is None:
+        result = {}
+        occ = []
+        for line in self.text:
+          if line.startswith("MO"):
+            buffer = line.split()
+            while buffer[0] != "OCC":
+              buffer.pop(0)
+            occ.append(float(buffer[3]))
+        result["Wfn"] = occ
+        self._occ_num = result
+     return self._occ_num 
+
+   def get_energies(self):
+       if self._energies is None:
+          buffer = self.text[-1]
+          self._energies = [float(buffer.split("ENERGY")[1].split()[1])]
+          self._virials =  [float(buffer.split("VIRIAL(-V/T)=")[1].split()[0])]
+       return self._energies
+
+   def get_virials(self):
+     if self._virials is None:
+        self.get_energies()
+     return self._virials
+
+   def get_charge(self):
+     if self._charge is None:
+        result = 0.
+        for line in self.text:
+          if "CHARGE" in line:
+            result += float(line.split("CHARGE =")[1].strip())
+        result -= self.num_elec
+        self._charge = result
+     return self._charge
+
+   def get_geometry(self):
+     if self._geometry is None:
+        Natoms = int(self.text[1].split()[6])
+        pos = 2
+        begin = pos
+        self._geometry = []
+        buffer = self.text[pos].split()
+        while pos<begin+Natoms:
+           temp = atom()
+           temp.name   = buffer[0]
+           temp.charge = float(buffer[9])
+           temp.coord  = (float(buffer[4]), float(buffer[5]), float(buffer[6]))
+           temp.basis  = []
+           self._geometry.append(temp)
+           pos += 1
+           buffer = self.text[pos].split()
+        b = self.basis
+        if b is not None:
+           try:
+             for f in b:
+               for at in self._geometry:
+                 if f.center is at.coord:
+                   at.basis.append(f)
+           except IndexError:
+              pass
+     return self._geometry
+
+   def get_basis(self):
+     if self._basis is None:
+        center = []
+        type = []
+        expo = []
+        conversion = [ "S", "X", "Y", "Z" ]
+        for line in self.text:
+           if line.startswith('CENTRE'):
+             buffer = line[20:].split()
+             for b in buffer:
+               center.append(int(b)-1)
+           elif line.startswith('TYPE'):
+             buffer = line[20:].split()
+             for b in buffer:
+               type.append(int(b))
+           elif line.startswith('EXPONENTS'):
+             buffer = line[10:].split()
+             for b in buffer:
+               expo.append(float(b.replace('D','e')))
+        if 10 in type: # Cartesian d orbitals
+          conversion += [ "XX", "YY", "ZZ", "XY", "XZ", "YZ" ]
+        else:          # Spherical d
+          conversion += [ "D2-", "D1-", "D0", "D1+", "D2+", "" ]
+        if 20 in type: # Cartesian f orbitals
+          conversion += [ "XXX", "YYY", "ZZZ", "YYX", "XXY", "XXZ",
+                          "ZZX", "ZZY", "YYZ", "XYZ" ]
+        else:          # Spherical f
+          conversion += [ "F3-", "F2-", "F1-", "F0", "F1+", "F2+", 
+                          "F3+", "", "", "" ]
+        for i in range(len(type)):
+          type[i] = conversion[type[i]-1]
+        assert ( len(expo) == len(type) )
+        assert ( len(expo) == len(center) )
+        
+        self._basis = []
+        for i in range(len(expo)):
+          contr = contraction()
+          gauss = gaussian()
+          atom = self.geometry[center[i]]
+          gauss.center = atom.coord
+          gauss.expo = expo[i]
+          gauss.sym  = type[i]
+          contr.append(1.,gauss)
+          self._basis.append(contr)
+     return self._basis
+
+   def get_mo_types(self):
+      if self._mo_types is None:
+        self.get_mo_sets()
+      return self._mo_types 
+
+   def get_mo_sets(self):
+      if self._mo_sets is None:
+         self._mo_sets = {}
+         index = 'Wfn'
+         self._mo_types = [index]
+         posend = {}
+         k=0
+         vectors = []
+         for line in self.text:
+           if line.startswith('MO'):
+             if k>0:
+               vectors.append(v)
+             v = orbital()
+             v.set = index
+             v.basis = self.basis
+             v.eigenvalue = float(line.split()[-1])
+             v.sym = None
+             k+=1
+           elif line.startswith('END'):
+             vectors.append(v)
+             k=0
+           elif k>0:
+             for c in line.split():
+               v.vector.append(float(c.replace('D','e')))
+         basis = self.basis
+         for v in vectors:
+           for i in range(len(basis)):
+             v.vector[i] *= basis[i].norm
+         self._mo_sets[index] = vectors
+      return self._mo_sets
+
+   def get_num_alpha(self):
+      if self._num_alpha is None:
+         self._num_alpha = self.num_elec-self.num_beta
+      return self._num_alpha 
+
+   def get_num_beta(self):
+      if self._num_beta is None:
+         self._num_beta = self.num_elec/2
+      return self._num_beta 
+
+   def get_determinants_mo_type(self):
+      if self._determinants_mo_type is None:
+        self._determinants_mo_type = self.mo_types[-1]
+      return self._determinants_mo_type
+
+   def get_csf_mo_type(self):
+      if self._csf_mo_type is None:
+         self._csf_mo_type = self.determinants_mo_type
+      return self._csf_mo_type
+
+   def get_determinants(self):
+      if self._determinants is None:
+        determinants = []
+        if self.csf is not None:
+           for csf in self.csf:
+              for new_det in csf.determinants:
+                 determinants.append(new_det)
+        else:
+           pass
+        if determinants != []:
+          self._determinants_mo_type = self.mo_types[-1]
+          self._determinants = determinants
+      return self._determinants
+
+   def get_csf(self):
+      if self._csf is None:
+
+        csf = []
+        new_csf = CSF()
+        new_spin_det_a = []
+        new_spin_det_b = []
+        ntot = 0
+        for i,n in enumerate(self.occ_num['Wfn']):
+          if n == 1.0:
+            if ntot < self.num_alpha:
+              new_spin_det_a.append(i)
+            else:
+              new_spin_det_b.append(i)
+            ntot += 1
+          elif n == 2.0:
+            new_spin_det_a.append(i)
+            new_spin_det_b.append(i)
+        new_csf.append(1.,new_spin_det_a,new_spin_det_b)
+        csf.append(new_csf)
+        self._determinants_mo_type = self.mo_types[-1]
+        if csf != []:
+           self._csf = csf
+      return self._csf
+
+
+   def get_closed_mos(self):
+      if self._closed_mos is None:
+         result = []
+         maxmo = len(self.mo_sets[self.determinants_mo_type])
+         for orb in range(maxmo):
+           present = True
+           for det in self.determinants:
+               for spin_det in det:
+                   if orb not in det[spin_det]: present = False
+           if present: result.append(orb)
+           self._closed_mos = result
+      return self._closed_mos
+
+   def get_virtual_mos(self):
+      if self._virtual_mos is None:
+         result = []
+         minmo = len(self.closed_mos)
+         maxmo = len(self.mo_sets[self.determinants_mo_type])
+         for orb in range(minmo,maxmo):
+           present = False
+           for det in self.determinants:
+               for spin_det in det:
+                   if orb in det[spin_det]: present = True
+           if not present: result.append(orb)
+           self._virtual_mos = result
+      return self._virtual_mos
+
+   def get_active_mos(self):
+      if self._active_mos is None:
+         cl = self.closed_mos
+         vi = self.virtual_mos
+         maxmo = len(self.mo_sets[self.determinants_mo_type])
+         result = []
+         for i in range(maxmo):
+           present = i in cl or i in vi
+           if not present:
+             result.append(i)
+         self._active_mos = result
+      return self._active_mos
+
+   def get_det_coefficients(self):
+      if self._det_coefficients is None:
+        self._det_coefficients = [ [1.] ]
+      return self._det_coefficients
+
+   def get_csf_coefficients(self):
+      if self._csf_coefficients is None:
+        self._csf_coefficients = [ [1.] ]
+      return self._csf_coefficients
+
+   def get_num_states(self):
+      if self._num_states is None:
+        self._num_states=1
+      return self._num_states
+
+# Properties
+# ----------
+   to_remove = []
+   for i, j in local_vars:
+     if i in resultsFile_defined_vars:
+        to_remove.append( (i,j) )
+   for i in to_remove:
+      local_vars.remove(i)
+
+   for i, j in local_vars:
+     if i not in defined_vars:
+        exec build_get_funcs(i) in locals()
+     exec build_property(i,j) in locals()
+   del to_remove, i, j
+
+
+# Output Routines
+# ---------------
+
+import string
+
+basis_correspond = {}
+basis_correspond['s'  ] = 1
+basis_correspond['x'  ] = 2
+basis_correspond['y'  ] = 3
+basis_correspond['z'  ] = 4
+basis_correspond['xx' ] = 5
+basis_correspond['yy' ] = 6
+basis_correspond['zz' ] = 7
+basis_correspond['xy' ] = 8
+basis_correspond['xz' ] = 9
+basis_correspond['yz' ] = 10
+basis_correspond['xxx'] = 11
+basis_correspond['yyy'] = 12
+basis_correspond['zzz'] = 13
+basis_correspond['xyy'] = 14
+basis_correspond['xxy'] = 15
+basis_correspond['xxz'] = 16
+basis_correspond['xzz'] = 17
+basis_correspond['yzz'] = 18
+basis_correspond['yyz'] = 19
+basis_correspond['xyz'] = 20
+basis_correspond['d-2'] = 5
+basis_correspond['d-1'] = 6
+basis_correspond['d+0'] = 7
+basis_correspond['d+1'] = 8
+basis_correspond['d+2'] = 9
+basis_correspond['f-3'] = 11
+basis_correspond['f-2'] = 12
+basis_correspond['f-1'] = 13
+basis_correspond['f+0'] = 14
+basis_correspond['f+1'] = 15
+basis_correspond['f+2'] = 16
+basis_correspond['f+3'] = 17
+
+def wfn_write(res,file,MO_type=None):
+  print >>file, " "+res.title.strip()
+  print >>file, "GAUSSIAN %14d MOL ORBITALS %6d PRIMITIVES %8d NUCLEI" \
+    %(len(res.closed_mos+res.active_mos), len(res.uncontracted_basis), len(res.geometry)),
+
+  # write geom
+  geom  = res.geometry
+  f=1.
+  if res.units == 'ANGS':
+    f=1./a0
+  for i,atom in enumerate(geom):
+   name = atom.name
+   for d in string.digits:
+     name = name.replace(d,'')
+   print >>file, "\n%3s %4d    (CENTRE%3d) %12.8f%12.8f%12.8f  CHARGE = %4.1f" \
+     %(name, i+1, i+1, atom.coord[0]*f, atom.coord[1]*f, atom.coord[2]*f, atom.charge),
+
+  # write basis
+  basis = res.uncontracted_basis
+  center = []
+  type = []
+  expo = []
+  for prim in basis:
+     c = prim.center
+     for i,atom in enumerate(geom):
+         atom_c = atom.coord
+         if atom_c == c:
+            atom_id = i+1
+     sym = basis_correspond[prim.sym]
+     center.append(atom_id)
+     type.append(sym)
+     expo.append(prim.expo)
+  k=0
+  for c in center:
+    if k%20 == 0:
+      print "\nCENTRE ASSIGNMENTS  ",
+    print "%2d"%(c),
+    k+=1
+  k=0
+  for t in type:
+    if k%20 == 0:
+      print "\nTYPE ASSIGNMENTS    ",
+    print "%2d"%(t),
+    k+=1
+  k=0
+  for e in expo:
+    if k%5 == 0:
+      print "\nEXPONENTS ",
+    print ("%13.7e"%(e)).replace('e','D'),
+    k+=1
+
+  print '\n',
+
+  # MOs
+  if MO_type is None:
+    MO_type = res.determinants_mo_type
+  try:
+    allMOs = res.uncontracted_mo_sets[MO_type]
+  except KeyError:
+    print "MO type not present in "+res.filename
+    return
+  mos = []
+  occ = res.occ_num[MO_type]
+  for i,mo in enumerate(allMOs):
+    mos.append( (mo.eigenvalue, mo, i) )
+  mos.sort()
+  for i,orb2 in enumerate(mos):
+   if occ[orb2[2]] > 0.:
+    orb = orb2[1]
+    print "MO %4d     MO 0.0        OCC NO =    %9.7f  ORB. ENERGY =%12.6f" \
+      %(i+1, occ[orb2[2]], orb.eigenvalue),
+    k=0
+    for c in orb.vector:
+      if k%5 == 0:
+        print "\n",
+      print "%15.8e"%(c),
+      k+=1
+    print "\n",
+  print "END DATA"
+  idx = res.mo_types.index(MO_type)
+  try:
+    print " THE  HF ENERGY =%20.12f THE VIRIAL(-V/T)="%(res.energies[idx]),
+    print "%12.8f"%(res.virials[idx]) 
+  except TypeError:
+    print " THE  HF ENERGY =%20.12f THE VIRIAL(-V/T)=%12.8f"%(0.,0.)
+
+
+
+
+
+
+def write_wfnFile(file,out=sys.stdout):
+  if "basis" in file.mo_sets.keys() : 
+    MoType = "basis"
+  else:
+    MoType = None
+  file.clean_uncontractions()
+  wfn_write(file,out,MoType)
+
+  
+fileTypes.append(wfnFile)
+
+if __name__ == '__main__':
+   main(wfnFile)
+

resultsFile/Modules/xmvbFile.py

@@ -0,0 +1,732 @@
+#!/usr/bin/python
+#   resultsFile is a library which allows to read output files of quantum 
+#   chemistry codes and write input files.
+#   Copyright (C) 2007 Anthony SCEMAMA 
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program; if not, write to the Free Software Foundation, Inc.,
+#   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+#   Anthony Scemama
+#   LCPQ - IRSAMC        
+#   Universite Paul Sabatier
+#   118, route de Narbonne      
+#   31062 Toulouse Cedex 4      
+#   scemama@irsamc.ups-tlse.fr 
+
+
+
+import include
+eval(include.code)
+
+import struct
+import re
+
+xmvbFile_defined_vars = [ "date", "version", "machine", "memory", "disk",\
+                "cpu_time", "author", "title", "units", "methods", "options", \
+                "spin_restrict", "conv_threshs", "energies", \
+                "ee_pot_energies", \
+                "Ne_pot_energies", "pot_energies", \
+                "kin_energies", "point_group", "num_elec", \
+                "charge", "multiplicity","nuclear_energy","dipole","geometry",\
+                "basis","mo_sets","mo_types","mulliken_mo","mulliken_ao",\
+                "mulliken_atom","lowdin_ao", "mulliken_atom","lowdin_atom",\
+                "two_e_int_ao", "determinants", "num_alpha", "num_beta",\
+                "closed_mos", "active_mos", "virtual_mos", \
+                "determinants_mo_type", "det_coefficients", \
+                "csf_mo_type", "csf_coefficients", "symmetries", "occ_num", \
+                "csf", "num_states"]
+
+class xmvbFile(resultsFile):
+   """ Class defining the xmvb file.
+   """
+
+   local_vars = list(local_vars)
+   defined_vars = list(xmvbFile_defined_vars)
+
+   def get_options(self):
+     if self._machine is None:
+        self.find_string("\\")
+        pos = self._pos
+        self.find_next_string("\\@")
+        end = self._pos
+        buffer = ""
+        self._options = []
+        for line in self.text[pos:end+1]:
+           buffer += line[1:].replace('\n','')
+        buffer = buffer.split('\\\\')
+        for l in buffer:
+          self._options.append(l.split('\\'))
+        self._options.pop()
+     return self._options
+
+   def get_machine(self):
+     if self._machine is None:
+        self._machine = self.options[0][2][5:].lower()
+     return self._machine
+
+   def get_version(self):
+     if self._version is None:
+       self._version = self.options[4][0].split('=')[1]
+     return self._version
+
+   def get_author(self):
+     if self._author is None:
+       self._author = self.options[0][7].lower()
+     return self._author
+
+   def get_charge(self):
+     if self._charge is None:
+       self._charge = float(self.options[3][0].split(',')[0])
+     return self._charge
+
+   def get_disk(self):
+     if self._disk is None:
+       try:
+         self.find_string("File lengths")
+       except IndexError:
+         return None
+       pos = self._pos
+       line = self.text[pos].split()
+       disk = 0
+       for i in line[4::2]:
+         disk += float(i)
+       disk = disk/1000.
+       if disk > 1.:
+         self._disk = str(disk)+" Gb"
+       else:
+         disk *= 1000.
+         if disk > 1.:
+           self._disk = str(disk)+" Mb"
+         else:
+           disk *= 1000.
+           self._disk = str(disk)+" kb"
+     return self._disk
+
+   def get_memory(self):
+     if self._memory is None:
+       try:
+         self.find_string("Leave Link")
+       except IndexError:
+         return None
+       pos = self._pos
+       line = self.text[pos].split()
+       memory = float(line[10])*8. / 1000000000.
+       if memory > 1.:
+         self._memory = str(memory)+" Gb"
+       else:
+         memory *= 1000.
+         if memory > 1.:
+           self._memory = str(memory)+" Mb"
+         else:
+           memory *= 1000.
+           self._memory = str(memory)+" kb"
+     return self._memory
+
+   def get_symmetries(self):
+     if self._symmetries is None:
+       try:
+         self.find_string("There are")
+       except IndexError:
+         return None
+       pos = self._pos
+       begin = pos
+       try:
+         self.find_next_string("Integral")
+       except IndexError:
+         return None
+       end = self._pos-1
+       sym = []
+       for k in range(begin,end):
+         buffer = self.text[k].split()
+         sym.append([buffer[8],int(buffer[2])])
+       self._symmetries = sym
+     return self._symmetries
+
+   def get_units(self):
+     if self._units is None:
+       try:
+         self.find_string("Coordinates")
+       except IndexError:
+         return None
+       pos = self._pos
+       units = self.text[pos].split()[4][1:-1]
+       if units != 'Angstroms':
+          self._units = 'BOHR'
+       else:
+          self._units = 'ANGS'
+     return self._units
+
+   def get_methods(self):
+     if self._methods is None:
+        methods = []
+        methods.append(self.options[0][4])
+        self._methods = methods
+     return self._methods
+
+   def get_spin_restrict(self):
+       if self._spin_restrict is None:
+          method = self.methods[0]
+          self._spin_restrict = True 
+          if method == 'UHF': self._spin_restrict = False
+       return self._spin_restrict
+
+
+   def get_conv_threshs(self):
+       if self._conv_threshs is None:
+          self._conv_threshs = []
+          for m in self.methods:
+            if m == 'RHF' or m == 'UHF' or m == 'ROHF':
+              self.find_string("SCF Done")
+              pos = self._pos + 1
+              self._conv_threshs.append(float(self.text[pos].split()[2]))
+            if m == 'CASSCF':
+              self.find_string("Enter MCSCF program")
+              self.find_next_string("USED ACCURACY IN CHECKING CONVEGERGENCE")
+              pos = self._pos
+              self._conv_threshs.append(float(self.text[pos].split('=')[1]))
+          if self._conv_threshs == []:
+              self._conv_threshs = None
+       return self._conv_threshs
+
+   def get_ee_pot_energies(self):
+     if self._ee_pot_energies is None:
+        self._ee_pot_energies = [] 
+        for i,e in enumerate(self.kin_energies):
+          self._ee_pot_energies.append(self.energies[i]\
+                          -self.nuclear_energy\
+                          -self.kin_energies[i]\
+                          -self.Ne_pot_energies[i])
+     return self._ee_pot_energies
+
+   def get_Ne_pot_energies(self):
+     if self._Ne_pot_energies is None:
+        self.find_string("N-N")
+        pos = self._pos
+        self._Ne_pot_energies = [float(self.text[pos].replace('=','= ').split()[3])]
+     return self._Ne_pot_energies
+
+   def get_point_group(self):
+     if self._point_group is None:
+        self._point_group = self.options[4][-1].split()[0].split('=')[1]
+     return self._point_group 
+
+   def get_geometry(self):
+     if self._geometry is None:
+        self._geometry = []
+        self._pos = 0
+        pos=0
+        try:
+           while True:
+              pos = self._pos
+              self.find_next_string("Number     Number      Type")
+              self._pos += 1
+        except IndexError:
+           pass
+        pos +=1
+        self._pos=pos
+        self.find_next_string("-----")
+        end = self._pos
+        while pos<end:
+           temp = atom()
+           buffer = self.text[pos].split()
+           temp.charge = float(buffer[1])
+           temp.coord  = (float(buffer[3]), float(buffer[4]), float(buffer[5]))
+           self._geometry.append(temp)
+           pos += 1 
+        for i,line in enumerate(self.options[3][1:]):
+           buffer = line.split(',')
+           self._geometry[i].name = buffer[0]
+#       try:
+#          b = self.basis
+#          for f in b:
+#            for at in self._geometry:
+#              if f.center is at.coord:
+#                at.basis.append(f)
+#       except IndexError:
+#          pass
+     return self._geometry
+
+   def get_basis(self):
+     if self._basis is None:
+        gfprint=False
+        gfinput=False
+        buffer = self.options[1][0].split()
+        if 'GFPRINT' in buffer: gfprint=True
+        elif 'GFINPUT' in buffer: gfinput=True
+       
+        if gfprint:
+          Polar=False
+          try:
+            self.find_string("Standard basis")
+          except:
+            self.find_string("General basis")
+          pos = self._pos
+          if "5D" in self.text[pos]: Polar=True
+          try:
+            self.find_next_string("AO basis set:")
+            pos = self._pos
+          except IndexError:
+            return None
+          self.find_string("Integral buffers")
+          end = self._pos
+          doLoop=True
+          while (doLoop):
+            try:
+              self.find_prev_string("There are")
+              end = self._pos
+            except:
+              doLoop = False
+          pos += 1
+          basis_read = []
+          line = self.text[pos].split()
+          iatom=0
+          atom = line[1]
+          while pos < end:
+             if line[0] == 'Atom':
+               index = int(line[3])
+               sym = line[4]
+               nfunc = int(line[5])
+               if atom != line[1]:
+                 iatom += 1
+               atom = line[1]
+               bf = []
+               pos+=1
+               line = self.text[pos].split()
+               for k in range(nfunc):
+                 expo = float(line[0].replace('D','E'))
+                 coef = float(line[1].replace('D','E'))
+                 if sym == "SP":
+                    coef2 = float(line[2])
+                    bf.append( [expo,coef,coef2] )
+                 else:
+                    bf.append( [expo,coef] )
+                 pos += 1
+                 line = self.text[pos].split()
+             if len(bf) > 0:
+               basis_read.append( [index,sym,bf,iatom] )
+        else:
+          print "GFPRINT should be present in the gaussian keywords."
+          return None
+        Nmax = basis_read[len(basis_read)-1][0]
+        basis = [None for i in range(Nmax)]
+        for b in basis_read:
+           basis[b[0]-1] = [b[1],b[2],b[3]]
+        NotNone = 0
+        ReadNone = False
+        for i in range(len(basis)-1,-1,-1):
+           if basis[i] == None:
+              ReadNone = True
+              basis[i] = list(basis[i+NotNone])
+           else:
+              if ReadNone:
+                 NotNone = 0
+                 ReadNone = False
+              NotNone += 1
+
+        k=0
+        while k<len(basis):
+           if basis[k][0] == "S":
+              mylist = []
+           elif basis[k][0] == "P":
+              mylist = [ "X", "Y", "Z" ]
+           elif basis[k][0] == "SP":
+              mylist = [ "S", "X", "Y", "Z" ]
+           elif basis[k][0] == "D":
+              if not Polar:
+                mylist = [ "XX", "YY", "ZZ", "XY", "XZ", "YZ" ]
+              else:
+                mylist = [ "D0", "D1+", "D1-", "D2+", "D2-" ]
+           elif basis[k][0] == "F":
+              if not Polar:
+                mylist = [ "XXX", "YYY", "ZZZ", "YYX", "XXY", "XXZ", "ZZX", "ZZY",
+                                "YYZ", "XYZ" ]
+              else:
+                mylist = [ "F0", "F1+", "F1-", "F2+", "F2-", "F3+", "F3-" ]
+           elif basis[k][0] == "G":
+              if not Polar:
+                mylist = [ "ZZZZ", "ZZZY", "YYZZ", "YYYZ", "YYYY", "ZZZX",
+                                "ZZXY", "YYXZ","YYYX", "XXZZ", "XXYZ", 
+                              "XXYY", "XXXZ","XXXY", "XXXX" ]
+              else:
+                mylist = [ "G0", "G1+", "G1-", "G2+", "G2+", "G3+", "G3-",
+                           "G4+", "G4-" ]
+          #elif basis[k][0] == "H":
+          #   mylist = [ "XXXXX", "YYYYY", "ZZZZZ", "XXXXY", "XXXXZ", "YYYYX", \
+          #                   "YYYYZ", "ZZZZX", "ZZZZY", "XXXYY", "XXXZZ", \
+          #                   "YYYXX", "YYYZZ", "ZZZXX", "ZZZYY", "XXXYZ", \
+          #                   "YYYXZ", "ZZZXY", "XXYYZ", "XXZZY", "YYZZX" ]
+          #elif basis[k][0] == "I":
+          #   mylist = [ "XXXXXX", "YYYYYY", "ZZZZZZ", "XXXXXY", "XXXXXZ", \
+          #                   "YYYYYX", "YYYYYZ", "ZZZZZX", "ZZZZZY", "XXXXYY", \
+          #                   "XXXXZZ", "YYYYXX", "YYYYZZ", "ZZZZXX", "ZZZZYY", \
+          #                   "XXXXYZ", "YYYYXZ", "ZZZZXY", "XXXYYY", "XXXZZZ", \
+          #                   "YYYZZZ", "XXXYYZ", "XXXZZY", "YYYXXZ", "YYYZZX", \
+          #                   "ZZZXXY", "ZZZYYX" ]
+           mylist = map(normalize_basis_name,mylist)
+           for i in mylist[:-1]:
+              basis[k][0] = i
+              basis.insert(k,list(basis[k]))
+              k+=1
+           for i in mylist[-1:]:
+              basis[k][0] = i
+           k+=1
+
+        self._basis = []
+        for buffer in basis:
+            contr = contraction()
+            for c in buffer[1]:
+              gauss = gaussian()
+              atom = self.geometry[int(buffer[2])]
+              gauss.center = atom.coord
+              gauss.expo = c[0]
+              gauss.sym  = buffer[0]
+              if len(c) == 3:
+                 if gauss.sym == "S":
+                    contr.append(c[1],gauss)
+                 else:
+                    contr.append(c[2],gauss)
+              else:
+                 contr.append(c[1],gauss)
+            self._basis.append(contr)
+
+     return self._basis
+
+   def get_mo_types(self):
+      if self._mo_types is None:
+        self.get_mo_sets()
+      return self._mo_types 
+
+   def get_mulliken_mo(self):
+      if self._mulliken_mo is None:
+         pass
+      return self._mulliken_mo
+
+   def get_mulliken_ao(self):
+       if self._mulliken_ao is None:
+          pass
+       return self._mulliken_ao
+
+   def get_lowdin_ao(self):
+       if self._lowdin_ao is None:
+          pass
+       return self._lowdin_ao
+
+
+   def get_mulliken_atom(self):
+       if self._mulliken_atom is None:
+          try:
+             self.find_string("Mulliken atomic charges")
+          except IndexError:
+             return None
+          self._pos += 2
+          pos = self._pos
+          self.find_next_string("Sum of Mulliken")
+          end = self._pos
+          line = self.text[pos].split()
+          vm = orbital()
+          vm.set = "Mulliken_Atom"
+          vm.eigenvalue = 0.
+          while pos < end:
+             value = float(line[2])
+             vm.vector.append(value)
+             vm.eigenvalue += value
+             pos += 1
+             line = self.text[pos].split()
+          self._mulliken_atom = vm
+       return self._mulliken_atom
+
+   def get_lowdin_atom(self):
+       if self._lowdin_atom is None:
+          pass
+       return self._lowdin_atom
+
+   def get_two_e_int_ao(self):
+      if self._two_e_int_ao is None:
+         pass
+      return self._two_e_int_ao
+
+   def get_closed_mos(self):
+      if self._closed_mos is None:
+         result = []
+         maxmo = len(self.mo_sets[self.determinants_mo_type])
+         for orb in range(maxmo):
+           present = True
+           for det in self.determinants:
+               for spin_det in det:
+                   if orb not in det[spin_det]: present = False
+           if present: result.append(orb)
+           self._closed_mos = result
+      return self._closed_mos
+
+   def get_virtual_mos(self):
+      if self._virtual_mos is None:
+         result = []
+         minmo = len(self.closed_mos)
+         maxmo = len(self.mo_sets[self.determinants_mo_type])
+         for orb in range(minmo,maxmo):
+           present = False
+           for det in self.determinants:
+               for spin_det in det:
+                   if orb in det[spin_det]: present = True
+           if not present: result.append(orb)
+           self._virtual_mos = result
+      return self._virtual_mos
+
+   def get_active_mos(self):
+      if self._active_mos is None:
+         cl = self.closed_mos
+         vi = self.virtual_mos
+         maxmo = len(self.mo_sets[self.determinants_mo_type])
+         result = []
+         for i in range(maxmo):
+           present = i in cl or i in vi
+           if not present:
+             result.append(i)
+         self._active_mos = result
+      return self._active_mos
+
+   def get_occ_num(self):
+     if self._occ_num is None:
+      if self.mulliken_mo is not None:
+        occ = {}
+        for motype in self.mo_types:
+            occ[motype] = [ mo.eigenvalue for mo in self.mulliken_mo ]
+        if occ != {}:
+          self._occ_num = occ
+     return self._occ_num 
+
+   def get_date(self):
+     if self._date is None:
+       self.find_string("Job started at")
+       pos = self._pos
+       self._date = self.text[pos][16:]
+     return self._date
+
+   def get_multiplicity(self):
+     if self._multiplicity is None:
+       self.find_string("nmul=")
+       pos = self._pos
+       self._multiplicity = int(self.text[pos].split('=')[-1])
+     return self._multiplicity
+
+   def get_num_elec(self):
+     if self._num_elec is None:
+       self.find_string("nelectron=")
+       pos = self._pos
+       self._num_elec= int(self.text[pos].split('=')[1].split()[0])
+     return self._num_elec
+
+   def get_nuclear_energy(self):
+     if self._nuclear_energy is None:
+       self.find_string("Nuclear Repulsion Energy:")
+       pos = self._pos
+       self._nuclear_energy = float(self.text[pos].split(':')[1])
+     return self._nuclear_energy
+
+   def get_title(self):
+     if self._title is None:
+       self.find_string("End of Input")
+       pos = self._pos+3
+       self._title = self.text[pos].strip()
+     return self._title
+
+   def get_cpu_time(self):
+     if self._cpu_time is None:
+       try:
+         self.find_string("Cpu for the Job:")
+       except IndexError:
+         return None
+       pos = self._pos
+       self._cpu_time = self.text[pos].split(':')[1].split()[0]+' s'
+     return self._cpu_time
+
+   def get_dipole(self):
+     if self._dipole is None:
+        self.find_string("Dipole moment")
+        pos = self._pos+2
+        line = self.text[pos].split()
+        self._dipole = []
+        self._dipole.append(float(line[1]))
+        self._dipole.append(float(line[3]))
+        self._dipole.append(float(line[5]))
+     return self._dipole
+
+
+   def get_energies(self):
+       if self._energies is None:
+          self._energies = []
+          self.find_string("Total Energy:")
+          pos = self._pos
+          self._energies.append(float(self.text[pos].split(':')[1]))
+       return self._energies
+
+   def get_pot_energies(self):
+     if self._pot_energies is None:
+        self._pot_energies = [] 
+        self.find_string("Potential energy:")
+        pos = self._pos
+        self._pot_energies.append(float(self.text[pos].split(':')[1]))
+     return self._pot_energies
+
+   def get_kin_energies(self):
+     if self._kin_energies is None:
+        self._kin_energies = [] 
+        self.find_string("Kinetic energy:")
+        pos = self._pos
+        self._kin_energies.append(float(self.text[pos].split(':')[1]))
+     return self._kin_energies
+
+   def get_mo_sets(self):
+      if self._mo_sets is None:
+         self._mo_types = ['VB']
+         posend = {}
+         self.find_string("norb=")
+         norb = int(self.text[self._pos].split("norb=")[1].split()[0])
+         self.find_string("OPTIMIZED ORBITALS")
+         pos = self._pos+3
+         iorb=0
+         vectors = []
+         while(iorb<norb):
+            lorb = len(self.text[pos].split())
+            pos += 1
+            begin = pos
+            for l in range(lorb):
+              iorb+=1
+              pos = begin
+              line = self.text[pos].split()
+              v = orbital()
+              v.set = self.mo_types[0]
+              v.basis = None
+              v.eigenvalue = float(iorb)
+              while len(line) > 0:
+                v.vector.append(float(line[l+1]))
+                pos += 1
+                line = self.text[pos].split()
+              vectors.append(v)
+         self._mo_sets = {}
+         self._mo_sets['VB'] = vectors
+      return self._mo_sets
+         
+   def get_num_alpha(self):
+      if self._num_alpha is None:
+         self._num_alpha = self.num_elec/2 + (self.multiplicity-1)/2
+      return self._num_alpha
+
+   def get_num_beta(self):
+      if self._num_beta is None:
+         self._num_beta = self.num_elec/2 - (self.multiplicity-1)/2
+      return self._num_beta
+
+   def get_determinants_mo_type(self):
+      if self._determinants_mo_type is None:
+         self._determinants_mo_type = self.mo_types[-1]
+      return self._determinants_mo_type
+
+   def get_csf_mo_type(self):
+      if self._csf_mo_type is None:
+         self._csf_mo_type = self.determinants_mo_type
+      return self._csf_mo_type
+
+   def get_determinants(self):
+      if self._determinants is None:
+        determinants = []
+        if self.csf is not None:
+           for csf in self.csf:
+              for new_det in csf.determinants:
+                 determinants.append(new_det)
+        else:
+           pass
+        if determinants != []:
+          self._determinants_mo_type = self.mo_types[-1]
+          self._determinants = determinants
+      return self._determinants
+
+   def get_csf(self):
+      if self._csf is None:
+        csf = []
+        csf_coefficients = []
+        self.find_string('COEFFICIENTS OF DETERMINANTS')
+        self.find_next_string('1')
+        pos = self._pos
+        buffer = self.text[pos]
+        while buffer.strip() != "":
+          tempcsf_a = []
+          tempcsf_b = []
+          buffer = self.text[pos]
+          coef = float(buffer.split()[1])
+          ii=0
+          while ii < self.num_elec:
+            buffer = buffer[24:].split()
+            for i in buffer:
+              ii+=1
+              if ii <= self.num_alpha:
+                tempcsf_a.append(int(i)-1)
+              else:
+                tempcsf_b.append(int(i)-1)
+            pos += 1
+            buffer = self.text[pos]
+          this_csf = CSF()
+          this_csf.append(1.,tempcsf_a,tempcsf_b)
+          csf.append(this_csf)
+          csf_coefficients.append([coef])
+        if csf != []:
+           self._csf = csf
+           self._csf_coefficients = csf_coefficients
+      return self._csf
+
+
+   def get_det_coefficients(self):
+      if self._det_coefficients is None:
+        if self.csf is not None:
+           self._det_coefficients = []
+           csf = self.csf
+           vector = []
+           for state_coef in self.csf_coefficients:
+              for i,c in enumerate(state_coef):
+                 for d in csf[i].coefficients:
+                    vector.append(c*d)
+              self._det_coefficients.append(vector)
+      return self._det_coefficients
+
+   def get_csf_coefficients(self):
+      if self._csf_coefficients is None:
+        self.get_csf()
+      return self._csf_coefficients
+
+   def get_num_states(self):
+      if self._num_states is None:
+        self._num_states=1
+      return self._num_states
+
+   to_remove = []
+   for i, j in local_vars:
+     if i in resultsFile_defined_vars:
+        to_remove.append( (i,j) )
+   for i in to_remove:
+      local_vars.remove(i)
+
+   for i, j in local_vars:
+     if i not in defined_vars:
+        exec build_get_funcs(i) in locals()
+     exec build_property(i,j) in locals()
+   del to_remove, i, j
+
+
+fileTypes.insert(0,xmvbFile)
+  
+if __name__ == '__main__':
+   main(xmvbFile)
+
+###### END #####
+

resultsFile/__init__.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python
+#   resultsFile is a library which allows to read output files of quantum 
+#   chemistry codes and write input files.
+#   Copyright (C) 2007 Anthony SCEMAMA 
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program; if not, write to the Free Software Foundation, Inc.,
+#   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+#   Anthony Scemama
+#   LCPQ - IRSAMC        
+#   Universite Paul Sabatier
+#   118, route de Narbonne      
+#   31062 Toulouse Cedex 4      
+#   scemama@irsamc.ups-tlse.fr 
+
+
+
+"""resultsFile library."""
+
+__author__ = "Anthony SCEMAMA <scemama@irsamc.ups-tlse.fr>"
+__date__   = "20 Nov 2007"
+
+import os
+all = [ "resultsFile", "getFile", "lib", "Modules" ]
+
+for mod in all:
+   try:
+     exec 'from '+mod+' import *'
+   except:
+     print "Error importing module", mod
+     pass
+
+

resultsFile/cython_setup

@@ -0,0 +1,51 @@
+#!/usr/bin/python
+#   resultsFile is a library which allows to read output files of quantum 
+#   chemistry codes and write input files.
+#   Copyright (C) 2007 Anthony SCEMAMA 
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program; if not, write to the Free Software Foundation, Inc.,
+#   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+#   Anthony Scemama
+#   LCPQ - IRSAMC        
+#   Universite Paul Sabatier
+#   118, route de Narbonne      
+#   31062 Toulouse Cedex 4      
+#   scemama@irsamc.ups-tlse.fr 
+
+
+
+from distutils.core import setup
+from distutils.extension import Extension
+from Cython.Distutils import build_ext
+
+
+"""
+./cython_setup build_ext --inplace
+"""
+
+ext_modules = [Extension("resultsFile_cython", ["resultsFile_cython.pyx"])]
+
+import os
+setup(name="resultsFile",
+      version=os.getenv("VERSION","1.0"),
+      author="Anthony Scemama",
+      author_email="scemama@irsamc.ups-tlse.fr",
+      license="gpl-license",
+      description="Module for I/O on Quantum Chemistry files.",
+      packages=["resultsFile","resultsFile.lib","resultsFile.Modules"],
+      cmdclass = {'build_ext': build_ext},
+      ext_modules = ext_modules
+      )
+

resultsFile/getFile.py

@@ -0,0 +1,54 @@
+#!/usr/bin/python
+#   resultsFile is a library which allows to read output files of quantum 
+#   chemistry codes and write input files.
+#   Copyright (C) 2007 Anthony SCEMAMA 
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program; if not, write to the Free Software Foundation, Inc.,
+#   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+#   Anthony Scemama
+#   LCPQ - IRSAMC        
+#   Universite Paul Sabatier
+#   118, route de Narbonne      
+#   31062 Toulouse Cedex 4      
+#   scemama@irsamc.ups-tlse.fr 
+
+
+
+from resultsFile import *
+import sys
+
+# Find fileType
+
+def getFile(name):
+ MyList = fileTypes+[None]
+ for fileType in MyList:
+   try:
+     file = fileType(name)
+     n = file.num_elec
+     if n is None or n <=0 or not isinstance(n,int):
+       raise TypeError
+     break
+   except:
+     pass
+
+ if fileType is None:
+   print "File type not recognized."
+   sys.exit(1)
+
+ return file
+
+if __name__=='__main__':
+  getFile(sys.argv[1])
+

resultsFile/resultsFile.py

@@ -0,0 +1,416 @@
+#!/usr/bin/python
+#   resultsFile is a library which allows to read output files of quantum 
+#   chemistry codes and write input files.
+#   Copyright (C) 2007 Anthony SCEMAMA 
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program; if not, write to the Free Software Foundation, Inc.,
+#   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+#   Anthony Scemama
+#   LCPQ - IRSAMC        
+#   Universite Paul Sabatier
+#   118, route de Narbonne      
+#   31062 Toulouse Cedex 4      
+#   scemama@irsamc.ups-tlse.fr 
+
+
+from lib import *
+import lib.basis as Basis
+import sys
+import copy
+
+fileTypes = []
+
+local_vars = [ \
+   # File properties
+    ( 'filename'     , "Name of the results file."),
+    ( 'text'         , "Text of the results file."),
+    ( 'pos'          , "Position in the results file."),
+    ( 'date'         , "When the calculation was performed."),
+    ( 'version'      , "Version of the code generating the file."),
+    ( 'author'       , "Who ran the calculation."),
+    ( 'machine'      , "Machine where the calculation was run."),
+    ( 'memory'       , "Requested memory for the calculation."),
+    ( 'disk'         , "Requested disk space for the calculation."),
+    ( 'num_proc'     , "Number of processors used."),
+    ( 'cpu_time'     , "CPU time."),
+   # General properties
+    ( 'title'         , "Title of the run."),
+    ( 'options'       , "Options given in the input file."),
+    ( 'units'         , "Units for the geometry (au or angstroms)."),
+    ( 'methods'       , "List of calculation methods."),
+    ( 'spin_restrict' , "Open-shell or closed-shell calculations."),
+    ( 'conv_threshs'  , "List of convergence thresholds."),
+    ( 'energies'      , "List of energies."),
+    ( 'one_e_energies', "List of one electron energies."),
+    ( 'two_e_energies', "List of two electron energies."),
+    ( 'ee_pot_energies',"List of electron-electron potential energies."),
+    ( 'Ne_pot_energies',"List of nucleus-electron potential energies."),
+    ( 'pot_energies'  , "List of potential energies."),
+    ( 'kin_energies'  , "List of kinetic energies."),
+    ( 'virials'       , "Virial ratios."),
+    ( 'mulliken_mo'   , "Mulliken atomic population in each MO."),
+    ( 'mulliken_ao'   , "Mulliken atomic population in each AO."),
+    ( 'lowdin_ao'     , "Lowdin atomic population in each AO."),
+    ( 'mulliken_atom' , "Mulliken atomic population."),
+    ( 'lowdin_atom'   , "Lowdin atomic population."),
+    ( 'dipole'        , "Dipole moment"),
+    ( 'quadrupole'    , "Quadrupole moment"),
+    ( 'num_states'    , "Number of electronic states"),
+   # Geometry properties
+    ( 'point_group'   , "Symmetry used."),
+    ( 'geometry'      , "Atom types and coordinates."),
+    ( 'symmetries'    , "Irreducible representations"),
+    ( 'num_elec'      , "Number of electrons."),
+    ( 'num_alpha'     , "Number of Alpha electrons."),
+    ( 'num_beta'      , "Number of Beta electrons."),
+    ( 'charge'        , "Charge of the system."),
+    ( 'multiplicity'  , "Spin multiplicity of the system."),
+    ( 'nuclear_energy', "Repulsion of the nuclei."),
+    ( 'gradient_energy', "Gradient of the Energy wrt nucl coord."),
+   # Basis set
+    ( 'basis'         , "Basis set definition"),
+    ( 'uncontracted_basis', "Uncontracted Basis set"),
+   # Orbitals
+    ( 'mo_sets'       , "List of molecular orbitals"),
+    ( 'mo_types'      , "Types of molecular orbitals (canonical, natural,...)"),
+    ( 'occ_num'       , "Occupation numbers"),
+    ( 'uncontracted_mo_sets', "List of molecular orbitals in the uncontracted basis set."),
+   # Determinants
+    ( 'closed_mos'  , "Closed shell molecular orbitals"),
+    ( 'active_mos'  , "Active molecular orbitals"),
+    ( 'virtual_mos'  , "Virtual molecular orbitals"),
+    ( 'csf'           , "List of Configuration State Functions"),
+    ( 'determinants'  , "List of Determinants"),
+    ( 'csf_mo_type'  , "MO type of the determinants"),
+    ( 'determinants_mo_type'  , "MO type of the determinants"),
+    ( 'csf_coefficients', "Coefficients of the CSFs"),
+    ( 'det_coefficients', "Coefficients of the determinants"),
+   # Integrals
+    ( 'one_e_int_ao'     , "One electron integrals in AO basis"),
+    ( 'two_e_int_ao'     , "Two electron integrals in AO basis"),
+    ( 'one_e_int_mo'     , "One electron integrals in MO basis"),
+    ( 'two_e_int_mo'     , "Two electron integrals in MO basis"),
+   ]
+
+resultsFile_defined_vars = ["text","uncontracted_basis", "uncontracted_mo_sets"]
+
+class resultsFile(object):
+   """ Class containing the definition of files.
+   """
+
+   local_vars = list(local_vars)
+   defined_vars = list(resultsFile_defined_vars)
+
+   def __init__(self,name):
+       """All local variables are set to None, except filename.
+       """
+       for var, doc in local_vars:
+          setattr(self,'_'+var,None)
+       self._filename = name
+
+
+   def get_text(self):
+       """Reads the whole file.
+       """
+       if self._text is None:
+          try:
+             file = open(self.filename,"r")
+             self._text = file.readlines()
+          except IOError:
+             print "Unable to open "+self.filename
+             sys.exit(1)
+          file.close()
+       return self._text
+
+   def get_uncontracted_basis(self):
+     if self._uncontracted_basis is None:
+       try:
+         from resultsFile_cython import get_uncontracted_basis as f
+         has_cython = True
+       except ImportError:
+         has_cython = False
+       basis = self.basis
+       if has_cython:
+         self._uncontracted_basis = f(basis)
+       else:
+         uncontr = []
+         for contr in basis:
+            for b in contr.prim:
+               uncontr.append(b)
+         self._uncontracted_basis = uncontr
+     return self._uncontracted_basis
+
+   def get_uncontracted_mo_sets(self):
+     if self._uncontracted_mo_sets is None:
+       try:
+         from resultsFile_cython import get_uncontracted_mo_sets as f
+         has_cython = True
+       except ImportError:
+         has_cython = False
+       if has_cython:
+         self._uncontracted_mo_sets = f(self.basis,
+                         self.uncontracted_basis,
+                         self.mo_sets,
+                         self.mo_types)
+       else:
+         uncontr = {}
+         basis = self.basis
+         for motype in self.mo_types:
+           uncontr[motype] = []
+           for mo in self.mo_sets[motype]:
+             lenmovector = len(mo.vector)
+             monew = orbital()
+             monew.basis = self.uncontracted_basis
+             monew.eigenvalue = mo.eigenvalue
+             monew.set = motype
+             v = []
+             for i, contr in enumerate(basis):
+               if i<lenmovector:
+                 ci = mo.vector[i]
+                 if ci == 0.:
+                   for p in range(len(contr.prim)):
+                      v.append(0.)
+                 else:
+                   for p, c in zip(contr.prim,contr.coef):
+                      v.append(c*ci/p.norm)
+             monew.vector = v
+             uncontr[motype].append(monew)
+         self._uncontracted_mo_sets = uncontr
+       #endif
+     return self._uncontracted_mo_sets
+
+   def clean_contractions(self):
+     basis = self.basis
+     newbasis = []
+     idx = range(len(basis))
+     for k,b1 in enumerate(basis):
+       addBasis=True
+       for l, b2 in enumerate(basis[:k]):
+         if b2 == b1:
+           idx[k] = l
+           addBasis=False
+           break
+       if addBasis:
+         newbasis.append(b1)
+     self._basis = newbasis 
+
+     mo_sets = self.mo_sets
+     for motype in self.mo_types:
+       for mo in mo_sets[motype]:
+         lenmovector = len(mo.vector)
+         newvec = [None for i in idx]
+         for i in idx:
+           newvec[i] = 0.
+         for k,l in enumerate(idx):
+           if k < lenmovector:
+             newvec[l] += mo.vector[k]
+         mo.vector = []
+         for c in newvec:
+           if c is not None:
+             mo.vector.append(c)
+
+   def clean_uncontractions(self):
+     basis = self.uncontracted_basis
+     newbasis = []
+     idx = range(len(basis))
+     for k,b1 in enumerate(basis):
+       addBasis=True
+       for l, b2 in enumerate(basis[:k]):
+         if b2 == b1:
+           idx[k] = l
+           addBasis=False
+           break
+       if addBasis:
+         newbasis.append(b1)
+     self._uncontracted_basis = newbasis 
+
+     mo_sets = self.uncontracted_mo_sets
+     for motype in self.mo_types:
+       for mo in mo_sets[motype]:
+         lenmovector = len(mo.vector)
+         newvec = [None for i in idx]
+         for i in idx:
+           newvec[i] = 0.
+         for k,l in enumerate(idx):
+           if k < lenmovector:
+             newvec[l] += mo.vector[k]
+         mo.vector = []
+         for c in newvec:
+           if c is not None:
+             mo.vector.append(c)
+       
+   def convert_to_cartesian(self):
+     basis = self.basis
+     newbasis = []
+     idx = range(len(basis))
+     map = []
+     weight = []
+     for i,b in enumerate(basis):
+       l, m = Basis.get_lm(b.sym)
+       if l is None:
+         newbasis.append(b)
+         map.append(i)
+         weight.append(1.)
+       else:
+         powers, coefs = xyz_from_lm(l,m)
+         for j,prim in enumerate(b.prim):
+           b.coef[j] /= prim.norm
+         for c, p in zip(coefs, powers):
+           contr = copy.deepcopy(b)
+           sym = ''
+           for l,letter in enumerate('xyz'):
+             sym += p[l]*letter
+           contr.sym = sym
+           for j,prim in enumerate(contr.prim):
+             prim.sym = sym
+             contr.coef[j] *= prim.norm
+           newbasis.append(contr)
+           map.append(i)
+           weight.append(c)
+
+     mo_sets = self.mo_sets
+     for motype in self.mo_types:
+       for mo in mo_sets[motype]:
+         newvec = []
+         vec = mo.vector
+         for i,w in zip(map,weight):
+           newvec.append(vec[i]*w)
+         mo.vector = newvec
+
+     same_as = {}
+     for i,b1 in enumerate(newbasis):
+       for j,b2 in enumerate(newbasis[:i]):
+         if b1 == b2:
+          same_as[i] = j
+          weight[j] += weight[i]
+          break
+     to_remove = same_as.keys()
+     to_remove.sort()
+     to_remove.reverse()
+     for i in to_remove:
+       newbasis.pop(i)
+       weight.pop(i)
+       map.pop(i)
+
+
+     for motype in self.mo_types:
+       for mo in mo_sets[motype]:
+         for i in to_remove:
+           index = same_as[i]
+           value = mo.vector.pop(i)
+           mo.vector[index] += value
+
+     self._basis = newbasis
+     self._mo_sets = mo_sets
+
+   def find_string(self,chars):
+       """Finds the 1st occurence of chars.
+       """
+       self._pos = 0
+       self.find_next_string(chars)
+
+   def find_last_string(self,chars):
+       """Finds the 1st occurence of chars.
+       """
+       self._pos = len(self.text)-1
+       self.find_prev_string(chars)
+
+   def find_next_string(self,chars):
+       """Finds the next occurence of chars.
+       """
+       pos  = self._pos
+       text = self.text
+       found = False
+       while not found and pos < len(text):
+          if chars in text[pos]:
+             found = True
+          else:
+             pos += 1
+       if not found:
+          raise IndexError
+       self._pos = pos
+
+   def find_prev_string(self,chars):
+       """Finds the next occurence of chars.
+       """
+       pos  = self._pos
+       text = self.text
+       found = False
+       while not found and pos < len(text):
+          if chars in text[pos]:
+             found = True
+          else:
+             pos -= 1
+       if not found:
+          raise IndexError
+       self._pos = pos
+
+
+   for i, j in local_vars:
+      if i not in defined_vars:
+         exec build_get_funcs(i) in locals()
+      exec build_property(i,j) in locals()
+   del i,j
+
+
+def main(fileType):
+   import getopt
+   print """
+    resultsFile version 1.0, Copyright (C) 2007 Anthony SCEMAMA
+    resultsFile comes with ABSOLUTELY NO WARRANTY; for details see the
+    gpl-license file.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; for details see the gpl-license file."""
+
+   full_list = fileType.defined_vars + resultsFile.defined_vars
+   try:
+     opts, args = getopt.gnu_getopt(sys.argv[1:],'',full_list)
+   except getopt.GetoptError:
+     args = []
+   if len(args) == 0:
+     usage(fileType)
+     sys.exit(2)
+   f = fileType(args[0])
+   for o,a in opts:
+     print o[2:]
+     print ''.join(['-' for k in o[2:]])
+     PrettyPrint = prettyPrint
+     exec 'PrettyPrint(f.'+o[2:]+')' in locals()
+     print ""
+   sys.exit(0)
+
+def usage(fileType):
+   print ""
+   print "Usage:"
+   print "------"
+   print ""
+   print sys.argv[0], '[options] file'
+   print ""
+   print "Options:"
+   print "--------"
+   print ""
+   for o in fileType.defined_vars + resultsFile.defined_vars:
+     line = ("  --"+o).ljust(30)+':  '
+     for l in fileType.local_vars:
+       if l[0] == o:
+         line += l[1]
+         break
+     print line
+   print ""
+
+   
+if __name__ == '__main__':
+   main(resultsFile)
+

resultsFile/resultsFile_cython.pyx

@@ -0,0 +1,241 @@
+#!/usr/bin/python
+#   resultsFile is a library which allows to read output files of quantum 
+#   chemistry codes and write input files.
+#   Copyright (C) 2007 Anthony SCEMAMA 
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program; if not, write to the Free Software Foundation, Inc.,
+#   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+#   Anthony Scemama
+#   LCPQ - IRSAMC        
+#   Universite Paul Sabatier
+#   118, route de Narbonne      
+#   31062 Toulouse Cedex 4      
+#   scemama@irsamc.ups-tlse.fr 
+
+
+from lib import *
+import lib.basis as Basis
+
+def get_uncontracted_basis(basis):
+   uncontr = []
+   for contr in basis:
+      for b in contr.prim:
+         uncontr.append(b)
+   return uncontr
+
+def get_uncontracted_mo_sets(basis,uncontracted_basis,mo_sets,mo_types):
+   cdef dict uncontr = {}
+   cdef int lenmovector
+   cdef int lenbasis = len(basis)
+   cdef double ci
+   cdef int i, j
+   for motype in mo_types:
+     uncontr[motype] = []
+     for mo in mo_sets[motype]:
+       lenmovector = len(mo.vector)
+       monew = orbital()
+       monew.basis = uncontracted_basis
+       monew.eigenvalue = mo.eigenvalue
+       monew.set = motype
+       v = []
+       for i in range(lenbasis):
+         contr = basis[i]
+         if i<lenmovector:
+           ci = mo.vector[i]
+           if ci == 0.:
+             for j in range(len(contr.prim)):
+                v.append(0.)
+           else:
+             for p, c in zip(contr.prim,contr.coef):
+                v.append(c*ci/p.norm)
+       monew.vector = v
+       uncontr[motype].append(monew)
+   return uncontr
+
+
+def clean_contractions(basis):
+  newbasis = []
+  cdef int i, k, l, lenmovector
+  idx = range(len(basis))
+  for k,b1 in enumerate(basis):
+    addBasis=True
+    for l, b2 in enumerate(basis[:k]):
+      if b2 == b1:
+        idx[k] = l
+        addBasis=False
+        break
+    if addBasis:
+      newbasis.append(b1)
+  self._basis = newbasis 
+
+  mo_sets = self.mo_sets
+  for motype in self.mo_types:
+    for mo in mo_sets[motype]:
+      lenmovector = len(mo.vector)
+      newvec = [None for i in idx]
+      for i in idx:
+        newvec[i] = 0.
+      for k,l in enumerate(idx):
+        if k < lenmovector:
+          newvec[l] += mo.vector[k]
+      mo.vector = []
+      for c in newvec:
+        if c is not None:
+          mo.vector.append(c)
+
+#  def clean_uncontractions(self):
+#    basis = self.uncontracted_basis
+#    newbasis = []
+#    idx = range(len(basis))
+#    for k,b1 in enumerate(basis):
+#      addBasis=True
+#      for l, b2 in enumerate(basis[:k]):
+#        if b2 == b1:
+#          idx[k] = l
+#          addBasis=False
+#          break
+#      if addBasis:
+#        newbasis.append(b1)
+#    self._uncontracted_basis = newbasis 
+
+#    mo_sets = self.uncontracted_mo_sets
+#    for motype in self.mo_types:
+#      for mo in mo_sets[motype]:
+#        lenmovector = len(mo.vector)
+#        newvec = [None for i in idx]
+#        for i in idx:
+#          newvec[i] = 0.
+#        for k,l in enumerate(idx):
+#          if k < lenmovector:
+#            newvec[l] += mo.vector[k]
+#        mo.vector = []
+#        for c in newvec:
+#          if c is not None:
+#            mo.vector.append(c)
+#      
+#  def convert_to_cartesian(self):
+#    basis = self.basis
+#    newbasis = []
+#    idx = range(len(basis))
+#    map = []
+#    weight = []
+#    for i,b in enumerate(basis):
+#      l, m = Basis.get_lm(b.sym)
+#      if l is None:
+#        newbasis.append(b)
+#        map.append(i)
+#        weight.append(1.)
+#      else:
+#        powers, coefs = xyz_from_lm(l,m)
+#        for j,prim in enumerate(b.prim):
+#          b.coef[j] /= prim.norm
+#        for c, p in zip(coefs, powers):
+#          contr = copy.deepcopy(b)
+#          sym = ''
+#          for l,letter in enumerate('xyz'):
+#            sym += p[l]*letter
+#          contr.sym = sym
+#          for j,prim in enumerate(contr.prim):
+#            prim.sym = sym
+#            contr.coef[j] *= prim.norm
+#          newbasis.append(contr)
+#          map.append(i)
+#          weight.append(c)
+
+#    mo_sets = self.mo_sets
+#    for motype in self.mo_types:
+#      for mo in mo_sets[motype]:
+#        newvec = []
+#        vec = mo.vector
+#        for i,w in zip(map,weight):
+#          newvec.append(vec[i]*w)
+#        mo.vector = newvec
+
+#    same_as = {}
+#    for i,b1 in enumerate(newbasis):
+#      for j,b2 in enumerate(newbasis[:i]):
+#        if b1 == b2:
+#         same_as[i] = j
+#         weight[j] += weight[i]
+#         break
+#    to_remove = same_as.keys()
+#    to_remove.sort()
+#    to_remove.reverse()
+#    for i in to_remove:
+#      newbasis.pop(i)
+#      weight.pop(i)
+#      map.pop(i)
+
+
+#    for motype in self.mo_types:
+#      for mo in mo_sets[motype]:
+#        for i in to_remove:
+#          index = same_as[i]
+#          value = mo.vector.pop(i)
+#          mo.vector[index] += value
+
+#    self._basis = newbasis
+#    self._mo_sets = mo_sets
+
+#  def find_string(self,chars):
+#      """Finds the 1st occurence of chars.
+#      """
+#      self._pos = 0
+#      self.find_next_string(chars)
+
+#  def find_last_string(self,chars):
+#      """Finds the 1st occurence of chars.
+#      """
+#      self._pos = len(self.text)-1
+#      self.find_prev_string(chars)
+
+#  def find_next_string(self,chars):
+#      """Finds the next occurence of chars.
+#      """
+#      pos  = self._pos
+#      text = self.text
+#      found = False
+#      while not found and pos < len(text):
+#         if chars in text[pos]:
+#            found = True
+#         else:
+#            pos += 1
+#      if not found:
+#         raise IndexError
+#      self._pos = pos
+
+#  def find_prev_string(self,chars):
+#      """Finds the next occurence of chars.
+#      """
+#      pos  = self._pos
+#      text = self.text
+#      found = False
+#      while not found and pos < len(text):
+#         if chars in text[pos]:
+#            found = True
+#         else:
+#            pos -= 1
+#      if not found:
+#         raise IndexError
+#      self._pos = pos
+
+
+#  for i, j in local_vars:
+#     if i not in defined_vars:
+#        exec build_get_funcs(i) in locals()
+#     exec build_property(i,j) in locals()
+#  del i,j
+
+

setup.py

@@ -0,0 +1,54 @@
+#!/usr/bin/python
+#   resultsFile is a library which allows to read output files of quantum 
+#   chemistry codes and write input files.
+#   Copyright (C) 2007 Anthony SCEMAMA 
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation; either version 2 of the License, or
+#   (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program; if not, write to the Free Software Foundation, Inc.,
+#   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+#   Anthony Scemama
+#   LCPQ - IRSAMC        
+#   Universite Paul Sabatier
+#   118, route de Narbonne      
+#   31062 Toulouse Cedex 4      
+#   scemama@irsamc.ups-tlse.fr 
+
+
+
+from distutils.core import setup
+
+"""
+- To create a source distribution, run:
+
+python setup.py sdist
+
+- To install the module, run:
+
+python setup.py install
+
+- To create an rpm distribution
+
+python setup.py bdist_rpm
+"""
+
+import os
+setup(name="resultsFile",
+      version=os.getenv("VERSION","1.0"),
+      author="Anthony Scemama",
+      author_email="scemama@irsamc.ups-tlse.fr",
+      license="gpl-license",
+      description="Module for I/O on Quantum Chemistry files.",
+      packages=["resultsFile","resultsFile.lib","resultsFile.Modules"]
+      )
+