Crystal calculation works up until Linear now.

Author: bbusemeyer

TODO.md

@@ -1,4 +1,7 @@
 - [ ] Bad use case: accidentally putting the same writer for multiple managers
       will screw up the process because the first time the writer writes, it delares itself 'done'
 - [ ] Manage path setup with setup script.
+  - crystal, properties, pyscf, and qwalk executible names and locations.
 - [ ] Compirable defaults between PySCF and Crystal are not the same.
+- [ ] Cannot yet do different paths with QMC and crystal because the basis and the orb file needs to be in the same place.
+  - May need to have the crystal manager export the results to the same directory (this means there are redundant files then).

crystal2qmc.py

@@ -369,7 +369,7 @@ def write_slater(basis,eigsys,kpt,outfn,orbfn,basisfn,maxmo_spin=-1):
       "  " + " ".join(dnorblines),
       "}"
     ]
-  with open(outfn) as outf:
+  with open(outfn,'w') as outf:
     outf.write("\n".join(outlines))
 
 ###############################################################################
@@ -759,21 +759,23 @@ def convert_crystal(
   #  All the files that will get produced.
   files={
       'kpts':[],
-      'basis':basename+".basis",
-      'jastrow':basename+".jast2",
+      'basis':base+".basis",
+      'jastrow2':base+".jast2",
+      'orbplot':{},
       'orb':{},
       'sys':{},
       'slater':{}
     }
   write_basis(basis,ions,files['basis'])
-  write_jast2(lat_parm,ions,files['jast2'])
+  write_jast2(lat_parm,ions,files['jastrow2'])
 
   for kpt in eigsys['kpt_coords']:
     if eigsys['ikpt_iscmpx'][kpt] and kset=='real': continue
     files['kpts'].append(kpt)
-    files['slater'][kpt]="%s_%d.slater"%(basename,eigsys['kpt_index'][kpt])
-    files['orb'][kpt]="%s_%d.orb"%(basename,eigsys['kpt_index'][kpt])
-    files['sys'][kpt]="%s_%d.sys"%(basename,eigsys['kpt_index'][kpt])
+    files['orbplot'][kpt]="%s_%d.plot"%(base,eigsys['kpt_index'][kpt])
+    files['slater'][kpt]="%s_%d.slater"%(base,eigsys['kpt_index'][kpt])
+    files['orb'][kpt]="%s_%d.orb"%(base,eigsys['kpt_index'][kpt])
+    files['sys'][kpt]="%s_%d.sys"%(base,eigsys['kpt_index'][kpt])
     write_slater(basis,eigsys,kpt,
         outfn=files['slater'][kpt],
         orbfn=files['orb'][kpt],

linear.py

@@ -3,26 +3,36 @@
 ####################################################
 class LinearWriter:
   def __init__(self,options={}):
-    self.qmc_type='Linear optimization'
-    self.sysfiles=['qw_000.sys']
-    self.wffiles=[]
-    #self.basenames=['qw_000']
-    self.completed=False
+    ''' Object for producing input into a variance optimization QWalk run. 
+    Args:
+      options (dict): editable options are as follows.
+        trialfunc (str): system and trial wavefunction section.
+        errtol (float): tolerance for the variance. 
+        minblocks (int): minimum number of VMC steps to take.
+        iterations (int): number of VMC steps to attempt.
+        macro_iterations (int): Number of optimize calls to make.
+    '''
+    self.trialfunc=''
     self.errtol=10
     self.minblocks=0
     self.total_nstep=2048*4 # 2048 gets stuck pretty often.
     self.total_fit=2048
     self.qmc_abr='energy'
+
+    self.qmc_type='Linear optimization'
+    self.qmc_abr='energy'
+    self.completed=False
     self.set_options(options)
+
   #-----------------------------------------------
-    
   def set_options(self, d):
     selfdict=self.__dict__
     for k in d.keys():
       if not k in selfdict.keys():
         print("Error:",k,"not a keyword for LinearWriter")
         raise InputError
       selfdict[k]=d[k]
+
   #-----------------------------------------------
   def is_consistent(self,other):
     #In principle we should check for the files, but 
@@ -45,21 +55,18 @@ def is_consistent(self,other):
     return True
 
   #-----------------------------------------------
-  def qwalk_input(self,infiles):
-    nfiles=len(infiles)
-    assert nfiles==len(self.sysfiles), "Check sysfiles"
-    assert nfiles==len(self.wffiles), "Check wffiles"
-
-    for inp,sys,wf in zip(infiles,self.sysfiles,self.wffiles):
-      
-      with open(inp,'w') as f:
+  def qwalk_input(self,infile):
+    if self.trialfunc=='':
+      print(self.__class__.__name__,": Trial function not ready. Postponing input file generation.")
+      self.completed=False
+    else:
+      with open(infile,'w') as f:
         f.write("method { linear \n")
         f.write("total_nstep %i \n"%self.total_nstep)
         f.write("total_fit %i \n"%self.total_fit)
         f.write("}\n")
-        f.write("include "+sys+"\n")
-        f.write("trialfunc { include %s\n"%wf)
-        f.write("}\n")
+        f.write(self.trialfunc)
+
     self.completed=True
 
 

manager.py

@@ -17,7 +17,7 @@
 ######################################################################
 # Misc functions. 
 ######################################################################
-def resolve_status(runner,reader,outfile, method='not_defined'):
+def resolve_status(runner,reader,outfile):
   #Check if the reader is done
   if reader.completed:
     return 'done'
@@ -67,19 +67,44 @@ def update_attributes(copyto,copyfrom,skip_keys=[],take_keys=[]):
       pass
   return updated
 
+def seperate_jastrow(wffile,optimizebasis=False):
+  ''' Seperate the jastrow section of a QWalk wave function file.'''
+  # Copied from utils/seperate_jastrow TODO: no copy, bad
+  wff=open(wffile,'r')
+  tokens=wff.read().split('\n')
+  in_jastrow=False
+  nopen=0
+  nclose=0
+  jastlines=[]
+  for line in tokens:
+    if 'jastrow2' in line.lower():
+      in_jastrow=True
+    if in_jastrow:
+      if not optimizebasis and 'optimizebasis' in line.lower():
+        continue
+      nopen+=line.count("{")
+      nclose+=line.count("}")
+    if in_jastrow and nopen >= nclose:
+      jastlines.append(line)
+  return '\n'.join(jastlines)
+
 ######################################################################
 # Manager classes.
 #######################################################################
 class CrystalManager:
   """ Internal class managing process of running a DFT job though crystal.
   Has authority over file names associated with this task."""
-  def __init__(self,writer,runner,name='crystal_run',path=None,crys_reader=None,prop_reader=None,
+  def __init__(self,writer,runner,creader=None,name='crystal_run',path=None,
+      preader=None,prunner=None,
       trylev=False,bundle=False,max_restarts=5):
     ''' CrystalManager manages the writing of a Crystal input file, it's running, and keeping track of the results.
     Args:
       writer (PySCFWriter): writer for input.
       reader (PySCFReader): to read PySCF output.
       runner (runner object): to run job.
+      creader (CrystalReader): Reads the crystal results, (None implies use default reader).
+      preader (PropertiesReader): Reads properties results, if any (None implies use default reader).
+      prunner (runner object): run properties if needed (None implies use same runner as crystal).
       name (str): identifier for this job. This names the files associated with run.
       trylev (bool): When restarting use LEVSHIFT option to encourage convergence, then do a rerun without LEVSHIFT.
       bundle (bool): Whether you'll use a bundling tool to run these jobs.
@@ -99,11 +124,14 @@ def __init__(self,writer,runner,name='crystal_run',path=None,crys_reader=None,pr
 
     print(self.logname,": initializing")
 
+    # Handle reader and runner defaults.
     self.writer=writer
-    if crys_reader is None: self.creader=crystal.CrystalReader()
-    else: self.creader=crys_reader
-    if prop_reader is None: self.preader=propertiesreader.PropertiesReader()
-    else: self.preader=prop_reader
+    if creader is None: self.creader=crystal.CrystalReader()
+    else: self.creader=creader
+    if preader is None: self.preader=propertiesreader.PropertiesReader()
+    else: self.preader=preader
+    if prunner is None: self.prunner=runner
+    else: self.prunner=prunner
     if runner is None: self.runner=RunnerPBS()
     else: self.runner=runner
 
@@ -143,15 +171,18 @@ def recover(self,other):
     # This is because you are taking the attributes from the older instance, and copying into the new instance.
 
     update_attributes(copyto=self,copyfrom=other,
-        skip_keys=['writer','runner','creader','preader','lev','savebroy',
+        skip_keys=['writer','runner','creader','preader','prunner','lev','savebroy',
                    'path','logname','name',
                    'trylev','max_restarts','bundle'],
-        take_keys=['restarts','completed'])
+        take_keys=['restarts','completed','qwfiles'])
 
     # Update queue settings, but save queue information.
     update_attributes(copyto=self.runner,copyfrom=other.runner,
         skip_keys=['queue','walltime','np','nn','jobname'],
         take_keys=['queueid'])
+    update_attributes(copyto=self.runner,copyfrom=other.runner,
+        skip_keys=['queue','walltime','np','nn','jobname'],
+        take_keys=['queueid'])
 
     update_attributes(copyto=self.creader,copyfrom=other.creader,
         skip_keys=[],
@@ -185,7 +216,7 @@ def nextstep(self):
         self.writer.write_prop_input(self.propinpfn)
 
     # Check on the CRYSTAL run
-    status=resolve_status(self.runner,self.creader,self.crysoutfn,method='crystal')
+    status=resolve_status(self.runner,self.creader,self.crysoutfn)
     print(self.logname,": status= %s"%(status))
 
     if status=="not_started":
@@ -237,7 +268,7 @@ def nextstep(self):
     # Ready for bundler or else just submit the jobs as needed.
     if self.bundle:
       self.scriptfile="%s.run"%self.name
-      self.bundle_ready=self.runner.script(self.scriptfile,self.driverfn)
+      self.bundle_ready=self.runner.script(self.scriptfile)
     else:
       qsubfile=self.runner.submit()
 
@@ -284,16 +315,38 @@ def export_qwalk(self):
     ''' Export QWalk input files into current directory.'''
     if len(self.qwfiles)==0:
       self.nextstep()
+
       if not self.completed:
         return False
-      else:
-        print(self.logname,": %s generating QWalk files."%self.name)
-        cwd=os.getcwd()
-        os.chdir(self.path)
-        self.qwfiles=crystal2qmc.convert_crystal(base=self.name)
-        os.chdir(cwd)
+
+      cwd=os.getcwd()
+      os.chdir(self.path)
+
+      print(self.logname,": %s attempting to generate QWalk files."%self.name)
+
+      # Check on the properties run
+      status=resolve_status(self.prunner,self.preader,self.propoutfn)
+      print(self.logname,": properties status= %s"%(status))
+      if status=='not_started':
+        self.prunner.add_command("cp %s INPUT"%self.propinpfn)
+        self.prunner.add_task("Pproperties &> %s"%self.propoutfn)
+
+        if self.bundle:
+          self.scriptfile="%s.run"%self.name
+          self.bundle_ready=self.prunner.script(self.scriptfile,self.driverfn)
+        else:
+          qsubfile=self.runner.submit()
+      elif status=='ready_for_analysis':
+        self.preader.collect(self.propoutfn)
+
+      if self.preader.completed:
+        self.qwfiles=crystal2qmc.convert_crystal(base=self.name,propoutfn=self.propoutfn)
+        print(self.logname,": crystal converted to QWalk input.")
+
+      os.chdir(cwd)
     with open(self.path+self.pickle,'wb') as outf:
       pkl.dump(self,outf)
+
     return True
 
   #----------------------------------------
@@ -381,7 +434,7 @@ def nextstep(self):
     if not self.writer.completed:
       self.writer.pyscf_input(self.driverfn,self.chkfile)
 
-    status=resolve_status(self.runner,self.reader,self.outfile, 'pyscf')
+    status=resolve_status(self.runner,self.reader,self.outfile)
     print(self.logname,": %s status= %s"%(self.name,status))
 
     if status=="not_started":
@@ -429,20 +482,19 @@ def export_qwalk(self):
       self.nextstep()
       if not self.completed:
         return False
-      else:
-        print(self.logname,": %s generating QWalk files."%self.name)
-        cwd=os.getcwd()
-        os.chdir(self.path)
-        self.qwfiles=pyscf2qwalk.print_qwalk_chkfile(self.chkfile)
-        os.chdir(cwd)
+      print(self.logname,": %s generating QWalk files."%self.name)
+      cwd=os.getcwd()
+      os.chdir(self.path)
+      self.qwfiles=pyscf2qwalk.print_qwalk_chkfile(self.chkfile)
+      os.chdir(cwd)
     with open(self.path+self.pickle,'wb') as outf:
       pkl.dump(self,outf)
     return True
 
   #----------------------------------------
   def status(self):
     ''' Determine the course of action based on info from reader and runner.'''
-    current_status = resolve_status(self.runner,self.reader,self.outfile, 'pyscf')
+    current_status = resolve_status(self.runner,self.reader,self.outfile)
     if current_status == 'done':
       return 'ok'
     elif current_status == 'retry':
@@ -492,6 +544,7 @@ def __init__(self,writer,reader,runner=None,trialfunc=None,
     self.bundle_ready=False
     self.infile="%s.%s"%(name,writer.qmc_abr)
     self.outfile="%s.o"%self.infile
+    self.qwfiles={}
     self.stdout="%s.out"%self.infile
 
     # Handle old results if present.
@@ -584,7 +637,7 @@ def nextstep(self):
         self.completed=True
       else:
         print(self.logname,": %s status= %s, attempting rerun."%(self.name,status))
-        exestr="%s %s"%' '.join(self.qwalk,self.infile)
+        exestr="%s %s"%' '.join((self.qwalk,self.infile))
         exestr+=" &> %s.out"%self.infile[-1]
         self.runner.add_task(exestr)
     elif status=='done':
@@ -595,7 +648,7 @@ def nextstep(self):
     # Ready for bundler or else just submit the jobs as needed.
     if self.bundle:
       self.scriptfile="%s.run"%self.name
-      self.bundle_ready=self.runner.script(self.scriptfile,self.driverfn)
+      self.bundle_ready=self.runner.script(self.scriptfile)
     else:
       qsubfile=self.runner.submit()
 
@@ -639,3 +692,27 @@ def collect(self):
     with open(self.path+self.pickle,'wb') as outf:
       pkl.dump(self,outf)
 
+  #----------------------------------------
+  def export_qwalk(self):
+    ''' Extract jastrow from the optimization run and return that file name.'''
+    # Theoretically more than just Jastrow can be provided, but practically that's the only type of wavefunction we tend to export.
+
+    assert self.writer.qmc_abr!='dmc',"DMC doesn't provide a wave function."
+
+    if len(self.qwfiles)==0:
+      self.nextstep()
+      if not self.completed:
+        return False
+      print(self.logname,": %s generating QWalk files."%self.name)
+      cwd=os.getcwd()
+      os.chdir(self.path)
+      self.qwfiles['wfout']="%s.wfout"%self.infile
+      newjast=seperate_jastrow(self.qwfiles['wfout'])
+      self.qwfiles['jastrow2']="%s.jast"%self.infile
+      with open(self.qwfiles['jastrow2'],'w') as outf:
+        outf.write(newjast)
+      os.chdir(cwd)
+
+    with open(self.path+self.pickle,'wb') as outf:
+      pkl.dump(self,outf)
+    return True

propertiesreader.py

@@ -8,27 +8,8 @@ def __init__(self):
     self.out={}
 #-------------------------------------------------      
   def collect(self,outfilename):
-    """ Collect results from output."""
+    """ Just check that results are there. The actual data is too large to want to store."""
     if os.path.isfile("GRED.DAT") and os.path.isfile("KRED.DAT"):
-      info, lat_parm, ions, basis, pseudo = read_gred()
-      eigsys = read_kred(info,basis)
-
-      if eigsys['nspin'] > 1:
-        eigsys['totspin'] = read_outputfile(outfilename)
-      else:
-        eigsys['totspin'] = 0
-
-      # Some of this info is redundant with the input. 
-      # But having all here makes conversion simpler.
-      # This data can be fed directly into the write_files in crystal2qmc.
-      self.out.update({
-          'lat_parm':lat_parm,
-          'ions':ions,
-          'basis':basis,
-          'pseudo':pseudo,
-          'eigsys':eigsys
-        })
-
       self.completed=True
     else:
       self.completed=False

tests/simple_test/simple_test.py

@@ -10,6 +10,7 @@
 from manager import PySCFManager,CrystalManager,QWalkManager
 from autorunner import PySCFRunnerLocal,PySCFRunnerPBS,RunnerPBS
 from variance import VarianceWriter,VarianceReader
+from linear import LinearWriter,LinearReader
 from trialfunc import SlaterJastrow
 import sys
 
@@ -51,6 +52,9 @@ def h2_tests():
 
 def si_tests():
   ''' Simple tests that check PBC is working Crystal and PySCF.'''
+  jobs=[]
+
+
   # Most basic possible job.
   cwriter=CrystalWriter({
       'xml_name':'../BFD_Library.xml',
@@ -69,50 +73,54 @@ def si_tests():
           walltime='0:10:00'
         )
     )
-
-  pwriter=PySCFPBCWriter({
-      'cif':open('si.cif','r').read()
-    })
-  pman=PySCFManager(
-      name='scf',
-      path='sipyscf',
-      writer=pwriter,
-      runner=PySCFRunnerPBS(
-          queue='secondary',
-          np=1,
-          walltime='0:20:00',
-          ppath=sys.path
-        )
+  jobs.append(cman)
+
+  #pwriter=PySCFPBCWriter({
+  #    'cif':open('si.cif','r').read()
+  #  })
+  #pman=PySCFManager(
+  #    name='scf',
+  #    path='sipyscf',
+  #    writer=pwriter,
+  #    runner=PySCFRunnerPBS(
+  #        queue='secondary',
+  #        np=1,
+  #        walltime='0:20:00',
+  #        ppath=sys.path
+  #      )
+  #  )
+
+  var=QWalkManager(
+      name='var',
+      path=cman.path,
+      writer=VarianceWriter(),
+      reader=VarianceReader(),
+      runner=RunnerPBS(
+          np=1,queue='secondary',walltime='0:10:00'
+        ),
+      trialfunc=SlaterJastrow(cman,kpoint=(0,0,0))
     )
 
-  return [cman,pman]
-
-def si_qmc():
-  ''' Do QMC on the trial functions from `si_tests`. '''
-  scfjobs=si_tests()
-  qmcjobs=[]
+  lin=QWalkManager(
+      name='linear',
+      path=cman.path,
+      writer=LinearWriter(),
+      reader=LinearReader(),
+      runner=RunnerPBS(
+          np=1,queue='secondary',walltime='1:00:00'
+        ),
+      trialfunc=SlaterJastrow(slatman=cman,jastman=var,kpoint=(0,0,0))
+    )
 
-  for scfman in scfjobs:
-    var=QWalkManager(
-        name='var',
-        path=scfman.path.replace('/','')+'_qmc',
-        writer=VarianceWriter(),
-        reader=VarianceReader(),
-        runner=RunnerPBS(
-            np=1,queue='secondary',walltime='0:10:00'
-          ),
-        trialfunc=SlaterJastrow(scfman)
-      )
-    qmcjobs.append(var)
+  jobs.append(var)
 
-  return qmcjobs
+  return [cman,var,lin]
 
 def run_tests():
   ''' Choose which tests to run and execute `nextstep()`.'''
   jobs=[]
   #jobs+=h2_tests()
-  #jobs+=si_tests()
-  jobs+=si_qmc()
+  jobs+=si_tests()
 
   for job in jobs:
     job.nextstep()

trialfunc.py

@@ -21,46 +21,52 @@ def __init__(self,slatman,jastman=None,kpoint=0):
     Returns:
       str or None: None if managers are not ready, QWalk section (str) if they are.
     '''
+    # Idea: kpoint=None means its not PBC.
     # TODO more transparent kpoint selection.
     self.slatman=slatman
     if jastman is None:
       self.jastman=slatman
     else:
       self.jastman=jastman
 
+    self.kpoint=kpoint
+
   #------------------------------------------------
   def export(self,qmcpath):
     ''' Export the wavefunction section for this trial wave function.
     Args: 
       path (str): QWalkManager.path
-      kpoint (int): the kpoint to choose for exporting. 
+      kpoint: the kpoint to choose for exporting. 
     Returns:
       str: system and wave fumction section for QWalk. Empty string if not ready.
     '''
+    # This assumes you're using 2-body, should be easy to make a new object or maybe an arg for 3body.
 
     # Ensure files are correctly generated.
     if not (self.slatman.export_qwalk() and self.jastman.export_qwalk()):
       return ''
 
-    if type(self.slatman.qwfiles['slater'])==list:
-      slater=self.slatman.qwfiles['slater'][kpoint]
-      sys=self.slatman.qwfiles['sys'][kpoint]
-    else:
+    if type(self.slatman.qwfiles['slater'])==str:
       slater=self.slatman.qwfiles['slater']
       sys=self.slatman.qwfiles['sys']
+    else:
+      slater=self.slatman.qwfiles['slater'][self.kpoint]
+      sys=self.slatman.qwfiles['sys'][self.kpoint]
     jastrow=self.jastman.qwfiles['jastrow2']
 
     # There may be a use case for these two to be different, but I want to check the first time this happens. 
     # You can have weird bugs if you use different system files for each wave function term, I think.
     # Should find a way to check for this bug. 
-    assert self.jastman.path+self.jastman.qwfiles['sys']==self.slatman.path+self.slatman.qwfiles['sys'],\
-        'System file probably should be the same between Jastrow and Slater files. '
+    # This doesn't work because we may have different jastrows in same directory, for instance.
+    #assert (self.jastman.path+self.jastman.name)==\
+    #    (self.slatman.path+self.slatman.name),\
+    #    'System file probably should be the same between Jastrow and Slater files. '
 
     outlines=[
-        'include %s/%s'%(os.path.relpath(qmcpath,self.slatman.path),sys),
+        'include %s'%os.path.relpath(self.slatman.path+sys,qmcpath),
         'trialfunc { slater-jastrow ',
-        '  wf1 { include %s/%s }'%(os.path.relpath(qmcpath,self.slatman.path),slater),
-        '  wf2 { include %s/%s }'%(os.path.relpath(qmcpath,self.slatman.path),jastrow),
+        '  wf1 { include %s }'%os.path.relpath(self.slatman.path+slater,qmcpath),
+        '  wf2 { include %s }'%os.path.relpath(self.slatman.path+jastrow,qmcpath),
         '}'
       ]
     return '\n'.join(outlines)

variance.py

@@ -46,6 +46,18 @@ def qwalk_input(self,infile):
 ####################################################
 class VarianceReader:
   def __init__(self,vartol=10,vardifftol=0.1,minsteps=2):
+    ''' Object for reading, diagnosing, and storing variance optimizer results.
+
+    The arguements control when the object sends a 'restart' flag.
+
+    Args:
+      vartol (float): Tolerance on the variance.
+      vardifftol (float): Tolerance of the change between the first and last variance.
+      minsteps (int): minimun number of steps to attempt >= 2.
+    Attributes:
+      output (dict): Results for energy, error, and other information.
+      completed (bool): Whether no more runs are needed.
+    '''
     self.output={}
     self.completed=False