def test_lattice_vectors(self):
conf = M.Configuration(self.infinite,
IN.zeros((0, 3), N.float32),
None)
self.assertEqual(conf.lattice_vectors(), ())
self.assertEqual(conf.cell_volume(), None)
conf = M.Configuration(self.cube,
IN.zeros((0, 3), N.float32),
IN.array(1., N.float32))
lv = conf.lattice_vectors()
self.assertTrue((lv[0] == N.array([1., 0., 0.], N.float32)).all())
self.assertTrue((lv[1] == N.array([0., 1., 0.], N.float32)).all())
self.assertTrue((lv[2] == N.array([0., 0., 1.], N.float32)).all())
self.assertEqual(conf.cell_volume(), 1.)
conf = M.Configuration(self.cuboid,
IN.zeros((0, 3), N.float32),
IN.array([1., 2., 4.], N.float32))
lv = conf.lattice_vectors()
self.assertTrue((lv[0] == N.array([1., 0., 0.], N.float32)).all())
self.assertTrue((lv[1] == N.array([0., 2., 0.], N.float32)).all())
self.assertTrue((lv[2] == N.array([0., 0., 4.], N.float32)).all())
self.assertEqual(conf.cell_volume(), 8.)
conf = M.Configuration(self.parallelepiped,
IN.zeros((0, 3), N.float32),
IN.array([[1., 2., 4.],
[8., 4., 2.],
[16., 4., 8.]], N.float32))
lv = conf.lattice_vectors()
self.assertTrue((lv[0] == N.array([1., 2., 4.], N.float32)).all())
self.assertTrue((lv[1] == N.array([8., 4., 2.], N.float32)).all())
self.assertTrue((lv[2] == N.array([16., 4., 8.], N.float32)).all())
self.assertAlmostEqual(conf.cell_volume(), 168.)
def test_properties(self):
masses = M.TemplateAtomProperty(self.universe,
"masses", "amu",
IN.array([1., 1., 16.], N.float32))
self.assertTrue(is_valid(masses))
self.assertEqual(masses.type, 'template_atom')
self.assertTrue(masses.universe == self.universe)
self.assertEqual(masses.element_shape, ())
self.assertEqual(masses.data.shape, (3,))
bead_masses = M.TemplateSiteProperty(self.universe,
"mass", "amu",
IN.array([1., 1.,
1., 1.,
8., 8.], N.float32))
self.assertTrue(is_valid(bead_masses))
self.assertEqual(bead_masses.type, 'template_site')
self.assertTrue(bead_masses.universe is self.universe)
self.assertEqual(bead_masses.element_shape, ())
self.assertEqual(bead_masses.data.shape, (6,))
velocities = M.SiteProperty(self.universe,
"velocity", "nm ps-1",
IN.zeros((60, 3), dtype=N.float64))
self.assertTrue(is_valid(velocities))
self.assertEqual(velocities.type, 'site')
self.assertTrue(velocities.universe is self.universe)
self.assertEqual(velocities.data.shape, (60, 3))
self.assertEqual(velocities.element_shape, (3,))
foo = M.AtomProperty(self.universe,
"foo", "",
IN.zeros((30, 2, 2), dtype=N.int16))
self.assertTrue(is_valid(foo))
self.assertEqual(foo.type, 'atom')
self.assertTrue(foo.universe is self.universe)
self.assertEqual(foo.data.shape, (30, 2, 2))
self.assertEqual(foo.element_shape, (2, 2))
def test_configuration(self):
mol = make_water_fragment()
universe = M.universe('cube', [(mol, 'water', 10)])
# Missing data
self.assertRaises(TypeError,
lambda: M.Configuration(universe))
# Positions but no cell parameters
self.assertRaises(TypeError,
lambda: M.Configuration(universe,
IN.zeros((30, 3), N.float32)))
# Positions and cell parameters of different dtype
self.assertRaises(ValueError,
lambda: M.Configuration(universe,
IN.zeros((30, 3), N.float32),
N.float64(10.)))
# Positions not an array
self.assertRaises(TypeError,
lambda: M.Configuration(universe,
list(IN.zeros((30, 3),
N.float32)),
N.float32(10.)))
# Positions of wrong shape
self.assertRaises(ValueError,
lambda: M.Configuration(universe,
IN.zeros((25, 3), N.float32),
N.float32(10.)))
# Cell parameters of wrong shape
self.assertRaises(ValueError,
lambda: M.Configuration(universe,
IN.zeros((30, 3), N.float32),
IN.zeros((3,), N.float32)))
def test_universe(self):
mol = M.fragment("water", (),
(("H1", M.atom(M.element("H"), 8)),
("H2", M.atom(M.element("H"), 8)),
("O", M.atom(M.element("O"), 2))),
(("H1", "O", "single"), ("H2", "O", "single")))
self.assertRaises(TypeError,
lambda: M.universe(0, [(mol, 'water', 10)]))
self.assertRaises(ValueError,
lambda: M.universe('strange', [(mol, 'water', 10)]))
self.assertRaises(ValueError,
lambda: M.universe('strange', [(mol, 10)]))
self.assertRaises(TypeError,
lambda: M.universe('infinite', mol))
self.assertRaises(ValueError,
lambda: M.universe('infinite', [("water", 10)]))
self.assertRaises(TypeError,
lambda: M.universe('infinite', [mol]))
self.assertRaises(ValueError,
lambda: M.universe('infinite', [(10, mol)]))
self.assertRaises(ValueError,
lambda: M.universe('infinite', [(mol, 'water', 10)],
[(IN.zeros((3,3), N.float64),
IN.zeros((3,), N.float64))]))
def __init__(self, universe, positions, cell_parameters):
api.validate_type(universe, Universe, "universe")
cell_param_shape = universe.cell_parameter_array_shape
nsites = universe.number_of_sites
# Allow cell_parameters=None for universes that don't
# need cell parameters.
if cell_parameters is None and cell_param_shape == (0,):
cell_parameters = IN.zeros(cell_param_shape, positions.dtype)
# At this point, positions and cell_parameters must be arrays
# of the required shapes.
api.validate_array(positions, (nsites, 3), self._allowed_dtypes, "positions")
api.validate_array(cell_parameters, cell_param_shape, self._allowed_dtypes, "cell_parameters")
if positions.dtype != cell_parameters.dtype:
raise ValueError("positions and cell parameters must have" " the same element type")
self._universe = universe
self._positions = positions
self._cell_parameters = cell_parameters
def test_selection(self):
mol = make_water_fragment(nsites=2)
universe = M.universe('cube', [(mol, 'water', 5)])
# Index occurs twice
self.assertRaises(ValueError,
lambda: M.AtomSelection(universe,
IN.zeros((2,), N.uint16)))
# Atom index too large
self.assertRaises(ValueError,
lambda: M.AtomSelection(universe,
IN.array([20], N.uint16)))
# Template atom index too large
self.assertRaises(ValueError,
lambda: M.TemplateAtomSelection(universe,
IN.array([3], N.uint8)))
# Site index too large
self.assertRaises(ValueError,
lambda: M.SiteSelection(universe,
IN.array([40], N.uint16)))
# Template site index too large
self.assertRaises(ValueError,
lambda: M.TemplateSiteSelection(universe,
IN.array([8], N.uint8)))
