def setUp(self): data0 = gen_sys(30, [0, 1, 0, 2, 1]) data1 = gen_sys(30, [0, 1, 0, 0]) sys0 = dpdata.LabeledSystem() sys1 = dpdata.LabeledSystem() sys0.data = data0 sys1.data = data1 sys0.to_deepmd_npy('system_0', set_size=10) sys1.to_deepmd_npy('system_1', set_size=10)
def coll_vasp_md(jdata): out_dir = jdata['out_dir'] md_nstep = jdata['md_nstep'] scale = jdata['scale'] pert_numb = jdata['pert_numb'] coll_ndata = jdata['coll_ndata'] cwd = os.getcwd() path_md = os.path.join(out_dir, global_dirname_04) path_md = os.path.abspath(path_md) assert (os.path.isdir(path_md)), "md path should exists" os.chdir(path_md) sys_md = glob.glob('sys-*') sys_md.sort() for ii in sys_md: os.chdir(ii) # convert outcars valid_outcars = [] for jj in scale: for kk in range(pert_numb): path_work = os.path.join("scale-%.3f" % jj, "%06d" % kk) outcar = os.path.join(path_work, 'OUTCAR') if os.path.isfile(outcar): with open(outcar, 'r') as fin: nforce = fin.read().count('TOTAL-FORCE') if nforce == md_nstep: valid_outcars.append(outcar) arg_cvt = " " if len(valid_outcars) == 0: raise RuntimeError( "MD dir: %s: find no valid outcar in sys %s, " "check if your vasp md simulation is correctly done" % (path_md, ii)) flag = True for oo in valid_outcars: if flag: _sys = dpdata.LabeledSystem(oo) if len(_sys) > 0: all_sys = _sys flag = False else: pass else: _sys = dpdata.LabeledSystem(oo) if len(_sys) > 0: all_sys.append(_sys) # create deepmd data if all_sys.get_nframes() >= coll_ndata: all_sys = all_sys.sub_system(np.arange(coll_ndata)) all_sys.to_deepmd_raw('deepmd') all_sys.to_deepmd_npy('deepmd', set_size=all_sys.get_nframes()) os.chdir(path_md) os.chdir(cwd)
def setUp(self): self.places = 5 self.e_places = 5 self.f_places = 5 self.v_places = 2 assert os.path.isdir('out_data_post_fp_pwmat'), 'out data for post fp pwmat should exist' if os.path.isdir('iter.000000') : shutil.rmtree('iter.000000') shutil.copytree('out_data_post_fp_pwmat', 'iter.000000') with open (param_pwmat_file, 'r') as fp : jdata = json.load (fp) post_fp(0, jdata) self.system_1 = dpdata.LabeledSystem('iter.000000/orig', fmt = 'deepmd/raw') self.system_2 = dpdata.LabeledSystem('iter.000000/02.fp/data.000', fmt = 'deepmd/raw')
def convert_data(jdata): s = dpdata.MultiSystems(*[ dpdata.LabeledSystem(x, fmt="gaussian/log") for x in glob.glob(os.path.join(fp_path, "*", "output")) ], type_map=jdata["type_map"]) s.to_deepmd_npy(data_path) dlog.info("Initial data is avaiable in %s" % os.path.abspath(data_path))
def setUp(self): type_map = ['C', 'H'] jdata = {"cluster_cutoff": 3.5, "cluster_minify": True} self.system_1 = take_cluster("cluster/14400.lammpstrj", type_map, 1125, jdata) self.system_2 = dpdata.LabeledSystem("cluster/input0_new.gaussianlog", fmt="gaussian/log") self.system_2.data['cells'] = self.system_1['cells'] self.places = 0
def create_init_tasks(target_folder, param_file, output, fp_json, verbose = True) : target_folder = os.path.abspath(target_folder) output = os.path.abspath(output) tool_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', 'template') jdata = json.load(open(os.path.join(target_folder, param_file))) fp_jdata = json.load(open(fp_json)) # fp settings mass_map = jdata['mass_map'] type_map = jdata['type_map'] fp_style = fp_jdata['fp_style'] fp_pp_path = fp_jdata['fp_pp_path'] fp_pp_files = fp_jdata['fp_pp_files'] cwd_ = os.getcwd() os.chdir(target_folder) fp_pp_path = os.path.abspath(fp_pp_path) os.chdir(cwd_) # init data sys init_data_prefix = jdata['init_data_prefix'] init_data_sys = jdata['init_data_sys'] for idx,ii in enumerate(init_data_sys): sys = dpdata.LabeledSystem(os.path.join(init_data_prefix, ii), fmt = 'deepmd/npy', type_map = type_map) nframes = sys.get_nframes() sys_dir = os.path.join(output, 'init_system.%03d' % idx) os.makedirs(sys_dir, exist_ok = True) if verbose : print('# working on ' + sys_dir) with open(os.path.join(sys_dir,'record'), 'w') as fp: fp.write(os.path.join(init_data_prefix, ii) + '\n') for ff in range(nframes) : task_dir = os.path.join(sys_dir, 'task.%06d' % ff) os.makedirs(task_dir, exist_ok = True) sys.to_vasp_poscar(os.path.join(task_dir, 'POSCAR')) # make fp cwd_ = os.getcwd() os.chdir(task_dir) for pp in fp_pp_files : if os.path.lexists(pp) : os.remove(pp) os.symlink(os.path.relpath(os.path.join(output, pp)), pp) if fp_style == 'vasp': if os.path.lexists('INCAR') : os.remove('INCAR') os.symlink(os.path.relpath(os.path.join(output, 'INCAR')), 'INCAR') elif fp_style == 'pwscf': try: fp_params = fp_jdata['user_fp_params'] user_input = True except: fp_params = fp_jdata['fp_params'] user_input = False make_pwscf('.', fp_params, mass_map, fp_pp_files, fp_pp_files, user_input) os.chdir(cwd_)
def test_post_fp_vasp_0(self): with open(param_file, 'r') as fp: jdata = json.load(fp) jdata['use_ele_temp'] = 2 post_fp_vasp(0, jdata, rfailed=0.3) sys = dpdata.LabeledSystem('iter.000000/02.fp/data.000/', fmt='deepmd/raw') self.assertEqual(sys.get_nframes(), 2) if sys.data['coords'][0][1][0] < sys.data['coords'][1][1][0]: idx = [1, 0] else: idx = [0, 1] ref_coord = self.ref_coord[idx] ref_cell = self.ref_cell[idx] ref_e = self.ref_e[idx] ref_f = self.ref_f[idx] ref_v = self.ref_v[idx] ref_at = self.ref_at for ff in range(2): self.assertAlmostEqual(ref_e[ff], sys.data['energies'][ff]) for ii in range(2): self.assertEqual(ref_at[ff], sys.data['atom_types'][ff]) for ff in range(2): for ii in range(2): for dd in range(3): self.assertAlmostEqual(ref_coord[ff][ii][dd], sys.data['coords'][ff][ii][dd]) self.assertAlmostEqual(ref_f[ff][ii][dd], sys.data['forces'][ff][ii][dd]) for ff in range(2): for ii in range(3): for jj in range(3): self.assertAlmostEqual(ref_v[ff][ii][jj], sys.data['virials'][ff][ii][jj], places=5) self.assertAlmostEqual(ref_cell[ff][ii][jj], sys.data['cells'][ff][ii][jj]) self.assertTrue( os.path.isfile('iter.000000/02.fp/data.000/set.000/aparam.npy')) aparam = np.load('iter.000000/02.fp/data.000/set.000/aparam.npy') natoms = sys.get_natoms() self.assertEqual(natoms, 2) self.assertEqual(list(list(aparam)[0]), [0, 0]) self.assertEqual(list(list(aparam)[1]), [1, 1])
def _make_fake_fp(iter_idx, sys_idx, nframes): for ii in range(nframes): dirname = os.path.join('iter.%06d' % iter_idx, '02.fp', 'task.%03d.%06d' % (sys_idx, ii)) os.makedirs(dirname, exist_ok=True) dirname = os.path.join('iter.%06d' % iter_idx, '02.fp', 'data.%03d' % sys_idx) os.makedirs(dirname, exist_ok=True) tmp_sys = dpdata.LabeledSystem( 'out_data_post_fp_vasp/02.fp/task.000.000000/OUTCAR') tmp_sys1 = tmp_sys.sub_system([0]) tmp_sys2 = tmp_sys1 for ii in range(1, nframes): tmp_sys2.append(tmp_sys1) tmp_sys2.to('deepmd/npy', dirname)
def gen_data(): tmpdata = Data(rand_pert=0.1, seed=1) sys = dpdata.LabeledSystem() sys.data['atom_names'] = ['foo', 'bar'] sys.data['coords'] = tmpdata.coord sys.data['atom_types'] = tmpdata.atype sys.data['cells'] = tmpdata.cell nframes = tmpdata.nframes natoms = tmpdata.natoms sys.data['coords'] = sys.data['coords'].reshape([nframes, natoms, 3]) sys.data['cells'] = sys.data['cells'].reshape([nframes, 3, 3]) sys.data['energies'] = np.zeros([nframes, 1]) sys.data['forces'] = np.zeros([nframes, natoms, 3]) sys.to_deepmd_npy('system', prec=np.float64) np.save('system/set.000/fparam.npy', tmpdata.fparam)
def test_post_fp_vasp_1(self): with open(param_file, 'r') as fp: jdata = json.load(fp) jdata['use_ele_temp'] = 1 post_fp_vasp(0, jdata, rfailed=0.3) sys = dpdata.LabeledSystem('iter.000000/02.fp/data.001/', fmt='deepmd/raw') self.assertEqual(sys.get_nframes(), 1) # if sys.data['coords'][0][1][0] < sys.data['coords'][1][1][0]: # idx = [0] # else : idx = [1] ref_coord = self.ref_coord[idx] ref_cell = self.ref_cell[idx] ref_e = self.ref_e[idx] ref_f = self.ref_f[idx] ref_v = self.ref_v[idx] ref_at = self.ref_at for ff in range(1): self.assertAlmostEqual(ref_e[ff], sys.data['energies'][ff]) for ii in range(2): self.assertEqual(ref_at[ff], sys.data['atom_types'][ff]) for ff in range(1): for ii in range(2): for dd in range(3): self.assertAlmostEqual(ref_coord[ff][ii][dd], sys.data['coords'][ff][ii][dd]) self.assertAlmostEqual(ref_f[ff][ii][dd], sys.data['forces'][ff][ii][dd]) for ff in range(1): for ii in range(3): for jj in range(3): self.assertAlmostEqual(ref_v[ff][ii][jj], sys.data['virials'][ff][ii][jj], places=5) self.assertAlmostEqual(ref_cell[ff][ii][jj], sys.data['cells'][ff][ii][jj]) fparam = np.load('iter.000000/02.fp/data.001/set.000/fparam.npy') self.assertEqual(fparam.shape[0], 1) self.assertEqual(list(fparam), [100000])
def test_coll(self): with open(param_file, 'r') as fp: jdata = json.load(fp) jdata['out_dir'] = self.odir print('here') coll_vasp_md(jdata) sys = dpdata.LabeledSystem(self.odir + '/02.md/sys-004/deepmd//', fmt='deepmd/raw') self.assertEqual(sys.get_nframes(), 2) if sys.data['coords'][0][1][0] < sys.data['coords'][1][1][0]: idx = [1, 0] else: idx = [0, 1] ref_coord = self.ref_coord[idx] ref_cell = self.ref_cell[idx] ref_e = self.ref_e[idx] ref_f = self.ref_f[idx] ref_v = self.ref_v[idx] ref_at = self.ref_at for ff in range(2): self.assertAlmostEqual(ref_e[ff], sys.data['energies'][ff]) for ii in range(2): self.assertEqual(ref_at[ff], sys.data['atom_types'][ff]) for ff in range(2): for ii in range(2): for dd in range(3): self.assertAlmostEqual(ref_coord[ff][ii][dd], sys.data['coords'][ff][ii][dd]) self.assertAlmostEqual(ref_f[ff][ii][dd], sys.data['forces'][ff][ii][dd]) for ff in range(2): for ii in range(3): for jj in range(3): self.assertAlmostEqual(ref_v[ff][ii][jj], sys.data['virials'][ff][ii][jj], places=5) self.assertAlmostEqual(ref_cell[ff][ii][jj], sys.data['cells'][ff][ii][jj])
def test_post_fp_vasp_0(self): with open(param_file, 'r') as fp: jdata = json.load(fp) post_fp_vasp(0, jdata) sys = dpdata.LabeledSystem('iter.000000/02.fp/data.000/', fmt='deepmd/raw') self.assertEqual(sys.get_nframes(), 2) if sys.data['coords'][0][1][0] < sys.data['coords'][1][1][0]: idx = [1, 0] else: idx = [0, 1] ref_coord = self.ref_coord[idx] ref_cell = self.ref_cell[idx] ref_e = self.ref_e[idx] ref_f = self.ref_f[idx] ref_v = self.ref_v[idx] ref_at = self.ref_at for ff in range(2): self.assertAlmostEqual(ref_e[ff], sys.data['energies'][ff]) for ii in range(2): self.assertEqual(ref_at[ff], sys.data['atom_types'][ff]) for ff in range(2): for ii in range(2): for dd in range(3): self.assertAlmostEqual(ref_coord[ff][ii][dd], sys.data['coords'][ff][ii][dd]) self.assertAlmostEqual(ref_f[ff][ii][dd], sys.data['forces'][ff][ii][dd]) for ff in range(2): for ii in range(3): for jj in range(3): self.assertAlmostEqual(ref_v[ff][ii][jj], sys.data['virials'][ff][ii][jj], places=5) self.assertAlmostEqual(ref_cell[ff][ii][jj], sys.data['cells'][ff][ii][jj])
def setUp(self): data0 = gen_sys(1) sys0 = dpdata.LabeledSystem() sys0.data = data0 sys0.to_deepmd_npy('system_0', set_size=10)
import dpdata my_system = dpdata.LabeledSystem('test.out', fmt='siesta/aimd_output') my_out = my_system.to('deepmd/raw', 'dpmd_raw')
def fp_error_test(self, machine_name, resource_dict, iteration=None, test_model=None): """Test your model quickly with the data generated from tesla. Parameters ---------- resource_dict : dict machine_name : str iteration : str, optional Select the iteration of data for testing. Default: the latest one. test_model : str, optional Select the iteration of model for testing. Default: the latest one. Return ------ """ logger = LogFactory(__name__).get_log() location = self.path if iteration is None: if self.step_code < 7: iteration = self.iteration - 1 else: iteration = self.iteration logger.info("Preparing structures from FP runs.") n_iter = 'iter.' + str(iteration).zfill(6) quick_test_dir = os.path.join(location, n_iter, '03.quick_test') os.makedirs(os.path.join(quick_test_dir, 'task.md'), exist_ok=True) task_list = glob(os.path.join(location, n_iter, '02.fp', 'task*')) task_list.sort() _stc_file = self._fp_output_style() _dpgen_output = self._fp_output_dpgen() _dpdata_format = self._fp_output_format() all_sys = None stcs = [] for idx, oo in enumerate(task_list): logger.debug(f"Task: {oo}") sys = dpdata.LabeledSystem(os.path.join(oo, _dpgen_output), fmt=_dpdata_format) stc = read(os.path.join(oo, _stc_file)) if len(sys) > 0: sys.check_type_map(type_map=self.param_data['type_map']) if idx == 0: all_sys = sys stcs.append(stc) else: try: all_sys.append(sys) stcs.append(stc) except (RuntimeError, TypeError, NameError): pass write(os.path.join(quick_test_dir, 'task.md/validate.xyz'), stcs, format='extxyz') atom_numb = np.sum(all_sys['atom_numbs']) dft_energy = all_sys['energies'] dft_force = all_sys['forces'] if test_model is None: if self.step_code < 2: test_model = self.iteration - 1 else: test_model = self.iteration model_iter = 'iter.' + str(test_model).zfill(6) model_dir = os.path.join(location, model_iter, '00.train') self._fp_generate_error_test(work_path=quick_test_dir, model_dir=model_dir) if not os.path.exists(os.path.join(quick_test_dir, 'task.md/conf.lmp')): _lmp_data = glob( os.path.join(location, n_iter, '01.model_devi', 'task*', 'conf.lmp'))[0] os.symlink(_lmp_data, os.path.join(quick_test_dir, 'task.md/conf.lmp')) logger.info("Quick tests task submitting.") job = self.md_single_task( work_path=quick_test_dir, model_path=model_dir, numb_models=self.param_data['numb_models'], forward_files=['conf.lmp', 'input.lammps', 'validate.xyz'], backward_files=[ 'model_devi.out', 'energy.log', 'quick_test.log', 'quick_test.err', 'dump.lammpstrj' ], outlog='quick_test.log', errlog='quick_test.err', machine_name=machine_name, resource_dict=resource_dict) job.run_submission() logger.info("Quick tests finished.") quick_test_result_dict = self._fp_error_test_result( quick_test_dir, atom_numb, dft_energy, dft_force) fig = self._fp_error_test_plot(iteration, **quick_test_result_dict) return quick_test_result_dict, fig
import dpdata import numpy as np sys = dpdata.LabeledSystem('./OUTCAR.relax', fmt = 'vasp/outcar') #sys.sub_system([0,1,2]).to_deepmd_npy('system',prec=np.float32) sys.to_deepmd_npy('system',set_size=5,prec=np.float32)
def setUp(self): self.LabeledSystem1 = dpdata.LabeledSystem(os.path.join('pwmat', 'OUT.MLMD'),\ fmt='movement' )
import dpdata cp2k_output = dpdata.LabeledSystem('cp2k_output', fmt='cp2k/output') print(cp2k_output['atom_names']) print(cp2k_output['atom_numbs']) print(cp2k_output['atom_types']) print(cp2k_output['cells']) print(cp2k_output['coords']) print(cp2k_output['energies']) print(cp2k_output['forces']) # no virial cp2k_output.to_deepmd_raw('dpmd_raw') cp2k_output.to_deepmd_npy('dpmd_npy')
def _preparedeepmdforLOG(self, logfilename): system = dpdata.LabeledSystem(logfilename, fmt=self.fmt) atom_pref_file = os.path.splitext(logfilename)[0] + ".atom_pref.npy" if os.path.exists(atom_pref_file): system.data["atom_pref"] = np.load(atom_pref_file) return system
def collect_data(target_folder, param_file, output, verbose = True, shuffle = True, merge = True) : target_folder = os.path.abspath(target_folder) output = os.path.abspath(output) # goto input cwd = os.getcwd() os.chdir(target_folder) jdata = json.load(open(param_file)) sys_configs_prefix = jdata.get('sys_configs_prefix', '') sys_configs = jdata.get('sys_configs', []) if verbose : max_str_len = max([len(str(ii)) for ii in sys_configs]) max_form_len = 16 ptr_fmt = '%%%ds %%%ds natoms %%6d nframes %%6d' % (max_str_len+5, max_form_len) # init systems init_data = [] init_data_prefix = jdata.get('init_data_prefix', '') init_data_sys = jdata.get('init_data_sys', []) for ii in init_data_sys: init_data.append(dpdata.LabeledSystem(os.path.join(init_data_prefix, ii), fmt='deepmd/npy')) # collect systems from iter dirs coll_data = {} numb_sys = len(sys_configs) model_devi_jobs = jdata.get('model_devi_jobs', {}) numb_jobs = len(model_devi_jobs) iters = ['iter.%06d' % ii for ii in range(numb_jobs)] # loop over iters to collect data for ii in range(len(iters)) : iter_data = glob.glob(os.path.join(iters[ii], '02.fp', 'data.[0-9]*[0-9]')) iter_data.sort() for jj in iter_data : sys = dpdata.LabeledSystem(jj, fmt = 'deepmd/npy') if merge: sys_str = sys.formula else: sys_str = (os.path.basename(jj).split('.')[-1]) if sys_str in coll_data.keys(): coll_data[sys_str].append(sys) else: coll_data[sys_str] = sys # print information if verbose: for ii in range(len(init_data)): print(ptr_fmt % (str(init_data_sys[ii]), init_data[ii].formula, init_data[ii].get_natoms(), init_data[ii].get_nframes() )) keys = list(coll_data.keys()) keys.sort() for ii in keys: if merge: sys_str = ii else : sys_str = str(sys_configs[int(ii)]) print(ptr_fmt % (sys_str, coll_data[ii].formula, coll_data[ii].get_natoms(), coll_data[ii].get_nframes() )) # shuffle system data if shuffle: for kk in coll_data.keys(): coll_data[kk].shuffle() # create output dir os.chdir(cwd) os.makedirs(output, exist_ok = True) # dump init data for idx,ii in enumerate(init_data): out_dir = 'init.' + (data_system_fmt % idx) ii.to('deepmd/npy', os.path.join(output, out_dir)) # dump iter data for kk in coll_data.keys(): out_dir = 'sys.%s' % kk nframes = coll_data[kk].get_nframes() coll_data[kk].to('deepmd/npy', os.path.join(output, out_dir), set_size = nframes)
""" check if INCAR temperature setting correct return the correct incar file """ outcar_file = open(outcar) for _ in range(1000000): line = outcar_file.readline() if 'SIGMA' in line: sigma = float(line.split('SIGMA')[1].split('=')[1].split()[0]) outcar_file.close() return sigma if args.outcar: ls = dpdata.LabeledSystem(args.outcar, fmt='outcar') e = ls['energies'] sigma = extract_sigma_outcar(args.outcar) if args.deepmd: print("**** If multiple sets exists, configs are disorded ****") ls = dpdata.System(args.deepmd, fmt='deepmd/npy') e = ls['energies'] sigma = np.load(os.path.join(args.deepmd, 'set.000/fparam.npy'))[0] #natoms=ls.get_natoms() idx = np.array(range(len(ls))) if args.idx: print("index file provided") idx = np.loadtxt(args.idx).astype('int') ls = ls.sub_system(idx)
def stat_iter(target_folder, param_file='param.json', verbose=True, mute=False): jdata = {} with open(f"{target_folder}/{param_file}") as param_file: jdata = json.load(param_file) iter_dict = defaultdict(lambda: defaultdict(int)) output = subprocess.run([ f"wc -l {target_folder}/iter.??????/02.fp/*out", ], shell=True, stdout=subprocess.PIPE).stdout data = output.decode() # split(b'\n') for line in data.split('\n'): if 'out' in line: num, relative_path_doc = line.strip().split(' ') path_doc = os.path.abspath(relative_path_doc) num = int(num) prefix, iter_dirname, stage, out_filename = path_doc.rsplit('/', 3) # pylint: disable=unused-variable pk_id, out_filename = path_doc.rsplit('/', 1) iter = int(iter_dirname.split('.')[-1]) # pylint: disable=unused-variable out_id = int(out_filename.strip().split('.')[-2]) # pylint: disable=unused-variable out_type = out_filename.strip().split('.')[0] iter_dict[pk_id][out_type] += num # for ii in output2 = subprocess.run([ f"ls -d -1 {target_folder}/iter.??????/02.fp/task.*/OUTCAR", ], shell=True, stdout=subprocess.PIPE).stdout data2 = output2.decode() if verbose: # print('find OUTCAR', data2) print("use param_jsonfile jdata['type_map']", jdata['type_map']) for line in data2.split('\n'): if line: # [/home/felix/workplace/SiC/iter.000002/02.fp/task.018.000040/OUTCAR] path_doc = os.path.abspath(line) pk_id, task_dirname, OUTCAR_filename = path_doc.rsplit('/', 2) # pylint: disable=unused-variable try: _sys = dpdata.LabeledSystem(path_doc, type_map=jdata['type_map']) except: try: _sys = dpdata.LabeledSystem(path_doc.replace( 'OUTCAR', 'vasprun.xml'), type_map=jdata['type_map']) except: _sys = dpdata.LabeledSystem() if len(_sys) == 1: pass else: if verbose: print( 'OUTCAR not label by dpdata, not convergence or unfinshed', path_doc) iter_dict[pk_id]['OUTCAR_not_convergence'] += 1 iter_dict[pk_id]['OUTCAR_total_count'] += 1 for pk_id in {**iter_dict}: if iter_dict[pk_id]['OUTCAR_total_count']: iter_dict[pk_id]['reff'] = round( iter_dict[pk_id]['OUTCAR_not_convergence'] / iter_dict[pk_id]['OUTCAR_total_count'], 5) for pk_id, value in iter_dict.items(): print(f"{pk_id}:candidate:{value['candidate']}" f":rest_failed:{value['rest_failed']}" f":rest_accurate:{value['rest_accurate']}" f":OUTCAR_total_count:{value['OUTCAR_total_count']}" f":OUTCAR_not_convergence:{value['OUTCAR_not_convergence']}" f":reff:{value['reff']}")
import dpdata import os # find all files with end of xml allXmlFiles = [] for filename in os.listdir('.'): if os.path.isfile(filename) and 'xml' in filename: allXmlFiles.append(filename) print(allXmlFiles) # create the file for name in allXmlFiles: tmp_list = name.split('.') os.system('mkdir ' + tmp_list[0]) d_xml = dpdata.LabeledSystem(name, fmt='vasp/xml') d_xml.to_deepmd_raw(tmp_list[0] + '/') print("{} is done!".format(name)) # combine the file f_box = open('./box.raw', 'w') f_coord = open('./coord.raw', 'w') f_energy = open('./energy.raw', 'w') f_force = open('./force.raw', 'w') for name in allXmlFiles: tmp_list = name.split('.') f_tmp_box = open('{}/box.raw'.format(tmp_list[0]), 'r') for line in f_tmp_box.readlines(): f_box.write(line) f_tmp_box.close()
def setUp(self): self.system = dpdata.LabeledSystem('pwmat/MOVEMENT', fmt='pwmat/MOVEMENT')
def coll_vasp_md(jdata): out_dir = jdata['out_dir'] md_nstep = jdata['md_nstep'] scale = jdata['scale'] pert_numb = jdata['pert_numb'] coll_ndata = jdata['coll_ndata'] cwd = os.getcwd() path_md = os.path.join(out_dir, global_dirname_04) path_md = os.path.abspath(path_md) assert (os.path.isdir(path_md)), "md path should exists" os.chdir(path_md) sys_md = glob.glob('sys-*') sys_md.sort() for ii in sys_md: os.chdir(ii) # convert outcars valid_outcars = [] for jj in scale: for kk in range(pert_numb): path_work = os.path.join("scale-%.3f" % jj, "%06d" % kk) outcar = os.path.join(path_work, 'OUTCAR') # dlog.info("OUTCAR",outcar) if os.path.isfile(outcar): #dlog.info("*"*40) with open(outcar, 'r') as fin: nforce = fin.read().count('TOTAL-FORCE') # dlog.info("nforce is", nforce) # dlog.info("md_nstep", md_nstep) # print(nforce,md_nstep) if nforce == md_nstep: valid_outcars.append(outcar) elif md_nstep == 0 and nforce == 1: valid_outcars.append(outcar) else: dlog.info( "WARNING : in directory %s nforce in OUTCAR is not equal to settings in INCAR" % (os.getcwd())) arg_cvt = " " if len(valid_outcars) == 0: raise RuntimeError( "MD dir: %s: find no valid outcar in sys %s, " "check if your vasp md simulation is correctly done" % (path_md, ii)) flag = True if ("type_map" in jdata) and isinstance(jdata["type_map"], list): type_map = jdata["type_map"] else: type_map = None for oo in valid_outcars: if flag: _sys = dpdata.LabeledSystem(oo, type_map=type_map) if len(_sys) > 0: all_sys = _sys flag = False else: pass else: _sys = dpdata.LabeledSystem(oo, type_map=type_map) if len(_sys) > 0: all_sys.append(_sys) # create deepmd data if all_sys.get_nframes() >= coll_ndata: all_sys = all_sys.sub_system(np.arange(coll_ndata)) all_sys.to_deepmd_raw('deepmd') all_sys.to_deepmd_npy('deepmd', set_size=all_sys.get_nframes()) os.chdir(path_md) os.chdir(cwd)