def __init__(self, writer, reader, runner=None, trialfunc=None, name='qw_run', path=None, bundle=False): ''' QWalkManager managers the writing of a QWalk input files, it's running, and keeping track of the results. Args: writer (qwalk writer): writer for input. reader (qwalk reader): to read job. runner (Runner object): to run job. trialfunc (TrialFunction): TrialFunction object for generating trail function input. Note: This is only used if write.trailfunc arguement==''. name (str): identifier for this job. This names the files associated with run. path (str): directory where this manager is free to store information. bundle (bool): False - submit jobs. True - dump job commands into a script for a bundler to run. qwalk (str): absolute path to qwalk executible. ''' self.name = name self.pickle = "%s.pkl" % (self.name) # Ensure path is set up correctly. if path is None: path = os.path.getcwd() if path[-1] != '/': path += '/' self.path = path self.logname = "%s@%s" % (self.__class__.__name__, self.path + self.name) #print(self.logname,": initializing") self.writer = writer self.reader = reader self.trialfunc = trialfunc if runner is not None: self.runner = runner else: self.runner = RunnerPBS() self.bundle = bundle self.completed = False self.scriptfile = None self.bundle_ready = False self.infile = name self.outfile = "%s.o" % self.infile # Note: qwfiles stores file names of results, used for exporting trial wave functions. self.qwfiles = {'jastrow2': '', 'wfout': ''} self.stdout = "%s.out" % self.infile # Handle old results if present. if os.path.exists(self.path + self.pickle): print(self.logname, ": rebooting old manager.") old = pkl.load(open(self.path + self.pickle, 'rb')) self.recover(old) # Update the file. if not os.path.exists(self.path): os.mkdir(self.path) with open(self.path + self.pickle, 'wb') as outf: pkl.dump(self, outf)
def h2_pyscf_equil_test(): jobs = [] xyz = open('structures/h2_equil.xyz', 'r') xyz.readline() # Remove headers. xyz.readline() scfman = PySCFManager(name='scf', path='test_h2eq_py', writer=PySCFWriter({ 'spin': 0, 'xyz': xyz.read() }), runner=PySCFRunnerPBS(queue='secondary', nn=1, np=16, walltime='0:01:00')) jobs.append(scfman) var = QWalkManager(name='var', path=scfman.path, writer=VarianceWriter(), reader=VarianceReader(), runner=RunnerPBS(nn=1, np=16, queue='secondary', walltime='0:05:00'), trialfunc=SlaterJastrow(scfman, kpoint=0)) jobs.append(var) lin = QWalkManager(name='linear', path=scfman.path, writer=LinearWriter(), reader=LinearReader(), runner=RunnerPBS(nn=1, np=16, queue='secondary', walltime='0:10:00'), trialfunc=SlaterJastrow(slatman=scfman, jastman=var, kpoint=0)) jobs.append(lin) dmc = QWalkManager(name='dmc', path=scfman.path, writer=DMCWriter(), reader=DMCReader(), runner=RunnerPBS( nn=1, np=16, queue='secondary', walltime='0:10:00', ), trialfunc=SlaterJastrow(slatman=scfman, jastman=lin)) jobs.append(dmc) return jobs
def si_pyscf_test(): ''' Simple tests that check PBC is working Crystal, and that QMC can be performed on the result.''' jobs=[] pwriter=PySCFPBCWriter({ 'gmesh':[16,16,16], 'cif':open('si.cif','r').read() }) pman=PySCFManager( name='scf', path='sipyscf', writer=pwriter, runner=PySCFRunnerPBS( queue='secondary', nn=1, np=16, walltime='4:00:00' ) ) jobs.append(pman) var=QWalkManager( name='var', path=pman.path, writer=VarianceWriter(), reader=VarianceReader(), runner=RunnerPBS( nn=1,queue='secondary',walltime='0:10:00' ), trialfunc=SlaterJastrow(pman,kpoint=0) ) jobs.append(var) lin=QWalkManager( name='lin', path=pman.path, writer=LinearWriter(), reader=LinearReader(), runner=RunnerPBS( nn=1,queue='secondary',walltime='0:30:00' ), trialfunc=SlaterJastrow(slatman=pman,jastman=var,kpoint=0) ) jobs.append(lin) return jobs
def si_crystal_test(): ''' Simple tests that check PBC is working Crystal, and that QMC can be performed on the result.''' jobs=[] cwriter=CrystalWriter({ 'xml_name':'../BFD_Library.xml', 'cutoff':0.2, 'kmesh':(4,4,4), }) cwriter.set_struct_fromcif(open('si.cif','r').read(),primitive=True) cwriter.set_options({}) cman=CrystalManager( name='crys', path='sicrys', writer=cwriter, runner=RunnerPBS( queue='secondary', nn=1, walltime='0:10:00' ) ) jobs.append(cman) var=QWalkManager( name='var', path=cman.path, writer=VarianceWriter(), reader=VarianceReader(), runner=RunnerPBS( nn=1,queue='secondary',walltime='0:10:00' ), trialfunc=SlaterJastrow(cman,kpoint=0) ) jobs.append(var) lin=QWalkManager( name='linear', path=cman.path, writer=LinearWriter(), reader=LinearReader(), runner=RunnerPBS( nn=1,queue='secondary',walltime='1:00:00' ), trialfunc=SlaterJastrow(slatman=cman,jastman=var,kpoint=0) ) jobs.append(lin) for kidx in cman.qwfiles['kpoints']: kpt=cman.qwfiles['kpoints'][kidx] dmc=QWalkManager( name='dmc_%d'%kidx, path=cman.path, writer=DMCWriter(), reader=DMCReader(), runner=RunnerPBS( nn=1,queue='secondary',walltime='1:00:00', ), trialfunc=SlaterJastrow(slatman=cman,jastman=lin,kpoint=kidx) ) jobs.append(dmc) return jobs
def mno_test(): ''' Test spinful calculations in PBC and real kpoint sampling. Also test trialfunc dependency. ''' jobs=[] cwriter=CrystalWriter({ 'xml_name':'../BFD_Library.xml', 'cutoff':0.2, 'kmesh':(4,4,4), 'total_spin':4 }) cwriter.set_struct_fromcif(open('mno.cif','r').read(),primitive=True) cwriter.set_options({}) cman=CrystalManager( name='crys', path='mnocrys', writer=cwriter, runner=RunnerPBS( queue='secondary', nn=1, walltime='1:00:00' ) ) jobs+=[cman] var=QWalkManager( name='var', path=cman.path, writer=VarianceWriter(), reader=VarianceReader(), runner=RunnerPBS( nn=1,queue='secondary',walltime='0:10:00' ), trialfunc=SlaterJastrow(cman,kpoint=(0,0,0)) ) lin=QWalkManager( name='linear', path=cman.path, writer=LinearWriter(), reader=LinearReader(), runner=RunnerPBS( nn=1,queue='secondary',walltime='1:00:00' ), trialfunc=SlaterJastrow(slatman=cman,jastman=var,kpoint=(0,0,0)) ) for kidx in cman.qwfiles['kpoints']: kpt=cman.qwfiles['kpoints'][kidx] if not sum(np.array(kpt)%(np.array(cman.kmesh)/2))<1e-14: print("complex kpt %d%d%d skipped"%kpt) continue dmc=QWalkManager( name='dmc_%d'%kidx, path=cman.path, writer=DMCWriter(), reader=DMCReader(), runner=RunnerPBS( nn=1,queue='secondary',walltime='1:00:00', ), trialfunc=SlaterJastrow(slatman=cman,jastman=lin,kpoint=kidx) ) jobs.append(dmc) return jobs
class QWalkManager: def __init__(self, writer, reader, runner=None, trialfunc=None, name='qw_run', path=None, bundle=False): ''' QWalkManager managers the writing of a QWalk input files, it's running, and keeping track of the results. Args: writer (qwalk writer): writer for input. reader (qwalk reader): to read job. runner (Runner object): to run job. trialfunc (TrialFunction): TrialFunction object for generating trail function input. Note: This is only used if write.trailfunc arguement==''. name (str): identifier for this job. This names the files associated with run. path (str): directory where this manager is free to store information. bundle (bool): False - submit jobs. True - dump job commands into a script for a bundler to run. qwalk (str): absolute path to qwalk executible. ''' self.name = name self.pickle = "%s.pkl" % (self.name) # Ensure path is set up correctly. if path is None: path = os.getcwd() if path[-1] != '/': path += '/' self.path = path self.logname = "%s@%s" % (self.__class__.__name__, self.path + self.name) #print(self.logname,": initializing") self.writer = writer self.reader = reader self.trialfunc = trialfunc if runner is not None: self.runner = runner else: self.runner = RunnerPBS() self.bundle = bundle self.completed = False self.infile = name self.outfile = "%s.o" % self.infile # Note: qwfiles stores file names of results, used for exporting trial wave functions. self.qwfiles = {'jastrow2': '', 'wfout': ''} self.stdout = "%s.out" % self.infile # Handle old results if present. if os.path.exists(self.path + self.pickle): print(self.logname, ": rebooting old manager.") old = pkl.load(open(self.path + self.pickle, 'rb')) self.recover(old) # Update the file. if not os.path.exists(self.path): os.mkdir(self.path) with open(self.path + self.pickle, 'wb') as outf: pkl.dump(self, outf) #------------------------------------------------ def recover(self, other): ''' Recover old class by copying over data. Retain variables from old that may change final answer.''' # Practically speaking, the run will preserve old `take_keys` and allow new changes to `skip_keys`. # 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', 'reader', 'path', 'logname', 'name', 'bundle' ], take_keys=['restarts', 'completed', 'trialfunc', '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.reader, copyfrom=other.reader, skip_keys=[], take_keys=['completed', 'output']) updated = update_attributes(copyto=self.writer, copyfrom=other.writer, skip_keys=[ 'maxcycle', 'errtol', 'minblocks', 'nblock', 'savetrace' ], take_keys=[ 'completed', 'tmoves', 'extra_observables', 'timestep', 'trialfunc' ]) if updated: self.writer.completed = False #------------------------------------------------ def nextstep(self): ''' Perform next step in calculation. trialfunc managers are updated if they aren't completed yet.''' # Recover old data. self.recover(pkl.load(open(self.path + self.pickle, 'rb'))) print(self.logname, ": next step.") # Check dependency is completed first. if self.writer.trialfunc == '': print(self.logname, ": checking trial function.") self.writer.trialfunc = self.trialfunc.export(self.path) # Work on this job. cwd = os.getcwd() os.chdir(self.path) # Write the input file. if not self.writer.completed: self.writer.qwalk_input(self.infile) status = resolve_status(self.runner, self.reader, self.outfile) print(self.logname, ": %s status= %s" % (self.name, status)) if status == "not_started" and self.writer.completed: exestr = "%s %s &> %s" % (paths['qwalk'], self.infile, self.stdout) self.runner.add_task(exestr) print(self.logname, ": %s status= submitted" % (self.name)) elif status == "ready_for_analysis": #This is where we (eventually) do error correction and resubmits status = self.reader.collect(self.outfile) if status == 'ok': print(self.logname, ": %s status= %s, task complete." % (self.name, status)) self.completed = True else: print( self.logname, ": %s status= %s, attempting rerun." % (self.name, status)) exestr = "%s %s &> %s" % (paths['qwalk'], self.infile, self.stdout) self.runner.add_task(exestr) elif status == 'done': self.completed = True # Ready for bundler or else just submit the jobs as needed. if not self.bundle: qsubfile = self.runner.submit( self.path.replace('/', '-') + self.name) # Update the file. with open(self.pickle, 'wb') as outf: pkl.dump(self, outf) os.chdir(cwd) #------------------------------------------------ def update_queueid(self, qid): ''' If a bundler handles the submission, it can update the queue info with this. Args: qid (str): new queue id from submitting a job. The Manager will check if this is running. ''' self.runner.queueid.append(qid) self._runready = False # After running, we won't run again without more analysis. # Update the file. with open(self.path + self.pickle, 'wb') as outf: pkl.dump(self, outf) #---------------------------------------- def status(self): ''' Check if this Manager has completed all it's tasks. Returns: str: 'ok' or 'not_finished'. ''' if self.reader.completed: return 'ok' else: return 'not_finished' #---------------------------------------- def collect(self): ''' Call the collect routine for readers.''' print(self.logname, ": collecting results.") self.reader.collect(self.path + self.outfile) # Update the file. with open(self.path + self.pickle, 'wb') as outf: pkl.dump(self, outf) #---------------------------------------- def export_qwalk(self): ''' Store resulting wave function into self.qwfiles['wfout']. Extract Jastrow and store in self.qwfiles['jastrow2'] Returns: bool: Whether it was successful.''' # Theoretically more than just Jastrow can be provided, but practically that's the only type of wavefunction we tend to export. # Recover old data. self.recover(pkl.load(open(self.path + self.pickle, 'rb'))) assert self.writer.qmc_abr != 'dmc', "DMC doesn't provide a wave function." if self.qwfiles['wfout'] == '': 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 = separate_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
def mno_crystal_test(): ''' Test spinful calculations in PBC and real kpoint sampling. Also test trialfunc dependency. ''' cwriter = CrystalWriter({ 'xml_name': '../../BFD_Library.xml', 'cutoff': 0.2, 'kmesh': (3, 3, 3), 'initial_spins': [1, 0], 'total_spin': 5 }) cwriter.set_struct_fromcif(open('structures/mno.cif', 'r').read(), primitive=True) cwriter.set_options({}) cman = CrystalManager(name='crys', path='test_mno_crys', writer=cwriter, runner=RunnerPBS(queue='secondary', nn=1, np=20, walltime='2:00:00')) var = QWalkManager(name='var', path=cman.path, writer=VarianceWriter(), reader=VarianceReader(), runner=RunnerPBS(nn=1, np=20, queue='secondary', walltime='0:10:00'), trialfunc=SlaterJastrow(cman, kpoint=0)) lin = QWalkManager(name='linear', path=cman.path, writer=LinearWriter(), reader=LinearReader(), runner=RunnerPBS(nn=1, np=20, queue='secondary', walltime='1:00:00'), trialfunc=SlaterJastrow(slatman=cman, jastman=var, kpoint=0)) jobs = [cman, var, lin] for kidx in cman.qwfiles['kpoints']: kpt = cman.qwfiles['kpoints'][kidx] dmc = QWalkManager(name='dmc_%d' % kidx, path=cman.path, writer=DMCWriter(), reader=DMCReader(), runner=RunnerPBS( nn=1, np=16, queue='secondary', walltime='1:00:00', ), trialfunc=SlaterJastrow(slatman=cman, jastman=lin, kpoint=kidx)) jobs.append(dmc) return jobs
def h2_crystal_equil_test(): jobs = [] cwriter = CrystalWriter({ 'xml_name': '../../BFD_Library.xml', 'cutoff': 0.2, 'spin_polarized': False }) cwriter.set_struct_fromxyz(open('structures/h2_equil.xyz', 'r').read()) cman = CrystalManager(name='crys', path='test_h2eq_crys', writer=cwriter, runner=RunnerPBS(queue='secondary', nn=1, np=16, walltime='0:01:00')) jobs.append(cman) var = QWalkManager(name='var', path=cman.path, writer=VarianceWriter(), reader=VarianceReader(), runner=RunnerPBS(nn=1, np=16, queue='secondary', walltime='0:05:00'), trialfunc=SlaterJastrow(cman, kpoint=0)) jobs.append(var) lin = QWalkManager(name='linear', path=cman.path, writer=LinearWriter(), reader=LinearReader(), runner=RunnerPBS(nn=1, np=16, queue='secondary', walltime='0:10:00'), trialfunc=SlaterJastrow(slatman=cman, jastman=var, kpoint=0)) jobs.append(lin) for kidx in cman.qwfiles['kpoints']: kpt = cman.qwfiles['kpoints'][kidx] dmc = QWalkManager(name='dmc_%d' % kidx, path=cman.path, writer=DMCWriter(), reader=DMCReader(), runner=RunnerPBS( nn=1, np=16, queue='secondary', walltime='0:10:00', ), trialfunc=SlaterJastrow(slatman=cman, jastman=lin, kpoint=kidx)) jobs.append(dmc) return jobs
def __init__(self, writer, runner, creader=None, name='crystal_run', path=None, preader=None, prunner=None, trylev=False, bundle=False, max_restarts=2): ''' 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. max_restarts (int): maximum number of times you'll allow restarting before giving up (and manually intervening). ''' # Where to save self. self.name = name self.pickle = "%s.pkl" % self.name # Ensure path is set up correctly. if path is None: path = os.path.getcwd() if path[-1] != '/': path += '/' self.path = path self.logname = "%s@%s" % (self.__class__.__name__, self.path + self.name) #print(self.logname,": initializing") # Handle reader and runner defaults. self.writer = writer if creader is None: self.creader = CrystalReader() else: self.creader = creader if preader is None: self.preader = 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 # Internal. self.crysinpfn = self.name self.propinpfn = self.name + '.prop' self.crysoutfn = self.crysinpfn + '.o' self.propoutfn = self.propinpfn + '.o' self.restarts = 0 self._runready = False self.scriptfile = None self.completed = False self.bundle = bundle self.qwfiles = { 'kpoints': [], 'basis': '', 'jastrow2': '', 'orbplot': {}, 'orb': {}, 'sys': {}, 'slater': {} } # Smart error detection. self.trylev = trylev self.max_restarts = max_restarts self.savebroy = [] self.lev = False # Handle old results if present. if os.path.exists(self.path + self.pickle): #print(self.logname,": rebooting old manager.") old = pkl.load(open(self.path + self.pickle, 'rb')) self.recover(old) # Update the file. if not os.path.exists(self.path): os.mkdir(self.path) with open(self.path + self.pickle, 'wb') as outf: pkl.dump(self, outf)
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, creader=None, name='crystal_run', path=None, preader=None, prunner=None, trylev=False, bundle=False, max_restarts=2): ''' 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. max_restarts (int): maximum number of times you'll allow restarting before giving up (and manually intervening). ''' # Where to save self. self.name = name self.pickle = "%s.pkl" % self.name # Ensure path is set up correctly. if path is None: path = os.path.getcwd() if path[-1] != '/': path += '/' self.path = path self.logname = "%s@%s" % (self.__class__.__name__, self.path + self.name) #print(self.logname,": initializing") # Handle reader and runner defaults. self.writer = writer if creader is None: self.creader = CrystalReader() else: self.creader = creader if preader is None: self.preader = 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 # Internal. self.crysinpfn = self.name self.propinpfn = self.name + '.prop' self.crysoutfn = self.crysinpfn + '.o' self.propoutfn = self.propinpfn + '.o' self.restarts = 0 self._runready = False self.scriptfile = None self.completed = False self.bundle = bundle self.qwfiles = { 'kpoints': [], 'basis': '', 'jastrow2': '', 'orbplot': {}, 'orb': {}, 'sys': {}, 'slater': {} } # Smart error detection. self.trylev = trylev self.max_restarts = max_restarts self.savebroy = [] self.lev = False # Handle old results if present. if os.path.exists(self.path + self.pickle): #print(self.logname,": rebooting old manager.") old = pkl.load(open(self.path + self.pickle, 'rb')) self.recover(old) # Update the file. if not os.path.exists(self.path): os.mkdir(self.path) with open(self.path + self.pickle, 'wb') as outf: pkl.dump(self, outf) #------------------------------------------------ def recover(self, other): ''' Recover old class by copying over data. Retain variables from old that may change final answer.''' # Practically speaking, the run will preserve old `take_keys` and allow new changes to `skip_keys`. # 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', 'prunner', 'lev', 'savebroy', 'path', 'logname', 'name', 'trylev', 'max_restarts', 'bundle' ], 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.prunner, copyfrom=other.prunner, skip_keys=['queue', 'walltime', 'np', 'nn', 'jobname'], take_keys=['queueid']) update_attributes(copyto=self.creader, copyfrom=other.creader, skip_keys=[], take_keys=['completed', 'output']) update_attributes(copyto=self.preader, copyfrom=other.preader, skip_keys=[], take_keys=['completed', 'output']) updated = update_attributes(copyto=self.writer, copyfrom=other.writer, skip_keys=['maxcycle', 'edifftol'], take_keys=[ 'completed', 'modisymm', 'restart', 'guess_fort', '_elements' ]) if updated: self.writer.completed = False #---------------------------------------- def nextstep(self): ''' Determine and perform the next step in the calculation.''' self.recover(pkl.load(open(self.path + self.pickle, 'rb'))) print(self.logname, ": next step.") cwd = os.getcwd() os.chdir(self.path) # Generate input files. if not self.writer.completed: if self.writer.guess_fort is not None: sh.copy(self.writer.guess_fort, 'fort.20') with open(self.crysinpfn, 'w') as f: self.writer.write_crys_input(self.crysinpfn) with open(self.propinpfn, 'w') as f: self.writer.write_prop_input(self.propinpfn) # Check on the CRYSTAL run status = resolve_status(self.runner, self.creader, self.crysoutfn) print(self.logname, ": status= %s" % (status)) if status == "not_started": self.runner.add_command("cp %s INPUT" % self.crysinpfn) self.runner.add_task("%s &> %s" % (paths['Pcrystal'], self.crysoutfn)) elif status == "ready_for_analysis": #This is where we (eventually) do error correction and resubmits status = self.creader.collect(self.crysoutfn) print(self.logname, ": status %s" % status) if status == 'killed': if self.restarts >= self.max_restarts: print( self.logname, ": restarts exhausted (%d previous restarts). Human intervention required." % self.restarts) else: print( self.logname, ": attempting restart (%d previous restarts)." % self.restarts) self.writer.restart = True if self.trylev: print(self.logname, ": trying LEVSHIFT.") self.writer.levshift = [10, 1] # No mercy. self.savebroy = deepcopy(self.writer.broyden) self.writer.broyden = [] self.lev = True sh.copy(self.crysinpfn, "%d.%s" % (self.restarts, self.crysinpfn)) sh.copy(self.crysoutfn, "%d.%s" % (self.restarts, self.crysoutfn)) sh.copy('fort.79', "%d.fort.79" % (self.restarts)) self.writer.guess_fort = './fort.79' sh.copy(self.writer.guess_fort, 'fort.20') self.writer.write_crys_input(self.crysinpfn) sh.copy(self.crysinpfn, 'INPUT') self.runner.add_task("%s &> %s" % (paths['Pcrystal'], self.crysoutfn)) self.restarts += 1 elif status == 'done' and self.lev: # We used levshift to converge. Now let's restart to be sure. print("Recovering from LEVSHIFTer.") self.writer.restart = True self.writer.levshift = [] self.creader.completed = False self.lev = False sh.copy(self.crysinpfn, "%d.%s" % (self.restarts, self.crysinpfn)) sh.copy(self.crysoutfn, "%d.%s" % (self.restarts, self.crysoutfn)) sh.copy('fort.79', "%d.fort.79" % (self.restarts)) self.writer.guess_fort = './fort.79' sh.copy(self.writer.guess_fort, 'fort.20') self.writer.write_crys_input(self.crysinpfn) sh.copy(self.crysinpfn, 'INPUT') self.runner.add_task("%s &> %s" % (paths['Pcrystal'], self.crysoutfn)) self.restarts += 1 # 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) else: qsubfile = self.runner.submit( self.path.replace('/', '-') + self.name) self.completed = self.creader.completed # Update the file. with open(self.pickle, 'wb') as outf: pkl.dump(self, outf) os.chdir(cwd) #---------------------------------------- def collect(self): ''' Call the collect routine for readers.''' print(self.logname, ": collecting results.") self.creader.collect(self.path + self.crysoutfn) # Update the file. with open(self.path + self.pickle, 'wb') as outf: pkl.dump(self, outf) #------------------------------------------------ def script(self, jobname=None): ''' Script execution lines for a bundler to pick up and run.''' if jobname is None: jobname = self.runner.jobname self.scriptfile = "%s.run" % jobname self._runready = self.runner.script(self.scriptfile) #------------------------------------------------ def submit(self, jobname=None): ''' Submit the runner's job to the queue. ''' qsubfile = self.runner.submit(jobname) return qsubfile #---------------------------------------- def to_json(self): raise NotImplementedError #---------------------------------------- def write_summary(self): self.creader.write_summary() #------------------------------------------------ def export_qwalk(self): ''' Export QWalk input files into current directory. Returns: bool: whether it was successful.''' self.recover(pkl.load(open(self.path + self.pickle, 'rb'))) ready = False if len(self.qwfiles['slater']) == 0: self.nextstep() if not self.completed: return False 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': ready = False self.prunner.add_command("cp %s INPUT" % self.propinpfn) self.prunner.add_task("%s &> %s" % (paths['Pproperties'], 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( self.path.replace('/', '-') + self.name) elif status == 'ready_for_analysis': self.preader.collect(self.propoutfn) if self.preader.completed: ready = True print(self.logname, ": converting crystal to QWalk input now.") self.qwfiles = crystal2qmc.convert_crystal( base=self.name, propoutfn=self.propoutfn) else: ready = False print( self.logname, ": conversion postponed because properties is not finished." ) os.chdir(cwd) else: ready = True with open(self.path + self.pickle, 'wb') as outf: pkl.dump(self, outf) return ready #---------------------------------------- def status(self): if self.completed: return 'ok' else: return 'not_finished'