class DP_fparam(Calculator):
"""
modify from DP class of deepmd
the vanilla one does not support fparam
"""
name = "DP"
implemented_properties = ["energy", "forces", "stress"]
def __init__(self, model, label="DP", fparam=0, **kwargs):
Calculator.__init__(self, label=label, **kwargs)
self.dp = DeepPot(model)
self.type_dict = dict(
zip(self.dp.get_type_map(), range(self.dp.get_ntypes())))
self.fparam = [fparam]
def calculate(self,
atoms=None,
properties=["energy", "forces", "stress"],
system_changes=all_changes):
coord = atoms.get_positions().reshape([1, -1])
cell = atoms.get_cell().reshape([1, -1])
symbols = atoms.get_chemical_symbols()
atype = [self.type_dict[k] for k in symbols]
e, f, v = self.dp.eval(coord, cell, atype, fparam=self.fparam)
self.results['energy'] = e[0]
self.results['forces'] = f[0]
self.results['stress'] = v[0]
class DP(Calculator):
name = "DP"
implemented_properties = ["energy", "forces", "stress"]
def __init__(self, model, label="DP", type_dict=None, **kwargs):
Calculator.__init__(self, label=label, **kwargs)
self.dp = DeepPot(model)
if type_dict:
self.type_dict = type_dict
else:
self.type_dict = dict(
zip(self.dp.get_type_map(), range(self.dp.get_ntypes())))
def calculate(self,
atoms=None,
properties=["energy", "forces", "stress"],
system_changes=all_changes):
coord = atoms.get_positions().reshape([1, -1])
cell = atoms.get_cell().reshape([1, -1])
symbols = atoms.get_chemical_symbols()
atype = [self.type_dict[k] for k in symbols]
e, f, v = self.dp.eval(coord, cell, atype)
self.results['energy'] = e[0]
self.results['forces'] = f[0]
self.results['stress'] = v[0]
def predict(self, dp):
"""
Predict energies and forces by deepmd-kit.
Parameters
----------
dp : deepmd.DeepPot or str
The deepmd-kit potential class or the filename of the model.
Returns
-------
labeled_sys : LabeledSystem
The labeled system.
"""
try:
# DP 1.x
import deepmd.DeepPot as DeepPot
except ModuleNotFoundError:
# DP 2.x
from deepmd.infer import DeepPot
if not isinstance(dp, DeepPot):
dp = DeepPot(dp)
type_map = dp.get_type_map()
ori_sys = self.copy()
ori_sys.sort_atom_names(type_map=type_map)
atype = ori_sys['atom_types']
labeled_sys = LabeledSystem()
if 'auto_batch_size' not in DeepPot.__init__.__code__.co_varnames:
for ss in self:
coord = ss['coords'].reshape((1, ss.get_natoms()*3))
if not ss.nopbc:
cell = ss['cells'].reshape((1, 9))
else:
cell = None
e, f, v = dp.eval(coord, cell, atype)
data = ss.data
data['energies'] = e.reshape((1, 1))
data['forces'] = f.reshape((1, ss.get_natoms(), 3))
data['virials'] = v.reshape((1, 3, 3))
this_sys = LabeledSystem.from_dict({'data': data})
labeled_sys.append(this_sys)
else:
# since v2.0.2, auto batch size is supported
coord = self.data['coords'].reshape((self.get_nframes(), self.get_natoms()*3))
if not self.nopbc:
cell = self.data['cells'].reshape((self.get_nframes(), 9))
else:
cell = None
e, f, v = dp.eval(coord, cell, atype)
data = self.data.copy()
data['energies'] = e.reshape((self.get_nframes(), 1))
data['forces'] = f.reshape((self.get_nframes(), self.get_natoms(), 3))
data['virials'] = v.reshape((self.get_nframes(), 3, 3))
labeled_sys = LabeledSystem.from_dict({'data': data})
return labeled_sys
class DP(Calculator):
name = "DP"
implemented_properties = ["energy", "forces", "virial", "stress"]
def __init__(self, model, label="DP", type_dict=None, **kwargs):
Calculator.__init__(self, label=label, **kwargs)
self.dp = DeepPot(model)
if type_dict:
self.type_dict = type_dict
else:
self.type_dict = dict(
zip(self.dp.get_type_map(), range(self.dp.get_ntypes())))
def calculate(self,
atoms=None,
properties=["energy", "forces", "virial"],
system_changes=all_changes):
coord = atoms.get_positions().reshape([1, -1])
if sum(atoms.get_pbc()) > 0:
cell = atoms.get_cell().reshape([1, -1])
else:
cell = None
symbols = atoms.get_chemical_symbols()
atype = [self.type_dict[k] for k in symbols]
e, f, v = self.dp.eval(coords=coord, cells=cell, atom_types=atype)
self.results['energy'] = e[0][0]
self.results['forces'] = f[0]
self.results['virial'] = v[0].reshape(3, 3)
# convert virial into stress for lattice relaxation
if "stress" in properties:
if sum(atoms.get_pbc()) > 0:
# the usual convention (tensile stress is positive)
# stress = -virial / volume
stress = -0.5 * (v[0].copy() +
v[0].copy().T) / atoms.get_volume()
# Voigt notation
self.results['stress'] = stress.flat[[0, 4, 8, 5, 2, 1]]
else:
raise PropertyNotImplementedError
def test_ener(args):
if args.rand_seed is not None:
np.random.seed(args.rand_seed % (2**32))
dp = DeepPot(args.model)
data = DeepmdData(args.system,
args.set_prefix,
shuffle_test=args.shuffle_test,
type_map=dp.get_type_map())
data.add('energy', 1, atomic=False, must=False, high_prec=True)
data.add('force', 3, atomic=True, must=False, high_prec=False)
data.add('virial', 9, atomic=False, must=False, high_prec=False)
if dp.get_dim_fparam() > 0:
data.add('fparam',
dp.get_dim_fparam(),
atomic=False,
must=True,
high_prec=False)
if dp.get_dim_aparam() > 0:
data.add('aparam',
dp.get_dim_aparam(),
atomic=True,
must=True,
high_prec=False)
test_data = data.get_test()
natoms = len(test_data["type"][0])
nframes = test_data["box"].shape[0]
numb_test = args.numb_test
numb_test = min(nframes, numb_test)
coord = test_data["coord"][:numb_test].reshape([numb_test, -1])
box = test_data["box"][:numb_test]
atype = test_data["type"][0]
if dp.get_dim_fparam() > 0:
fparam = test_data["fparam"][:numb_test]
else:
fparam = None
if dp.get_dim_aparam() > 0:
aparam = test_data["aparam"][:numb_test]
else:
aparam = None
energy, force, virial, ae, av = dp.eval(coord,
box,
atype,
fparam=fparam,
aparam=aparam,
atomic=True)
energy = energy.reshape([numb_test, 1])
force = force.reshape([numb_test, -1])
virial = virial.reshape([numb_test, 9])
ae = ae.reshape([numb_test, -1])
av = av.reshape([numb_test, -1])
l2e = (l2err(energy - test_data["energy"][:numb_test].reshape([-1, 1])))
l2f = (l2err(force - test_data["force"][:numb_test]))
l2v = (l2err(virial - test_data["virial"][:numb_test]))
l2ea = l2e / natoms
l2va = l2v / natoms
# print ("# energies: %s" % energy)
print("# number of test data : %d " % numb_test)
print("Energy L2err : %e eV" % l2e)
print("Energy L2err/Natoms : %e eV" % l2ea)
print("Force L2err : %e eV/A" % l2f)
print("Virial L2err : %e eV" % l2v)
print("Virial L2err/Natoms : %e eV" % l2va)
detail_file = args.detail_file
if detail_file is not None:
pe = np.concatenate((np.reshape(test_data["energy"][:numb_test],
[-1, 1]), np.reshape(energy, [-1, 1])),
axis=1)
np.savetxt(detail_file + ".e.out", pe, header='data_e pred_e')
pf = np.concatenate((np.reshape(test_data["force"][:numb_test],
[-1, 3]), np.reshape(force, [-1, 3])),
axis=1)
np.savetxt(detail_file + ".f.out",
pf,
header='data_fx data_fy data_fz pred_fx pred_fy pred_fz')
pv = np.concatenate((np.reshape(test_data["virial"][:numb_test],
[-1, 9]), np.reshape(virial, [-1, 9])),
axis=1)
np.savetxt(
detail_file + ".v.out",
pv,
header=
'data_vxx data_vxy data_vxz data_vyx data_vyy data_vyz data_vzx data_vzy data_vzz pred_vxx pred_vxy pred_vxz pred_vyx pred_vyy pred_vyz pred_vzx pred_vzy pred_vzz'
)
sum_err[ii] += ee * ee * ss
sum_siz[ii] += ss
for ii in range(nitems):
sum_err[ii] = np.sqrt(sum_err[ii] / sum_siz[ii])
return sum_err
def test_ener (dp, args) :
if args.rand_seed is not None :
np.random.seed(args.rand_seed % (2**32))
<<<<<<< HEAD
dp = DeepPot(args.model)
=======
>>>>>>> 93aa90768089e265465f93fb3d9f99b494d56b09
data = DeepmdData(args.system, args.set_prefix, shuffle_test = args.shuffle_test, type_map = dp.get_type_map())
data.add('energy', 1, atomic=False, must=False, high_prec=True)
data.add('force', 3, atomic=True, must=False, high_prec=False)
data.add('virial', 9, atomic=False, must=False, high_prec=False)
if dp.get_dim_fparam() > 0:
data.add('fparam', dp.get_dim_fparam(), atomic=False, must=True, high_prec=False)
if dp.get_dim_aparam() > 0:
data.add('aparam', dp.get_dim_aparam(), atomic=True, must=True, high_prec=False)
test_data = data.get_test ()
natoms = len(test_data["type"][0])
nframes = test_data["box"].shape[0]
numb_test = args.numb_test
numb_test = min(nframes, numb_test)
<<<<<<< HEAD
=======
