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)
