def test_permutation_local_repeatable(self):
n_sd = 800
idx = range(n_sd)
u01 = np.random.random(n_sd)
cell_start = [0, 0, 20, 250, 700, n_sd]
# Arrange
particles = DummyParticles(backend, n_sd=n_sd)
particles.get_particles(attributes={'n': np.zeros(n_sd)})
sut = particles.state
sut._State__idx = TestState.storage(idx)
idx_length = len(sut._State__idx)
sut._State__tmp_idx = TestState.storage([0] * idx_length)
cell_id = []
for i in range(len(cell_start) - 1):
cell_id = cell_id + [i] * cell_start[i+1]
sut.whole_attributes['cell id'].data = TestState.storage(cell_id)
sut._State__cell_start = TestState.storage(cell_start)
sut._State__sorted = True
sut._State__n_sd = particles.n_sd
u01 = TestState.storage(u01)
# Act
sut.permutation_local(u01)
expected = backend.to_ndarray(sut._State__idx)
sut._State__idx = TestState.storage(idx)
sut.permutation_local(u01)
# Assert
np.testing.assert_array_equal(sut._State__idx, expected)
assert sut._State__sorted == True
sut._State__sort_by_cell_id()
np.testing.assert_array_equal(sut._State__idx[:50], expected[:50])
def test_moment_0d():
# Arrange
n_part = 10000
v_mean = 2e-6
d = 1.2
v_min = 0.01e-6
v_max = 10e-6
n_sd = 32
spectrum = Lognormal(n_part, v_mean, d)
v, n = linear(n_sd, spectrum, (v_min, v_max))
T = np.full_like(v, 300.)
n = discretise_n(n)
particles = DummyParticles(backend, n_sd)
attribute = {'n': n, 'volume': v, 'temperature': T}
particles.get_particles(attribute)
state = particles.state
true_mean, true_var = spectrum.stats(moments='mv')
# TODO: add a moments_0 wrapper
moment_0 = np.empty((1, ), dtype=int)
moments = np.empty((1, 1), dtype=float)
# Act
state.moments(moment_0, moments, specs={'volume': (0, )})
discr_zero = moments[0, 0]
state.moments(moment_0, moments, specs={'volume': (1, )})
discr_mean = moments[0, 0]
state.moments(moment_0, moments, specs={'volume': (2, )})
discr_mean_radius_squared = moments[0, 0]
state.moments(moment_0, moments, specs={'temperature': (0, )})
discr_zero_T = moments[0, 0]
state.moments(moment_0, moments, specs={'temperature': (1, )})
discr_mean_T = moments[0, 0]
state.moments(moment_0, moments, specs={'temperature': (2, )})
discr_mean_T_squared = moments[0, 0]
# Assert
assert abs(discr_zero - 1) / 1 < 1e-3
assert abs(discr_mean - true_mean) / true_mean < .01e-1
true_mrsq = true_var + true_mean**2
assert abs(discr_mean_radius_squared - true_mrsq) / true_mrsq < .05e-1
assert discr_zero_T == discr_zero
assert discr_mean_T == 300.
assert discr_mean_T_squared == 300.**2
def test_permutation_global_repeatable(self):
n_sd = 800
idx = range(n_sd)
u01 = np.random.random(n_sd)
# Arrange
particles = DummyParticles(backend, n_sd=n_sd)
sut = TestableStateFactory.empty_state(particles)
sut._State__idx = TestState.storage(idx)
idx_length = len(sut._State__idx)
sut._State__tmp_idx = TestState.storage([0] * idx_length)
sut._State__sorted = True
sut._State__n_sd = particles.n_sd
u01 = TestState.storage(u01)
# Act
sut.permutation_global(u01)
expected = backend.to_ndarray(sut._State__idx)
sut._State__sorted = True
sut._State__idx = TestState.storage(idx)
sut.permutation_global(u01)
# Assert
np.testing.assert_array_equal(sut._State__idx, expected)
assert sut._State__sorted == False
def test_housekeeping(self, volume, n):
# Arrange
particles = DummyParticles(backend, n_sd=len(n))
attributes = {'n': n, 'volume': volume}
particles.get_particles(attributes)
sut = particles.state
# TODO
sut.healthy = TestState.storage([0])
# Act
n_sd = sut.SD_num
# Assert
assert sut['volume'].shape == sut['n'].shape
assert sut.SD_num == (n != 0).sum()
assert sut['n'].sum() == n.sum()
assert (sut['volume'] * sut['n']).sum() == (volume * n).sum()
def test_observer(self):
class Observer:
def __init__(self, particles):
self.steps = 0
self.particles = particles
self.particles.observers.append(self)
def notify(self):
self.steps += 1
assert self.steps == self.particles.n_steps
steps = 33
particles = DummyParticles(Default, 44)
observer = Observer(particles)
particles.run(steps)
assert observer.steps == steps
def test_sort_by_cell_id(self, n, cells, n_sd, idx, new_idx, cell_start, thread_number):
# Arrange
particles = DummyParticles(backend, n_sd=n_sd)
particles.get_particles(attributes={'n': np.zeros(n_sd)})
sut = particles.state
sut.whole_attributes['n'].data = TestState.storage(n)
n_cell = max(cells) + 1
sut.whole_attributes['cell id'].data = TestState.storage(cells)
sut._State__idx = TestState.storage(idx)
idx_length = len(sut._State__idx)
sut._State__cell_start = TestState.storage([0] * (n_cell + 1))
sut._State__n_sd = particles.n_sd
sut._State__cell_caretaker = backend.make_cell_caretaker(sut._State__idx, sut._State__cell_start)
# Act
sut._State__sort_by_cell_id()
# Assert
assert len(sut._State__idx) == idx_length
np.testing.assert_array_equal(np.array(new_idx), backend.to_ndarray(sut._State__idx[:sut.SD_num]))
np.testing.assert_array_equal(np.array(cell_start), backend.to_ndarray(sut._State__cell_start))
def test_final_state(croupier):
# Arrange
n_part = 10000
v_mean = 2e-6
d = 1.2
v_min = 0.01e-6
v_max = 10e-6
n_sd = 64
x = 4
y = 4
attributes = {}
spectrum = Lognormal(n_part, v_mean, d)
attributes['volume'], attributes['n'] = linear(n_sd, spectrum,
(v_min, v_max))
particles = DummyParticles(backend, n_sd)
particles.set_environment(DummyEnvironment, {'grid': (x, y)})
particles.croupier = croupier
attributes['cell id'] = backend.array((n_sd, ), dtype=int)
cell_origin_np = np.concatenate(
[np.random.randint(0, x, n_sd),
np.random.randint(0, y, n_sd)]).reshape((2, -1))
attributes['cell origin'] = backend.from_ndarray(cell_origin_np)
position_in_cell_np = np.concatenate(
[np.random.rand(n_sd), np.random.rand(n_sd)]).reshape((2, -1))
attributes['position in cell'] = backend.from_ndarray(position_in_cell_np)
particles.get_particles(attributes)
# Act
u01 = backend.from_ndarray(np.random.random(n_sd))
particles.permute(u01)
_ = particles.state.cell_start
# Assert
assert (np.diff(particles.state['cell id'][particles.state._State__idx]) >=
0).all()
def test_permutation_global(self):
n_sd = 8
idx = range(n_sd)
u01 = [.1, .4, .2, .5, .9, .1, .6, .3]
# Arrange
particles = DummyParticles(backend, n_sd=n_sd)
sut = TestableStateFactory.empty_state(particles)
sut._State__idx = TestState.storage(idx)
idx_length = len(sut._State__idx)
sut._State__tmp_idx = TestState.storage([0] * idx_length)
sut._State__sorted = True
sut._State__n_sd = particles.n_sd
u01 = TestState.storage(u01)
# Act
sut.permutation_global(u01)
# Assert
expected = np.array([1, 3, 5, 7, 6, 0, 4, 2])
np.testing.assert_array_equal(sut._State__idx, expected)
assert sut._State__sorted == False
def test_recalculate_cell_id(self):
# Arrange
n = np.ones(1, dtype=np.int64)
droplet_id = 0
initial_position = Default.from_ndarray(np.array([[0], [0]]))
grid = (1, 1)
particles = DummyParticles(backend, n_sd=1)
particles.set_environment(DummyEnvironment, {'grid': grid})
cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes(initial_position)
attribute = {'n': n, 'cell id': cell_id, 'cell origin': cell_origin, 'position in cell': position_in_cell}
particles.get_particles(attribute)
sut = particles.state
sut['cell origin'][0, droplet_id] = .1
sut['cell origin'][1, droplet_id] = .2
sut['cell id'][droplet_id] = -1
# Act
sut.recalculate_cell_id()
# Assert
assert sut['cell id'][droplet_id] == 0
def get_displacement(self):
particles = DummyParticles(Default, n_sd=len(self.n))
particles.set_environment(
DummyEnvironment, {
'dt': self.dt,
'grid': self.grid,
'courant_field_data': self.courant_field_data
})
positions = Default.from_ndarray(np.array(self.positions))
cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes(
positions)
attributes = {
'n': self.n,
'cell id': cell_id,
'cell origin': cell_origin,
'position in cell': position_in_cell
}
particles.get_particles(attributes)
sut = Displacement(particles_builder=particles,
scheme=self.scheme,
sedimentation=self.sedimentation)
return sut, particles
def get_dummy_particles_and_sdm(n_length):
particles = DummyParticles(backend, n_sd=n_length)
dv = 1
particles.set_environment(Box, {'dv': dv, 'dt': 0})
sdm = Coalescence(particles, StubKernel(particles.backend))
return particles, sdm