def test_boundary_condition(self): # Arrange n = np.ones(1, dtype=np.int64) grid = (1, 1) particles = DummyParticles(Default, n_sd=len(n), dt=1) particles.set_mesh(grid) particles.set_environment( DummyEnvironment, ((np.array([[0, 0]]).T, np.array([[0, 0]])), )) positions = Default.from_ndarray(np.array([[0, 0]])) cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes( positions) particles.state = StateFactory.state(n=n, intensive={}, extensive={}, cell_id=cell_id, cell_origin=cell_origin, position_in_cell=position_in_cell, particles=particles) sut = Displacement(particles=particles, sedimentation=True) particles.set_terminal_velocity(ConstantTerminalVelocity) # Act sut() # Assert assert particles.state.SD_num == 0
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) sut = TestableStateFactory.empty_state(particles) sut.n = TestState.storage(n) n_cell = max(cells) + 1 sut.cell_id = TestState.storage(cells) sut._State__idx = TestState.storage(idx) idx_length = len(sut._State__idx) sut._State__tmp_idx = TestState.storage([0] * idx_length) sut._State__cell_start = TestState.storage([0] * (n_cell + 1)) sut._State__cell_start_p = backend.array( (thread_number, len(sut._State__cell_start)), dtype=int) sut._State__n_sd = particles.n_sd # 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_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) 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) cell_id = [] for i in range(len(cell_start) - 1): cell_id = cell_id + [i] * cell_start[i + 1] sut.cell_id = 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_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_calculate_displacement(self): # Arrange n = np.ones(1) grid = (1, 1) particles = DummyParticles(Default, n_sd=len(n)) particles.set_mesh(grid) a = .1 b = .2 w = .25 particles.set_environment( DummyEnvironment, ((np.array([[a, b]]).T, np.array([[0, 0]])), )) positions = Default.from_ndarray(np.array([[w, 0]])) cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes( positions) particles.state = StateFactory.state(n=n, intensive={}, extensive={}, cell_id=cell_id, cell_origin=cell_origin, position_in_cell=position_in_cell, particles=particles) sut = Advection(particles=particles, scheme='FTFS') # Act sut.calculate_displacement(sut.displacement, sut.courant, particles.state.cell_origin, particles.state.position_in_cell) # Assert np.testing.assert_equal(sut.displacement[0, 0], (1 - w) * a + w * b)
def test_boundary_condition(self): # Arrange n = np.ones(1) grid = (1, 1) particles = DummyParticles(Default, n_sd=len(n)) particles.set_mesh(grid) particles.set_environment( DummyEnvironment, ((np.array([[0, 0]]).T, np.array([[0, 0]])), )) droplet_id = 0 positions = Default.from_ndarray(np.array([[0, 0]])) cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes( positions) particles.state = StateFactory.state(n=n, intensive={}, extensive={}, cell_id=cell_id, cell_origin=cell_origin, position_in_cell=position_in_cell, particles=particles) sut = Advection(particles=particles) state = particles.state state.cell_origin[droplet_id, 0] = 1.1 state.cell_origin[droplet_id, 1] = 1.2 # Act sut.boundary_condition(state.cell_origin) # Assert assert state.cell_origin[droplet_id, 0] == 0 assert state.cell_origin[droplet_id, 1] == 0
def test_update_position(self): # Arrange n = np.ones(1) grid = (1, 1) particles = DummyParticles(Default, n_sd=len(n)) particles.set_mesh(grid) particles.set_environment( DummyEnvironment, ((np.array([[0, 0]]).T, np.array([[0, 0]])), )) droplet_id = 0 px = .1 py = .2 positions = Default.from_ndarray(np.array([[px, py]])) cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes( positions) particles.state = StateFactory.state(n=n, intensive={}, extensive={}, cell_id=cell_id, cell_origin=cell_origin, position_in_cell=position_in_cell, particles=particles) sut = Advection(particles=particles) sut.displacement[droplet_id, 0] = .1 sut.displacement[droplet_id, 1] = .2 # Act sut.update_position(particles.state.position_in_cell, sut.displacement) # Assert for d in range(2): assert particles.state.position_in_cell[droplet_id, d] == ( positions[droplet_id, d] + sut.displacement[droplet_id, d])
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) state = TestableStateFactory.state_0d(n=n, extensive={'volume': v}, intensive={'temperature': T}, particles=particles) 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 get_dummy_particles_and_sdm(n_length): particles = DummyParticles(backend, n_sd=n_length, dt=0) dv = 1 particles.set_mesh_0d(dv) particles.set_environment(Box, {}) sdm = SDM(particles, StubKernel(particles.backend)) return particles, sdm
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 spectrum = Lognormal(n_part, v_mean, d) v, n = linear(n_sd, spectrum, (v_min, v_max)) n = discretise_n(n) particles = DummyParticles(backend, n_sd) particles.set_mesh((x, y)) particles.croupier = croupier 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((-1, 2)) 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((-1, 2)) position_in_cell = backend.from_ndarray(position_in_cell_np) state = TestableStateFactory.state(n=n, extensive={'volume': v}, intensive={}, cell_id=cell_id, cell_origin=cell_origin, position_in_cell=position_in_cell, particles=particles) particles.state = state # Act u01 = backend.from_ndarray(np.random.random(n_sd)) particles.permute(u01) _ = particles.state.cell_start # Assert assert (np.diff(state.cell_id[state._State__idx]) >= 0).all()
def test_housekeeping(self, volume, n): # Arrange particles = DummyParticles(backend, n_sd=len(n)) sut = TestableStateFactory.state_0d(n=n, extensive={'volume': volume}, intensive={}, particles=particles) # 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_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_advection(self): n = np.ones(1) grid = (3, 3) particles = DummyParticles(Default, n_sd=len(n)) particles.set_mesh(grid) particles.set_environment(DummyEnvironment, ((np.ones( (4, 3)), np.zeros((3, 4))), )) positions = Default.from_ndarray(np.array([[1.5, 1.5]])) cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes( positions) particles.state = StateFactory.state(n=n, intensive={}, extensive={}, cell_id=cell_id, cell_origin=cell_origin, position_in_cell=position_in_cell, particles=particles) sut = Advection(particles=particles) sut() np.testing.assert_array_equal(particles.state.cell_origin[0, :], np.array([2, 1]))
def test_single_cell(self): # Arrange n = np.ones(1) grid = (1, 1) particles = DummyParticles(Default, n_sd=len(n)) particles.set_mesh(grid) particles.set_environment( DummyEnvironment, ((np.array([[.1, .2]]).T, np.array([[.3, .4]])), )) positions = Default.from_ndarray(np.array([[0.5, 0.5]])) cell_id, cell_origin, position_in_cell = particles.mesh.cellular_attributes( positions) particles.state = StateFactory.state(n=n, intensive={}, extensive={}, cell_id=cell_id, cell_origin=cell_origin, position_in_cell=position_in_cell, particles=particles) sut = Advection(particles=particles) # Act sut()
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_mesh(grid) particles.set_environment(DummyEnvironment, (None, )) sut = TestableStateFactory.state_2d(n=n, intensive={}, extensive={}, particles=particles, positions=initial_position) sut.cell_origin[droplet_id, 0] = .1 sut.cell_origin[droplet_id, 1] = .2 sut.cell_id[droplet_id] = -1 # Act sut.recalculate_cell_id() # Assert assert sut.cell_id[droplet_id] == 0