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)