def refine_tasks(from_task, to_task, err) :
jdata = json.load(open(os.path.join(from_task, 'in.json')))
equi_conf = get_task_file_abspath(from_task, jdata['equi_conf'])
model = get_task_file_abspath(from_task, jdata['model'])
create_path(to_task)
copied_conf = os.path.join(os.path.abspath(to_task), 'conf.lmp')
shutil.copyfile(equi_conf, copied_conf)
jdata['equi_conf'] = 'conf.lmp'
linked_model = os.path.join(os.path.abspath(to_task), 'graph.pb')
shutil.copyfile(model, linked_model)
jdata['model'] = 'graph.pb'
jdata['orig_task'] = from_task
jdata['refine_error'] = err
cwd = os.getcwd()
os.chdir(to_task)
with open('in.json', 'w') as fp:
json.dump(jdata, fp, indent=4)
os.chdir(cwd)
from_name = os.path.join(from_task, '00.angle_on')
to_name = os.path.join(to_task, '00.angle_on')
_refine_tasks(from_name, to_name, err, 'angle_on')
from_name = os.path.join(from_task, '01.deep_on')
to_name = os.path.join(to_task, '01.deep_on')
_refine_tasks(from_name, to_name, err, 'deep_on')
from_name = os.path.join(from_task, '02.bond_angle_off')
to_name = os.path.join(to_task, '02.bond_angle_off')
_refine_tasks(from_name, to_name, err, 'bond_angle_off')
def exec_args(args, parser=None):
if args.command is None:
parser.print_help()
exit
if args.command == 'gen':
output = args.output
jdata = json.load(open(args.PARAM, 'r'))
ti.make_tasks(output, jdata)
elif args.command == 'compute':
job = args.JOB
jdata = json.load(open(os.path.join(job, 'ti_settings.json'), 'r'))
equi_conf = get_task_file_abspath(job, jdata['equi_conf'])
natoms = get_natoms(equi_conf)
if 'copies' in jdata:
natoms *= np.prod(jdata['copies'])
nmols = natoms // 3
if args.inte_method == 'inte':
ti.post_tasks(job,
jdata,
args.Eo,
Eo_err=args.Eo_err,
To=args.To,
natoms=nmols,
scheme=args.scheme,
shift=args.shift)
elif args.inte_method == 'mbar':
ti.post_tasks_mbar(job, jdata, args.Eo, natoms=nmols)
else:
raise RuntimeError('unknow integration method')
elif args.command == 'refine':
ti.refine_task(args.input, args.output, args.error)
def post_task(iter_name, natoms=None, is_water=None):
# j_file = os.path.join(iter_name, 'in.json')
j_file = os.path.join(iter_name, 'equi_settings.json')
with open(j_file, 'r') as f:
jdata = json.load(f)
if natoms == None:
equi_conf = get_task_file_abspath(iter_name, jdata['equi_conf'])
natoms = get_natoms(equi_conf)
if 'copies' in jdata:
natoms *= np.prod(jdata['copies'])
if is_water is None:
is_water = jdata.get('is_water', False)
else:
pass
if is_water is True:
nmols = natoms // 3
elif is_water is False:
nmols = natoms
else:
raise RuntimeError(
'must specify key "is_water" of bool value in jdata')
stat_skip = jdata['stat_skip']
stat_bsize = jdata['stat_bsize']
log_file = os.path.join(iter_name, 'log.lammps')
info = _compute_thermo(log_file, nmols, stat_skip, stat_bsize)
ptr = _print_thermo_info(info)
info_dict = info.copy()
out_lmp = os.path.abspath(os.path.join(iter_name, 'out.lmp'))
info_dict['out_lmp'] = out_lmp
info_dict['job_dir'] = iter_name
with open(os.path.join(iter_name, 'result'), 'w') as f:
f.write(ptr)
# open(').write(ptr).close()
with open(os.path.join(iter_name, 'result.json'), 'w') as f:
json.dump(info_dict, f, indent=4)
# f.write(json.dump(info))
# open(, 'w').write(json.dumps(info)).close()
return info_dict
def post_task(iter_name, natoms=None, is_water=False):
j_file = os.path.join(iter_name, 'in.json')
jdata = json.load(open(j_file))
if natoms == None:
equi_conf = get_task_file_abspath(iter_name, jdata['equi_conf'])
natoms = get_natoms(equi_conf)
if 'copies' in jdata:
natoms *= np.prod(jdata['copies'])
is_water = jdata.get('is_water', True)
if is_water is True:
nmols = natoms // 3
elif is_water is False:
nmols = natoms
else:
raise RuntimeError(
'must specify key "is_water" of bool value in jdata')
stat_skip = jdata['stat_skip']
stat_bsize = jdata['stat_bsize']
log_file = os.path.join(iter_name, 'log.lammps')
info = _compute_thermo(log_file, nmols, stat_skip, stat_bsize)
ptr = _print_thermo_info(info)
open(os.path.join(iter_name, 'result'), 'w').write(ptr)
open(os.path.join(iter_name, 'result.json'), 'w').write(json.dumps(info))
return info
def refine_task (from_task, to_task, err) :
from_task = os.path.abspath(from_task)
to_task = os.path.abspath(to_task)
from_json = os.path.join(from_task, 'in.json')
to_json = os.path.join(to_task, 'in.json')
from_jdata = json.load(open(from_json))
to_jdata = from_jdata
path = from_jdata['path']
from_ti = os.path.join(from_task, 'ti.out')
if not os.path.isfile(from_ti) :
raise RuntimeError("cannot find file %s, task should be computed befor refined" % from_ti)
tmp_array = np.loadtxt(from_ti)
all_t = tmp_array[:,0]
integrand = tmp_array[:,1]
ntask = all_t.size
if path == 't' or path == 't-ginv':
interval_nrefine = compute_nrefine(all_t, integrand, err, all_t)
elif path == 'p' :
interval_nrefine = compute_nrefine(all_t, integrand, err)
else :
raise RuntimeError('unknow path ' + path)
refined_t = []
back_map = []
for ii in range(0, ntask-1) :
refined_t.append(all_t[ii])
back_map.append(ii)
hh = (all_t[ii+1] - all_t[ii]) / interval_nrefine[ii]
for jj in range(1, interval_nrefine[ii]) :
refined_t.append(all_t[ii] + jj * hh)
back_map.append(-1)
refined_t.append(all_t[-1])
back_map.append(ntask-1)
if to_jdata['path'] == 't-ginv' :
to_jdata['path'] = 't'
if to_jdata['path'] == 't' :
to_jdata['temps'] = refined_t
elif to_jdata['path'] == 'p' :
to_jdata['press'] = refined_t
else :
raise RuntimeError('unknow path ' + path)
to_jdata['orig_task'] = from_task
to_jdata['back_map'] = back_map
to_jdata['refine_error'] = err
to_jdata['equi_conf'] = get_task_file_abspath(from_task, from_jdata['equi_conf'])
to_jdata['model'] = get_task_file_abspath(from_task, from_jdata['model'])
# create_path(to_task)
# with open(to_json, 'w') as fp :
# json.dump(to_jdata, fp, indent=4)
make_tasks(to_task, to_jdata)
from_task_list = glob.glob(os.path.join(from_task, 'task.[0-9]*'))
from_task_list.sort()
to_task_list = glob.glob(os.path.join(to_task, 'task.[0-9]*'))
to_task_list.sort()
assert(len(from_task_list) == ntask)
assert(len(to_task_list) == len(refined_t))
for ii in range(len(to_task_list)) :
if back_map[ii] < 0 :
continue
for jj in ['data', 'log.lammps'] :
shutil.copyfile(
os.path.join(from_task_list[back_map[ii]], jj),
os.path.join(to_task_list[ii], jj),
)
with open(os.path.join(to_task_list[ii], 'from.dir'), 'w') as fp:
fp.write(from_task_list[back_map[ii]])
def post_tasks(iter_name, jdata, Eo, Eo_err = 0, To = None, natoms = None, scheme = 'simpson', shift = 0.0) :
equi_conf = get_task_file_abspath(iter_name, jdata['equi_conf'])
if natoms == None :
natoms = get_natoms(equi_conf)
if 'copies' in jdata :
natoms *= np.prod(jdata['copies'])
stat_skip = jdata['stat_skip']
stat_bsize = jdata['stat_bsize']
ens = jdata['ens']
path = jdata['path']
all_tasks = glob.glob(os.path.join(iter_name, 'task.[0-9]*'))
all_tasks.sort()
ntasks = len(all_tasks)
all_t = []
all_e = []
all_e_err = []
integrand = []
integrand_err = []
all_enthalpy = []
all_msd_xyz = []
if 'nvt' in ens and path == 't' :
# TotEng
stat_col = 3
print('# TI in NVT along T path')
elif 'npt' in ens and (path == 't' or path == 't-ginv') :
# Enthalpy
stat_col = 4
print('# TI in NPT along T path')
elif 'npt' in ens and path == 'p' :
# volume
stat_col = 7
print('# TI in NPT along P path')
else:
raise RuntimeError('invalid ens or path setting' )
print('# natoms: %d' % natoms)
for ii in all_tasks :
# get T or P
thermo_name = os.path.join(ii, 'thermo.out')
tt = float(open(thermo_name).read())
all_t.append(tt)
# get energy stat
log_name = os.path.join(ii, 'log.lammps')
data = get_thermo(log_name)
np.savetxt(os.path.join(ii, 'data'), data, fmt = '%.6e')
ea, ee = block_avg(data[:, stat_col],
skip = stat_skip,
block_size = stat_bsize)
enthalpy, _ = block_avg(data[:, 5], skip = stat_skip, block_size = stat_bsize)
msd_xyz = data[-1, -1]
# COM corr
if path == 't' or path == 't-ginv' :
ea += 1.5 * pc.Boltzmann * tt / pc.electron_volt
# print('~~', tt, ea, 1.5 * pc.Boltzmann * tt / pc.electron_volt)
elif path == 'p' :
temp = jdata['temp']
ea += 1.5 * pc.Boltzmann * temp / pc.electron_volt
else :
raise RuntimeError('invalid path setting' )
# normalized by number of atoms
ea /= natoms
if path == 't' or path == 't-ginv':
ea -= shift
ee /= np.sqrt(natoms)
all_e.append(ea)
all_e_err.append(ee)
all_enthalpy.append(enthalpy)
all_msd_xyz.append(msd_xyz)
# gen integrand
if path == 't' or path == 't-ginv':
integrand.append(ea / (tt * tt))
integrand_err.append(ee / (tt * tt))
elif path == 'p' :
# cvt from barA^3 to eV
unit_cvt = 1e5 * (1e-10**3) / pc.electron_volt
integrand.append(ea * unit_cvt)
integrand_err.append(ee * unit_cvt)
else:
raise RuntimeError('invalid path setting' )
all_print = []
all_print.append(all_t)
all_print.append(integrand)
all_print.append(all_e)
all_print.append(all_e_err)
all_print.append(all_enthalpy)
all_print.append(all_msd_xyz)
all_print = np.array(all_print)
np.savetxt(os.path.join(iter_name, 'ti.out'),
all_print.T,
fmt = '%.8e',
header = 't/p Integrand U/V U/V_err enthalpy msd_xyz')
info0 = _compute_thermo(os.path.join(all_tasks[ 0], 'log.lammps'), natoms, stat_skip, stat_bsize)
info1 = _compute_thermo(os.path.join(all_tasks[-1], 'log.lammps'), natoms, stat_skip, stat_bsize)
_print_thermo_info(info0, 'at start point')
_print_thermo_info(info1, 'at end point')
if To is not None :
index = all_t.index(To)
if index == None :
if 'nvt' == ens :
raise RuntimeError('cannot find %f in T', To)
elif 'npt' in ens :
raise RuntimeError('cannot find %f in P', To)
all_t_1 = all_t[0:index+1]
integrand_1 = integrand[0:index+1]
integrand_err_1 = integrand_err[0:index+1]
all_t_1 = np.flip(all_t_1, 0)
integrand_1 = np.flip(integrand_1, 0)
integrand_err_1 = np.flip(integrand_err_1, 0)
all_t_2 = all_t[index:]
integrand_2 = integrand[index:]
integrand_err_2 = integrand_err[index:]
all_temps_1, all_press_1, all_fe_1, all_fe_err_1, all_fe_sys_err_1 \
= _thermo_inte(jdata, Eo, Eo_err, all_t_1, integrand_1, integrand_err_1, scheme = scheme)
all_temps_2, all_press_2, all_fe_2, all_fe_err_2, all_fe_sys_err_2 \
= _thermo_inte(jdata, Eo, Eo_err, all_t_2, integrand_2, integrand_err_2, scheme = scheme)
all_temps_1 = np.flip(all_temps_1, 0)
all_press_1 = np.flip(all_press_1, 0)
all_fe_1 = np.flip(all_fe_1, 0)
all_fe_err_1 = np.flip(all_fe_err_1, 0)
all_fe_sys_err_1 = np.flip(all_fe_sys_err_1, 0)
all_temps = np.append(all_temps_1, all_temps_2[1:])
all_press = np.append(all_press_1, all_press_2[1:])
all_fe = np.append(all_fe_1, all_fe_2[1:])
all_fe_err = np.append(all_fe_err_1, all_fe_err_2[1:])
all_fe_sys_err = np.append(all_fe_sys_err_1, all_fe_sys_err_2[1:])
else :
all_temps, all_press, all_fe, all_fe_err, all_fe_sys_err \
= _thermo_inte(jdata, Eo, Eo_err, all_t, integrand, integrand_err, scheme = scheme, all_e=all_e)
# print('ti.py:debug:data', data)
result = ""
# result_file = open(f"{iter_name}/../result", 'w')
if 'nvt' == ens :
print('#%8s %20s %9s %9s %9s' % ('T(ctrl)', 'F', 'stat_err', 'inte_err', 'err'))
result += ('#%8s %20s %9s %9s %9s\n' % ('T(ctrl)', 'F', 'stat_err', 'inte_err', 'err'))
for ii in range(len(all_temps)) :
print ('%9.2f %20.12f %9.2e %9.2e %9.2e'
% (all_temps[ii], all_fe[ii], all_fe_err[ii], all_fe_sys_err[ii], np.linalg.norm([all_fe_err[ii], all_fe_sys_err[ii]])))
result += ('%9.2f %20.12f %9.2e %9.2e %9.2e\n'
% (all_temps[ii], all_fe[ii], all_fe_err[ii], all_fe_sys_err[ii], np.linalg.norm([all_fe_err[ii], all_fe_sys_err[ii]])))
elif 'npt' in ens :
print('#%8s %15s %20s %9s %9s %9s' % ('T(ctrl)', 'P(ctrl)', 'F', 'stat_err', 'inte_err', 'err'))
result += ('#%8s %15s %20s %9s %9s %9s\n' % ('T(ctrl)', 'P(ctrl)', 'F', 'stat_err', 'inte_err', 'err'))
for ii in range(len(all_temps)) :
print ('%9.2f %15.8e %20.12f %9.2e %9.2e %9.2e'
% (all_temps[ii], all_press[ii], all_fe[ii], all_fe_err[ii], all_fe_sys_err[ii], np.linalg.norm([all_fe_err[ii], all_fe_sys_err[ii]])))
result += ('%9.2f %15.8e %20.12f %9.2e %9.2e %9.2e\n'
% (all_temps[ii], all_press[ii], all_fe[ii], all_fe_err[ii], all_fe_sys_err[ii], np.linalg.norm([all_fe_err[ii], all_fe_sys_err[ii]])))
# print(all_temps[ii], all_press[ii], all_fe[ii], all_fe_err[ii], all_fe_sys_err[ii], np.linalg.norm([all_fe_err[ii], all_fe_sys_err[ii]]))
# result_file.close()
data = dict(all_temps=all_temps.tolist(), all_press=all_press.tolist(),
all_fe=all_fe.tolist(), all_fe_stat_err=all_fe_err.tolist(), all_fe_inte_err=all_fe_sys_err.tolist(),
all_fe_tot_err=np.linalg.norm([all_fe_err[ii], all_fe_sys_err[ii]]).tolist())
# data = [all_temps.tolist(), all_press.tolist(),
# all_fe.tolist(), all_fe_err.tolist(), all_fe_sys_err.tolist(),
# np.linalg.norm([all_fe_err[ii], all_fe_sys_err[ii]]).tolist()]
info = dict(start_point_info=info0, end_point_info=info1, data=data)
# print('result', result)
with open(os.path.join(iter_name, '../', 'result'), 'w') as f:
f.write(result)
with open(os.path.join(iter_name, 'result.json'), 'w') as f:
f.write(json.dumps(info))
return info