def test_box_center():
dl = eex.datalayer.DataLayer("test_box_center", backend="memory")
tmp = {"x": 5, "y": 6, "z": 7}
# Normal set/get
dl.set_box_center(tmp)
comp = dl.get_box_center()
assert dict_compare(tmp, comp)
# Check failure
with pytest.raises(KeyError):
dl.set_box_center({'x': tmp['x']})
# Set/get with units
utype = {"x": "nanometers", "y": "nanometers", "z": "nanometers"}
dl.set_box_center(tmp, utype=utype)
comp = dl.get_box_center(utype=utype)
assert np.isclose(comp["x"], tmp["x"])
assert np.isclose(comp["y"], tmp["y"])
assert np.isclose(comp["z"], tmp["z"])
# Set/get with units
utype_1 = {"x": "angstroms", "y": "angstroms", "z": "angstroms"}
dl.set_box_center(tmp, utype=utype)
comp = dl.get_box_center(utype=utype_1)
assert np.isclose(comp["x"], tmp["x"] * 10)
assert np.isclose(comp["y"], tmp["y"] * 10)
assert np.isclose(comp["z"], tmp["z"] * 10)
utype_2 = {"x": "miles", "y": "miles", "z": "miles"}
with pytest.raises(AssertionError):
dl.set_box_center(tmp, utype=utype_2)
comp = dl.get_box_center()
assert dict_compare(tmp, comp)
def test_add_nb_parameter_units():
# Create empty data layer
dl = eex.datalayer.DataLayer("test_add_nb_parameters", backend="memory")
# Create system with three molecules
atom_sys = _build_atom_df(3)
# Add atomic system to datalayer
dl.add_atoms(atom_sys)
# Add AB LJ parameters to data layer - add to single atom
dl.add_nb_parameter(atom_type=1,
nb_name="LJ",
nb_model="AB",
nb_parameters=[1.0, 1.0],
utype=[
"kJ * mol ** -1 * nanometers ** 12",
"kJ * mol ** -1 * nanometers ** 6"
])
# Add AB LJ parameters to data layer - add to two atoms
dl.add_nb_parameter(atom_type=1,
nb_name="LJ",
nb_model="AB",
nb_parameters=[2.0, 2.0],
atom_type2=2,
utype=[
"kJ * mol ** -1 * nanometers ** 12",
"kJ * mol ** -1 * nanometers ** 6"
])
# Test atom types out of order
dl.add_nb_parameter(atom_type=3,
nb_name="LJ",
nb_model="AB",
nb_parameters=[2.0, 2.0],
atom_type2=1,
utype=[
"kJ * mol ** -1 * nanometers ** 12",
"kJ * mol ** -1 * nanometers ** 6"
])
# Grab stored test parameters
test_parameters = dl.list_nb_parameters(nb_name="LJ")
# make sure this grabs all stored values
assert (set(list(test_parameters)) == set([(1, None), (1, 2), (1, 3)]))
# Check conversion
assert dict_compare(test_parameters[(1, None)], {'A': 1.e12, 'B': 1.e6})
assert dict_compare(test_parameters[(1, 2)], {'A': 2.e12, 'B': 2.e6})
assert dict_compare(test_parameters[(1, 3)], {'A': 2.e12, 'B': 2.e6})
# Check keywords
test_parameters2 = dl.list_nb_parameters(nb_name="LJ", itype="single")
assert (list(test_parameters2) == [(1, None)])
test_parameters3 = dl.list_nb_parameters(nb_name="LJ", itype="pair")
assert (list(test_parameters3) == [(1, 2), (1, 3)])
def test_mixing_table():
dl = eex.datalayer.DataLayer("test_add_nb_parameters", backend="memory")
# Create system with three molecules
atom_sys = _build_atom_df(3)
# Add atomic system to datalayer
dl.add_atoms(atom_sys)
# Add mixing rule to datalayer
dl.set_mixing_rule("arithmetic")
# Add AB LJ parameters to data layer - add to single atom
dl.add_nb_parameter(atom_type=1,
nb_name="LJ",
nb_model="epsilon/sigma",
nb_parameters={
'epsilon': 1.0,
'sigma': 2.0
})
# Add AB LJ parameters to data layer - add to single atom
dl.add_nb_parameter(atom_type=2,
nb_name="LJ",
nb_model="epsilon/sigma",
nb_parameters={
'epsilon': 2.0,
'sigma': 1.0
})
# Apply mixing rule
dl.build_LJ_mixing_table()
# Get mixed parameters
pairIJ = dl.list_nb_parameters(nb_name="LJ",
itype="pair",
nb_model="epsilon/sigma")
ans = {
(1, 1): {
'sigma': 2.,
'epsilon': 1,
},
(1, 2): {
'sigma': 1.5,
'epsilon': (2.)**(1. / 2.)
},
(2, 2): {
'sigma': 1.,
'epsilon': 2.
},
}
assert (dict_compare(pairIJ, ans))
def test_get_term_parameters_units():
"""
Test obtaining parameters from the DL with units
"""
dl = eex.datalayer.DataLayer("test_get_parameters_units")
utype_2b = {"K": "(kJ / mol) * angstrom ** -2", "R0": "angstrom"}
assert 0 == dl.add_term_parameter(2,
"harmonic", {
"K": 4.0,
"R0": 5.0
},
utype=utype_2b)
assert 1 == dl.add_term_parameter(2,
"harmonic", {
"K": 6.0,
"R0": 7.0
},
utype=utype_2b)
utype_2scale = {
"K": "2.0 * (kJ / mol) * angstrom ** -2",
"R0": "2.0 * angstrom"
}
parm1 = dl.get_term_parameter(2, 0, utype=utype_2scale, ftype="harmonic")
assert parm1[0] == "harmonic"
assert dict_compare(parm1[1], {"K": 2.0, "R0": 2.5})
parm2 = dl.get_term_parameter(
2, 0, utype=[utype_2scale["K"], utype_2scale["R0"]], ftype="harmonic")
assert parm2[0] == "harmonic"
assert dict_compare(parm2[1], {"K": 2.0, "R0": 2.5})
with pytest.raises(TypeError):
dl.get_term_parameter(2, 0, utype={5, 6}, ftype="harmonic")
with pytest.raises(KeyError):
utype = {"K": "(kJ / mol) * angstrom ** -2"}
dl.get_term_parameter(2, 0, utype=utype, ftype="harmonic")
def test_get_term_parameter():
"""
Test obtaining parameters from the DL
"""
dl = eex.datalayer.DataLayer("test_get_parameters")
# Add a few parameters
assert 0 == dl.add_term_parameter(2, "harmonic", {"K": 4.0, "R0": 5.0})
assert 1 == dl.add_term_parameter(2, "harmonic", {"K": 6.0, "R0": 7.0})
parm1 = dl.get_term_parameter(2, 0)
assert parm1[0] == "harmonic"
assert dict_compare(parm1[1], {"K": 4.0, "R0": 5.0})
assert dict_compare(parm1[1], {"K": 4.0, "R0": 5.0 + 1.e-12})
parm2 = dl.get_term_parameter(2, 1)
assert parm2[0] == "harmonic"
assert dict_compare(parm2[1], {"K": 6.0, "R0": 7.0})
with pytest.raises(KeyError):
dl.get_term_parameter(2, 1231234123)
def test_mixing_rule():
dl = eex.datalayer.DataLayer("test_add_nb_parameters", backend="memory")
# Create system with three molecules
atom_sys = _build_atom_df(3)
# Add atomic system to datalayer
dl.add_atoms(atom_sys)
# Add mixing rule to datalayer
dl.set_mixing_rule("geometric")
# Check failure
with pytest.raises(ValueError):
dl.set_mixing_rule("test")
with pytest.raises(TypeError):
dl.set_mixing_rule(5)
# Add AB LJ parameters to data layer - add to single atom
dl.add_nb_parameter(atom_type=1,
nb_name="LJ",
nb_model="epsilon/sigma",
nb_parameters={
'epsilon': 1.0,
'sigma': 2.0
})
# Add Buckingham parameter to datalayer
dl.add_nb_parameter(atom_type=2,
nb_name="Buckingham",
nb_parameters={
"A": 1.0,
"C": 1.0,
"rho": 1.0
})
# This should fail because we can not combine LJ and Buckingham parameters.
with pytest.raises(ValueError):
dl.mix_LJ_parameters(atom_type1=1, atom_type2=2)
with pytest.raises(KeyError):
dl.mix_LJ_parameters(atom_type1=1, atom_type2=3)
# Overwrite Buckingham parameter
dl.add_nb_parameter(atom_type=2,
nb_name="LJ",
nb_model="epsilon/sigma",
nb_parameters={
'epsilon': 1.0,
'sigma': 1.0
})
# Apply mixing rule
dl.mix_LJ_parameters(atom_type1=1, atom_type2=2)
# Get values from datalayer and check
params = dl.get_nb_parameter(atom_type=1,
atom_type2=2,
nb_model="epsilon/sigma")
ans = {'sigma': 2**(1. / 2.), 'epsilon': 1.}
assert dict_compare(params, ans)
def test_get_nb_parameter():
# Create empty data layer
dl = eex.datalayer.DataLayer("test_add_nb_parameters", backend="memory")
# Create system with three molecules
atom_sys = _build_atom_df(3)
# Add atomic system to datalayer
dl.add_atoms(atom_sys)
# Add AB LJ parameters to data layer - add to single atom
dl.add_nb_parameter(atom_type=1,
nb_name="LJ",
nb_model="AB",
nb_parameters={
'A': 1.0,
'B': 2.0
})
# Add Buckingham parameter to datalayer
dl.add_nb_parameter(atom_type=2,
nb_name="Buckingham",
nb_parameters={
"A": 1.0,
"C": 1.0,
"rho": 1.0
})
# The following should raise an error because (1,2) interaction is not set
with pytest.raises(KeyError):
dl.get_nb_parameter(atom_type=1, atom_type2=2, nb_model="AB")
# Test that what returned is expected
assert dict_compare(dl.get_nb_parameter(atom_type=2), {
"A": 1.0,
"C": 1.0,
"rho": 1.0
})
assert dict_compare(dl.get_nb_parameter(atom_type=1, nb_model="AB"), {
'A': 1.0,
'B': 2.0
})
# Test conversion of AB to different forms
assert dict_compare(
dl.get_nb_parameter(atom_type=1, nb_model="epsilon/sigma"), {
'epsilon': 1.0,
'sigma': (1. / 2.)**(1. / 6.)
})
assert dict_compare(
dl.get_nb_parameter(atom_type=1, nb_model="epsilon/Rmin"), {
'epsilon': 1.0,
'Rmin': 1
})
# Test that correct parameters are pulled from data layer based on name
assert (set(dl.list_stored_nb_types()) == set(["LJ", "Buckingham"]))
assert dict_compare(dl.list_nb_parameters(nb_name="LJ"),
{(1, None): {
'A': 1.,
'B': 2.
}})
comp = {(2, None): {'A': 1.0, "C": 1.0, "rho": 1.0}}
assert dict_compare(dl.list_nb_parameters(nb_name="Buckingham"), comp)
# Test translation of units
comp = {(1, None): {'A': 1.e-12, 'B': 2.e-6}}
result = dl.list_nb_parameters(nb_name="LJ",
utype={
'A':
"kJ * mol ** -1 * nanometers ** 12",
'B': "kJ * mol ** -1 * nanometers ** 6"
})
assert dict_compare(result, comp)
# Sigma/epsilon test
comp = {
'sigma': (1. / 2.)**(1. / 6.),
'epsilon': eex.units.conversion_factor('kJ', 'kcal')
}
result = dl.get_nb_parameter(atom_type=1,
nb_model='epsilon/sigma',
utype={
'epsilon': 'kcal * mol ** -1',
'sigma': 'angstrom'
})
assert dict_compare(result, comp)
def test_box_size():
dl = eex.datalayer.DataLayer("test_box_size", backend="memory")
tmp = {
"a": 5,
"b": 6,
"c": 7,
"alpha": np.pi / 3,
"beta": 0.0,
"gamma": 0.0
}
# Normal set/get
dl.set_box_size(tmp)
comp = dl.get_box_size()
assert dict_compare(tmp, comp)
# Set/get with units
utype = {
"a": "nanometers",
"b": "nanometers",
"c": "nanometers",
"alpha": "radian",
"beta": "radian",
"gamma": "radian"
}
dl.set_box_size(tmp, utype=utype)
comp = dl.get_box_size(utype=utype)
assert np.isclose(comp["a"], tmp["a"])
assert np.isclose(comp["b"], tmp["b"])
assert np.isclose(comp["c"], tmp["c"])
assert np.isclose(comp["alpha"], tmp["alpha"])
assert np.isclose(comp["beta"], tmp["beta"])
assert np.isclose(comp["gamma"], tmp["gamma"])
# Set/get with units
utype_1 = {
"a": "angstroms",
"b": "angstroms",
"c": "angstroms",
"alpha": "degree",
"beta": "degree",
"gamma": "degree"
}
dl.set_box_size(tmp, utype=utype)
comp = dl.get_box_size(utype=utype_1)
assert np.isclose(comp["a"], tmp["a"] * 10)
assert np.isclose(comp["b"], tmp["b"] * 10)
assert np.isclose(comp["c"], tmp["c"] * 10)
assert np.isclose(comp["alpha"], tmp["alpha"] * 180.0 / np.pi)
assert np.isclose(comp["beta"], tmp["beta"] * 180.0 / np.pi)
assert np.isclose(comp["gamma"], tmp["gamma"] * 180.0 / np.pi)
utype_2 = {
"a": "miles",
"b": "miles",
"c": "miles",
"alpha": "radians",
"beta": "radians",
"gamma": "radians"
}
with pytest.raises(AssertionError):
dl.set_box_size(tmp, utype=utype_2)
comp = dl.get_box_size()
assert dict_compare(tmp, comp)
