def test_atoms_data_with_ff_map(self):
natoms, natom_types, atomic_masses_dict = \
LammpsForceFieldData.get_basic_system_info(self.polymer_linear_ff_decorated)
topology = Topology.from_molecule(self.polymer_linear_ff_decorated,
ff_map="ff_map")
atoms_data, molid_to_atomid = LammpsForceFieldData.get_atoms_data(
[self.polymer_linear_ff_decorated], [1],
self.polymer_linear_ff_decorated, atomic_masses_dict, [topology])
for i, atom in enumerate(atoms_data):
key = self.polymer_linear_ff_decorated[i].ff_map
self.assertEqual(atom[2], atomic_masses_dict[key][0])
def test_atoms_data_with_ff_map(self):
natoms, natom_types, atomic_masses_dict = \
LammpsForceFieldData.get_basic_system_info(self.polymer_linear_ff_decorated)
topology = Topology.from_molecule(self.polymer_linear_ff_decorated,
ff_map="ff_map")
atoms_data, molid_to_atomid = LammpsForceFieldData.get_atoms_data(
[self.polymer_linear_ff_decorated], [1],
self.polymer_linear_ff_decorated, atomic_masses_dict,
[topology])
for i, atom in enumerate(atoms_data):
key = self.polymer_linear_ff_decorated[i].ff_map
self.assertEqual(atom[2], atomic_masses_dict[key][0])
def from_file(cls, name, input_template, user_settings,
lammps_data=None, data_filename="in.data",
is_forcefield=False):
"""
Returns LammpsInputSet from input file template and input data.
Args:
name (str)
input_template (string): path to the input template file.
user_settings (dict): User lammps settings, the keys must
correspond to the keys in the template.
lammps_data (string/LammpsData/LammpsForceFieldData): path to the
data file or an appropriate object
data_filename (string): name of the the lammps data file.
is_forcefield (bool): whether the data file has forcefield and
topology info in it. This is required only if lammps_data is
a path to the data file instead of a data object.
Returns:
LammpsInputSet
"""
user_settings["data_file"] = data_filename
lammps_input = LammpsInput.from_file(input_template, user_settings)
if isinstance(lammps_data, six.string_types):
if is_forcefield:
lammps_data = LammpsForceFieldData.from_file(lammps_data)
else:
lammps_data = LammpsData.from_file(lammps_data)
return cls(name, lammps_input, lammps_data=lammps_data,
data_filename=data_filename)
def from_file(name, filename, lammps_data=None, data_filename="in.data",
user_lammps_settings={}, is_forcefield=False):
"""
Read in the input settings from json file as ordereddict.
Note: with monty.serialization.loadfn the order of paramters in the
json file is not preserved
Args:
filename (string): name of the file with the lamps control
paramters
lammps_data (string/LammpsData/LammpsForceFieldData): path to the
data file or an appropriate object
data_filename (string): name of the the lammps data file
user_lammps_settings (dict): User lammps settings
is_forcefield (bool): whether the data file has forcefield and
topology info in it. This is required only if lammps_data is
a path to the data file instead of a data object
Returns:
DictLammpsInput
"""
with open(filename) as f:
config_dict = json.load(f, object_pairs_hook=OrderedDict)
lammps_data = lammps_data
if isinstance(lammps_data, six.string_types):
if is_forcefield:
lammps_data = LammpsForceFieldData.from_file(lammps_data)
else:
lammps_data = LammpsData.from_file(lammps_data)
return DictLammpsInput(name, config_dict, lammps_data=lammps_data,
data_filename=data_filename,
user_lammps_settings=user_lammps_settings)
def test_from_file(self):
self.lammps_ff_data.write_data_file(
os.path.join(test_dir, "lammps_ff_data.dat"))
lammps_ff_data = LammpsForceFieldData.from_file(
os.path.join(test_dir, "lammps_ff_data.dat"))
np.testing.assert_almost_equal(lammps_ff_data.atomic_masses,
self.lammps_ff_data.atomic_masses,
decimal=10)
np.testing.assert_almost_equal(lammps_ff_data.pair_coeffs,
self.lammps_ff_data.pair_coeffs,
decimal=10)
np.testing.assert_almost_equal(lammps_ff_data.bond_coeffs,
self.lammps_ff_data.bond_coeffs,
decimal=10)
np.testing.assert_almost_equal(lammps_ff_data.angle_coeffs,
self.lammps_ff_data.angle_coeffs,
decimal=10)
np.testing.assert_almost_equal(lammps_ff_data.atoms_data,
self.lammps_ff_data.atoms_data,
decimal=10)
np.testing.assert_almost_equal(lammps_ff_data.bonds_data,
self.lammps_ff_data.bonds_data,
decimal=10)
np.testing.assert_almost_equal(lammps_ff_data.angles_data,
self.lammps_ff_data.angles_data,
decimal=10)
self.assertEqual(str(lammps_ff_data), str(self.lammps_ff_data))
def setUp(self):
self.polymer_linear = Molecule.from_file(
os.path.join(test_dir, "polymer_linear.xyz"))
charges = [-0.1187, 0.0861, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861,
0.0861, -0.0326, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861,
0.0861, -0.0326, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861,
0.0861, -0.0326, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861,
0.0861, -0.0326, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861,
0.0861, -0.0326, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861,
0.0861, -0.0326, 0.0861, 0.0861, -0.2792, -0.1187, 0.0861,
0.0861, 0.0861]
ff_map = ["C3", "H3", "H3", "H3", "O", "C2", "H2",
"H2", "C2", "H2", "H2", "O", "C2", "H2",
"H2", "C2", "H2", "H2", "O", "C2", "H2",
"H2", "C2", "H2", "H2", "O", "C2", "H2",
"H2", "C2", "H2", "H2", "O", "C2", "H2",
"H2", "C2", "H2", "H2", "O", "C2", "H2",
"H2", "C2", "H2", "H2", "O", "C3", "H3", "H3", "H3"]
self.polymer_linear.add_site_property("charge", charges)
self.polymer_linear.add_site_property("ff_map", ff_map)
self.topology = Topology.from_molecule(self.polymer_linear)
self.forcefield = ForceField.from_file(
os.path.join(test_dir, "ffmap_data.yaml"))
box_size = [[0.0, 50],
[0.0, 50],
[0.0, 50]]
self.lammps_ff_data = LammpsForceFieldData.from_forcefield_and_topology(
[self.polymer_linear], [1], box_size, self.polymer_linear,
self.forcefield, [self.topology])
def from_file(name, filename, data_filename=None, is_forcefield=False):
"""
Read in the input settings from json file as ordereddict. Also
reads in the datafile if provided.
Note: with monty.serialization.loadfn the order of paramters in the
json file is not preserved
Args:
filename (string): name of the file with the lamps control
paramters
data_filename (string): path to the data file
is_forcefield (bool): whether the data file has forcefield and
topology info in it.
Returns:
DictLammpsInput
"""
with open(filename) as f:
config_dict = json.load(f, object_pairs_hook=OrderedDict)
lammps_data = None
if data_filename:
if is_forcefield:
lammps_data = LammpsForceFieldData.from_file(data_filename)
else:
lammps_data = LammpsData.from_file(data_filename)
return DictLammpsInput(name, config_dict, lammps_data)
def run_task(self, fw_spec):
gaussian_file = fw_spec['prev_gaussian_freq']
mol = fw_spec["molecule"]
molecules = [mol]
# list of gaussian files, one for each molecule type in molecules
gaussian_files = [gaussian_file]
# pack the molecules using packmol
param_list = [{
"number":
100,
"inside box": [-14.82, -14.82, -14.82, 14.82, 14.82, 14.82]
}]
pmr = PackmolRunner(molecules, param_list)
packed_molecule = pmr.run()
# lammps input
input_filename = 'mol.inp'
data_filename = 'mol.data'
# generate amber force field data
lammps_data = LammpsForceFieldData.from_amber(molecules,
param_list["number"],
param_list["inside box"],
packed_molecule,
gaussian_files)
user_lammps_settings = {
"fix1": "NPT all npt temp 298 298 100.0 iso 1.0 1.0 100.0",
"fix2": "NVT all nvt temp 298 298 100.0"
}
lammps_input = NPTNVTLammpsInput(
data_obj=lammps_data, user_lammps_settings=user_lammps_settings)
lammps_input.write_input(input_filename, data_file=data_filename)
def run_task(self, fw_spec):
molecules = self["constituent_molecules"]
mols_number = self["mols_number"]
input_filename = self["input_filename"]
forcefield = self["forcefield"]
topologies = self["topologies"]
user_settings = self.get("user_settings", {})
data_filename = user_settings.get("data_file", "lammps.data")
final_molecule = self["final_molecule"]
if isinstance(final_molecule, six.string_types):
final_molecule = Molecule.from_file(final_molecule)
lammps_ff_data = LammpsForceFieldData.from_forcefield_and_topology(
molecules, mols_number, self["box_size"], final_molecule,
forcefield, topologies)
lammps_input_set = LammpsInputSet.from_file(
"forcefield",
self["input_file"],
user_settings=user_settings,
lammps_data=lammps_ff_data,
data_filename=data_filename,
is_forcefield=True)
lammps_input_set.write_input(input_filename, data_filename)
def setUpClass(cls):
atoms = OrderedDict([('hw', 'h'), ('ow', 'o')])
bonds = OrderedDict([((u'hw', u'ow'), [553.0, 0.957]),
((u'hw', u'hw'), [553.0, 1.513])])
angles = OrderedDict([((u'hw', u'ow', u'hw'), [0.0, 104.52])])
vdws = OrderedDict([(u'hw', [0.0, 0.0]), (u'ow', [1.7683, 0.1520])])
forcefield = ForceField(atoms, bonds, angles, pairs=vdws)
h2o_coords = [[9.626, 6.787, 12.673],
[9.626, 8.420, 12.673],
[10.203, 7.604, 12.673]]
h2o = Molecule(["H", "H", "O"], h2o_coords)
# h2o, h-o, h-o, h=1, h=2, o=3
top_atoms = [['h', 'hw'], ['o', 'ow']]
top_bonds = [[1, 3, ('hw', 'ow')], [2, 3, ('hw', 'ow')]]
top_angles = [[1, 3, 2, ('hw', 'ow', 'hw')]]
topology = Topology(top_atoms, top_bonds, top_angles)
mols = [h2o]
mols_number = [1]
box_size = [[0.0, 10.0], [0.0, 10.0], [0.0, 10.0]]
molecule = h2o
topologies = [topology]
cls.lammps_ff_data = LammpsForceFieldData.from_forcefield_and_topology(
mols, mols_number,
box_size, molecule,
forcefield,
topologies)
def from_file(cls,
name,
input_template,
user_settings,
lammps_data=None,
data_filename="in.data",
is_forcefield=False):
"""
Returns LammpsInputSet from input file template and input data.
Args:
input_template (string): path to the input template file.
user_settings (dict): User lammps settings, the keys must
correspond to the keys in the template.
lammps_data (string/LammpsData/LammpsForceFieldData): path to the
data file or an appropriate object
data_filename (string): name of the the lammps data file.
is_forcefield (bool): whether the data file has forcefield and
topology info in it. This is required only if lammps_data is
a path to the data file instead of a data object.
Returns:
LammpsInputSet
"""
lammps_input = LammpsInput.from_file(input_template, user_settings)
if isinstance(lammps_data, six.string_types):
if is_forcefield:
lammps_data = LammpsForceFieldData.from_file(lammps_data)
else:
lammps_data = LammpsData.from_file(lammps_data)
return cls(name,
lammps_input,
lammps_data=lammps_data,
data_filename=data_filename)
def from_file(name,
filename,
data_obj=None,
data_file=None,
is_forcefield=False):
"""
Read in the input settings from json file as ordereddict. Also
reads in the datafile if provided.
Note: with monty.serialization.loadfn the order of paramters in the
json file is not preserved
Args:
filename (string): name of the file with the lamps control
paramters
data_obj (LammpsData): LammpsData object
data_file (string): name of the data file name
is_forcefield (bool): whether the data file has forcefield and
topology info in it.
Returns:
DictLammpsInput
"""
with open(filename) as f:
config_dict = json.load(f, object_pairs_hook=OrderedDict)
lammps_data = None
if data_file:
if is_forcefield:
lammps_data = LammpsForceFieldData.from_file(data_file)
else:
lammps_data = LammpsData.from_file(data_file)
if data_obj and isinstance(data_obj, LammpsData):
lammps_data = data_obj
return DictLammpsInput(name, config_dict, lammps_data)
def test_from_file(self):
self.lammps_ff_data.write_data_file(
os.path.join(test_dir, "lammps_ff_data.dat"))
lammps_ff_data = LammpsForceFieldData.from_file(
os.path.join(test_dir, "lammps_ff_data.dat"))
np.testing.assert_almost_equal(lammps_ff_data.atomic_masses,
self.lammps_ff_data.atomic_masses,
decimal=10)
np.testing.assert_almost_equal(lammps_ff_data.pair_coeffs,
self.lammps_ff_data.pair_coeffs,
decimal=10)
np.testing.assert_almost_equal(lammps_ff_data.bond_coeffs,
self.lammps_ff_data.bond_coeffs,
decimal=10)
np.testing.assert_almost_equal(lammps_ff_data.angle_coeffs,
self.lammps_ff_data.angle_coeffs,
decimal=10)
np.testing.assert_almost_equal(lammps_ff_data.atoms_data,
self.lammps_ff_data.atoms_data,
decimal=10)
np.testing.assert_almost_equal(lammps_ff_data.bonds_data,
self.lammps_ff_data.bonds_data,
decimal=10)
np.testing.assert_almost_equal(lammps_ff_data.angles_data,
self.lammps_ff_data.angles_data,
decimal=10)
self.assertEqual(str(lammps_ff_data), str(self.lammps_ff_data))
def test_pair_coeffs(self):
natoms, natom_types, atomic_masses_dict = \
LammpsForceFieldData.get_basic_system_info(self.dmoe)
# atom_types = list(atomic_masses_dict.keys())
ans_atomtype_ids = [x[0] for x in atomic_masses_dict.values()]
pair_coeffs = self.lammps_ff_data.pair_coeffs
atomtype_ids = [x[0] for x in pair_coeffs]
self.assertEqual(ans_atomtype_ids, atomtype_ids)
def __init__(self, data_file, trajectory_file, log_file="log.lammps",
is_forcefield=False):
self.data_file = data_file
self.trajectory_file = trajectory_file
self.log_file = log_file
self.lammps_log = LammpsLog(log_file)
if is_forcefield:
self.lammps_data = LammpsForceFieldData.from_file(data_file)
else:
self.lammps_data = LammpsData.from_file(data_file)
self._set_mol_masses_and_charges()
self._parse_trajectory()
def setUpClass(cls):
polymer_chain = Molecule.from_file(os.path.join(test_dir, "polymer_chain.xyz"))
polymer_linear = Molecule.from_file(os.path.join(test_dir, "polymer_linear.xyz"))
cls.polymer_matrix = Molecule.from_file(os.path.join(test_dir, "polymer_matrix.xyz"))
charges = [-0.1187, 0.0861, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861,
0.0861, -0.0326, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861,
0.0861, -0.0326, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861,
0.0861, -0.0326, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861,
0.0861, -0.0326, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861,
0.0861, -0.0326, 0.0861, 0.0861, -0.2792, -0.0326, 0.0861,
0.0861, -0.0326, 0.0861, 0.0861, -0.2792, -0.1187, 0.0861,
0.0861, 0.0861]
polymer_linear.add_site_property("charge", charges)
topology = Topology.from_molecule(polymer_linear)
cls.polymer_linear_ff_decorated = Molecule.from_file(
os.path.join(test_dir,"polymer_linear.xyz"))
ff_map = ['C2', 'H3', 'H2', 'H3', 'O', 'C3', 'H2', 'H3', 'C2', 'H3',
'H2', 'O', 'C2', 'H3', 'H2', 'C3', 'H2', 'H3', 'O', 'C3',
'H2', 'H3', 'C2', 'H3', 'H2', 'O', 'C2', 'H3', 'H2', 'C3',
'H2', 'H3', 'O', 'C3', 'H2', 'H3', 'C2', 'H3', 'H2', 'O',
'C2', 'H3', 'H2', 'C3', 'H2', 'H3', 'O', 'C3', 'H2', 'H3', 'H2']
cls.polymer_linear_ff_decorated.add_site_property("ff_map", ff_map)
atoms = OrderedDict([("C", "C"), ("H", "H"), ("O", "O")])
bonds = OrderedDict([((u'C', u'O'), [1000, 1.4115]),
((u'C', u'H'), [1000, 1.1041]),
((u'C', u'C'), [1000, 1.5075])])
pairs = OrderedDict([((u'O', u'O'), [75844.8, 0.2461, 396.9]),
((u'H', u'H'), [2649.6, 0.2674, 27.22]),
((u'C', u'C'), [14976.0, 0.3236, 637.6])])
angles = OrderedDict([((u'C', u'C', u'H'), [42.9, 110.1]),
((u'H', u'C', u'H'), [38.5, 109.47]),
((u'H', u'C', u'O'), [56.0, 109.48]),
((u'C', u'C', u'O'), [86.0, 108.54]),
((u'C', u'O', u'C'), [74.5, 108.05])])
dihedrals = OrderedDict([((u'H', u'C', u'O', u'C'), [0.0, 0.0, -0.73, 0.0]),
((u'H', u'C', u'C', u'H'), [0.0, 0.0, 0.28, 0.0]),
((u'C', u'C', u'O', u'C'), [1.76, 0.67, 0.04, 0.0]),
((u'H', u'C', u'C', u'O'), [0.0, 0.0, 0.28, 0.0]),
((u'O', u'C', u'C', u'O'), [0.41, -2.1, -0.6, -0.82])])
forcefield = ForceField(atoms, bonds, angles, dihedrals=dihedrals, pairs=pairs)
cls.molecules = [polymer_chain] * 3
cls.mols_number = [7, 3, 1]
box_size = [[0.0, 50], [0.0, 50], [0.0, 50]]
cls.topologies = [topology] * len(cls.molecules)
cls.lammps_ff_data_1 = LammpsForceFieldData.from_forcefield_and_topology(
cls.molecules, cls.mols_number, box_size, cls.polymer_matrix,
forcefield, cls.topologies)
def test_system_info_with_ff_map(self):
natoms, natom_types, atomic_masses_dict = \
LammpsForceFieldData.get_basic_system_info(self.polymer_linear_ff_decorated)
ans_atom_masses_dict = OrderedDict([('H2', [1, 1.00794]),
('H3', [2, 1.00794]),
('C2', [3, 12.0107]),
('C3', [4, 12.0107]),
('O', [5, 15.9994])])
self.assertEqual(natoms, 51)
self.assertEqual(natom_types, 5)
self.assertEqual(atomic_masses_dict.keys(), ans_atom_masses_dict.keys())
for k, v in atomic_masses_dict.items():
self.assertEqual(ans_atom_masses_dict[k][1], v[1])
def from_file(cls, name, filename, lammps_data=None, data_filename="in.data",
user_lammps_settings={}, is_forcefield=False):
"""
Reads lammps style and JSON style input files putting the settings in an ordered dict (config_dict).
Note: with monty.serialization.loadfn the order of paramters in the
json file is not preserved
Args:
filename (string): name of the file with the lamps control
paramters
lammps_data (string/LammpsData/LammpsForceFieldData): path to the
data file or an appropriate object
data_filename (string): name of the the lammps data file
user_lammps_settings (dict): User lammps settings
is_forcefield (bool): whether the data file has forcefield and
topology info in it. This is required only if lammps_data is
a path to the data file instead of a data object
Returns:
DictLammpsInput
"""
try:
with open(filename) as f:
config_dict = json.load(f, object_pairs_hook=OrderedDict)
except ValueError:
with open(filename, 'r') as f:
data = f.read().splitlines()
config_dict = OrderedDict()
for line in data:
if line and not line.startswith("#"):
spt_line = (line.split(None, 1))
if spt_line[0] in config_dict:
if isinstance(config_dict[spt_line[0]], list):
config_dict[spt_line[0]].append(spt_line[1])
else:
config_dict[spt_line[0]] = [config_dict[spt_line[0]], spt_line[1]]
else:
config_dict[spt_line[0]] = spt_line[1]
lammps_data = lammps_data
if isinstance(lammps_data, six.string_types):
if is_forcefield:
lammps_data = LammpsForceFieldData.from_file(lammps_data)
else:
lammps_data = LammpsData.from_file(lammps_data)
return cls(name, config_dict, lammps_data=lammps_data,
data_filename=data_filename,
user_lammps_settings=user_lammps_settings)
def test_lammps_wflow(self):
lammps_data = LammpsForceFieldData.from_file(self.data_file)
log_filename = "peo.log"
dump_filename = "peo.dump"
dcd_traj_filename = "peo.dcd"
timestep = 1 # in fmsec for 'real' units
n_timesteps = 1000
dump_freq = 50
T = [300, 300, 100.0] # start, end, damp
P = [0, 0, 100.0]
# override default settings read from the json file with these
user_settings = {"log": log_filename,
"timestep": timestep,
"run": n_timesteps,
"pair_style": "buck/coul/cut 15.0",
"pair_coeff": ["1 1 2649.6 0.2674 27.22",
"1 2 4320.0 0.2928 137.6",
"1 3 14176.0 0.2563 104.0",
"2 2 14976.0 0.3236 637.6",
"2 3 33702.4 0.2796 503.0",
"3 3 75844.8 0.2461 396.9"],
"thermo_style": "custom step time temp press pe ke etotal enthalpy fmax fnorm",
"fix": "NPT all npt temp {T[0]} {T[1]} {T[2]} iso {P[0]} {P[1]} {P[2]}".format(T=T, P=P),
"dump": [
"peodump all custom {} {} id type x y z ix iy iz mol".format(dump_freq, dump_filename),
"traj all dcd {} {}".format(dump_freq, dcd_traj_filename)]}
if not LAMMPS_CMD:
# fake run
lammps_bin = "cp ../../reference_files/peo.* ."
dry_run = True
else:
lammps_bin = LAMMPS_CMD
dry_run = False
wf = wf_from_input_template(self.input_template, lammps_data, "npt.data", user_settings,
is_forcefield=True, input_filename="lammps.inp", lammps_bin=lammps_bin,
db_file=">>db_file<<", dry_run=dry_run)
self.lp.add_wf(wf)
# run
rapidfire(self.lp, fworker=FWorker(env={"db_file": os.path.join(db_dir, "db.json")}))
d = self._get_task_collection().find_one()
self._check_run(d)
def setUp(self):
# DMOE = Dimethoxyethane
self.dmoe = Molecule.from_file(os.path.join(test_dir, "dmoe.xyz"))
dmoe_charges = [-0.10, 0.09, 0.09, 0.09,
-0.34, -0.01, 0.09, 0.09,
-0.01, 0.09, 0.09, -0.34,
-0.10, 0.09, 0.09, 0.09]
self.dmoe.add_site_property("charge", dmoe_charges)
ff_map = ["C3", "H3", "H3", "H3",
"O", "C2", "H2", "H2",
"C2", "H2", "H2", "O",
"C3", "H3", "H3", "H3"]
self.dmoe.add_site_property("ff_map", ff_map)
self.topology = Topology.from_molecule(self.dmoe, ff_map="ff_map")
self.forcefield = ForceField.from_file(
os.path.join(test_dir, "ffmap_data.yaml"))
self.box_size = [[0.0, 10], [0.0, 10], [0.0, 10]]
self.lammps_ff_data = \
LammpsForceFieldData.from_forcefield_and_topology(
[self.dmoe], [1], self.box_size, self.dmoe, self.forcefield, [self.topology])
def test_to_and_from_file(self):
self.lammps_ff_data_1.write_data_file(
os.path.join(test_dir,"lammps_ff_data.dat"))
lammps_ff_data_2 = LammpsForceFieldData.from_file(
os.path.join(test_dir,"lammps_ff_data.dat"))
np.testing.assert_almost_equal(self.lammps_ff_data_1.bond_coeffs,
lammps_ff_data_2.bond_coeffs)
np.testing.assert_almost_equal(self.lammps_ff_data_1.pair_coeffs,
lammps_ff_data_2.pair_coeffs)
np.testing.assert_almost_equal(self.lammps_ff_data_1.angle_coeffs,
lammps_ff_data_2.angle_coeffs)
np.testing.assert_almost_equal(self.lammps_ff_data_1.dihedral_coeffs,
lammps_ff_data_2.dihedral_coeffs)
np.testing.assert_almost_equal(self.lammps_ff_data_1.atoms_data,
lammps_ff_data_2.atoms_data, decimal=10)
self.assertEqual(self.lammps_ff_data_1.bonds_data,
lammps_ff_data_2.bonds_data)
self.assertEqual(self.lammps_ff_data_1.angles_data,
lammps_ff_data_2.angles_data)
self.assertEqual(self.lammps_ff_data_1.dihedrals_data,
lammps_ff_data_2.dihedrals_data)
def setUpClass(cls):
atoms = OrderedDict([('hw', 'h'), ('ow', 'o')])
bonds = OrderedDict([((u'hw', u'ow'), [553.0, 0.957]),
((u'hw', u'hw'), [553.0, 1.513])])
angles = OrderedDict([((u'hw', u'ow', u'hw'), [0.0, 104.52])])
vdws = OrderedDict([(u'hw', [0.0, 0.0]), (u'ow', [1.7683, 0.1520])])
forcefield = ForceField(atoms, bonds, angles, vdws=vdws)
h2o_coords = [[9.626, 6.787, 12.673], [9.626, 8.420, 12.673],
[10.203, 7.604, 12.673]]
h2o = Molecule(["H", "H", "O"], h2o_coords)
# h2o, h-o, h-o, h=1, h=2, o=3
top_atoms = [['h', 'hw'], ['o', 'ow']]
top_bonds = [[1, 3, ('hw', 'ow')], [2, 3, ('hw', 'ow')]]
top_angles = [[1, 3, 2, ('hw', 'ow', 'hw')]]
topology = Topology(top_atoms, top_bonds, top_angles)
mols = [h2o]
mols_number = [1]
box_size = [[0.0, 10.0], [0.0, 10.0], [0.0, 10.0]]
molecule = h2o
topologies = [topology]
cls.lammps_ff_data = LammpsForceFieldData.from_forcefield_and_topology(
mols, mols_number, box_size, molecule, forcefield, topologies)
def from_file(name,
filename,
lammps_data=None,
data_filename="in.data",
user_lammps_settings={},
is_forcefield=False):
"""
Read in the input settings from json file as ordereddict.
Note: with monty.serialization.loadfn the order of paramters in the
json file is not preserved
Args:
filename (string): name of the file with the lamps control
paramters
lammps_data (string/LammpsData/LammpsForceFieldData): path to the
data file or an appropriate object
data_filename (string): name of the the lammps data file
user_lammps_settings (dict): User lammps settings
is_forcefield (bool): whether the data file has forcefield and
topology info in it. This is required only if lammps_data is
a path to the data file instead of a data object
Returns:
DictLammpsInput
"""
with open(filename) as f:
config_dict = json.load(f, object_pairs_hook=OrderedDict)
lammps_data = lammps_data
if isinstance(lammps_data, six.string_types):
if is_forcefield:
lammps_data = LammpsForceFieldData.from_file(lammps_data)
else:
lammps_data = LammpsData.from_file(lammps_data)
return DictLammpsInput(name,
config_dict,
lammps_data=lammps_data,
data_filename=data_filename,
user_lammps_settings=user_lammps_settings)
