From d5afdfbb66d8ceb87b8917d316715d61dc6db5a8 Mon Sep 17 00:00:00 2001
From: "Timothy A. Smith" <tasmith4@illinois.edu>
Date: Mon, 17 Jun 2019 12:26:51 -0500
Subject: [PATCH] put setup fixtures in test.py
---
test.py | 154 ++++++++++++++++++++++++++++++++++++++++++++++++++++----
1 file changed, 143 insertions(+), 11 deletions(-)
diff --git a/test.py b/test.py
index 3db55b6..dbc6261 100644
--- a/test.py
+++ b/test.py
@@ -16,7 +16,6 @@ from pyopencl.tools import ( # noqa
pytest_generate_tests_for_pyopencl
as pytest_generate_tests)
-import setup_fixtures as setup
import kernel_fixtures as kernel
@@ -53,6 +52,139 @@ def get_weno_program():
return _WENO_PRG[0]
+class RoeParams:
+ def __init__(self, nvars, ndim, d):
+ self.nvars = nvars
+ self.ndim = ndim
+ self.d = d
+
+ def mat_bounds(self):
+ return self.nvars, self.nvars
+
+ def vec_bounds(self):
+ return self.nvars
+
+
+class FluxDerivativeParams:
+ def __init__(self, nvars, ndim, nx, ny, nz):
+ self.nvars = nvars
+ self.ndim = ndim
+
+ self.nx = nx
+ self.ny = ny
+ self.nz = nz
+
+ self.nhalo = 3
+ self.nx_halo = self.nx + 2*self.nhalo
+ self.ny_halo = self.ny + 2*self.nhalo
+ self.nz_halo = self.nz + 2*self.nhalo
+
+ def state_bounds(self):
+ return self.nvars, self.nx_halo, self.ny_halo, self.nz_halo
+
+ def flux_bounds(self):
+ return self.nvars, self.ndim, self.nx_halo, self.ny_halo, self.nz_halo
+
+ def metric_bounds(self):
+ return self.ndim, self.ndim, self.nx_halo, self.ny_halo, self.nz_halo
+
+ def jacobian_bounds(self):
+ return self.nx_halo, self.ny_halo, self.nz_halo
+
+
+class FluxDerivativeArrays:
+ def __init__(self, states, fluxes, metrics, metric_jacobians):
+ self.states = states
+ self.fluxes = fluxes
+ self.metrics = metrics
+ self.metric_jacobians = metric_jacobians
+
+
+def setup_roe_params(nvars, ndim, direction):
+ dirs = {"x" : 1, "y" : 2, "z" : 3}
+ return RoeParams(nvars, ndim, dirs[direction])
+
+
+def setup_flux_derivative_params(nvars, ndim, n):
+ return FluxDerivativeParams(nvars, ndim, n, n, n)
+
+
+def setup_empty_array_on_device(queue, shape):
+ return cl.array.empty(queue, shape, dtype=np.float32, order="F")
+
+
+def setup_identity(n):
+ return np.identity(n).astype(np.float32).copy(order="F")
+
+
+def setup_random_array(*shape):
+ return np.random.random_sample(shape).astype(np.float32).copy(order="F")
+
+
+def setup_random_array_on_device(queue, *shape):
+ return cl.array.to_device(queue, setup_random_array(*shape))
+
+
+def setup_random_flux_derivative_arrays(params):
+ states = setup_random_array(*params.state_bounds())
+ fluxes = setup_random_array(*params.flux_bounds())
+ metrics = setup_random_array(*params.metric_bounds())
+ metric_jacobians = setup_random_array(*params.jacobian_bounds())
+
+ return FluxDerivativeArrays(states, fluxes, metrics, metric_jacobians)
+
+
+def setup_random_flux_derivative_arrays_on_device(ctx_factory, params):
+ queue = get_queue(ctx_factory)
+
+ states = setup_random_array_on_device(queue, *params.state_bounds())
+ fluxes = setup_random_array_on_device(queue, *params.flux_bounds())
+ metrics = setup_random_array_on_device(queue, *params.metric_bounds())
+ metric_jacobians = setup_random_array_on_device(queue, *params.jacobian_bounds())
+
+ return FluxDerivativeArrays(states, fluxes, metrics, metric_jacobians)
+
+
+def arrays_from_string(string_arrays):
+ return split_map_to_list(string_arrays, array_from_string, ":")
+
+
+def array_from_string(string_array):
+ if ";" not in string_array:
+ if "," not in string_array:
+ array = array_from_string_1d(string_array)
+ else:
+ array = array_from_string_2d(string_array)
+ else:
+ array = array_from_string_3d(string_array)
+ return array.copy(order="F")
+
+
+def array_from_string_3d(string_array):
+ if string_array[0] == ";":
+ return array_from_string_1d(string_array[1:]).reshape((-1, 1, 1))
+ else:
+ return np.array(split_map_to_list(string_array, array_from_string_2d, ";"))
+
+
+def array_from_string_2d(string_array):
+ if string_array[0] == ",":
+ return array_from_string_1d(string_array[1:]).reshape((-1, 1))
+ else:
+ return np.array(split_map_to_list(string_array, array_from_string_1d, ","))
+
+
+def array_from_string_1d(string_array):
+ if string_array[0] == "i":
+ return np.array(split_map_to_list(string_array[1:], int, " "))
+ else:
+ return np.array(split_map_to_list(string_array, float, " "), dtype=np.float32)
+
+
+def split_map_to_list(string, map_func, splitter):
+ return list(map(map_func, string.split(splitter)))
+
+
def compare_arrays(a, b):
assert a == approx(b)
@@ -151,14 +283,14 @@ def test_roe_uniform_grid(ctx_factory, states_str, fluxes_str, direction):
queue = get_queue(ctx_factory)
prg = get_weno_program()
- params = setup.roe_params(nvars=5, ndim=3, direction=direction)
- states = setup.array_from_string(states_str)
- metrics_frozen = setup.identity(params.ndim)
+ params = setup_roe_params(nvars=5, ndim=3, direction=direction)
+ states = array_from_string(states_str)
+ metrics_frozen = setup_identity(params.ndim)
R, Rinv, lam = kernel.roe_eigensystem(queue, prg, params, states, metrics_frozen)
compare_roe_identity(states, R, Rinv)
- fluxes = setup.array_from_string(fluxes_str)
+ fluxes = array_from_string(fluxes_str)
compare_roe_property(states, fluxes, R, Rinv, lam)
@@ -166,8 +298,8 @@ def test_matvec(ctx_factory):
queue = get_queue(ctx_factory)
prg = get_weno_program()
- a = setup.random_array(10, 10)
- b = setup.random_array(10)
+ a = setup_random_array(10, 10)
+ b = setup_random_array(10)
c = kernel.mult_mat_vec(queue, prg, alpha=1.0, a=a, b=b)
@@ -180,8 +312,8 @@ def test_compute_flux_derivatives(ctx_factory):
prg = get_weno_program()
prg = transform_compute_flux_derivative_basic(prg)
- params = setup.flux_derivative_params(ndim=3, nvars=5, n=10)
- arrays = setup.random_flux_derivative_arrays(params)
+ params = setup_flux_derivative_params(ndim=3, nvars=5, n=10)
+ arrays = setup_random_flux_derivative_arrays(params)
kernel.compute_flux_derivatives(queue, prg, params, arrays)
@@ -192,8 +324,8 @@ def test_compute_flux_derivatives_gpu(ctx_factory):
prg = get_weno_program()
prg = transform_compute_flux_derivative_gpu(queue, prg)
- params = setup.flux_derivative_params(ndim=3, nvars=5, n=10)
- arrays = setup.random_flux_derivative_arrays_on_device(ctx_factory, params)
+ params = setup_flux_derivative_params(ndim=3, nvars=5, n=10)
+ arrays = setup_random_flux_derivative_arrays_on_device(ctx_factory, params)
kernel.compute_flux_derivatives(queue, prg, params, arrays)
--
GitLab