def test_sort():
length = 100
a = np.array(np.random.rand(length), dtype=np.float32)
b = wrap(a, backend='cuda')
res_gpu = argsort(b).get()
res_cpu = np.argsort(a)
assert np.all(res_gpu == res_cpu)
def make_vortices(nv, backend):
x = np.linspace(-1, 1, nv)
y = x.copy()
gamma = np.ones(nv)
u = np.zeros_like(x)
v = np.zeros_like(x)
x, y, gamma, u, v = wrap(x, y, gamma, u, v, backend=backend)
return x, y, gamma, u, v, nv
def setup_velocities(self, T, num_particles):
np.random.seed(123)
vx = np.random.uniform(0, 1., size=num_particles).astype(np.float64)
vy = np.random.uniform(0, 1., size=num_particles).astype(np.float64)
T_current = np.average(vx ** 2 + vy ** 2)
scaling_factor = (T / T_current) ** 0.5
vx = vx * scaling_factor
vy = vy * scaling_factor
return wrap(vx, vy, backend=self.backend)
def setup(self):
u_host = np.zeros((self.nx, self.ny)).astype(np.float32)
u_host[0, :] = self.bc(self.xmin, self.y)
u_host[-1, :] = self.bc(self.xmax, self.y)
u_host[:, 0] = self.bc(self.x, self.ymin)
u_host[:, -1] = self.bc(self.x, self.ymax)
self.u = wrap(u_host.flatten(), backend=self.backend)
self.err = carr.zeros_like(self.u)
def test_argsort(backend):
check_import(backend)
# Given
nparr1 = np.random.randint(0, 100, 16, dtype=np.int32)
devarr1 = array.wrap(nparr1, backend=backend)
# When
out = array.argsort(devarr1)
# Then
ans = np.argsort(nparr1)
assert np.all(out.get() == ans)
def setup_positions(self, num_particles, dx):
ndim = np.ceil(num_particles ** 0.5)
dim_length = ndim * dx
self.xmax = dim_length * 3
self.ymax = dim_length * 3
xmin_eff = ((self.xmax - self.xmin) - dim_length) / 2.
xmax_eff = ((self.xmax - self.xmin) + dim_length) / 2.
x, y = np.mgrid[xmin_eff:xmax_eff:dx, xmin_eff:xmax_eff:dx]
x = x.ravel().astype(np.float64)[:num_particles]
y = y.ravel().astype(np.float64)[:num_particles]
return wrap(x, y, backend=self.backend)
def test_sort_by_keys(backend):
check_import(backend)
# Given
nparr1 = np.random.randint(0, 100, 16, dtype=np.int32)
nparr2 = np.random.randint(0, 100, 16, dtype=np.int32)
dev_array1, dev_array2 = array.wrap(nparr1, nparr2, backend=backend)
# When
out_array1, out_array2 = array.sort_by_keys([dev_array1, dev_array2])
# Then
order = np.argsort(nparr1)
act_result1 = np.take(nparr1, order)
act_result2 = np.take(nparr2, order)
assert np.all(out_array1.get() == act_result1)
assert np.all(out_array2.get() == act_result2)
def setup_positions(self, num_particles, dx):
ndim = np.ceil(num_particles**(1 / 3.))
dim_length = ndim * dx
self.xmax = 3 * (1 + round(dim_length * 1.5 / 3.))
self.ymax = 3 * (1 + round(dim_length * 1.5 / 3.))
self.zmax = 3 * (1 + round(dim_length * 1.5 / 3.))
xmin_eff = ((self.xmax - self.xmin) - dim_length) / 2.
xmax_eff = ((self.xmax - self.xmin) + dim_length) / 2.
x, y, z = np.mgrid[xmin_eff:xmax_eff:dx, xmin_eff:xmax_eff:dx,
xmin_eff:xmax_eff:dx]
x = x.ravel().astype(np.float64)[:num_particles]
y = y.ravel().astype(np.float64)[:num_particles]
z = z.ravel().astype(np.float64)[:num_particles]
return wrap(x, y, z, backend=self.backend)
def test_radix_sort_by_keys():
backend = 'cython'
for use_openmp in [True, False]:
get_config().use_openmp = use_openmp
# Given
nparr1 = np.random.randint(0, 100, 16, dtype=np.int32)
nparr2 = np.random.randint(0, 100, 16, dtype=np.int32)
dev_array1, dev_array2 = array.wrap(nparr1, nparr2, backend=backend)
# When
out_array1, out_array2 = array.sort_by_keys([dev_array1, dev_array2],
use_radix_sort=True)
# Then
order = np.argsort(nparr1)
act_result1 = np.take(nparr1, order)
act_result2 = np.take(nparr2, order)
assert np.all(out_array1.get() == act_result1)
assert np.all(out_array2.get() == act_result2)
get_config().use_openmp = False
def test_sort_by_keys_with_output(backend):
check_import(backend)
# Given
nparr1 = np.random.randint(0, 100, 16, dtype=np.int32)
nparr2 = np.random.randint(0, 100, 16, dtype=np.int32)
dev_array1, dev_array2 = array.wrap(nparr1, nparr2, backend=backend)
out_arrays = [array.zeros_like(dev_array1), array.zeros_like(dev_array2)]
# When
array.sort_by_keys([dev_array1, dev_array2],
out_list=out_arrays,
use_radix_sort=False)
# Then
order = np.argsort(nparr1)
act_result1 = np.take(nparr1, order)
act_result2 = np.take(nparr2, order)
assert np.all(out_arrays[0].get() == act_result1)
assert np.all(out_arrays[1].get() == act_result2)
super().reset_arrays()
self.sorted_keys.fill(0)
def build(self):
self.reset_arrays()
self.fill_keys(self.x, self.y, self.h, self.qmax, self.indices,
self.keys)
self.sorted_keys, self.sorted_indices = carr.sort_by_keys(
[self.keys, self.indices],
key_bits=self.max_bits, backend=self.backend)
self.scan_keys(keys=self.sorted_keys,
start_indices=self.start_indices)
self.fill_bin_counts(self.sorted_keys, self.start_indices,
self.bin_counts, self.num_particles)
if __name__ == "__main__":
import sys
backend = sys.argv[1] if len(sys.argv) > 1 else 'cython'
np.random.seed(123)
num_particles = 20
x = np.random.uniform(0, 10., size=num_particles).astype(np.float32)
y = np.random.uniform(0, 10., size=num_particles).astype(np.float32)
x, y = wrap(x, y, backend=backend)
nnps = NNPSRadixSort(x, y, 3., 10., 10., backend=backend)
nnps.build()
nnps.get_neighbors()
print(nnps.start_indices)
print(nnps.bin_counts)
print(nnps.nbr_lengths)
self.qmax, self.rmax, self.start_indices,
self.sorted_indices, self.bin_counts,
self.nbr_starts, self.nbrs, self.max_key)
if __name__ == "__main__":
import sys
import matplotlib.pyplot as plt
backend = sys.argv[1] if len(sys.argv) > 1 else 'cython'
np.random.seed(123)
num_particles = 10000
x, y, z = np.mgrid[0:30:50j, 0:30:50j, 0:30:50j]
x = x.ravel().astype(np.float64)
y = y.ravel().astype(np.float64)
z = z.ravel().astype(np.float64)
x, y, z = wrap(x, y, z, backend=backend)
nnps = NNPSRadixSortPeriodic(x,
y,
z,
3.,
0.01,
30.,
30.,
30.,
backend=backend)
nnps.build()
nnps.get_neighbors()
nbrs = nnps.find_nearest_neighbors(75000)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim(30)