def runCode(self, parrent, name, **kwargs): worker, name = \ super(parrent, self).run(kwargs['program'], name, **kwargs) if 'no_subfolder' not in kwargs or not kwargs['no_subfolder']: self.setting['root_dir'] = name def run(): if 'charge' in kwargs: self.setChargeMultiplicity(kwargs['charge'], 1) inp = self.write(name, **kwargs) new_name = None if 'new_name' in kwargs: new_name = kwargs['new_name'] return worker.start(inp, new_name) if not os.path.exists(name): return run() elif 'rename_if_exist' in self.setting\ and self.setting['rename_if_exist']: n_name = len(glob.glob("%s_[0-9]" % name)) + 1 new_name = name + '_%d' % n_name while os.path.exists(new_name): n_name = n_name + 1 new_name = name + '_%d' % n_name kwargs['root_dir'] = new_name qtk.warning("folder %s exists, running under %s" % (name, new_name)) return run() elif self.setting['overwrite']: qtk.warning("Overwrite existing folder %s" % name) return run() else: qtk.report("QMInp.run", "%s exists" % name)
def PPCheck(xc, element, pp_file_str, **kwargs): if xc == 'lda': xc = 'pade' ne = qtk.n2ve(element) try: if 'dcacp' in kwargs and kwargs['dcacp']: pp_path = os.path.join(xc.upper(), "%s_DCACP_%s" %\ (element, xc.upper())) if element in qtk.setting.dcacp_dict: pp_path = pp_path + "_%s" % qtk.setting.dcacp_dict[element] pp_file = os.path.join(qtk.setting.cpmd_dcacp_url, pp_path) else: pp_path = os.path.join(xc, element + '-q' + str(qtk.n2ve(element))) pp_file = os.path.join(qtk.setting.cpmd_pp_url, pp_path) saved_pp_path = os.path.join(qtk.setting.cpmd_pp, pp_file_str) if not os.path.exists(saved_pp_path) \ and qtk.setting.download_pp: if pp_file: new_pp = os.path.join(qtk.setting.cpmd_pp, pp_file_str) pp_content = urllib2.urlopen(pp_file).read() qtk.report('PPCheck', 'pp file %s not found in %s, ' \ % (pp_file_str, qtk.setting.cpmd_pp) + \ 'but found on internet, download now...') new_pp_file = open(new_pp, 'w') new_pp_file.write(pp_content) new_pp_file.close() pp_file = new_pp return saved_pp_path except: qtk.warning('something wrong with pseudopotential')
def __call__(self, *coord, **kwargs): if 'unit' not in kwargs: unit = 'angstrom' else: unit = kwargs['unit'].lower() if unit not in ['angstrom', 'bohr']: qtk.warning('unit %s not reconized, set to Bohr' % unit) unit = 'bohr' R = np.atleast_2d(np.array(coord)) if len(coord) == 3: try: x, y, z = [float(c) for c in coord] R = np.atleast_2d(np.array([x, y, z])) except TypeError: pass if unit == 'angstrom': R = [r / 0.529177249 for r in R] if not self.interp: self.interpolate() if len(R) == 1: return self.interp(R)[0] else: return self.interp(R)
def start(self, InpClass, new_name=None, root_dir=None): self.inp = InpClass if not new_name: self.name = self.inp.final_name else: self.name = new_name if self.inp.finalized: cwd = os.getcwd() os.chdir(self.inp.final_path) run_setup = copy.deepcopy(self.setting) del run_setup['program'] if 'debug' in self.setting and self.setting['debug']: out = qmjob.QMRun(self.name, self.qmcode, **run_setup) os.chdir(cwd) else: try: out = qmjob.QMRun(self.name, self.qmcode, **run_setup) except Exception, err: qtk.warning("qmjob finished unexpectedly for '" + \ self.name + "'" + ", with error message:\n"\ + str(err)) out = GenericQMOutput() finally: os.chdir(cwd)
def resize(self, cn, hn): too_small = False if cn < self.param['Cn']: too_small = True else: self.param['Cn'] = cn tmp = [0 for i in range(cn)] tmp[:len(self.param['Ci'])] = self.param['Ci'] self.param['Ci'] = copy.deepcopy(tmp) if len(hn) < len(self.param['h_ij']): too_small = True else: n = len(hn) tmp = [0 for i in range(n)] tmp[:len(self.param['r_nl'])] = self.param['r_nl'] self.param['r_nl'] = copy.deepcopy(tmp) tmp = [np.zeros((0,0)) for i in range(len(hn))] tmp[:len(self.param['h_ij'])] = self.param['h_ij'] self.param['h_ij'] = copy.deepcopy(tmp) if not too_small: for i in range(len(hn)): n = hn[i] h = self.param['h_ij'][i] if n > len(h): tmp = np.zeros((n,n)) tmp[:len(h), :len(h)] = h self.param['h_ij'][i] = tmp else: qtk.warning('PP dimension too small') self.dim = self.getDim() return self
def start(self, InpClass, new_name=None): self.inp = InpClass if not new_name: self.name = self.inp.final_name else: self.name = new_name if self.inp.finalized: cwd = os.getcwd() os.chdir(self.inp.final_path) run_setup = copy.deepcopy(self.setting) del run_setup['program'] if 'debug' in self.setting and self.setting['debug']: out = qmjob.QMRun(self.name, self.qmcode, **run_setup) os.chdir(cwd) else: try: out = qmjob.QMRun(self.name, self.qmcode, **run_setup) except Exception, err: qtk.warning("qmjob finished unexpectedly for '" + \ self.name + "'" + ", with error message:\n"\ + str(err)) out = GenericQMOutput() finally: os.chdir(cwd)
def qmRunAll(inp_list, root=None,**kwargs): if 'block_size' not in kwargs: kwargs['block_size'] = 1 job = [] for inp in inp_list: job.append([inp, inp.molecule.name]) inp = inp_list[0] if inp.setting['threads'] != 1 and 'threads' not in kwargs: kwargs['threads'] = setting.cpu_count / inp.setting['threads'] if root is None: qtk.parallelize(qtk.qmRunJob, job, **kwargs) else: if os.path.exists(root): if 'overwrite' in kwargs and kwargs['overwrite']: qtk.warning("overwrite existing folder %s" % root) shutil.rmtree(root) os.makedirs(root) else: qtk.warning("%s exists, " % root +\ "joining calculations with other threads") else: os.makedirs(root) cwd = os.getcwd() os.chdir(root) qtk.parallelize(qtk.qmRunJob, job, **kwargs) os.chdir(cwd)
def qmRunAll(inp_list, root=None, **kwargs): if 'block_size' not in kwargs: kwargs['block_size'] = 1 job = [] for inp in inp_list: job.append([inp, inp.molecule.name]) inp = inp_list[0] if inp.setting['threads'] != 1 and 'threads' not in kwargs: kwargs['threads'] = setting.cpu_count / inp.setting['threads'] if root is None: qtk.parallelize(qtk.qmRunJob, job, **kwargs) else: if os.path.exists(root): if 'overwrite' in kwargs and kwargs['overwrite']: qtk.warning("overwrite existing folder %s" % root) shutil.rmtree(root) os.makedirs(root) else: qtk.warning("%s exists, " % root +\ "joining calculations with other threads") else: os.makedirs(root) cwd = os.getcwd() os.chdir(root) qtk.parallelize(qtk.qmRunJob, job, **kwargs) os.chdir(cwd)
def write_xyz(self, name=None, **kwargs): def listStr(data_list): out = str(data_list) out = out.replace('[', '') out = out.replace(']', '') return out.replace(',', '') out = sys.stdout if not name else open(name,"w") if 'fractional' in kwargs and kwargs['fractional']: if self.celldm and self.scale: out.write(str(self.N)+"\n\n") for I in xrange(0, self.N): out.write("%-2s " % self.type_list[I]) out.write(" ".join("% 8.4f" % i \ for i in self.R_scale[I][:])) out.write('\n') out.write("\ncelldm: %s\n" % listStr(self.celldm)) out.write('scale: %s\n' % listStr(self.scale)) if self.symmetry: out.write('symmetry: %s\n' % self.symmetry) else: del kwargs['fractional'] qtk.warning('celldm or scale not set, print cartician') self.write(name, **kwargs) else: out.write(str(self.N)+"\n\n") for I in xrange(0, self.N): out.write("%-2s " % self.type_list[I]) out.write(" ".join("% 8.4f" % i for i in self.R[I][:])) out.write("\n") if name: out.close()
def __call__(self, *coord, **kwargs): if 'unit' not in kwargs: unit = 'angstrom' else: unit = kwargs['unit'].lower() if unit not in ['angstrom', 'bohr']: qtk.warning('unit %s not reconized, set to Bohr' % unit) unit = 'bohr' R = np.atleast_2d(np.array(coord)) if len(coord) == 3: try: x, y, z = [float(c) for c in coord] R = np.atleast_2d(np.array([x,y,z])) except TypeError: pass if unit == 'angstrom': R = [r / 0.529177249 for r in R] if not self.interp: self.interpolate() if len(R) == 1: return self.interp(R)[0] else: return self.interp(R)
def cm_check(self, mol): ve = mol.getValenceElectrons() if (ve % 2) == (mol.multiplicity % 2): msg = "Multiplicity %d " % mol.multiplicity + \ "and %d valence electrons " % ve +\ "\n(with charge %3.1f) " % float(mol.charge) +\ "are not compatible" qtk.warning(msg)
def pdump(obj, name): try: with open(name, 'wb') as pfile: pickle.dump(obj, pfile) except TypeError: qtk.warning('possible issues with ctypes extensions') obj = copy.deepcopy(obj) structure = qtk.get_nested_structure(obj)
def n2Z(Zn): match = [m for m in z_list.iterkeys() if m in Zn] mlen = [len(s) for s in match] if len(match) > 0: ind = np.argmax(mlen) return float(z_list[match[ind]]) else: qtk.warning("n2Z: element type " + str(Zn) + " is not defined, returning nuclear charge 0") return 0
def run(self, name=None, **kwargs): self.setting.update(kwargs) if self.setting['theory'] in ['hf']: optimizer = PlainSCFSolver opt_arg = [ self.ht_ham, self.ht_olp, self.ht_occ_model, self.ht_exp_alpha ] elif is_gga(self) or is_mgga(self): optimizer = CDIISSCFSolver opt_arg = [ self.ht_ham, self.ht_olp, self.ht_occ_model, self.ht_dm_alpha ] elif is_hgga(self) or is_mhgga(self): optimizer = EDIIS2SCFSolver opt_arg = [ self.ht_ham, self.ht_olp, self.ht_occ_model, self.ht_dm_alpha ] scf_solver = optimizer(threshold=self.setting['wf_convergence'], maxiter=self.setting['scf_step']) scf_solver(*opt_arg) if self.setting['theory'] is not 'hf': fock_alpha = np.zeros(self.ht_olp.shape) self.ht_ham.reset(self.ht_dm_alpha) self.ht_ham.compute_energy() self.ht_ham.compute_fock(fock_alpha) self.ht_exp_alpha.from_fock_and_dm(fock_alpha, self.ht_dm_alpha, self.ht_olp) self.ht_solver = scf_solver try: self.Et = self.ht_ham.cache['energy'] self.mov = self.ht_exp_alpha.coeffs.__array__() self.mo_vectors = self.mov self.mo_eigenvalues = self.ht_exp_alpha.energies except Exception as err: qtk.warning('SCF did not converged: %s' % err) self.Et = np.nan self.mol = self.molecule out = qtk.QM.gaussianbasis_io.GaussianBasisOutput() for attr in dir(out): if not hasattr(self, attr): setattr(self, attr, getattr(out, attr)) for attr in dir(self): if not attr.startswith('_'): setattr(out, attr, getattr(self, attr)) return out
def n2Z(Zn): match = [m for m in z_list.iterkeys() if m in Zn] mlen = [len(s) for s in match] if len(match) > 0: ind = np.argmax(mlen) return float(z_list[match[ind]]) else: qtk.warning("n2Z: element type " + str(Zn) +\ " is not defined, returning nuclear charge 0") return 0
def read_xyz(self, name, **kwargs): xyz = open(name, 'r') content = xyz.readlines() xyz.close() content = [line.replace('\t', ' ') for line in content] prop_list = ['charge', 'celldm', 'scale', 'symmetry'] for prop in prop_list: try: prop_str = filter(lambda x: prop in x, content)[0] prop_str = re.sub('.*:', '', prop_str) prop_data = prop_str.split(' ') prop_data = filter(None, prop_data) if len(prop_data) == 1: try: setattr(self, prop, float(prop_data[0])) except Exception as exc: if prop == 'symmetry': setattr(self, prop, prop_data[0].strip()) elif len(prop_data) > 1: setattr(self, prop, [float(_) for _ in prop_data]) except ValueError as exc: setattr(self, prop, False) qtk.warning("setting attribute %s with error: %s" % \ (prop, exc)) except: setattr(self, prop, False) if not self.charge: self.charge = 0 if self.celldm or self.scale: self.periodic = True if self.celldm: assert len(self.celldm) == 6 self.N = int(content[0]) coord_list = content[2 : self.N + 2] coord = [filter(None,[a for a in entry.split(' ')]) for entry in coord_list] type_list = list(np.array(coord)[:,0]) self.type_list = [str(elem) for elem in type_list] self.Z = [qtk.n2Z(elem) for elem in self.type_list] self.Z = np.array(self.Z) self.R = np.array(coord)[:,1:4].astype(float) self.box = False if self.celldm: self.periodic = True angle = self.celldm[3:] angle_sum = sum([abs(entry) for entry in angle]) if angle_sum == 0: self.box = self.celldm[:3] self.R_scale = copy.deepcopy(self.R) self.R = qtk.fractional2xyz(self.R_scale, self.celldm)
def Z2n(Z): if type_list.has_key(Z): return type_list[Z] elif type(Z) is float: return "ATOM_%4.2f" % Z qtk.warning("Z2n: atomic number not defined, return HETATM") elif type(Z) is int: return "ATOM_%d" % Z qtk.warning("Z2n: atomic number not defined, return HETATM") else: qtk.exit("Z2n: atomic number " + str(Z) + " is not defined")
def Z2n(Z): if type_list.has_key(Z): return type_list[Z] elif type(Z) is float: return 'ATOM_%4.2f' % Z qtk.warning('Z2n: atomic number not defined, return HETATM') elif type(Z) is int: return 'ATOM_%d' % Z qtk.warning('Z2n: atomic number not defined, return HETATM') else: qtk.exit("Z2n: atomic number " + str(Z) + " is not defined")
def PPCheck(xc, pp_theory, pp_path, element): theory_dict = { 'lda': 'pade', 'pbe0': 'pbe', 'pbesol': 'pbe', 'hse06': 'pbe', } name = '%s_%s_%s' % (element, xc, pp_theory) pp_file = os.path.join(pp_path, name) if not os.path.exists(pp_file) and qtk.setting.download_pp: if pp_theory != 'nlcc': if pp_theory in theory_dict.keys(): pp_theory = theory_dict[pp_theory] url_root = qtk.setting.bigdft_pp_url element_str = element + '-q%d' % qtk.n2ve(element) url = url_root + '%s/%s' % (pp_theory, element_str) page = False try: page = urllib2.urlopen(url).readlines() pattern = re.compile(r'^.*</*pre>.*$') pp_se = filter(pattern.match, page) pp_start = page.index(pp_se[0]) pp_end = page.index(pp_se[1]) page = page[pp_start:pp_end] page[0] = page[0].split('>')[-1] except: qtk.warning('something wrong with url:%s' % url) pp = ''.join(page) else: url = qtk.setting.bigdft_pp_nlcc_url page = urllib2.urlopen(url).readlines() string = filter(lambda x: '"psppar.%s' % element in x, page)[-1] index = page.index(string) + 2 pp = [] itr = 0 while '</pre>' not in page[index + itr] \ and index + itr < len(page)\ and itr < 20: pp.append(page[index + itr]) itr = itr + 1 pp = ''.join(pp) if pp: qtk.report('', 'pp file %s not found in %s.' %\ (name, pp_path) +\ ' But found in cp2k page, download now...') new_pp_file = open(pp_file, 'w') new_pp_file.write(pp) new_pp_file.close() return pp_file
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 __init__(self, qmout, **kwargs): WaveletOutput.__init__(self, qmout, **kwargs) self.info = '' try: with open(qmout, 'r') as raw_yml: self.detail = yaml.load(raw_yml) except Exception as err: qtk.warning("error when loading yaml file: %s" % err) if 'Last Iteration' in self.detail.keys(): self.Et = self.detail['Last Iteration']['EKS'] else: qtk.warning("Entry Last Iteration not found")
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 PPCheck(xc, pp_theory, pp_path, element): theory_dict = { 'lda': 'pade', } name = '%s_%s_%s' % (element, xc, pp_theory) pp_file = os.path.join(pp_path, name) if not os.path.exists(pp_file) and qtk.setting.download_pp: if pp_theory != 'nlcc': if pp_theory in theory_dict.keys(): pp_theory = theory_dict[pp_theory] url_root = qtk.setting.bigdft_pp_url element_str = element + '-q%d' % qtk.n2ve(element) url = url_root + '%s/%s' % (pp_theory, element_str) page = False try: page = urllib2.urlopen(url).readlines() pattern = re.compile(r'^.*</*pre>.*$') pp_se = filter(pattern.match, page) pp_start = page.index(pp_se[0]) pp_end = page.index(pp_se[1]) page = page[pp_start:pp_end] page[0] = page[0].split('>')[-1] except: qtk.warning('something wrong with url:%s' % url) pp = ''.join(page) else: url = qtk.setting.bigdft_pp_nlcc_url page = urllib2.urlopen(url).readlines() string = filter(lambda x: '"psppar.%s' % element in x, page)[-1] index = page.index(string) + 2 pp = [] itr = 0 while '</pre>' not in page[index + itr] \ and index + itr < len(page)\ and itr < 20: pp.append(page[index + itr]) itr = itr + 1 pp = ''.join(pp) if pp: qtk.report('', 'pp file %s not found in %s.' %\ (name, pp_path) +\ ' But found in cp2k page, download now...') new_pp_file = open(pp_file, 'w') new_pp_file.write(pp) new_pp_file.close() return pp_file
def cleanPath(self, path, force=False): if os.path.exists(path): if force: try: os.remove(path) except OSError: shutil.rmtree(path) else: qtk.prompt(path + ' exists, overwrite?') try: os.remove(path) except OSError: shutil.rmtree(path) except: qtk.warning("can not remove file: " + path)
def PPCheck(xc, element, pp_file_str, **kwargs): ne = qtk.n2ve(element) saved_pp_path = os.path.join(qtk.setting.espresso_pp, pp_file_str) if not os.path.exists(saved_pp_path) and qtk.setting.download_pp: qtk.status("PPCheck", pp_file_str) url = os.path.join(qtk.setting.espresso_pp_url, pp_file_str) try: pp_content = urllib2.urlopen(url).read() qtk.report('', 'pp file %s not found in %s. ' \ % (pp_file_str, qtk.setting.espresso_pp) + \ 'but found in espresso page, download now...') new_pp_file = open(saved_pp_path, 'w') new_pp_file.write(pp_content) new_pp_file.close() except: qtk.warning('something wrong with pseudopotential')
def qmWriteAll(inp_list, root, **kwargs): if os.path.exists(root): if 'overwrite' in kwargs and kwargs['overwrite']: qtk.warning("overwrite existing folder %s" % root) shutil.rmtree(root) os.makedirs(root) else: qtk.warning("%s exists, " % root +\ "joining calculations with other threads") else: os.makedirs(root) cwd = os.getcwd() os.chdir(root) for inp in inp_list: inp.write(inp.molecule.name) os.chdir(cwd)
def primitiveCell(symmetry): if symmetry == 'fcc': return 0.5 * np.array([ [0, 1, 1], [1, 0, 1], [1, 1, 0], ]) elif symmetry == 'bcc': return 0.5 * np.array([ [-1, 1, 1], [1, -1, 1], [1, 1, -1], ]) else: qtk.warning('symmetry %s not found' % symmetry) return np.ones(3)
def removeAtoms(self, indices): if type(indices) is int: indices = [indices] indices.sort() i_max = indices[-1] if i_max <= self.N - 1: for i in range(len(indices)): index = indices[len(indices) - 1 - i] self.N -= 1 self.R = np.delete(self.R, index, 0) self.Z = np.delete(self.Z, index) self.type_list = list(np.delete(self.type_list, index)) else: msg = "index:%d out of range:%d, nothing has happend"\ % (index, self.N) qtk.warning(msg)
def run_jobs(q_in, q_out): for inps in iter(q_in.get, None): ind = inps[-1] # index of job inps = inps[:-1] # actual input sequence out = [] try: for args in inps: if type(args[-1]) == dict: # check known args input kwargs = args[-1] args = args[:-1] out.append(target_function(*args, **kwargs)) else: out.append(target_function(*args)) q_out.put([out, ind]) # output result with index except: qtk.warning('job failed!') q_out.put([np.nan, ind])
def __init__(self, pattern, qm_property='Et', **kwargs): if 'program' not in kwargs: kwargs['program'] = qtk.setting.qmcode if 'unit' not in kwargs: kwargs['unit'] = 'Eh' out_files = sorted(glob.glob(pattern)) if not out_files: qtk.warning('no output files matched %s' % pattern) files = [] values = [] self.qmout = [] self.names = [] for out in out_files: out_file = os.path.split(out)[1] out_file = re.sub('\.out', '', out_file) qmout = qtk.QMOut(out, program=kwargs['program']) qmout.inUnit(kwargs['unit']) try: value = getattr(qmout, qm_property) except: qtk.warning('%s not found for file %s' %\ (qm_property, out_file)) value = np.nan files.append(out_file) values.append(value) self.names.append(out_file) self.qmout.append(qmout) self.data = pd.Series(values, index=files) method_strlist = [m for m in dir(self.data)] method_list = [] for m in method_strlist: try: if callable(getattr(self.data, m)): method_list.append(m) except: pass p = re.compile('^[a-z].*$') method_list = filter(p.match, method_list) for m in method_list: if m not in dir(self): setattr(self, m, getattr(self.data, m))
def update(self, inp_list, out_list, info_list): print len(inp_list), len(out_list), len(info_list) print inp_list, out_list for i in range(len(inp_list)): content = str(inp_list[i]) comment = str(info_list[i]) data = out_list[i] q = self.log.list(content) if len(q) == 0: qtk.warning("no entry found with %s" % content) self.log.push(content, data, comment) else: if len(q) > 1: qtk.warning("found multiple entry with %s" % content) entry = q[-1] entry.data = out_list[i] entry.comment = info_list[i] self.log.commit()
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 get_coord(self, mol): qtk.warning( "temporary implementation for special cases of cubic AlGaAs") coord = self.random()[1] mut_list = coord['mutation'][0] ref_list = self.mutation_list[0] scale = np.asarray(self.structure.scale) for ind_i in range(len(ref_list)): i = ref_list[ind_i] base_R = self.structure.R_scale[i] for ind_j in range(len(ref_list)): j = ref_list[ind_j] diff = np.linalg.norm(base_R - mol.R_scale[j] * scale) print diff if diff < 1E-5: print 'yo' mut_list[ind_j] = mol.Z[j] print mut_list print coord return coord
def PPCheck(xc, element, pp_file_str, **kwargs): ne = qtk.n2ve(element) try: pp_path = os.path.join(xc, element + '-q' + str(qtk.n2ve(element))) pp_file = os.path.join(qtk.setting.cpmd_pp_url, pp_path) saved_pp_path = os.path.join(qtk.setting.cpmd_pp, pp_file_str) if not os.path.exists(saved_pp_path) and qtk.setting.download_pp: if pp_file: new_pp = os.path.join(qtk.setting.cpmd_pp, pp_file_str) pp_content = urllib2.urlopen(pp_file).read() qtk.report('', 'pp file %s not found in %s. ' \ % (pp_file_str, qtk.setting.cpmd_pp) + \ 'but found in cp2k page, download now...') new_pp_file = open(new_pp, 'w') new_pp_file.write(pp_content) new_pp_file.close() pp_file = new_pp return saved_pp_path except: qtk.warning('something wrong with pseudopotential')
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 write_xyz(self, name=None, **kwargs): def listStr(data_list): out = str(data_list) out = out.replace('[', '') out = out.replace(']', '') return out.replace(',', '') out = sys.stdout if not name else open(name,"w") if 'fractional' in kwargs and kwargs['fractional']: if self.celldm and self.scale: if 'comment' in kwargs: out.write(str(self.N)+"\n" + str(kwargs['comment']) + "\n") else: out.write(str(self.N)+"\n\n") for I in xrange(0, self.N): out.write("%-2s " % self.type_list[I]) out.write(" ".join("% 8.4f" % i \ for i in self.R_scale[I][:])) out.write('\n') out.write("\ncelldm: %s\n" % listStr(self.celldm)) out.write('scale: %s\n' % listStr(self.scale)) if self.symmetry: out.write('symmetry: %s\n' % self.symmetry) else: del kwargs['fractional'] qtk.warning('celldm or scale not set, print cartician') self.write(name, **kwargs) else: if 'comment' in kwargs: out.write(str(self.N)+"\n" + str(kwargs['comment']) + "\n") else: out.write(str(self.N)+"\n\n") for I in xrange(0, self.N): out.write("%-2s " % self.type_list[I]) out.write(" ".join("% 8.4f" % i for i in self.R[I][:])) out.write("\n") if name: out.close()
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 write(self, cpmd_name, espresso_name): if not os.path.exists(cpmd_name): qtk.report("PP", "writing cpmd PP file") cpmd_write(self, cpmd_name) cpmd_exists = False else: cpmd_exists = True qtk.prompt('cpmd pp path:%s exist' % cpmd_name) if (cpmd_name == espresso_name and not cpmd_exists)\ or not os.path.exists(espresso_name): qtk.report("PP", 'start converting Goedecker PP') conv_pp = sp.Popen("%s %s" % \ (qtk.setting.espresso_cpmd2upf_exe, cpmd_name), shell=True) conv_pp.wait() if conv_pp.returncode != 0: qtk.warning('conversion failed...') else: os.rename(cpmd_name + '.UPF', espresso_name) else: qtk.prompt('espresso pp path:%s exist' % espresso_name)
def setDescriptor(self, descriptor, **kwargs): self.descriptor = descriptor if 'threads' in kwargs: self.threads = int(kwargs['threads']) else: self.threads = 1 qtk.report("DataSet", "reading folder", self.path) qtk.report("Descriptor", self.descriptor) if descriptor == 'CoulombMatrix': if 'matrix_size' not in kwargs: qtk.warning("matrix size not assigend, " + \ "using default value") qtk.warning("matrix size WILL CHANGE " + \ "according to numer of atoms in the molecule") self.matrix_size = 0 else: self.matrix_size = kwargs['matrix_size'] else: qtk.exit("descriptor" + descriptor + "is not implemented") if self.threads > 1: data_list = [] for data in sorted(\ glob.glob(self.path + '/' + self.pattern)): data_list.append([descriptor, self.matrix_size, {'xyz':data}]) self.data = qtk.parallelize(DataPoint, data_list, threads=self.threads) else: for data in sorted(\ glob.glob(self.path + '/' + self.pattern)): self.data.append(\ DataPoint(descriptor, self.matrix_size, xyz=data)\ ) self.data_size = len(self.data)
def runCode(self, parrent, name, **kwargs): worker, name = \ super(parrent, self).run(kwargs['program'], name, **kwargs) if 'no_subfolder' not in kwargs or not kwargs['no_subfolder']: self.setting['root_dir'] = name def run(): if 'charge' in kwargs: self.setChargeMultiplicity(kwargs['charge'], 1) inp = self.write(name, **kwargs) new_name = None if 'new_name' in kwargs: new_name = kwargs['new_name'] return worker.start(inp, new_name) if not os.path.exists(name): return run() elif self.setting['overwrite']: qtk.warning("Overwrite existing folder %s" % name) return run() else: qtk.report("QMInp.run", "%s exists" % name)
def plot_band(self, path, dk=0.1, n_cb=2, n_vb=2, krange=1, ax=None): if not hasattr(self, 'kpoints_symmetrized'): qtk.warning( 'Make sure full kmesh is available. Brillouinize might help') p, ticks = self._kPath(path, dk) x = np.linspace(0, len(p) - 1, 100) tick_pos, tick_txt = ticks[0], ticks[1] if ax is None: fig, ax = plt.subplots() bands = [] bands_out = [] occ = np.array(self.occupation) vb_top = np.where(occ < 1)[0][0] for b in range(vb_top - n_vb, vb_top + n_cb): bout, cb = self._interpolate(b, krange=krange) band_points = bout(p) bands_out.append(bout) interb = interp1d(range(len(p)), band_points, kind='linear') if b < vb_top: color = 'r' else: color = 'b' if b == vb_top or b == vb_top + 1: bands.append(bout) plt.plot(x, interb(x), color=color) plt.plot(band_points, ls='', marker='x', color=color) for pos in tick_pos: plt.axvline(pos, color='k') plt.axhline(0, color='r', ls='--') plt.axhline(cb, color='b', ls='--') ax.set_xticks(tick_pos) ax.set_xticklabels(tick_txt) ax.set_xlim([0, len(p) - 1]) return ax
def plot_band(self, path, dk=0.1, n_cb=2, n_vb=2, krange=1, ax=None): if not hasattr(self, 'kpoints_symmetrized'): qtk.warning('Make sure full kmesh is available. Brillouinize might help') p, ticks = self._kPath(path, dk) x = np.linspace(0, len(p)-1, 100) tick_pos, tick_txt = ticks[0], ticks[1] if ax is None: fig, ax = plt.subplots() bands = [] bands_out = [] occ = np.array(self.occupation) vb_top = np.where(occ < 1)[0][0] for b in range(vb_top - n_vb, vb_top + n_cb): bout, cb = self._interpolate(b, krange=krange) band_points = bout(p) bands_out.append(bout) interb = interp1d(range(len(p)), band_points, kind='linear') if b < vb_top: color = 'r' else: color = 'b' if b == vb_top or b == vb_top + 1: bands.append(bout) plt.plot(x,interb(x), color=color) plt.plot(band_points, ls='', marker='x', color=color) for pos in tick_pos: plt.axvline(pos, color='k') plt.axhline(0, color='r', ls='--') plt.axhline(cb, color='b', ls='--') ax.set_xticks(tick_pos) ax.set_xticklabels(tick_txt) ax.set_xlim([0, len(p)-1]) return ax
def QMOut(out=None, **kwargs): out_dict = { "cpmd": cpmd.out, "vasp": vasp.out, "abinit": abinit.out, "espresso": espresso.out, "nwchem": nwchem.out, "horton": horton.out, "gaussian": gaussian.out, "bigdft": bigdft.out, } if "unit" in kwargs: unit = kwargs["unit"] else: unit = "Ha" output = qtk.QMOutput() if out is not None and not os.path.exists(out): qtk.warning("%s not found" % out) # return qtk.QMOut() else: if "program" in kwargs: p_str = kwargs["program"] if "debug" in kwargs and kwargs["debug"]: # return out_dict[p_str](out).inUnit(unit) output = out_dict[p_str](out) else: try: # return out_dict[p_str](out) output = out_dict[p_str](out) except Exception as e: qtk.warning("%s failed with message: %s" % (out, e)) # qout = qtk.QMOut() output.path, output.name = os.path.split(out) # return output.inUnit(unit) else: for p in out_dict.itervalues(): try: output = p(out) except: pass qtk.warning("something wrong with output file, " + "pass 'program' eplicitly") return output.inUnit(unit)
def ESP(self, coord=None, **kwargs): """ method for electron density Note: CUBE file is assumed to be orthorohmbic """ data = self.data grid = self.grid if 'molecule' not in kwargs: mol = self.molecule else: try: mol = copy.deepcopy(qtk.toMolecule(kwargs['molecule'])) except: qtk.exit("error when loading molecule:%s" % \ str(kwargs['molecule'])) N = mol.N Q = self.integrate() Z_sum = sum(mol.Z) ne_diff = abs(Q - Z_sum) ve_diff = abs(Q - mol.getValenceElectrons()) if min(ne_diff, ve_diff) > 1E-2: qtk.warning("charge not conserved... ESP is wrong!") qtk.warning("charge integrate to %.2f, " % Q + \ "while nuclear charge adds to %.2f" % Z_sum) if ve_diff < ne_diff: Z = [qtk.n2ve(qtk.Z2n(z)) for z in mol.Z] Z = np.array(Z).reshape(N, 1) else: Z = mol.Z.reshape(N, 1) structure = np.hstack([Z, mol.R * 1.889725989]) if coord is not None: x, y, z = np.array(coord) * 1.889725989 V = ESP_c.esp_point(grid, structure, data, x, y, z) return V else: qtk.warning("known issue: unidentifed memory leak") out = copy.deepcopy(self) out.molecule = mol out.data = np.nan_to_num( ESP_cube_c.esp_cube(grid, structure, data) ) return out
def __init__(self, qmoutXML, **kwargs): PlanewaveOutput.__init__(self, qmoutXML, **kwargs) if qmoutXML: #xml_file = open(qmoutXML) tree = ET.parse(qmoutXML) #xml_file.close() self.xml = tree.getroot() self.Et, self.unit = qtk.convE(float(self.xml[-2][-5][1].text), 'eV-Eh', '-') self.info = self.xml[0][1].text self.SCFStep = len(self.xml[-2])-9 try: # kpoints and band structure data kpoints = [] band = [] occ = [] for i in range(len(self.xml[2][1])): k_str = self.xml[2][1][i].text weight = float(self.xml[2][2][i].text) band_k = [] occ_k = [] bk_xml = self.xml[-2][-3][0][5][0][i] for b_xml in bk_xml: b, o = [float(c) for c in b_xml.text.split()] band_k.append(b) occ_k.append(o) coord = [float(c) for c in k_str.split()] coord.append(weight) kpoints.append(coord) band.append(band_k) occ.append(occ_k) self.mo_eigenvalues = copy.deepcopy(band[0]) self.kpoints = np.array(kpoints) self.band = np.array(band) self.occupation = occ[0] diff = np.diff(occ[0]) pos = diff[np.where(abs(diff) > 0.5)] mask = np.in1d(diff, pos) ind = np.array(range(len(diff))) if len(ind[mask]) > 0: N_state = ind[mask][0] vb = max(self.band[:, N_state]) cb = min(self.band[:, N_state + 1]) vb_pos = np.argmax(self.band[:, N_state]) cb_pos = np.argmin(self.band[:, N_state + 1]) self.Eg = cb - vb if vb_pos == cb_pos: self.Eg_direct = True else: self.Eg_direct = False # DOS data dos = [] self.E_fermi = float(self.xml[-2][-1][0].text) print self.E_fermi for dos_xml in self.xml[-2][-1][1][0][5][0]: dos_lst = filter(None, dos_xml.text.split(' ')) dos_E = [float(d) for d in dos_lst] dos.append(dos_E) self.dos = np.array(dos) except: qtk.warning("error when accessing kpoint data for %s"\ % self.name)
def write(self, name=None, **kwargs): self.setting.update(kwargs) self.setting['root_dir'] = name self.setting['no_molecule'] = False if name: self.setting['output'] = True name = os.path.splitext(name)[0] else: self.setting['output'] = False incar, molecule = \ super(PlanewaveInput, self).write('INCAR', **self.setting) self.setting['no_molecule'] = True kpoints = \ super(PlanewaveInput, self).write('KPOINTS', **self.setting) poscar = \ super(PlanewaveInput, self).write('POSCAR', **self.setting) potcar = \ super(PlanewaveInput, self).write('POTCAR', **self.setting) # !!!!!!!!!!! TODO !!!!!!!!!!! # Center molecule # charge multiplicity # optimizer # # write CPMD to modulize structure manipulation? PPPath = [] n_list = [] R_list = [] def catPOTCAR(path): if os.path.exists(path): PPPath.append(path) else: qtk.exit("PP file: " + path + " not found") def getNlist(atom_number): n_list.append(atom_number) def getRlist(coord): R_list.append(coord) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # construct to POSCAR and POTCAR data molecule.sort() type_index = molecule.index type_list = molecule.type_list Z = molecule.Z self.pp_path = None if 'pp_path' not in self.setting: if 'pp_theory' not in self.setting: theory_dict = { 'pbe': 'pbe', 'pbe0': 'pbe', 'hse06': 'pbe', 'hse03': 'pbe', 'lda': 'lda', } if self.setting['theory'] not in theory_dict: qtk.warning("%s is not supported, change theory to LDA" \ % (self.setting['theory'])) self.setting['theory'] = 'lda' theory = theory_dict[self.setting['theory']] if theory.lower() not in ['pbe', 'lda']: qtk.warning('xc: %s is not supported, using LDA PP' % \ theory.upper()) theory = 'LDA' self.pp_path = qtk.setting.vasp_pp + '_%s_%s' % \ (theory.upper(), self.setting['pp_type'].upper()) else: self.pp_path = qtk.setting.vasp_pp + '_%s_%s' % \ (self.setting['pp_theory'].upper(), self.setting['pp_type'].upper()) else: self.pp_path = self.setting['pp_path'] for atom_type in xrange(0,len(type_index)-1): type_n = type_index[atom_type+1] - type_index[atom_type] # check special PP folder # not yet implemented # default PP path type_name = type_list[type_index[atom_type]] AtomPP = os.path.join(self.pp_path, type_name, 'POTCAR') catPOTCAR(AtomPP) getNlist(type_n) for I in\ xrange(type_index[atom_type],type_index[atom_type+1]): getRlist(molecule.R[I][:]) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # write to INCAR and generate POTCAR qtk.report("vasp.inp", "writing", "INCAR") incar.write("SYSTEM = %s\n" % self.setting['info']) incar.write("ISMEAR = 0\n") incar.write("IBRION = 2\n") if 'restart' in self.setting and self.setting['restart']: incar.write("ISTART = 1\n") if 'cutoff' in self.setting: cutoff = self.setting['cutoff'] incar.write("ENCUT = %.2f" % (cutoff * 13.605698066)) incar.write(" # in eV, that is %.1f Ry\n" % cutoff) if 'scf_step' in self.setting: incar.write('NELM = %d\n' % self.setting['scf_step']) if 'vdw' in self.setting: vdw = self.setting['vdw'].lower() if vdw != 'none': if vdw=='d2': incar.write("IVDW = 10\n") elif vdw=='d3': incar.write("IVDW = 11\n") elif vdw=='d3-bj': incar.write("IVDW = 12\n") elif vdw=='mbd': incar.write("IVDW = 202\n") elif vdw=='mbd_iter': incar.write("IVDW = 212\n") else: qtk.exit("VDW '%s' is not supported for VASP" % vdw) if 'ks_states' in self.setting: vs = int(round(self.molecule.getValenceElectrons() / 2.0)) nbnd = vs + self.setting['ks_states'] incar.write("NBANDS = %d\n" % nbnd) if 'full_kmesh' in self.setting and self.setting['full_kmesh']: incar.write("ISYM = -1\n") if self.setting['theory'] == 'pbe0': incar.write("LHFCALC = .TRUE.\n") incar.write("GGA = PE\n") elif self.setting['theory'] == 'hse06': incar.write("GGA = PE\n") incar.write("\n##HSE setting\n") incar.write("LHFCALC = .TRUE.\n") incar.write("HFSCREEN = 0.2 \n") incar.write("ALGO = D\n") if molecule.charge != 0: nve = molecule.getValenceElectrons() incar.write("NELECT = %d\n" % (nve)) if 'save_density'not in self.setting\ or not self.setting['save_density']: incar.write("LCHARG = .FALSE.\n") if 'scalapack' not in self.setting: incar.write("LSCALAPACK = .FALSE.\n") elif not self.setting['scalapack']: incar.write("LSCALAPACK = .FALSE.\n") incar.close() # !!!!!!!!!!!!!!!! # write to KPOINTS qtk.report("vasp.inp", "writing", "KPOINTS") if 'kmesh' not in self.setting: kpoints.write("Gamma-point only\n") kpoints.write(" 1 ! one k-point\n") kpoints.write("rec ! in units of reciprocal vector\n") kpoints.write(" 0 0 0 1 ! coordinates and weight\n") else: k1, k2, k3 = self.setting['kmesh'] kpoints.write("Automatic mesh\n") kpoints.write(" 0 ! number of k-points = 0") kpoints.write(" ->automatic generation scheme\n") kpoints.write("Gamma ! generate a Gamma centered grid\n") kpoints.write(" %d %d %d ! number of k grids\n" % (k1, k2, k3)) kpoints.close(no_cleanup=True) # !!!!!!!!!!!!!!! # write to POSCAR qtk.report("vasp.inp", "writing", "POSCAR") poscar.write(self.setting['info'] + '\n') poscar.write("1.0\n") self.celldm2lattice() for i in range(3): for j in range(3): poscar.write(" %7.4f" % self.setting['lattice'][i,j]) poscar.write(" ! lattic vector a(%d)\n" %i) for n in n_list: poscar.write(str(n) + ' ') poscar.write("! number of atoms in order of POTCAR\n") poscar.write("cart ! cartesian coordinates\n") for R in R_list: for X in R: poscar.write(" %7.4f" % X) poscar.write("\n") poscar.close(no_cleanup=True) # !!!!!!!!!!!!!!! # write to POTCAR qtk.report("vasp.inp", "writing", "POTCAR") for PP_file in PPPath: qtk.report("vasp.inp.POTCAR", PP_file) if name: with open(PP_file) as PP: for line in PP: potcar.write(str(line)) else: potcar.write("cat %s\n" % PP_file) potcar.close(no_cleanup=True) return incar
def __init__(self, qmout, **kwargs): PlanewaveOutput.__init__(self, qmout, **kwargs) out_file = open(qmout) data = out_file.readlines() out_file.close() EStrList = filter(lambda x: 'Etotal' in x, data) EList = filter(lambda x: 'ETOT' in x, data) self.scf_step = len(EList) if self.scf_step > 0: Et_list = [float(filter(None, s.split(' '))[2]) for s in EList] self.Et = Et_list[-1] elif len(EStrList) > 0: EStr = EStrList[-1] self.Et = float(EStr.split(' ')[-1]) if len(EStrList) > 0: EStr = EStrList[-1] detailInd = data.index(EStr) self.detail = data[detailInd-7:detailInd] xangst = filter(lambda x: 'xangst' in x, data)[-1] angst_n = len(data) - data[::-1].index(xangst) - 1 xcart = filter(lambda x: 'xcart' in x, data)[-1] cart_n = len(data) - data[::-1].index(xcart) - 1 Rstr = copy.deepcopy(data[angst_n:cart_n]) Rstr[0] = Rstr[0].replace('xangst', '') R = [[float(r) for r in filter(None, s.split(' '))] for s in Rstr] N = len(R) ZstrOriginal = filter(lambda x: ' typat' in x, data)[-1] Zstr = ZstrOriginal.replace('typat', '') Zind = [int(z) for z in filter(None, Zstr.split(' '))] ZindItr = data.index(ZstrOriginal) while len(Zind) != N: ZindItr += 1 ZindNewStr = filter(None, data[ZindItr].split(' ')) ZindNew = [int(z) for z in ZindNewStr] Zind.extend(ZindNew) Znuc = filter(lambda x: 'znucl ' in x, data)[-1] Znuc = filter(None, Znuc.replace('znucl', '').split(' ')) Znuc = [float(z) for z in Znuc] build = [] for i in range(N): Z = [Znuc[Zind[i]-1]] Z.extend(R[i]) build.append(Z) self.molecule = qtk.Molecule() self.molecule.build(build) if self.scf_step > 0: fStr = filter(lambda x: 'tesian forces (hartree/b' in x, data)[-1] fInd = data.index(fStr) fData = data[fInd+1:fInd+1+N] force = [] for f in fData: fStr = filter(None, f.split(' '))[1:] force.append([float(fs) for fs in fStr]) self.force = np.array(force) self.occupation = [] try: r1p = re.compile(r'^[ a-z]{17} +[ 0-9.E+-]+$') r2p = re.compile(r'^ +[a-z]+ +.*$') report = filter(r2p.match, filter(r1p.match, data)) occ_pattern = filter(lambda x: ' occ ' in x, report)[-1] occ_pattern_ind = len(report) - report[::-1].index(occ_pattern) occ_pattern_end = report[occ_pattern_ind] occ_ind_start = len(data) - data[::-1].index(occ_pattern) - 1 occ_ind_end = len(data) - data[::-1].index(occ_pattern_end) - 1 for i in range(occ_ind_start, occ_ind_end): for occ in filter(None, data[i].split(' ')): try: self.occupation.append(float(occ)) except: pass except Exception as err: qtk.warning("error when extracting occupation number with" +\ " error message: %s" % str(err)) cell_pattern = re.compile(r'^ R.*=.* G.*=.*$') cell_list = filter(cell_pattern.match, data) cell = [] for cstr in cell_list: cell.append( [float(c) for c in filter(None, cstr.split(' '))[1:4]]) self.lattice = np.array(cell) / 1.889726124993 self.celldm = qtk.lattice2celldm(self.lattice) self.molecule.R_scale = qtk.xyz2fractional( self.molecule.R, self.celldm) eigStr = os.path.join(os.path.split(qmout)[0], '*_EIG') eigFileList = glob.glob(eigStr) if len(eigFileList) != 0: if len(eigFileList) > 1: qtk.warning("more than one o_EIG files found") eigFile = open(eigFileList[0]) eigData = eigFile.readlines() eigFile.close() spinList = filter(lambda x: 'SPIN' in x, eigData) if len(spinList) != 0: spinFactor = 2 maxInd = eigData.index(spinList[-1]) else: spinFactor = 1 maxInd = len(eigData) ind = [] for kStr in filter(lambda x: 'kpt#' in x, eigData): ind.append(eigData.index(kStr)) band = [] kpoints = [] if spinFactor == 1: for i in range(len(ind)): wcoord = eigData[ind[i]].split('wtk=')[-1].split(', kpt=') weight = float(wcoord[0]) cStr = filter(None, wcoord[1].split('(')[0].split(' ')) coord = [float(c) for c in cStr] coord.append(weight) kpoints.append(coord) s = ind[i] + 1 if i < len(ind) - 1: e = ind[i+1] else: e = len(eigData) eig_i = filter(None, ''.join(eigData[s:e]).split(' ')) band.append([qtk.convE(float(ew), 'Eh-eV')[0] for ew in eig_i]) self.band = np.array(band) self.kpoints = np.array(kpoints) self.mo_eigenvalues = np.array(band[0]).copy() if len(self.occupation) > 0: diff = np.diff(self.occupation) ind = np.array(range(len(diff))) pos = diff[np.where(abs(diff) > 0.5)] mask = np.in1d(diff, pos) if len(ind[mask]) > 0: N_state = ind[mask][0] vb = max(self.band[:, N_state]) cb = min(self.band[:, N_state + 1]) vb_pos = np.argmax(self.band[:, N_state]) cb_pos = np.argmin(self.band[:, N_state + 1]) self.Eg = cb - vb if vb_pos == cb_pos: self.Eg_direct = True else: self.Eg_direct = False else: qtk.warning("spin polarized band data " +\ "extraction is not yet implemented") else: qtk.warning('no k-point information (o_EIG file) found')
def __init__(self, qmout, **kwargs): PlanewaveOutput.__init__(self, qmout, **kwargs) out_file = open(qmout) data = out_file.readlines() out_file.close() Et_pattern = re.compile("^.*total energy *=.*$") f_pattern = re.compile("^.*atom.*type.*force.*=.*$") Et_list = filter(Et_pattern.match, data) f_list = filter(f_pattern.match, data) if len(Et_list) > 0: Et_str = filter(Et_pattern.match, data)[-1] Et = float(Et_str.split()[-2]) self.Et, self.unit = qtk.convE(Et, 'Ry-Eh') out_folder = os.path.split(os.path.abspath(qmout))[0] save = glob.glob(os.path.join(out_folder, '*.save')) # extract force information if len(f_list) > 0: fstr = [filter(None, fstr.split('=')[-1].split(' ')) for fstr in f_list] # atomic unit force, HF/au, converted from Ry/au self.force = 0.5 * np.array( [[float(comp) for comp in atm] for atm in fstr] ) # extract band structure from xml files if save: save = save[0] try: data_xml = os.path.join(save, 'data-file.xml') xml_file = open(data_xml) tree = ET.parse(xml_file) xml_file.close() self.xml = tree.getroot() kpoints = [] band = [] # extract celldm celldm = [] cellVec = [] for i in range(1, 4): cellvStr = filter(None, self.xml[2][4][i].text.replace('\n', '').split(' ') ) cellVec.append([float(v) for v in cellvStr]) self.celldm = qtk.cellVec2celldm(cellVec) # extract structure R = [] N = int(self.xml[3][0].text.replace('\n', '')) Nsp = int(self.xml[3][1].text.replace('\n', '')) for i in range(N): RiStr = self.xml[3][5+Nsp+i].get('tau') Ri = [float(r) * 0.529177249 for r in RiStr.split(' ')] ni = self.xml[3][5+Nsp+i].get('SPECIES') Z = [qtk.n2Z(ni)] Z.extend(Ri) R.append(Z) self.molecule = qtk.Molecule() self.molecule.build(R) # access data for each kpoint for k in self.xml[-2]: k_str = k[0].text coord = [float(c) for c in k_str.split()] weight = float(k[1].text.split()[0]) coord.append(weight) kpoints.append(coord) ev_file = os.path.join(save, k[2].attrib['iotk_link']) k_xml_file = open(ev_file) k_xml = ET.parse(k_xml_file) k_xml_file.close() ev_k = k_xml.getroot() ev_str = ev_k[2].text.split() ev = [qtk.convE(float(entry), 'Eh-eV')[0]\ for entry in ev_str] band.append(ev) occ_str = ev_k[3].text.split() occ = [float(entry) for entry in occ_str] self.kpoints = np.array(kpoints) self.mo_eigenvalues = copy.deepcopy(band[0]) self.band = np.array(band) self.occupation = occ diff = np.diff(occ) pos = diff[np.where(abs(diff) > 0.5)] mask = np.in1d(diff, pos) ind = np.array(range(len(diff))) if len(ind[mask]) > 0: N_state = ind[mask][0] vb = max(self.band[:, N_state]) cb = min(self.band[:, N_state + 1]) vb_pos = np.argmax(self.band[:, N_state]) cb_pos = np.argmin(self.band[:, N_state + 1]) self.Eg = cb - vb if vb_pos == cb_pos: self.Eg_direct = True else: self.Eg_direct = False cell = [] for i in range(1, 4): vec = filter( None, self.xml[2][4][i].text.replace('\n', '').split(' ')) cell.append([float(v) for v in vec]) self.lattice = np.array(cell) / 1.889726124993 self.celldm = qtk.lattice2celldm(self.lattice) self.molecule.R_scale = qtk.xyz2fractional( self.molecule.R, self.celldm) except IOError: qtk.warning('xml file of job %s not found' % qmout) else: qtk.warning('job %s not finished' % qmout)
def __init__(self, qmout=None, **kwargs): GaussianBasisOutput.__init__(self, qmout, **kwargs) if qmout: self.program = 'nwchem' outfile = open(qmout, 'r') data = outfile.readlines() outfile.close() Et = filter(lambda x: 'Total' in x and 'energy' in x, data) try: self.Et = float(Et[-1].split( )[-1]) except: self.Et = np.nan try: _Et = filter(lambda x: 'total' in x and 'energy' in x, data) _Et = float(_Et[-1].split( )[-1]) self.Et = _Et except: pass # necessary for opening *.movecs file n_basis = filter(lambda x: 'functions' in x, data) if ':' in n_basis[-1]: try: self.n_basis = int(n_basis[-1].split(':')[1]) except: self.n_basis = np.nan elif '=' in n_basis[-1]: try: self.n_basis = int(n_basis[-1].split('=')[1]) except: self.n_basis = np.nan nuclear = filter(lambda x: 'repulsion' in x, data)[-1] self.nuclear_repulsion = float(nuclear.split(' ')[-1]) def getBasis(): ###################################### # extract basis function information # ###################################### basis_dict = {"S":0, "P":1, "D":2, "F":3, "G":4, "H":5} basis_P = re.compile(r" *[0-9]+ [A-Z] [0-9]\.[0-9]{8}") batom_P = re.compile(r"^ [0-9A-Za-z\-_\.]+ *\([A-Z][a-z]*\)") bname_P = re.compile(r"\((.*)\)") coord_P = re.compile(r"^ [0-9A-Za-z\.\-_]+ +[- ][0-9\.]{9,}") basisStr = filter(basis_P.match, data) batomStr = filter(batom_P.match, data) coordStr = filter(coord_P.match, data) # change 'Sulphur' to 'Sulfur' for NWChem format # 'Sulphur' 'Sulfur' def atomNameConv(old, new): _matched = filter(lambda x: old in x, batomStr) if _matched: _matched = _matched[0] _s = batomStr.index(_matched) batomStr[_s] = re.sub(old, new, batomStr[_s]) _s = data.index(_matched) data[_s] = re.sub(old, new, data[_s]) atomNameConv('Sulphur', 'Sulfur') atomNameConv('Aluminium', 'Aluminum') _exponents = [float(filter(None, s.split(' '))\ [2]) for s in basisStr] _coefficients = [float(filter(None, s.split(' '))\ [3]) for s in basisStr] _N = [int(filter(None, s.split(' '))[0])\ for s in basisStr] _type = [filter(None, s.split(' '))[1]\ for s in basisStr] _bfnInd = [data.index(batom) for batom in batomStr] _bfnEndPtn = re.compile(r" Summary of \"") _bfnEndStr = filter(_bfnEndPtn.match, data)[0] _bfnInd.append(data.index(_bfnEndStr)) _ao_keys = [0] for ind in range(len(_bfnInd)-1): _key = _ao_keys[-1] for i in range(_bfnInd[ind]+4, _bfnInd[ind+1]): if len(data[i]) > 1: _key = _key + 1 _ao_keys.append(_key) _atoms = [getattr(pt, bname_P.match( filter(None, s.split(' '))[1]).group(1).lower()).symbol\ for s in batomStr] self.type_list = [re.split(r'[\._]', filter(None, s.split(' '))[0])[0].title()\ for s in coordStr] self.type_list_unique = list( collections.OrderedDict.fromkeys(self.type_list) ) self.R = np.array([filter(None, s.split(' '))[1:4]\ for s in coordStr]).astype(float) self.N = len(self.R) self.Z = [qtk.n2Z(e) for e in self.type_list] self.R_bohr = 1.889725989 * self.R ZR = [] for i in range(self.N): vec = [self.Z[i]] vec.extend(self.R[i]) ZR.append(vec) self.molecule = qtk.Molecule() self.molecule.build(ZR) _N.append(0) self.basis = [] for i in range(len(self.type_list)): e = self.type_list[i] center = self.R_bohr[i] ind = self.type_list_unique.index(e) bfn_base = {} bfn_base['atom'] = e bfn_base['center'] = center bfn_base['index'] = i exp = [] cef = [] for g in range(_ao_keys[ind], _ao_keys[ind+1]): exp.append(_exponents[g]) cef.append(_coefficients[g]) if _N[g] != _N[g+1] or g+1 >= _ao_keys[ind+1]: bfn = copy.deepcopy(bfn_base) bfn['exponents'] = copy.deepcopy(exp) bfn['coefficients'] = copy.deepcopy(cef) if _type[g] in basis_dict: _bfnList = self.basisList(basis_dict[_type[g]]) for bStr in _bfnList: bfn['type'] = _type[g].lower() + bStr self.basis.append(copy.deepcopy(bfn)) exp = [] cef = [] try: getBasis() except AttributeError as err: qtk.warning('failed to get basis information with error: %s.'\ % err + ' Weird atom names?') movecs = os.path.join(self.path, self.stem) + '.modat' if os.path.exists(movecs): self.getMO(movecs)
def PPString(inp, mol, i, n, outFile): """ append PP file names to inp.pp_files """ alchemy = re.compile('^\w*2\w*_\d\d\d$') ppstr = re.sub('\*', '', mol.string[i]) if ppstr: PPStr = ppstr pp_root, pp_ext = os.path.split(ppstr) else: if inp.setting['pp_type'] == 'geodecker': element = mol.type_list[i].title() if 'd_shell' in inp.setting: if type(inp.setting['d_shell']) is not list: inp.setting['d_shell'] = [inp.setting['d_shell']] if qtk.n2ve(mol.type_list[i].title()) > 10: shell = '-d' elif 'd_shell' in inp.setting \ and element in inp.setting['d_shell']: shell = '-d' else: element = qtk.element[mol.type_list[i].title()] if element.group < 3 and mol.Z[i] > 1: if mol.Z[i] != 3: shell = '-sp' else: shell = '-s' else: shell = '' pp_xc_dict = { 'lda': 'pz', 'pbe0': 'pbe', 'b3lyp': 'blyp', } pp_xc = inp.setting['pp_theory'].lower() if pp_xc in pp_xc_dict: pp_xc = pp_xc_dict[pp_xc] PPStr = ''.join([c for c in mol.type_list[i] if not c.isdigit()])\ + '.' + pp_xc + shell + '-hgh.UPF' elif inp.setting['pp_type'] == 'cpmd': PPStr = PPName(inp, mol, i, n) xc = inp.setting['pp_theory'].lower() if not mol.string[i]: if inp.setting['pp_type'] == 'geodecker': PPCheck(pp_xc, mol.type_list[i].title(), PPStr) elif inp.setting['pp_type'] == 'cpmd': saved_pp = PPCheck_cpmd(pp_xc, mol.type_list[i].title(), PPStr) new_pp1 = saved_pp + '.UPF' conv_pp = sp.Popen("%s %s" % \ (qtk.setting.espresso_cpmd2upf_exe, saved_pp), shell=True) conv_pp.wait() new_pp1_file = os.path.split(new_pp1)[1] new_pp1_trg = os.path.join(qtk.setting.espresso_pp, new_pp1_file) if not os.path.exists(new_pp1_trg): shutil.copy(new_pp1, qtk.setting.espresso_pp) PPStr = PPStr + '.UPF' elif alchemy.match(mol.string[i]): cpmd_pp = alchemyPP(xc, PPStr) new_pp1 = cpmd_pp + '.UPF' if not os.path.exists(new_pp1): qtk.report('espresso', "rewrite Goedecker's PP to UPF") conv_pp = sp.Popen("%s %s" % \ (qtk.setting.espresso_cpmd2upf_exe, cpmd_pp), shell=True) conv_pp.wait() if conv_pp.returncode != 0: # dirty fix for espresso alchemy conversion routine qtk.warning('conversion failed..., trying path end points') root, _ = os.path.splitext(PPStr) element_str = re.sub('_.*', '', root) element1 = re.sub('2.*', '', element_str) element2 = re.sub('.*2', '', element_str) fraction = float(re.sub('.*_', '', root))/100 if fraction == 0.0: strpp = element1 + "_q" + str(qtk.n2ve(element1)) +\ "_" + xc + '.psp' elif fraction == 1.0: strpp = element2 + "_q" + str(qtk.n2ve(element2)) +\ "_" + xc + '.psp' else: qtk.exit("PP conversion failed for intermediate lambda") strpp = os.path.join(qtk.setting.cpmd_pp, strpp) conv_pp = sp.Popen("%s %s" % \ (qtk.setting.espresso_cpmd2upf_exe, strpp), shell=True) conv_pp.wait() os.rename(strpp + '.UPF', new_pp1) new_pp1_file = os.path.split(new_pp1)[1] new_pp1_trg = os.path.join(qtk.setting.espresso_pp, new_pp1_file) if not os.path.exists(new_pp1_trg): shutil.copy(new_pp1, qtk.setting.espresso_pp) PPStr = PPStr + '.UPF' return PPStr
def PPCheck(xc, element, pp_file_str, **kwargs): pp_file = None pp_content = None if xc == 'lda': xc = 'pade' elif xc == 'pbe0': xc = 'pbe' ne = qtk.n2ve(element) try: if 'dcacp' in kwargs and kwargs['dcacp']\ and element in qtk.setting.dcscp_list: pp_path = os.path.join(xc.upper(), "%s_DCACP_%s" %\ (element, xc.upper())) if element in qtk.setting.dcacp_dict: pp_path = pp_path + "_%s" % qtk.setting.dcacp_dict[element] #pp_file = os.path.join(qtk.setting.cpmd_dcacp_url, pp_path) else: pp_path = os.path.join(xc, element + '-q' + str(qtk.n2ve(element))) pp_file = os.path.join(qtk.setting.cpmd_pp_url, pp_path) saved_pp_path = os.path.join(qtk.setting.cpmd_pp, pp_file_str) if not os.path.exists(saved_pp_path) and qtk.setting.download_pp: new_pp = os.path.join(qtk.setting.cpmd_pp, pp_file_str) if 'dcacp' in kwargs and kwargs['dcacp']\ and element in qtk.setting.dcscp_list: root_list = filter(None, qtk.setting.cpmd_dcacp_url.split('/')) root = '//'.join(root_list[:2]) url = qtk.setting.cpmd_dcacp_url html = ''.join(urllib2.urlopen(url).readlines()) pp_links = BeautifulSoup(html).body.findAll( 'a', attrs={'class': 'table'} ) if kwargs['pp_type'].title() == 'Goedecker': pp_flag = r'/SG/' elif kwargs['pp_type'].upper() == 'MT': pp_flag = r'/MT/' pp_path = filter(lambda x: xc.upper() in x and pp_flag in x, [l['href'] for l in pp_links if l.text == element.title()]) pp_content = urllib2.urlopen(root + pp_path[0]).readlines() elif pp_file: pp_content = urllib2.urlopen(pp_file).readlines() pattern = re.compile(r'^.*</*pre>.*$') pp_se = filter(pattern.match, pp_content) pp_start = pp_content.index(pp_se[0]) pp_end = pp_content.index(pp_se[1]) pp_content = pp_content[pp_start:pp_end] pp_content[0] = pp_content[0].split('>')[-1] if pp_content: for i in range(len(pp_content)): pp_str = pp_content[i] pp_content[i] = pp_str.replace('&', '&') qtk.report('PPCheck', 'pp file %s not found in %s, ' \ % (pp_file_str, qtk.setting.cpmd_pp) + \ 'download now...') new_pp_file = open(new_pp, 'w') new_pp_file.write(''.join(pp_content)) new_pp_file.close() pp_file = new_pp return saved_pp_path except Exception as e: qtk.warning('something wrong with pseudopotential with error: '+\ str(e))
def parallelize(target_function, input_list, **kwargs): """ target_function is implemented in a general way supposely any function would work But it could break down if target_function assumes some convoluted data structure input_list is a list of list. Each input entry should be wrapped properly as a list **kwargs can be passed py passing dictionary Example: # a toy target function def f(a, b, **kwargs): if 'factor' in kwargs: factor = kwargs['factor'] else: factor = 1 return a + b*factor input_list = [[i,j,{'factor':3}] for i in range(10) for j in range(10)] out_list = parallelize(f, input_list, block_size=10) """ if 'threads' in kwargs: threads = kwargs['threads'] else: threads = setting.cpu_count if 'block_size' in kwargs: block_size = kwargs['block_size'] else: if len(input_list) > threads*3: block_size = len(input_list)/(threads*3) else: block_size = 1 ############################################# # runing target function of a single thread # ############################################# def run_jobs(q_in, q_out): for inps in iter(q_in.get, None): ind = inps[-1] # index of job inps = inps[:-1] # actual input sequence out = [] try: for args in inps: if type(args[-1]) == dict: # check known args input kwargs = args[-1] args = args[:-1] out.append(target_function(*args, **kwargs)) else: out.append(target_function(*args)) q_out.put([out, ind]) # output result with index except: qtk.warning('job failed!') q_out.put([np.nan, ind]) ###### end of single thread definition ###### # devide input_list into chunks according to block_size def chunks(_list, _size): for i in range(0, len(_list), _size): yield _list[i:i+_size] input_block = list(chunks(input_list, block_size)) # setup empty queue output_stack = [] output = [] qinp = mp.Queue() qout = mp.Queue() # start process with empty queue jobs = [] for thread in range(threads): p = mp.Process(target=run_jobs, args=(qinp, qout)) p.start() jobs.append(p) # put I/O data into queue for parallel processing index = range(len(input_block)) for ind, inps in zip(index, input_block): inps.append(ind) # append inp index qinp.put(inps) # put inp to input queue for thread in jobs: qinp.put(None) # while not queue.empty' is NOT reliable for i in range(len(input_block)): # collect output from each subprocess try: output_stack.append(qout.get()) # check keyboard interrupt and terminate subprocess except KeyboardInterrupt: qtk.warning('jobs terminated by keyboard interrupt') for p in jobs: p.terminate() try: sys.exit(0) except SystemExit: os._exit(0) for thread in jobs: thread.join() # clean up queues while not qinp.empty(): qinp.get() while not qout.empty(): qout.get() if len(output_stack)>0: # sort/restructure output according to input order output_stack = sorted(output_stack, key=operator.itemgetter(1)) # loop though all input for corresponding output for data_out in output_stack: # if output is list of class, in-line iteration doesn't work output.append(data_out[0]) return flatten(output)
def submit(inp_list, root, **remote_settings): necessary_list = [ 'ip', 'submission_script', ] default_dict = { 'username': None, 'password': None, 'flags': None, 'timeout': 40, } for k, v in default_dict.iteritems(): exec "%s = %s" % (k, v) if len(inp_list) * 5 > 40: timeout = len(inp_list) * 5 if 'password' in remote_settings: password = remote_settings['password'] if 'username' in remote_settings: username = remote_settings['username'] if 'remote_path' not in remote_settings: remote_path = './%s' % root else: remote_path = remote_settings['remote_path'] if 'timeout' in remote_settings: timeout = remote_settings['timeout'] if 'prefix' in remote_settings: prefix = remote_settings['prefix'] else: prefix = '' if 'flags' in remote_settings: flags = remote_settings['flags'] if 'threads' not in remote_settings: threads = inp_list[0].setting['threads'] else: threads = remote_settings['threads'] if threads != inp_list[0].setting['threads']: qtk.report('submit', 'reset job threads to %d' % threads) for inp in inp_list: inp.setting['threads'] = threads if 'qthreads' not in remote_settings: qthreads = threads else: qthreads = remote_settings['qthreads'] for s in necessary_list: if s not in remote_settings: qtk.exit('cluster setting:%s not defined' % s) else: exec "%s = '%s'" % (s, remote_settings[s]) if type(inp_list) is not list: inp_list = [inp_list] program = inp_list[0].setting['program'] if os.path.exists(root): if 'overwrite' in remote_settings \ and remote_settings['overwrite']: qtk.warning("root directory %s exist, overwrite..." % root) shutil.rmtree(root) cwd = os.getcwd() os.makedirs(root) os.chdir(root) for inp in inp_list: inp.write(inp.molecule.name) os.chdir(cwd) else: qtk.warning("root directory %s exist, uploading existing folder"\ % root) else: cwd = os.getcwd() os.makedirs(root) os.chdir(root) for inp in inp_list: inp.write(inp.molecule.name) os.chdir(cwd) if 'compress' not in remote_settings: remote_settings['compress'] = False if len(inp_list) > 5: remote_settings['compress'] = True if remote_settings['compress']: qtk.report("submit", "compressing input files") cmd = 'tar -zcf %s %s' % (root + '.tar.gz', root) run = sp.Popen(cmd, shell=True, stdin=sp.PIPE) run.stdin.flush() run.communicate() run.wait() rootToSend = root + '.tar.gz' remote_dest = remote_path + '.tar.gz' qtk.report("submit", "compression completed") else: rootToSend = root remote_dest = remote_path paramiko_kwargs = {} if username: paramiko_kwargs['username'] = username if password: paramiko_kwargs['password'] = password ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.load_system_host_keys() ssh.connect(ip, **paramiko_kwargs) ssh_stdin, ssh_stdout, ssh_stderr = \ ssh.exec_command('ls %s' % remote_path) sshout = ssh_stdout.read() if len(sshout) > 0: if 'overwrite' in remote_settings \ and remote_settings['overwrite']: status = 'remote path %s exists, overwrite...' % remote_path cmd = 'rm -r %s' % remote_path remoteRun(cmd, status, ssh) else: qtk.exit('remote path %s exists' % remote_path) ssh_newkey = 'Are you sure you want to continue connecting' patterns = [ssh_newkey, '[Pp]assword:', pexpect.EOF] if username: userStr = username + '@' else: userStr = '' cmd = 'scp -qr %s %s%s:%s' % (rootToSend, userStr, ip, remote_dest) qtk.report('submit', 'scp input files...') qtk.report('submit-remote_command', cmd) p = pexpect.spawn(cmd) i = p.expect(patterns, timeout=timeout) if i == 0: qtk.report('submit', 'adding %s to known_hosts' % ip) p.sendline('yes') i = p.expect(patterns, timeout=timeout) if i == 1: p.sendline(password) i = p.expect(patterns, timeout=timeout) if i == 2: if not p.before: qtk.report('submit', 'scp completed') else: qtk.warning('scp message: %s' % p.before) if remote_settings['compress']: status = "decompress remote input files" cmd = 'tar xf %s' % rootToSend remoteRun(cmd, status, ssh) status = "remove remote tar file" cmd = 'rm %s' % rootToSend remoteRun(cmd, status, ssh) qtk.report('submit', 'done') exe = qtk.setting.program_dict[program] cmd = "%s \"%s\" %s %d %d '%s' %s" % (submission_script, exe, remote_path, threads, qthreads, flags, prefix) status = 'submitting jobs...' remoteRun(cmd, status, ssh) ssh.exec_command("echo %s > %s/cmd.log" % (cmd, remote_path)) qtk.report('submit', 'submission completed') ssh.close() if 'debug' in remote_settings and remote_settings['debug']: pass else: qtk.report('submit', 'cleanup local files') shutil.rmtree(root) if os.path.exists(root + '.tar.gz'): os.remove(root + '.tar.gz')
def Al1st(qminp, **setting): assert 'ref_dir' in setting assert os.path.exists(setting['ref_dir']) if 'runjob' not in setting: setting['runjob'] = True qminp = copy.deepcopy(univ.toInp(qminp, **setting)) name = qminp.molecule.name if 'out_dir' in setting: name = setting['out_dir'] del setting['out_dir'] qminp.molecule.name = name qminp.setting['root_dir'] = name if qminp.setting['program'] == 'cpmd': setting['restart'] = True setting['scf_step'] = 1 rst = os.path.join(setting['ref_dir'], 'RESTART') assert os.path.exists(rst) rst = os.path.abspath(rst) if 'dependent_files' in setting: setting['dependent_files'].append(rst) else: setting['dependent_files'] = [rst] elif qminp.setting['program'] == 'abinit': setting['restart'] = True setting['scf_step'] = 0 rstList = glob.glob(os.path.join(setting['ref_dir'], '*o_WFK')) assert len(rstList) > 0 rstSrc = rstList[-1] rstTar = rstSrc.replace('o_WFK', 'i_WFK') rstTar = os.path.split(rstTar)[-1] if 'dependent_file' in setting: setting['dependent_files'].append([rstSrc, name+'i_WFK']) else: setting['dependent_files'] = [[rstSrc, name+'i_WFK']] elif qminp.setting['program'] == 'espresso': wfn = glob.glob(setting['ref_dir'] + '/*.wfc[0-9]*') if 'threads' not in setting or setting['threads'] != len(wfn): qtk.warning('threads must be the same as ref_dir, reset to %d'\ % len(wfn)) setting['threads'] = len(wfn) setting['restart'] = True setting['scf_step'] = 1 rst = glob.glob(setting['ref_dir'] + '/*.restart*') save = glob.glob(setting['ref_dir'] + '/*.save') if 'dependent_files' in setting: for lst in [wfn, rst, save]: setting['dependent_files'].extend(lst) else: setting['dependent_files'] = wfn for lst in [rst, save]: setting['dependent_files'].extend(lst) elif qminp.setting['program'] == 'vasp': setting['restart'] = True setting['scf_step'] = 1 wfn_list = glob.glob(setting['ref_dir'] + '/WAVECAR') assert len(wfn_list) == 1 wfn = wfn_list[0] if 'dependent_files' in setting: setting['dependent_files'].append(wfn) else: setting['dependent_files'] = [wfn] elif qminp.setting['program'] == 'bigdft': pass elif qminp.setting['program'] == 'nwchem': pass if setting['runjob']: qmout = qminp.run(name, **setting) return qmout else: qminp.molecule.name = name qminp.setting.update(setting) new_inp = qtk.QMInp(qminp.molecule, **qminp.setting) return new_inp