def test_multi_step(backend):
# Arrange
n_sd = 256
n = np.random.randint(1, 64, size=n_sd)
v = np.random.uniform(size=n_sd)
core, sut = get_dummy_core_and_sdm(backend, n_sd)
sut.compute_gamma = lambda prob, rand, is_first_in_pair: backend_fill(
prob, rand.to_ndarray() > 0.5, odd_zeros=True)
attributes = {'n': n, 'volume': v}
core.build(attributes)
# Act
for _ in range(32):
sut()
core.particles.sanitize()
# Assert
assert np.amin(core.particles['n'].to_ndarray()) >= 0
actual = np.sum(core.particles['n'].to_ndarray() *
core.particles['volume'].to_ndarray())
desired = np.sum(n * v)
np.testing.assert_approx_equal(actual=actual,
desired=desired,
significant=8)
def test_single_collision(self, v_2, T_2, n_2):
# Arrange
particles, sut = TestSDMSingleCell.get_dummy_core_and_sdm(len(n_2))
sut.compute_gamma = lambda prob, rand: backend_fill(prob, 1)
attributes = {'n': n_2, 'volume': v_2, 'temperature': T_2}
particles.build(attributes)
# Act
sut()
# Assert
state = particles.state
assert np.sum(state['n'].to_ndarray() * state['volume'].to_ndarray() *
state['temperature'].to_ndarray()) == np.sum(n_2 * T_2 *
v_2)
new_T = np.sum(T_2 * v_2) / np.sum(v_2)
assert np.isin(round(new_T, 10),
np.round(state['temperature'].to_ndarray(), 10))
assert np.sum(particles.state['n'].to_ndarray() *
particles.state['volume'].to_ndarray()) == np.sum(n_2 *
v_2)
assert np.sum(
particles.state['n'].to_ndarray()) == np.sum(n_2) - np.amin(n_2)
if np.amin(n_2) > 0:
assert np.amax(
particles.state['volume'].to_ndarray()) == np.sum(v_2)
assert np.amax(particles.state['n'].to_ndarray()) == max(
np.amax(n_2) - np.amin(n_2), np.amin(n_2))
def test_single_collision_same_n(backend, n_in, n_out):
# Arrange
core, sut = TestSDMSingleCell.get_dummy_core_and_sdm(backend, 2)
sut.compute_gamma = lambda prob, rand: backend_fill(prob, 1)
attributes = {'n': np.full(2, n_in), 'volume': np.full(2, 1.)}
core.build(attributes)
# Act
sut()
# Assert
np.testing.assert_array_equal(sorted(core.particles['n'].to_ndarray()), sorted(n_out))
def test_multi_droplet(backend, v, n, p):
# Arrange
core, sut = TestSDMSingleCell.get_dummy_core_and_sdm(backend, len(n))
sut.compute_gamma = lambda prob, rand: backend_fill(prob, p, True)
attributes = {'n': n, 'volume': v}
core.build(attributes)
# Act
sut()
# Assert
assert np.amin(core.particles['n'].to_ndarray()) >= 0
assert np.sum(core.particles['n'].to_ndarray() * core.particles['volume'].to_ndarray()) == np.sum(n * v)
def test_single_collision_same_n(self, n_in, n_out):
# Arrange
particles, sut = TestSDMSingleCell.get_dummy_particles_and_sdm(2)
sut.compute_gamma = lambda prob, rand: backend_fill(backend, prob, 1)
attributes = {'n': np.full(2, n_in), 'volume': np.full(2, 1.)}
particles.get_particles(attributes)
# Act
sut()
# Assert
np.testing.assert_array_equal(
sorted(particles.backend.to_ndarray(particles.state['n'])),
sorted(n_out))
def test_multi_droplet(self, v, n, p):
# Arrange
particles, sut = TestSDMSingleCell.get_dummy_particles_and_sdm(len(n))
sut.compute_gamma = lambda prob, rand: backend_fill(
backend, prob, p, True)
attributes = {'n': n, 'volume': v}
particles.get_particles(attributes)
# Act
sut()
# Assert
assert np.amin(particles.state['n']) >= 0
assert np.sum(particles.state['n'] *
particles.state['volume']) == np.sum(n * v)
def test_multi_collision(backend, v_2, n_2, p):
# Arrange
core, sut = TestSDMSingleCell.get_dummy_core_and_sdm(backend, len(n_2))
sut.compute_gamma = lambda prob, rand: backend_fill(prob, p)
attributes = {'n': n_2, 'volume': v_2}
core.build(attributes)
# Act
sut()
# Assert
state = core.particles
gamma = min(p, max(n_2[0] // n_2[1], n_2[1] // n_2[1]))
assert np.amin(state['n']) >= 0
assert np.sum(state['n'].to_ndarray() * state['volume'].to_ndarray()) == np.sum(n_2 * v_2)
assert np.sum(state['n'].to_ndarray()) == np.sum(n_2) - gamma * np.amin(n_2)
assert np.amax(state['volume'].to_ndarray()) == gamma * v_2[np.argmax(n_2)] + v_2[np.argmax(n_2) - 1]
assert np.amax(state['n'].to_ndarray()) == max(np.amax(n_2) - gamma * np.amin(n_2), np.amin(n_2))
def test_single_collision(backend, v_2, T_2, n_2):
# Arrange
const = 1.
core, sut = get_dummy_core_and_sdm(backend, len(n_2))
sut.compute_gamma = lambda prob, rand, is_first_in_pair: backend_fill(
prob, 1)
attributes = {
'n': n_2,
'volume': v_2,
'heat': const * T_2 * v_2,
'temperature': T_2
}
core.build(attributes)
# Act
sut()
# Assert
particles = core.particles
a = particles['n'].to_ndarray()
b = particles['volume'].to_ndarray()
c = particles['temperature'].to_ndarray()
np.testing.assert_approx_equal(const * np.sum(
particles['n'].to_ndarray() * particles['volume'].to_ndarray() *
particles['temperature'].to_ndarray()),
const * np.sum(n_2 * T_2 * v_2),
significant=7)
new_T = np.sum(T_2 * v_2) / np.sum(v_2)
assert np.isin(
round(new_T, 7),
np.round(particles['temperature'].to_ndarray().astype(float), 7))
assert np.sum(particles['n'].to_ndarray() *
particles['volume'].to_ndarray()) == np.sum(n_2 * v_2)
assert np.sum(
core.particles['n'].to_ndarray()) == np.sum(n_2) - np.amin(n_2)
if np.amin(n_2) > 0:
assert np.amax(
core.particles['volume'].to_ndarray()) == np.sum(v_2)
assert np.amax(core.particles['n'].to_ndarray()) == max(
np.amax(n_2) - np.amin(n_2), np.amin(n_2))
def test_multi_collision(self, v_2, n_2, p):
# Arrange
particles, sut = TestSDMSingleCell.get_dummy_particles_and_sdm(
len(n_2))
sut.compute_gamma = lambda prob, rand: backend_fill(backend, prob, p)
attributes = {'n': n_2, 'volume': v_2}
particles.get_particles(attributes)
# Act
sut()
# Assert
state = particles.state
gamma = min(p, max(n_2[0] // n_2[1], n_2[1] // n_2[1]))
assert np.amin(state['n']) >= 0
assert np.sum(state['n'] * state['volume']) == np.sum(n_2 * v_2)
assert np.sum(state['n']) == np.sum(n_2) - gamma * np.amin(n_2)
assert np.amax(
state['volume']
) == gamma * v_2[np.argmax(n_2)] + v_2[np.argmax(n_2) - 1]
assert np.amax(state['n']) == max(
np.amax(n_2) - gamma * np.amin(n_2), np.amin(n_2))
def test_multi_step(self):
# Arrange
n_sd = 256
n = np.random.randint(1, 64, size=n_sd)
v = np.random.uniform(size=n_sd)
particles, sut = TestSDMSingleCell.get_dummy_particles_and_sdm(n_sd)
sut.compute_gamma = lambda prob, rand: backend_fill(
backend, prob, backend.to_ndarray(rand) > 0.5, odd_zeros=True)
attributes = {'n': n, 'volume': v}
particles.get_particles(attributes)
# Act
for _ in range(32):
sut()
# Assert
assert np.amin(particles.state['n']) >= 0
actual = np.sum(particles.state['n'] * particles.state['volume'])
desired = np.sum(n * v)
np.testing.assert_almost_equal(actual=actual, desired=desired)
def _compute_gamma(prob, rand, is_first_in_pair):
from PySDM.dynamics import Coalescence
backend_fill(prob, p)
Coalescence.compute_gamma(sut, prob, rand, is_first_in_pair)
