class TestParticlesSlimSource(TestParticlesSource):
tested_class = SlimCUDSSource
def setUp(self):
self.points = [
[0.0, 0.0, 0.0], [1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]
self.bonds = [[0, 1], [0, 3], [1, 3, 2]]
self.point_temperature = [10., 20., 30., 40.]
self.point_radius = [1., 2., 3., 4.]
self.point_mass = [4., 8., 16., 32.]
self.bond_temperature = [60., 80., 190., 5.]
self.container = Particles('test')
# add particles
def particle_iter():
for temp, radius, mass, point in zip(
self.point_temperature,
self.point_radius,
self.point_mass,
self.points):
yield Particle(coordinates=point,
data=DataContainer(
TEMPERATURE=temp,
RADIUS=radius,
MASS=mass))
self.point_uids = self.container.add(particle_iter())
# add bonds
def bond_iter():
for temp, indices in zip(self.bond_temperature, self.bonds):
yield Bond(particles=[self.point_uids[index]
for index in indices],
data=DataContainer(
TEMPERATURE=temp,
))
self.bond_uids = self.container.add(bond_iter())
# for testing save/load visualization
self.temp_dir = tempfile.mkdtemp()
def test_particles(self):
cuds = self.container
source = SlimCUDSSource(cuds=cuds)
self.assertEqual(len(source._point_scalars_list), 4)
for entry in ['', 'MASS', 'RADIUS', 'TEMPERATURE']:
self.assertIn(entry, source._point_scalars_list)
dataset = source.data
self.assertEqual(dataset.point_data.number_of_arrays, 1)
self.assertEqual(source.point_scalars_name, 'MASS')
source.point_scalars_name = "TEMPERATURE"
dataset = source.data
points = dataset.points.to_array()
vtk_cuds = source._vtk_cuds
self.assertEqual(dataset.point_data.number_of_arrays, 1)
temperature = dataset.point_data.get_array('TEMPERATURE')
for key, index in vtk_cuds.particle2index.iteritems():
point = self.container.get(key)
assert_array_equal(points[index], point.coordinates)
self.assertEqual(temperature[index], point.data[CUBA.TEMPERATURE])
source.point_scalars_name = "MASS"
self.assertEqual(dataset.point_data.number_of_arrays, 1)
dataset = source.data
mass = dataset.point_data.get_array('MASS')
for key, index in vtk_cuds.particle2index.iteritems():
point = self.container.get(key)
assert_array_equal(points[index], point.coordinates)
self.assertEqual(mass[index], point.data[CUBA.MASS])
source.point_scalars_name = ""
dataset = source.data
self.assertEqual(dataset.point_data.number_of_arrays, 0)
def test_available_keys(self):
available_keys = _available_keys(self.container)
self.assertEqual(available_keys["point_scalars"],
{CUBA.TEMPERATURE,
CUBA.RADIUS,
CUBA.MASS})
self.assertEqual(available_keys["point_vectors"], set())
self.assertEqual(available_keys["cell_scalars"], {CUBA.TEMPERATURE})
self.assertEqual(available_keys["cell_vectors"], set())
def test_bonds(self):
source = SlimCUDSSource(cuds=self.container)
# We should have two entries in the available cuba data, one for
# temperature and one for blank
self.assertEqual(len(source._cell_scalars_list), 2)
for entry in ['', 'TEMPERATURE']:
self.assertIn(entry, source._cell_scalars_list)
dataset = source.data
# The actual array set in the cell data should be empty if selection
# is blank
self.assertEqual(dataset.cell_data.number_of_arrays, 1)
self.assertEqual(source.cell_scalars_name, 'TEMPERATURE')
# Clearing should empty the data again
source.cell_scalars_name = ""
dataset = source.data
self.assertEqual(dataset.cell_data.number_of_arrays, 0)
# Selecting temperature triggers the transfer from cuds to vtk cuds
# of only the selected array
source.cell_scalars_name = "TEMPERATURE"
dataset = source.data
vtk_cuds = source._vtk_cuds
bonds = [
bond for bond in cell_array_slicer(dataset.lines.to_array())]
number_of_bonds = len(self.bonds)
self.assertEqual(len(bonds), number_of_bonds)
self.assertEqual(len(vtk_cuds.bond2index), number_of_bonds)
self.assertEqual(dataset.cell_data.number_of_arrays, 1)
temperature = dataset.cell_data.get_array('TEMPERATURE')
for key, index in vtk_cuds.bond2index.iteritems():
bond = self.container.get(key)
particles = [
vtk_cuds.particle2index[uid] for uid in bond.particles]
self.assertEqual(bonds[index], particles)
self.assertEqual(temperature[index], bond.data[CUBA.TEMPERATURE])
@unittest.skip("Cannot perform save/load with SlimCUDSSource")
def test_save_load_visualization_with_mlab(self):
pass
@unittest.skip("Cannot perform save/load with SlimCUDSSource")
def test_save_load_visualization_with_null_engine(self):
pass
def test_start_setup(self):
source = SlimCUDSSource(cuds=self.container)
self.assertEqual(source.point_scalars_name, "MASS")
self.assertEqual(source.point_vectors_name, "")
self.assertEqual(source.cell_scalars_name, "TEMPERATURE")
self.assertEqual(source.cell_vectors_name, "")
self.assertEqual(len(source._point_scalars_list), 4)
self.assertEqual(len(source._point_vectors_list), 1)
self.assertEqual(len(source._cell_scalars_list), 2)
self.assertEqual(len(source._cell_vectors_list), 1)
source = SlimCUDSSource(cuds=self.container,
point_scalars="TEMPERATURE")
self.assertEqual(source.point_scalars_name, "TEMPERATURE")
self.assertEqual(source.point_vectors_name, "")
self.assertEqual(source.cell_scalars_name, "TEMPERATURE")
self.assertEqual(source.cell_vectors_name, "")
self.assertEqual(len(source._point_scalars_list), 4)
self.assertEqual(len(source._point_vectors_list), 1)
self.assertEqual(len(source._cell_scalars_list), 2)
self.assertEqual(len(source._cell_vectors_list), 1)
def test_changing_names(self):
source = SlimCUDSSource(cuds=self.container,
point_scalars="TEMPERATURE")
point_attrs, cell_attrs = get_all_attributes(source.data)
self.assertEqual(len(point_attrs["scalars"]), 1)
self.assertEqual(point_attrs["scalars"][0], "TEMPERATURE")
source.point_scalars_name = ""
point_attrs, cell_attrs = get_all_attributes(source.data)
self.assertEqual(len(point_attrs["scalars"]), 0)
def test_unexistent_choice(self):
# This should work and trigger no error
source = SlimCUDSSource(point_scalars="TEMPERATURE")
self.assertEqual(source.point_scalars_name, '')
def test_changing_cuds(self):
source = SlimCUDSSource()
source.cuds = self.container
source.point_scalars_name = "TEMPERATURE"
point_attrs, cell_attrs = get_all_attributes(source.data)
self.assertEqual(len(point_attrs["scalars"]), 1)
self.assertEqual(point_attrs["scalars"][0], "TEMPERATURE")
source.point_scalars_name = ""
point_attrs, cell_attrs = get_all_attributes(source.data)
self.assertEqual(len(point_attrs["scalars"]), 0)
def test_combo_selection_preserved(self):
dummy_engine = DummyEngine()
source = SlimCUDSSource(cuds=dummy_engine.get_dataset("particles"),
point_scalars="MASS", point_vectors="")
self.assertEqual(source.point_scalars_name, "MASS")
self.assertEqual(source.point_vectors_name, "")
source.start()
self.assertEqual(source.point_scalars_name, "MASS")
self.assertEqual(source.point_vectors_name, "")
# define the interatomic force as material relation
lj = api.LennardJones_6_12([mat, mat], name='LennardJones')
lj.cutoff_distance = 2.5
lj.energy_well_depth = 1.0
lj.van_der_waals_radius = 1.0
# lj.material = [cuds.get('mat'), cuds.get('mat')]
cuds.add([lj])
# initialization of the simulation
sim = Simulation(cuds, "LAMMPS", engine_interface=EngineInterface.Internal)
sim.run()
thermo = api.NoseHoover(name='thermo')
thermo.temperature = [1.0, 1.2]
thermo.coupling_time = 0.00000025
thermo.material = [cuds.get(mat.uid)]
cuds.add([thermo])
pc = cuds.get_by_name('Test')
# pc is now a proxy to the pc in the "wrapper" managed by the sim.
particle = pc.get(input_particles[0].uid)
particle.data[CUBA.VELOCITY] = [
numpy.random.uniform(-0.5, 0.5),
numpy.random.uniform(-0.5, 0.5),
numpy.random.uniform(-0.5, 0.5)
]
pc.update([particle])
sim.run()
