def parallel_listener(self,result_queue): qtk.progress("MonteCarlo", "waiting results from", self.parallel, "threads") # check result every 0.01 second, HARD CODED while result_queue.empty(): sleep(0.01) result = result_queue.get() # collect results qtk.done() # indicate job done # return results to master return result[0], result[1], result[2]
def parallel_listener(self, result_queue): qtk.progress("MonteCarlo", "waiting results from", self.parallel, "threads") # check result every 0.01 second, HARD CODED while result_queue.empty(): sleep(0.01) result = result_queue.get() # collect results qtk.done() # indicate job done # return results to master return result[0], result[1], result[2]
def run(self): while not self.converged(): pop = self.get_pop() qtk.progress("Optimizer", "GE iteration with %d new points" % len(pop)) self.register(pop) fit, info = self.fitness(pop) print pop print fit print info if type(fit) is list: self.update(pop, fit, info) else: self.update(pop, [fit], [info])
def __init__(self, path=':memory:', db_str=None, **kwargs): if not db_str: db_str = 'sqlite:///' + path self.engine = create_engine(db_str, **kwargs) self.name = db_str if os.path.exists(path): qtk.progress('DB', 'loading existing database: %s' % path) Base.metadata.create_all(self.engine) self.session = self.get_session(new=True)
def eeKernel(self, coord=None, batch_size=1): if coord is None: coord = self.molecule.R else: coord = np.atleast_2d(coord).astype(float) out = [] itr = 1 for chunk in np.array_split(coord, batch_size): if itr > 1: qtk.progress("eeKernel", "processing batch: %d\n" % itr) itr += 1 out.append(eeKernel(self.basis, chunk)) return np.concatenate(out)
def eeKernel(self, coord=None, batch_size=1, **kwargs): if coord is None: coord = self.molecule.R else: coord = np.atleast_2d(coord).astype(float) out = [] itr = 1 for chunk in np.array_split(coord, batch_size): if itr > 1: qtk.progress("eeKernel", "processing batch: %d\n" % itr) itr += 1 out.append(eeKernel(self.basis, chunk)) return np.concatenate(out)
def sys_run(cmd_str, log_file=None): if log_file: log = open(log_file, 'w') try: qtk.progress("QMRun", cmd_str) if log_file: run = sp.Popen(cmd_str, shell=True, stdout=log) else: run = sp.Popen(cmd_str, shell=True) run.wait() except Exception as err: qtk.warning('%s failed with error: %s' % (cmd_str, err)) if log_file: log.close()
def iterate(self, size=0.005): dv = self.dv oldE = self.E() if self.new_deltadv is None: self.old_deltadv = self.dE_ddv() else: self.old_deltadv = self.new_deltadv self.dv = self.normalize(dv - self.old_deltadv * size) self.update(self.dv) self.new_deltadv = self.dE_ddv() newE = self.E() norm1 = np.linalg.norm(self.old_deltadv) norm2 = np.linalg.norm(self.new_deltadv) angle = np.dot(self.old_deltadv, self.new_deltadv) / (norm1 * norm2) angle = np.arccos(angle) * 180 / np.pi msg = "E=% 13.6E, grad_angle=% 8.3f, |grad|=%8.3f\n" % \ (newE, angle, norm1) qtk.progress("ofdft", msg)
def iterate(self, size=0.005): dv = self.dv oldE = self.E() if self.new_deltadv is None: self.old_deltadv = self.dE_ddv() else: self.old_deltadv = self.new_deltadv self.dv = self.normalize(dv - self.old_deltadv*size) self.update(self.dv) self.new_deltadv = self.dE_ddv() newE = self.E() norm1 = np.linalg.norm(self.old_deltadv) norm2 = np.linalg.norm(self.new_deltadv) angle = np.dot(self.old_deltadv, self.new_deltadv) / (norm1 * norm2) angle = np.arccos(angle) * 180 / np.pi msg = "E=% 13.6E, grad_angle=% 8.3f, |grad|=%8.3f\n" % \ (newE, angle, norm1) qtk.progress("ofdft", msg)
def read_gaussian(fchk, **kwargs): if 'name' in kwargs: cube = kwargs['name'] root, ext = os.path.splitext(cube) if ext != '.cube': print ext qtk.warning("extension .cube is required for many " + \ "visualization programs") else: root, ext = os.path.splitext(fchk) cube = root + '.cube' qtk.progress("CUBE", "writing file %s\n" % cube) if 'flag' not in kwargs: flag = 'density=scf' else: flag = kwargs['flag'] if 'grid' in kwargs: grid = kwargs['grid'] cmd = '%s 1 %s %s %s -1' % (qtk.gaussian_cubegen_exe, flag, fchk, cube) run = sp.Popen(cmd, shell=True, stdin=sp.PIPE) for i in range(len(grid)): vec = grid[i] if i == 0: # for formated output msg = '-1 %f %f %f\n' % (vec[1], vec[2], vec[3]) elif i == 1: # for Bohr as grid unit msg = '%d %f %f %f\n' % (-vec[0], vec[1], vec[2], vec[3]) else: msg = '%d %f %f %f\n' % (vec[0], vec[1], vec[2], vec[3]) run.stdin.write(msg) else: cmd = '%s 1 %s %s %s' % (qtk.gaussian_cubegen_exe, flag, fchk, cube) run = sp.Popen(cmd, shell=True, stdin=sp.PIPE) run.stdin.flush() run.communicate() run.wait() q = qtk.CUBE(cube, format='cube') zcoord = np.hstack([q.molecule.Z[:, np.newaxis], q.molecule.R]) zcoord[:,1:4] = zcoord[:,1:4] / 0.529177249 return q.data, zcoord, q.grid
def e_coulomb(self, gridpoints, **kwargs): new, occ, kw, gridpoints = self._e_setting(gridpoints, **kwargs) if 'batch_size' in kwargs: batch_size = kwargs['batch_size'] del kwargs['batch_size'] else: batch_size = 1 out = [] itr = 1 coord = gridpoints for chunk in np.array_split(coord, batch_size): qtk.progress("e_coulomb", "processing batch: %d\n" % itr) itr += 1 kernel = new.coulombKernel(chunk / 1.8897261245650618, **kwargs) rho = new.getRho(gridpoints=chunk, **kw) out.append(0.5 * rho * kernel) return np.concatenate(out)
def read_gaussian(fchk, **kwargs): if 'name' in kwargs: cube = kwargs['name'] root, ext = os.path.splitext(cube) if ext != '.cube': print ext qtk.warning("extension .cube is required for many " + \ "visualization programs") else: root, ext = os.path.splitext(fchk) cube = root + '.cube' qtk.progress("CUBE", "writing file %s\n" % cube) if 'flag' not in kwargs: flag = 'density=scf' else: flag = kwargs['flag'] if 'grid' in kwargs: grid = kwargs['grid'] cmd = '%s 1 %s %s %s -1' % (qtk.gaussian_cubegen_exe, flag, fchk, cube) run = sp.Popen(cmd, shell=True, stdin=sp.PIPE) for i in range(len(grid)): vec = grid[i] if i == 0: # for formated output msg = '-1 %f %f %f\n' % (vec[1], vec[2], vec[3]) elif i == 1: # for Bohr as grid unit msg = '%d %f %f %f\n' % (-vec[0], vec[1], vec[2], vec[3]) else: msg = '%d %f %f %f\n' % (vec[0], vec[1], vec[2], vec[3]) run.stdin.write(msg) else: cmd = '%s 1 %s %s %s' % (qtk.gaussian_cubegen_exe, flag, fchk, cube) run = sp.Popen(cmd, shell=True, stdin=sp.PIPE) run.stdin.flush() run.communicate() run.wait() q = qtk.CUBE(cube, format='cube') zcoord = np.hstack([q.molecule.Z[:, np.newaxis], q.molecule.R]) zcoord[:, 1:4] = zcoord[:, 1:4] / 0.529177249 return q.data, zcoord, q.grid
def Molecules(file_name, **kwargs): """read nested xyz file and return molecule list""" xyz = open(file_name, 'r') content = xyz.readlines() content = [line.replace('\t', ' ') for line in content] xyz.close() itr = 0 more_data = True mols = [] while more_data: try: N = int(content[itr]) prop_list = content[itr + 1] try: prop_list = np.array(prop_list.split(' ')).astype(float) except Exception as err: qtk.warning(str(err)) prop_list = prop_list coord_list = content[itr + 2:itr + N + 2] coord = [ filter(None, [a for a in entry.split(' ')]) for entry in coord_list ] type_list = list(np.array(coord)[:, 0]) type_list = [str(elem) for elem in type_list] Z = np.array([qtk.n2Z(elem) for elem in type_list]) R = np.array(coord)[:, 1:4].astype(float) mol_data = {} for var in ['N', 'type_list', 'Z', 'R']: mol_data[str(var)] = eval(var) itr += N + 2 mols.append(qtk.Molecule(molecule_data=mol_data)) except Exception as err: qtk.progress( "Molecules", "%d molecules have been loaded with message %s." % (len(mols), str(err))) more_data = False return mols
def e_coulomb(self, gridpoints, **kwargs): new, occ, kw, gridpoints = self._e_setting(gridpoints, **kwargs) if 'batch_size' in kwargs: batch_size = kwargs['batch_size'] del kwargs['batch_size'] else: batch_size = 1 out = [] itr = 1 coord = gridpoints for chunk in np.array_split(coord, batch_size): qtk.progress("e_coulomb", "processing batch: %d\n" % itr) itr += 1 kernel = new.coulombKernel( chunk / 1.8897261245650618, **kwargs ) rho = new.getRho(gridpoints = chunk, **kw) out.append(0.5 * rho * kernel) return np.concatenate(out)
def push(self, content=None, data=None, comment=None, date=None): if date is None: date = dt.now() entry = Entry(date=date, content=content, comment=comment, data=data) qtk.progress("DB", "adding entry", content, data, comment) self.session.add(entry) try: qtk.progress("DB", "attempt to commit...") self.session.commit() qtk.progress("DB", "done") except Exception as err: qtk.warning('can not commit, error: %s' % err)
def pack_list(data_list, **kwargs): if isinstance(data_list[0], qtk.Molecule): typ = 'molecule' Z = [m.Z for m in data_list] max_N = max(map(len, Z)) elif isinstance(data_list[0], qtk.QMOutput): typ = 'output' Z = [o.molecule.Z for o in data_list if hasattr(o, 'molecule')] max_N = max(map(len, Z)) else: qtk.exit("not supported datatype") if 'output' not in kwargs: kwargs['output'] = 'dictionary' xyzs = [] Zs = [] Es = [] xyzStr = [] for i in range(len(data_list)): if i % 5000 == 0: qtk.progress("processing %d" % (i + 1)) if typ == 'output': if hasattr(data_list[i], 'molecule'): molecule = data_list[i].molecule else: molecule = None Es.append(data_list[i].Et) elif typ == 'molecule': molecule = data_list[i] if molecule is not None: zeroR = np.zeros([max_N - molecule.N, 3]) zeroZ = np.zeros(max_N - molecule.N) xyz = np.vstack([molecule.R, zeroR]).tolist() Z = np.hstack([molecule.Z, zeroZ]) if len(xyzs) == 0: #xyzs = xyz Zs = Z else: #xyzs = np.stack([xyzs,xyz]) Zs = np.vstack([Zs, Z]) xyzs.append(xyz) if kwargs['output'] == 'extended_xyz': xyzStr.append('%d\n' % molecule.N) if typ == 'output': xyzStr.append('%f\n' % data_list[i].Et) elif typ == 'molecule': xyzStr.append('\n') for I in range(molecule.N): r = molecule.R[I] xyzStr.append('%-2s % 8.4f % 8.4f % 8.4f\n'\ % (molecule.type_list[I], r[0], r[1], r[2])) xyzs = np.array(xyzs) if len(Es) > 0: Es = np.array(Es) if len(xyzStr) > 0: xyzStr = ''.join(xyzStr) if kwargs['output'] == 'dictionary': out = {'xyz': xyzs, 'Z': Zs} if len(Es) > 0: out['E'] = np.array(Es) elif kwargs['output'] == 'extended_xyz': out = xyzStr else: qtk.warning('not supported output format:%s' % kwargs['output']) out = None return out
def predict(self, size, **kwargs): template = copy.deepcopy(self.rest_set) index = range(len(self.rest_set)) rd.shuffle(index) test_list = index[:size] i = 0 self.test_set = [self.rest_set[i] for i in test_list] self.kernelVectors = np.atleast_2d([]) self.testCoord = np.array([data.getVector() for data in self.test_set]) rrows, rcolumns = self.refCoord.shape trows, tcolumns = self.testCoord.shape # exteral C module qtk.progress("Predition", "generating",\ "%dx%d" % (trows, rrows),\ "kernel projection..." ) self.kernelVectors = kv.kernel_vectors(self.refCoord, rrows, rcolumns, self.testCoord, trows, tcolumns, self.kernel, self.klargs) qtk.done() test_true = [] test_pred = [] for i in range(len(self.test_set)): prediction = np.dot(self.kernelVectors[i], self.alphas) self.test_set[i].prediction = prediction test_true.append(self.test_set[i].ref) test_pred.append(prediction) # analize and status report self.testTrue = np.array(test_true) self.testPred = np.array(test_pred) self.error = abs(self.testPred - self.testTrue) self.MAE = sum(self.error) / len(self.error) self.RMSE = np.sqrt(sum(self.error**2) / len(self.testTrue)) max_index = list(self.error).index(max(self.error)) min_index = list(self.error).index(min(self.error)) max_name = self.test_set[max_index].getName() min_name = self.test_set[min_index].getName() qtk.report("predicted MAE", self.MAE) qtk.report("predicted RMSE", self.RMSE) qtk.report("Maximum error", max(self.error), max_name) qtk.report("Minimum error", min(self.error), min_name) def error_estimate(ker, vec): tmp = np.vstack([ker, vec]) K = np.vstack([tmp.T, np.append(vec, 1)]).T old = np.linalg.det(ker) new = np.linalg.det(K) #kvec = np.dot(ker, vec.T) #nvec = np.linalg.norm(vec) #nkvec = np.linalg.norm(kvec) # angle #return np.arccos(np.dot(kvec,vec)/nvec/nkvec) # length return new / old #ee = error_estimate(self.kernelMatrix, self.kernelVectors[0]) def error_i(i): return error_estimate(self.kernelMatrix, self.kernelVectors[i]) verror = np.vectorize(error_i) self.errorEstimate = verror(range(trows))
def training(self, size, **kwargs): """ set up training set, test set, and calculate alphas """ # 'lambda' is a python keyword... if 'deviation' in kwargs: self._lambda = kwargs['deviation'] else: self._lambda = 0 qtk.report("Deviation parameter", self._lambda) template = copy.deepcopy(self.data) index = range(self.data_size) rd.shuffle(index) max_index = size i = 0 self.training_set = [] self.training_index = [] reference_vector = [] ref_coord = [] # keep the flexibility for unset reference datapoint while i < max_index: if i == self.data_size: qtk.exit("reference not set") data_point = template[index[i]] if not np.isnan(data_point.ref): self.training_set.append(data_point) self.training_index.append(index[i]) reference_vector.append(data_point.getRef()) ref_coord.append(data_point.getVector()) else: max_index += 1 i += 1 self.refVector = np.array(reference_vector) self.refCoord = np.array(ref_coord) self.rest_set = [ data for i, data in enumerate(template) if i not in self.training_index ] def reset_alpha(i): self.rest_set[i].alpha = np.nan vreset_alpha = np.vectorize(reset_alpha) vreset_alpha(range(len(self.rest_set))) rows, columns = self.refCoord.shape qtk.progress("Kernel", "generating",\ "%dx%d" % (size, size), "kernel matrix...") # exteral C module self.kernelMatrix = km.kernel_matrix(self.refCoord, rows, columns, self.kernel, self.klargs) qtk.done() if 'eigen' in kwargs and kwargs['eigen']: qtk.progress("Kernel", "proceed diagonalization...") self.kernelEW, self.kernelEV =\ np.linalg.eigh(self.kernelMatrix) qtk.done() qtk.progress("Kernel", "inverting...") self.alphas = np.dot(np.linalg.inv(self.kernelMatrix\ + self._lambda*np.eye(size))\ ,self.refVector) qtk.done() def set_alpha(i): self.training_set[i].alpha = self.alphas[i] vset_alpha = np.vectorize(set_alpha) vset_alpha(range(len(self.training_set)))
def predict(self, size, **kwargs): template = copy.deepcopy(self.rest_set) index = range(len(self.rest_set)) rd.shuffle(index) test_list = index[:size] i = 0 self.test_set = [self.rest_set[i] for i in test_list] self.kernelVectors = np.atleast_2d([]) self.testCoord = np.array( [data.getVector() for data in self.test_set]) rrows, rcolumns = self.refCoord.shape trows, tcolumns = self.testCoord.shape # exteral C module qtk.progress("Predition", "generating",\ "%dx%d" % (trows, rrows),\ "kernel projection..." ) self.kernelVectors = kv.kernel_vectors(self.refCoord, rrows, rcolumns, self.testCoord, trows, tcolumns, self.kernel,self.klargs) qtk.done() test_true = [] test_pred = [] for i in range(len(self.test_set)): prediction = np.dot(self.kernelVectors[i], self.alphas) self.test_set[i].prediction = prediction test_true.append(self.test_set[i].ref) test_pred.append(prediction) # analize and status report self.testTrue = np.array(test_true) self.testPred = np.array(test_pred) self.error = abs(self.testPred - self.testTrue) self.MAE = sum(self.error)/len(self.error) self.RMSE = np.sqrt(sum(self.error**2)/len(self.testTrue)) max_index = list(self.error).index(max(self.error)) min_index = list(self.error).index(min(self.error)) max_name = self.test_set[max_index].getName() min_name = self.test_set[min_index].getName() qtk.report("predicted MAE", self.MAE) qtk.report("predicted RMSE", self.RMSE) qtk.report("Maximum error", max(self.error), max_name) qtk.report("Minimum error", min(self.error), min_name) def error_estimate(ker, vec): tmp = np.vstack([ker, vec]) K = np.vstack([tmp.T, np.append(vec,1)]).T old = np.linalg.det(ker) new = np.linalg.det(K) #kvec = np.dot(ker, vec.T) #nvec = np.linalg.norm(vec) #nkvec = np.linalg.norm(kvec) # angle #return np.arccos(np.dot(kvec,vec)/nvec/nkvec) # length return new/old #ee = error_estimate(self.kernelMatrix, self.kernelVectors[0]) def error_i(i): return error_estimate(self.kernelMatrix, self.kernelVectors[i]) verror = np.vectorize(error_i) self.errorEstimate = verror(range(trows))
def training(self, size, **kwargs): """ set up training set, test set, and calculate alphas """ # 'lambda' is a python keyword... if 'deviation' in kwargs: self._lambda = kwargs['deviation'] else: self._lambda = 0 qtk.report("Deviation parameter", self._lambda) template = copy.deepcopy(self.data) index = range(self.data_size) rd.shuffle(index) max_index = size i = 0 self.training_set = [] self.training_index = [] reference_vector = [] ref_coord = [] # keep the flexibility for unset reference datapoint while i<max_index: if i==self.data_size: qtk.exit("reference not set") data_point = template[index[i]] if not np.isnan(data_point.ref): self.training_set.append(data_point) self.training_index.append(index[i]) reference_vector.append(data_point.getRef()) ref_coord.append(data_point.getVector()) else: max_index += 1 i += 1 self.refVector = np.array(reference_vector) self.refCoord = np.array(ref_coord) self.rest_set = [data for i, data in enumerate(template) if i not in self.training_index] def reset_alpha(i): self.rest_set[i].alpha = np.nan vreset_alpha = np.vectorize(reset_alpha) vreset_alpha(range(len(self.rest_set))) rows, columns = self.refCoord.shape qtk.progress("Kernel", "generating",\ "%dx%d" % (size, size), "kernel matrix...") # exteral C module self.kernelMatrix = km.kernel_matrix(self.refCoord, rows, columns, self.kernel,self.klargs) qtk.done() if 'eigen' in kwargs and kwargs['eigen']: qtk.progress("Kernel", "proceed diagonalization...") self.kernelEW, self.kernelEV =\ np.linalg.eigh(self.kernelMatrix) qtk.done() qtk.progress("Kernel", "inverting...") self.alphas = np.dot(np.linalg.inv(self.kernelMatrix\ + self._lambda*np.eye(size))\ ,self.refVector) qtk.done() def set_alpha(i): self.training_set[i].alpha = self.alphas[i] vset_alpha = np.vectorize(set_alpha) vset_alpha(range(len(self.training_set)))
def QMRun(inp, program=setting.qmcode, **kwargs): """ interface to run qmcode with written inp files. It manages to start qmcode in **cwd**, write to output, collect result, clean up scratch, tmp files according to setup. However, each code require different implementation. input: inp(str): path to input file code(str): qmcode to run, default set to setting.qmcode kwargs (optional): threads=n(int): number of threads per job bigmem=Boolean: big memory request, implemented for CPMD and others CPMD: save_restart=Boolean scr=/path/to/scratch """ if 'threads' in kwargs: _threads = kwargs['threads'] else: _threads = 1 if 'bigmem' in kwargs: _bigmem = kwargs['bigmem'] else: if setting.memory > 16: _bigmem = True else: _bigmem = False if 'omp' in kwargs: omp = kwargs['omp'] else: omp = 1 if 'save_restart' in kwargs: _save_restart = kwargs['save_restart'] else: _save_restart = False if 'save_density' in kwargs: _save_density = kwargs['save_density'] else: _save_density = False if 'chdir' in kwargs and kwargs['chdir']\ or 'run_dir' in kwargs and kwargs['run_dir']: dest_dir = os.path.splitext(inp)[0] cwd = os.getcwd() os.chdir(dest_dir) ########################################### # SYSTEM CALL SUBPROCESS: Running mpi job # ########################################### def compute(exestr, outpath, threads_per_job, **kwargs): """ initiate a single MPI job, wait for it, and write to output """ os.environ["OMP_NUM_THREADS"] = str(omp) outfile = open(outpath, "w") if threads_per_job > 1: mpi_cmd = "%s %d" % (setting.mpistr, threads_per_job) for mpi_flag in setting.mpi_flags: if mpi_flag == '--cpus-per-proc': flag = mpi_flag + ' ' + str(threads_per_job) else: flag = mpi_flag mpi_cmd = mpi_cmd + ' ' + flag cmd = mpi_cmd + ' ' + exestr else: cmd = exestr ut.progress('QMInp.run', 'running job with command: %s\n' % cmd) if 'env' in kwargs: run = sp.Popen(cmd, shell=True, stdout=outfile, env=kwargs['env']) else: run = sp.Popen(cmd, shell=True, stdout=outfile) # wait each mpijob to finish before lauching another # otherwise all mpijobs will be launched simutaniously run.wait() outfile.close() ########## END OF SYSTEM CALL ########## ################################# # SYSTEM CALL for post analysis # ################################# def sys_run(cmd_str, log_file=None): if log_file: log = open(log_file, 'w') try: qtk.progress("QMRun", cmd_str) if log_file: run = sp.Popen(cmd_str, shell=True, stdout=log) else: run = sp.Popen(cmd_str, shell=True) run.wait() except Exception as err: qtk.warning('%s failed with error: %s' % (cmd_str, err)) if log_file: log.close() ########## END OF SYSTEM CALL ########## ####################### # CPMD IMPLEMENTATION # ####################### if program.lower() == 'cpmd': if 'exe' in kwargs: exe = kwargs['exe'] else: exe = setting.cpmd_exe if 'scr' in kwargs and kwargs['scr']: scrdir = kwargs['scr'] ut.delete(inpname, 'FILEPATH', 2) ut.insert(inpname, 'CPMD', ' FILEPATH\n %s' % scrdir) inp_list = sorted(glob.glob('*.inp')) for job in inp_list: out = os.path.splitext(job)[0] + '.out' exestr = "%s %s" % (exe, job) compute(exestr, out, _threads) if (len(inp_list) > 1): rst_list = sorted(glob.glob('RESTART.*')) if rst_list: rst_n = rst_list[-1] if os.path.exists('RESTART'): os.remove('RESTART') os.link(rst_n, 'RESTART') final_out = re.sub(r'_[0-9][0-9].out$', '.out', out) if final_out != out: os.copy(out, final_out) # clean up files files = sorted(glob.glob('*')) tmp = filter(\ lambda x: '.out' not in x \ and '.inp' not in x\ and '.psp' not in x\ and '.xyz' not in x\ and 'KPTS_GENERATION' not in x\ and 'RESTART' not in x\ and 'DENSITY' not in x\ and 'SPINDEN' not in x, files ) for f in tmp: os.remove(f) if not _save_restart: rst_list = sorted(glob.glob("RESTART*")) for rfile in rst_list: os.remove(rfile) densities = sorted(glob.glob('*DEN*')) for i in range(len(densities)): exe = setting.cpmd_cpmd2cube_exe cmd = "%s -fullmesh %s" % (exe, densities[i]) log_name = densities[i] + '_%02d.log' % i sys_run(cmd, log_name) #log = open(log_name, 'w') #try: # run = sp.Popen("%s -fullmesh %s" % (exe, densities[i]), # shell=True, # stdout=log) # run.wait() #except Exception as err: # qtk.warning('%s failed with error: %s' % (exe, err)) #log.close() if os.path.exists(out): qio_out = qio.QMOut(out, program='cpmd') else: qio_out = None ####################### # VASP IMPLEMENTATION # ####################### elif program.lower() == 'vasp': if 'exe' in kwargs: exestr = kwargs['exe'] else: exestr = setting.vasp_exe qmoutput = inp + '.out' qmlog = inp + '.log' compute(exestr, qmoutput, _threads) qio_out = qio.QMOut('vasprun.xml', program='vasp') if not _save_restart: try: os.remove('WAVECAR') except: pass try: os.remove('POTCAR') except: pass os.rename(qmoutput, qmlog) shutil.copyfile('vasprun.xml', qmoutput) ######################### # NWChem IMPLEMENTATION # ######################### elif program.lower() == 'nwchem': if 'exe' in kwargs: exe = kwargs['exe'] else: exe = setting.nwchem_exe exestr = "%s %s" % (exe, inp) qmoutput = os.path.splitext(inp)[0] + '.out' compute(exestr, qmoutput, _threads) qio_out = qio.QMOut(qmoutput, program='nwchem') files = sorted(glob.glob('*.*')) tmp = filter(\ lambda x: '.out' not in x \ and '.inp' not in x\ and '.cube' not in x\ and '.movecs' not in x, files ) for f in tmp: os.remove(f) movecs = sorted(glob.glob('*.movecs')) for f in movecs: exe = setting.nwchem_mov2asc_exe nb = qio_out.n_basis out = re.sub('\.movecs', '.modat', f) exestr = "%s %d %s %s" % (exe, nb, f, out) sys_run(exestr) #try: # run = sp.Popen(exestr, shell=True) # run.wait() # qio_out.getMO(out) #except Exception as err: # qtk.warning('%s failed with error: %s' % (exe, err)) if not _save_restart: os.remove(f) ######################### # BigDFT IMPLEMENTATION # ######################### elif program.lower() == 'bigdft': if 'exe' in kwargs: exe = kwargs['exe'] else: exe = setting.bigdft_exe env = os.environ.copy() inp = os.path.splitext(inp)[0] exestr = "%s %s" % (exe, inp) qmoutput = inp + '.out' qmlog = 'log-%s.yaml' % inp compute(exestr, qmoutput, _threads, env=env) qio_out = qio.QMOut(qmlog, program='bigdft') ######################### # Abinit IMPLEMENTATION # ######################### elif program.lower() == 'abinit': if 'exe' in kwargs: exe = kwargs['exe'] else: exe = setting.abinit_exe inp = os.path.splitext(inp)[0] exestr = "%s < %s" % (exe, inp + '.files') qmlog = inp + '.log' qmoutput = inp + '.out' compute(exestr, qmlog, _threads) # unfold bandstructure if 'unfold' in kwargs and kwargs['unfold']: folds = kwargs['unfold'] exe = setting.abinit_f2b_exe wfk_list = sorted(glob.glob("*_WFK")) if len(wfk_list) > 0: wfk = wfk_list[-1] qtk.progress("QMRun", "linking wfk file %s to unfold_WFK" % wfk) os.link(wfk, 'unfold_WFK') wfk_root = wfk.replace('_WFK', '') log_name = '%s_f2b.log' % wfk_root fold_str = [str(f) for f in folds] cmd_str = "%s unfold_WFK %s" % (exe, ':'.join(fold_str)) sys_run(cmd_str, log_name) qtk.progress("QMRun", "Done, remove unfold_WFK") os.remove('unfold_WFK') #try: # qtk.progress("QMRun", cmd_str) # run = sp.Popen(cmd_str, shell=True, stdout=log) # run.wait() #except Exception as err: # qtk.warning('%s failed with error: %s' % (exe, err)) #log.close() else: qtk.warning('unfolding but no wavefunction file found...') if 'unfold_cleanup' in kwargs and kwargs['unfold_cleanup']: qtk.progress("QMRun", "deleting all WFK files") for wfk in sorted(glob.glob("*_WFK")): os.remove(wfk) # clean up files files = sorted(glob.glob('*')) tmp = filter(\ lambda x: '.out' not in x \ and '.f2b' not in x\ and '.log' not in x\ and '.inp' not in x\ and '.files' not in x\ and 'psp' not in x\ and '_EIG' not in x\ and '_WFK' not in x\ and '_DOS' not in x\ and '_DEN' not in x, files ) for f in tmp: os.remove(f) if not _save_restart: for rst in sorted(glob.glob('*_WFK')): os.remove(rst) if not _save_density: for den in sorted(glob.glob('*_DEN')): os.remove(den) densities = sorted(glob.glob('*_DEN')) if len(densities) > 0: i = len(densities) - 1 exe = setting.abinit_cut3d_exe #den_inp = densities[i] + '.cov' den_inp = densities[-1] + '.cov' cube_file = inp + '.cube' den_inp_file = open(den_inp, 'wb') den_inp_file.write("%s\n14\n%s\n0" % (densities[i], cube_file)) den_inp_file.close() log_name = densities[i] + '.log' cmd = "%s < %s" % (exe, den_inp) sys_run(cmd, log_name) #log = open(log_name, 'w') #try: # run = sp.Popen("%s < %s" % (exe, den_inp), # shell=True, # stdout=log) # run.wait() #except Exception as err: # qtk.warning('%s failed with error: %s' % (exe, err)) #log.close() qio_out = qtk.QMOut(qmoutput, program='abinit') ############################# # Gaussian09 IMPLEMENTATION # ############################# elif program.lower() == 'gaussian': if 'exe' in kwargs: exe = kwargs['exe'] else: exe = setting.gaussian_exe exestr = "%s %s" % (exe, inp) qmoutput = os.path.splitext(inp)[0] + '.out' qmlog = os.path.splitext(inp)[0] + '.log' compute(exestr, qmoutput, _threads) os.rename(qmlog, qmoutput) chks = sorted(glob.glob('*.chk')) for chk in chks: exe = setting.gaussian_formchk_exe exestr = "%s %s" % (exe, chk) sys_run(exestr) #run = sp.Popen(exestr, shell=True) #run.wait() if _save_density: fchk = sorted(glob.glob("*.fchk"))[-1] q = qtk.CUBE(fchk) qio_out = qio.QMOut(qmoutput, program='gaussian') ################################## # QuantumESPRESSO IMPLEMENTATION # ################################## elif program.lower() == 'espresso': if 'exe' in kwargs: exe = kwargs['exe'] else: exe = setting.espresso_exe inp_list = sorted(glob.glob('*.inp')) for job in inp_list: out = os.path.splitext(job)[0] + '.out' exestr = "%s < %s" % (exe, job) compute(exestr, out, _threads) qio_out = qio.QMOut(out, program='espresso') if not _save_restart: rst_list = sorted(glob.glob("*.wfc*")) rst_list.extend(sorted(glob.glob("*.restart_*"))) else: rst_list = [] for r in rst_list: os.remove(r) ######################### # GAMESS IMPLEMENTATION # ######################### elif program.lower() == 'gamess': ut.exit("ERROR! program '%s' not implemented" % program) # and others... # else: ut.exit("ERROR! program '%s' not recognized" % program) if 'cwd' in locals(): os.chdir(cwd) qio_out.path = inp return qio_out
def pack(data_list, **kwargs): if isinstance(data_list[0], qtk.Molecule): typ = 'molecule' Z = [m.Z for m in data_list] max_N = max(map(len, Z)) elif isinstance(data_list[0], qtk.QMOutput): typ = 'output' Z = [o.molecule.Z for o in data_list if hasattr(o, 'molecule')] max_N = max(map(len, Z)) else: qtk.warning("not supported datatype") if 'output' not in kwargs: kwargs['output'] = 'dictionary' xyzs = [] Zs = [] Es = [] xyzStr = [] for i in range(len(data_list)): if i % 5000 == 0: qtk.progress("processing %d" % (i + 1)) if typ == 'output': if hasattr(data_list[i], 'molecule'): molecule = data_list[i].molecule else: molecule = None Es.append(data_list[i].Et) elif typ == 'molecule': molecule = data_list[i] if molecule is not None: zeroR = np.zeros([max_N - molecule.N, 3]) zeroZ = np.zeros(max_N - molecule.N) xyz = np.vstack([molecule.R, zeroR]).tolist() Z = np.hstack([molecule.Z, zeroZ]) if len(xyzs) == 0: #xyzs = xyz Zs = Z else: #xyzs = np.stack([xyzs,xyz]) Zs = np.vstack([Zs,Z]) xyzs.append(xyz) if kwargs['output'] == 'extended_xyz': xyzStr.append('%d\n' % molecule.N) if typ == 'output': xyzStr.append('%f\n' % data_list[i].Et) elif typ == 'molecule': xyzStr.append('\n') for I in range(molecule.N): r = molecule.R[I] xyzStr.append('%-2s % 8.4f % 8.4f % 8.4f\n'\ % (molecule.type_list[I], r[0], r[1], r[2])) xyzs = np.array(xyzs) if len(Es) > 0: Es = np.array(Es) if len(xyzStr) > 0: xyzStr = ''.join(xyzStr) if kwargs['output'] == 'dictionary': out = {'xyz': xyzs, 'Z': Zs} if len(Es) > 0: out['E'] = np.array(Es) elif kwargs['output'] == 'extended_xyz': out = xyzStr else: qtk.warning('not supported output format:%s' % kwargs['output']) out = None return out
def close(self, **kwargs): """ finalize input content by either 1) creating folder, coping dependent files and write input content to file with correct name or 2) print to screen Note that is returns full path to the file is writes to for posprocessing """ self.path = os.getcwd() if self.output: # process file name if 'name' in kwargs: name = kwargs['name'] else: name = self.file_name if self.prefix: name = self.prefix + name self.root_dir = self.prefix + self.root_dir if self.suffix: name = name + self.suffix self.root_dir = self.root_dir + self.suffix if self.extension: name = name + '.' + self.extension self.final_name = name full_dir_path = self.path # process directory name and clean up if self.root_dir: full_dir_path = os.path.join(self.path, self.root_dir) if name: full_path = os.path.join(full_dir_path, name) if not 'no_cleanup' in kwargs or not kwargs['no_cleanup']: if self.root_dir: self.cleanPath(full_dir_path, self.overwrite) self.cleanPath(full_path, self.overwrite) if not os.path.exists(full_dir_path): os.makedirs(full_dir_path) self.final_path = full_dir_path # copy dependent files if 'dependent_files' in kwargs: self.dependent_files.extend(kwargs['dependent_files']) for dep_entry in self.dependent_files: if type(dep_entry) is str: # copy file directly dep = dep_entry dep_name = os.path.split(dep)[1] dep_src = os.path.abspath(dep) dep_tar = os.path.join(full_dir_path, dep_name) elif type(dep_entry) is list: # copy file to different name [src, name] dep = dep_entry[1] dep_name = os.path.split(dep)[1] dep_src = os.path.abspath(dep_entry[0]) #dep_src = os.path.join(dep_src, dep_name) dep_tar = os.path.join(full_dir_path, dep_name) elif type(dep_entry) is dict: # copy file to different path/name {src: path/name} dep = dep_entry.keys()[0] dep_name = os.path.split(dep)[1] dep_src = os.path.abspath(dep) dep_tar = os.path.join(full_dir_path, dep_entry[dep]) if os.path.exists(dep_src): try: shutil.copytree(dep_src, dep_tar) except OSError: if hasattr(self, 'link_dep') and self.link_dep: try: os.link(dep_src, dep_tar) qtk.progress('QMInp', '%s is linked\n' % \ os.path.split(dep_tar)[-1]) except Exception as err: qtk.warning('error when linking %s, ' \ % os.path.split(dep_tar)[-1]\ + 'attempt to copy...') try: shutil.copy(dep_src, dep_tar) qtk.progess('QMInp', 'done.') except Exception as err: qtk.warning('failed! skipping %s' % \ os.path.split(dep_tar)[-1]) else: shutil.copy(dep_src, dep_tar) else: qtk.warning('dependent file: %s not found' % dep) inp = sys.stdout if not self.output else open(full_path, 'w') for string in self.content: if string: inp.write(string) if self.output: inp.close() self.finalized = True