From 80190d7292300e67e634b71f651e504dfa5dafe8 Mon Sep 17 00:00:00 2001 From: Ilya Antonov Date: Mon, 20 Jul 2020 21:11:20 +0100 Subject: [PATCH] first simulations - there is a shift which causes problems --- .gitignore | 1 + Makefile | 11 +- entrypoint.py | 61 +++- entrypoint_notebook.ipynb | 318 ++++++++++++++++++ kernels/potential_evaluator.py | 31 +- ...earch.py => potential_minimum_searcher.py} | 27 +- potential_python.py | 5 +- ....py => test_potential_minimum_searcher.py} | 4 +- utils/array_stacker.py | 6 + utils/info.py | 16 +- 10 files changed, 427 insertions(+), 53 deletions(-) create mode 100644 entrypoint_notebook.ipynb rename kernels/{potential_minimum_search.py => potential_minimum_searcher.py} (84%) rename tests/{test_potential_minimum_search.py => test_potential_minimum_searcher.py} (94%) diff --git a/.gitignore b/.gitignore index c18dd8d..6bbbd0d 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ __pycache__/ +.ipynb_checkpoints/ diff --git a/Makefile b/Makefile index 08e0da8..bb0c3f1 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,12 @@ -run: +jupyter: + jupyter notebook --no-browser --port 8888 --allow-root --NotebookApp.token='' --NotebookApp.password='' +cuda: @@time(\ - time python potential_minimum_gridsearch.py \ + time python entrypoint.py \ + ) + @echo -e "\nšŸ¬ Finished\n" +cpu: + @@time(\ + time python potential_python.py \ ) @echo -e "\nšŸ¬ Finished\n" diff --git a/entrypoint.py b/entrypoint.py index f82f0ca..68a0db4 100644 --- a/entrypoint.py +++ b/entrypoint.py @@ -1,20 +1,23 @@ import math import itertools +from collections import defaultdict pi = math.pi import numpy as np from numba import cuda from numba.cuda.cudadrv.devicearray import DeviceNDArray +import matplotlib.pyplot as plt from functions.potential import potential_function_cuda from kernels.potential_evaluator import PotentialEvaluator +from kernels.potential_minimum_searcher import PotentialMinimumSearcher from utils.array_stacker import ArrayStacker # Parameters for simulation ################################################### -NUMBER_OF_PHI_POINTS = 100 -NUMBER_OF_FIELD_POINTS = 40 -NUMBER_OF_FIELD_POINTS_PER_RUN = 20 +NUMBER_OF_PHI_POINTS = 10 +NUMBER_OF_FIELD_POINTS = 10 +NUMBER_OF_FIELD_POINTS_PER_RUN = 10 NUMBER_OF_FIELD_RUNS = ( NUMBER_OF_FIELD_POINTS - 1 ) // NUMBER_OF_FIELD_POINTS_PER_RUN + 1 @@ -26,10 +29,13 @@ phixx_array = np.linspace(-pi, pi, NUMBER_OF_PHI_POINTS) # Kernels ##################################################################### -potential_evaluator = PotentialEvaluator(NUMBER_OF_PHI_POINTS, potential_function_cuda) -THREADS_PER_BLOCK = potential_evaluator.allocate_max_threads(8) BLOCKS_PER_GRID = (NUMBER_OF_FIELD_POINTS_PER_RUN, NUMBER_OF_FIELD_POINTS_PER_RUN) -potential_evaluator.verify_blocks_per_grid(BLOCKS_PER_GRID) + +potential_evaluator = PotentialEvaluator(NUMBER_OF_PHI_POINTS, potential_function_cuda) +THREADS_PER_BLOCK_potential_evaluation = potential_evaluator.allocate_max_threads(8) + +potential_minimum_searcher = PotentialMinimumSearcher(NUMBER_OF_PHI_POINTS) +THREADS_PER_BLOCK_potential_search = potential_minimum_searcher.allocate_max_threads() # Execution ################################################################### DEVICE_lr_array = cuda.to_device(lr_array) @@ -44,9 +50,14 @@ ), dtype=np.float32, ) +DEVICE_grid_search_result_array = cuda.device_array( + shape=(NUMBER_OF_FIELD_POINTS_PER_RUN, NUMBER_OF_FIELD_POINTS_PER_RUN, 4), + dtype=np.float32, +) # Go through teach of the field section and evaluate ########################## -FIELD_SECTIONS = [[None] * NUMBER_OF_FIELD_RUNS for i in range(0, NUMBER_OF_FIELD_RUNS)] +quadrants = defaultdict(lambda: [[None] * NUMBER_OF_FIELD_RUNS for i in range(0, NUMBER_OF_FIELD_RUNS)]) + for (L_RUN, R_RUN) in itertools.product( range(0, NUMBER_OF_FIELD_RUNS), range(0, NUMBER_OF_FIELD_RUNS) ): @@ -55,7 +66,7 @@ ) L_OFFSET = int(L_RUN * NUMBER_OF_FIELD_POINTS_PER_RUN) R_OFFSET = int(R_RUN * NUMBER_OF_FIELD_POINTS_PER_RUN) - potential_evaluator.kernel[BLOCKS_PER_GRID, THREADS_PER_BLOCK]( + potential_evaluator.kernel[BLOCKS_PER_GRID, THREADS_PER_BLOCK_potential_evaluation]( DEVICE_phixx_array, DEVICE_lr_array, L_OFFSET, @@ -63,9 +74,37 @@ ALPHA, DEVICE_potential_array, ) + potential_minimum_searcher.kernel[ + BLOCKS_PER_GRID, THREADS_PER_BLOCK_potential_search + ](DEVICE_potential_array, DEVICE_grid_search_result_array) + + + grid_search_result_array = DEVICE_grid_search_result_array.copy_to_host() + quadrants["potential"][L_RUN][R_RUN] = grid_search_result_array[:,:,0] + quadrants["phi01"][L_RUN][R_RUN] = phixx_array[grid_search_result_array[:,:,1].astype(int)] + quadrants["phi02"][L_RUN][R_RUN] = phixx_array[grid_search_result_array[:,:,2].astype(int)] + quadrants["phi03"][L_RUN][R_RUN] = phixx_array[grid_search_result_array[:,:,3].astype(int)] - FIELD_SECTIONS[L_RUN][R_RUN] = DEVICE_potential_array.copy_to_host() +result = {} +for key, value in quadrants.items(): + print(f"šŸ¦‘--------------------{key}--------------------") + result[key] = ArrayStacker.stack_into_square(value) + print(result[key]) -TOTAL_FIELD = ArrayStacker.stack_into_square(FIELD_SECTIONS) -print(TOTAL_FIELD) +############################################################################### +# sudo yum install python36-tkinter and do ssh -X to print on own computer # +############################################################################### +fig, ax = plt.subplots(1, 1, sharex=True, sharey=True, figsize=(5, 5)) + +im = ax.imshow( + # result["potential"], + result["phi01"], + extent = [LOWER, UPPER, LOWER, UPPER], + origin= 'lower', + cmap='cividis', + # cmap='YlGnBu' + # interpolation='spline36' +) +cbar = fig.colorbar(im) +plt.show() diff --git a/entrypoint_notebook.ipynb b/entrypoint_notebook.ipynb new file mode 100644 index 0000000..052ef81 --- /dev/null +++ b/entrypoint_notebook.ipynb @@ -0,0 +1,318 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Potential Plot\n", + "> - Extension following Oleg's discussion on 2020-06-28\n", + "\n", + "Minimization of the following:\n", + "\n", + "$$\n", + "\\bar{u}_\\text{pot} = \\frac{U}{E_J} = -\\big[ \\alpha\\cos(\\varphi_{02}) + \\cos(\\varphi_{03}) + \\cos(\\varphi_{01}) + \\\\\n", + "+ \\cos(\\varphi_{02} - \\varphi_{01} - L) + \\cos(\\varphi_{02} - \\varphi_{03} + R)\\big]\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import itertools\n", + "from collections import defaultdict\n", + "\n", + "pi = math.pi\n", + "\n", + "import numpy as np\n", + "from numba import cuda\n", + "from numba.cuda.cudadrv.devicearray import DeviceNDArray\n", + "import matplotlib.pyplot as plt\n", + "plt.style.use('my_official')\n", + "\n", + "from functions.potential import potential_function_cuda\n", + "from kernels.potential_evaluator import PotentialEvaluator\n", + "from kernels.potential_minimum_searcher import PotentialMinimumSearcher\n", + "from utils.array_stacker import ArrayStacker" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Parameters of the simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "NUMBER_OF_PHI_POINTS = 150\n", + "NUMBER_OF_FIELD_POINTS = 50\n", + "NUMBER_OF_FIELD_POINTS_PER_RUN = 10\n", + "NUMBER_OF_FIELD_RUNS = (\n", + " NUMBER_OF_FIELD_POINTS - 1\n", + ") // NUMBER_OF_FIELD_POINTS_PER_RUN + 1\n", + "ALPHA = 1\n", + "LOWER = -0.5\n", + "UPPER = 1.5\n", + "\n", + "lr_array = np.linspace(LOWER * 2 * pi, UPPER * 2 * pi, NUMBER_OF_FIELD_POINTS)\n", + "phixx_array = np.linspace(-pi, pi, NUMBER_OF_PHI_POINTS)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create kernels to cuda" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "šŸ³ Allocating THREADS_PER_BLOCK = (8, 8, 8)\n", + "šŸ³ Allocating THREADS_PER_BLOCK = (32, 32)\n" + ] + } + ], + "source": [ + "BLOCKS_PER_GRID = (NUMBER_OF_FIELD_POINTS_PER_RUN, NUMBER_OF_FIELD_POINTS_PER_RUN)\n", + "\n", + "potential_evaluator = PotentialEvaluator(NUMBER_OF_PHI_POINTS, potential_function_cuda)\n", + "THREADS_PER_BLOCK_potential_evaluation = potential_evaluator.allocate_max_threads(8)\n", + "\n", + "potential_minimum_searcher = PotentialMinimumSearcher(NUMBER_OF_PHI_POINTS)\n", + "THREADS_PER_BLOCK_potential_search = potential_minimum_searcher.allocate_max_threads()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Execution\n", + "- Allocate arrays on GPU\n", + "- As we split the field up into quadrants, create a quadrant array that will stitch fields together" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "šŸ¦‘ Running (L=0/4), (R=0/4)\n", + "šŸ¦‘ Running (L=0/4), (R=1/4)\n", + "šŸ¦‘ Running (L=0/4), (R=2/4)\n", + "šŸ¦‘ Running (L=0/4), (R=3/4)\n", + "šŸ¦‘ Running (L=0/4), (R=4/4)\n", + "šŸ¦‘ Running (L=1/4), (R=0/4)\n", + "šŸ¦‘ Running (L=1/4), (R=1/4)\n", + "šŸ¦‘ Running (L=1/4), (R=2/4)\n", + "šŸ¦‘ Running (L=1/4), (R=3/4)\n", + "šŸ¦‘ Running (L=1/4), (R=4/4)\n", + "šŸ¦‘ Running (L=2/4), (R=0/4)\n", + "šŸ¦‘ Running (L=2/4), (R=1/4)\n", + "šŸ¦‘ Running (L=2/4), (R=2/4)\n", + "šŸ¦‘ Running (L=2/4), (R=3/4)\n", + "šŸ¦‘ Running (L=2/4), (R=4/4)\n", + "šŸ¦‘ Running (L=3/4), (R=0/4)\n", + "šŸ¦‘ Running (L=3/4), (R=1/4)\n", + "šŸ¦‘ Running (L=3/4), (R=2/4)\n", + "šŸ¦‘ Running (L=3/4), (R=3/4)\n", + "šŸ¦‘ Running (L=3/4), (R=4/4)\n", + "šŸ¦‘ Running (L=4/4), (R=0/4)\n", + "šŸ¦‘ Running (L=4/4), (R=1/4)\n", + "šŸ¦‘ Running (L=4/4), (R=2/4)\n", + "šŸ¦‘ Running (L=4/4), (R=3/4)\n", + "šŸ¦‘ Running (L=4/4), (R=4/4)\n" + ] + } + ], + "source": [ + "DEVICE_lr_array = cuda.to_device(lr_array)\n", + "DEVICE_phixx_array = cuda.to_device(phixx_array)\n", + "DEVICE_potential_array = cuda.device_array(\n", + " shape=(\n", + " NUMBER_OF_FIELD_POINTS_PER_RUN,\n", + " NUMBER_OF_FIELD_POINTS_PER_RUN,\n", + " NUMBER_OF_PHI_POINTS,\n", + " NUMBER_OF_PHI_POINTS,\n", + " NUMBER_OF_PHI_POINTS,\n", + " ),\n", + " dtype=np.float32,\n", + ")\n", + "DEVICE_grid_search_result_array = cuda.device_array(\n", + " shape=(NUMBER_OF_FIELD_POINTS_PER_RUN, NUMBER_OF_FIELD_POINTS_PER_RUN, 4),\n", + " dtype=np.float32,\n", + ")\n", + "\n", + "# Go through teach of the field section and evaluate ##########################\n", + "quadrants = defaultdict(lambda: [[None] * NUMBER_OF_FIELD_RUNS for i in range(0, NUMBER_OF_FIELD_RUNS)])\n", + "for (L_RUN, R_RUN) in itertools.product(\n", + " range(0, NUMBER_OF_FIELD_RUNS), range(0, NUMBER_OF_FIELD_RUNS)\n", + "):\n", + " print(\n", + " f\"šŸ¦‘ Running (L={L_RUN}/{NUMBER_OF_FIELD_RUNS - 1}), (R={R_RUN}/{NUMBER_OF_FIELD_RUNS - 1})\"\n", + " )\n", + " L_OFFSET = int(L_RUN * NUMBER_OF_FIELD_POINTS_PER_RUN)\n", + " R_OFFSET = int(R_RUN * NUMBER_OF_FIELD_POINTS_PER_RUN)\n", + " potential_evaluator.kernel[BLOCKS_PER_GRID, THREADS_PER_BLOCK_potential_evaluation](\n", + " DEVICE_phixx_array,\n", + " DEVICE_lr_array,\n", + " L_OFFSET,\n", + " R_OFFSET,\n", + " ALPHA,\n", + " DEVICE_potential_array,\n", + " )\n", + " potential_minimum_searcher.kernel[\n", + " BLOCKS_PER_GRID, THREADS_PER_BLOCK_potential_search\n", + " ](DEVICE_potential_array, DEVICE_grid_search_result_array)\n", + " \n", + " grid_search_result_array = DEVICE_grid_search_result_array.copy_to_host()\n", + " quadrants[\"potential\"][L_RUN][R_RUN] = grid_search_result_array[:,:,0]\n", + " quadrants[\"phi01\"][L_RUN][R_RUN] = phixx_array[grid_search_result_array[:,:,1].astype(int)] / (2 * pi)\n", + " quadrants[\"phi02\"][L_RUN][R_RUN] = phixx_array[grid_search_result_array[:,:,2].astype(int)] / (2 * pi)\n", + " quadrants[\"phi03\"][L_RUN][R_RUN] = phixx_array[grid_search_result_array[:,:,3].astype(int)] / (2 * pi)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Accumulate results\n", + "- Collect up results\n", + "- Plot" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "šŸ¦‘--------------------potential--------------------\n", + "šŸ¦‘--------------------phi01--------------------\n", + "šŸ¦‘--------------------phi02--------------------\n", + "šŸ¦‘--------------------phi03--------------------\n", + "[[3.7503917 3.5060625 3.2732792 ... 3.2732792 3.5060625 3.7503917]\n", + " [3.6416993 3.4027705 3.176096 ... 3.4028053 3.64158 3.6416993]\n", + " [3.5640454 3.3314278 3.1128476 ... 3.5638413 3.8070552 3.5640454]\n", + " ...\n", + " [3.5640454 3.8070552 3.5638413 ... 3.1128476 3.3314278 3.5640454]\n", + " [3.6416993 3.64158 3.4028053 ... 3.176096 3.4027705 3.6416993]\n", + " [3.7503917 3.5060625 3.2732792 ... 3.2732792 3.5060625 3.7503917]]\n" + ] + } + ], + "source": [ + "result = {}\n", + "for key, value in quadrants.items():\n", + " print(f\"šŸ¦‘--------------------{key}--------------------\")\n", + " result[key] = ArrayStacker.stack_into_square(value)\n", + "print(result[\"potential\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "fig, ax = plt.subplots(1, 1, sharex=True, sharey=True, figsize=(4, 4))\n", + "\n", + "im = ax.imshow(\n", + " # result[\"potential\"],\n", + " result[\"potential\"],\n", + " extent = [LOWER, UPPER, LOWER, UPPER],\n", + " origin= 'lower',\n", + " #cmap='summer',\n", + " cmap='YlGnBu',\n", + " interpolation='spline36',\n", + " vmin=0, vmax=2.5\n", + ")\n", + "cbar = fig.colorbar(im)\n", + "cbar.set_ticks([0, 0.5, 1, 1.5, 2, 2.5])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matplotlib.colorbar.Colorbar" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(cbar)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/kernels/potential_evaluator.py b/kernels/potential_evaluator.py index 46f3d7c..6893326 100644 --- a/kernels/potential_evaluator.py +++ b/kernels/potential_evaluator.py @@ -17,15 +17,17 @@ def __init__( self.gpu_info = gpu_check() def allocate_max_threads( - self, user_defined_number: Optional[int]=None + self, user_defined_number: Optional[int] = None, + verbose=False ) -> Tuple[int, int, int]: - print( - f"""Thread parameters: + if verbose: + print( + f"""Thread parameters: > Max threads per block: {self.gpu_info['max_threads_per_block']} > Max threads in x: {self.gpu_info['max_block_dim_x']} > Max threads in y: {self.gpu_info['max_block_dim_y']} > Max threads in z: {self.gpu_info['max_block_dim_z']}""" - ) + ) max_threads_approximation = int( self.gpu_info["max_threads_per_block"] ** (1 / 3) ) @@ -37,17 +39,18 @@ def allocate_max_threads( min(max_threads_approximation, self.gpu_info["max_block_dim_y"]), min(max_threads_approximation, self.gpu_info["max_block_dim_z"]), ) - print(f"šŸ³ Allocating (THREADS_PER_BLOCK = {max_thread_allocation})") + print(f"šŸ³ {'Allocating':<20} THREADS_PER_BLOCK = {max_thread_allocation}") return max_thread_allocation - def verify_blocks_per_grid(self, blocks_per_grid: Tuple) -> bool: - print( - f"""Block parameters: + def verify_blocks_per_grid(self, blocks_per_grid: Tuple, verbose=False) -> bool: + if verbose: + print( + f"""Block parameters: > Max blocks in x: {self.gpu_info['max_grid_dim_x']} > Max blocks in y: {self.gpu_info['max_grid_dim_y']} > Max blocks in z: {self.gpu_info['max_grid_dim_z']}""" - ) + ) for (block_dim, max_dim) in zip( blocks_per_grid, [ @@ -59,7 +62,7 @@ def verify_blocks_per_grid(self, blocks_per_grid: Tuple) -> bool: if block_dim > max_dim: print("šŸ¦‘ Allocating too many blocks") return False - print(f"šŸ³ Verified BLOCKS_PER_GRID={blocks_per_grid}") + print(f"šŸ³ {'Verified':<20} BLOCKS_PER_GRID={blocks_per_grid}") return True def kernel_wrapper(self): @@ -78,9 +81,11 @@ def kernel( """ phixx_array: array of the values that phi01, phi02, phi03 lr_array: array of the values for phil and phir - L_offset, R_offset: because of finite memory on device, we will launch this - function multiple times but with different offsets to cover the whole - lr_array + L_offset, R_offset: because of finite memory on device, grid search is performed + on separate qudrants of the field. + In order to a global lr_array, this offset + if introduced to access elements for the different quadrants + alpha: variables parametr array_out: allocate either with cuda.device_array or passing in a numpy array diff --git a/kernels/potential_minimum_search.py b/kernels/potential_minimum_searcher.py similarity index 84% rename from kernels/potential_minimum_search.py rename to kernels/potential_minimum_searcher.py index ec36222..3e60b97 100644 --- a/kernels/potential_minimum_search.py +++ b/kernels/potential_minimum_searcher.py @@ -16,15 +16,17 @@ def __init__(self, number_of_phi_points: int): self.gpu_info = gpu_check() def allocate_max_threads( - self, user_defined_number: Optional[int] = None + self, user_defined_number: Optional[int] = None, + verbose=False ) -> Tuple[int, int]: - print( - f"""Thread parameters: + if verbose: + print( + f"""Thread parameters: > Max threads per block: {self.gpu_info['max_threads_per_block']} > Max threads in x: {self.gpu_info['max_block_dim_x']} > Max threads in y: {self.gpu_info['max_block_dim_y']} > Max threads in z: {self.gpu_info['max_block_dim_z']}""" - ) + ) max_threads_approximation = int( self.gpu_info["max_threads_per_block"] ** (1 / 2) ) @@ -35,7 +37,7 @@ def allocate_max_threads( min(max_threads_approximation, self.gpu_info["max_block_dim_x"]), min(max_threads_approximation, self.gpu_info["max_block_dim_x"]), ) - print(f"šŸ³ Allocating (THREADS_PER_BLOCK = {max_thread_allocation})") + print(f"šŸ³ {'Allocating':<20} THREADS_PER_BLOCK = {max_thread_allocation}") return max_thread_allocation @@ -44,18 +46,15 @@ def kernel_wrapper(self): @cuda.jit def kernel( - potential_grid: DeviceNDArray, - # L_offset: int, - # R_offset: int, - array_out: DeviceNDArray, + potential_grid: DeviceNDArray, array_out: DeviceNDArray, ): """Take a 5D grid loaded into memory and find the minimum for each L-R point - L_offset, R_offset: because of finite memory on device, we might need an offset - potential_grid: array allocated on the device that stores the results of - previous potential evaluation. L, R index the field that - it was evaluated at + potential_grid: array with the evaluated potential values at each L,R point + array_out: array with a [min_potential, min_phi01, min_phi02, min_phi03] for + each L,R point """ + L = cuda.blockIdx.x R = cuda.blockIdx.y @@ -99,7 +98,7 @@ def kernel( phi01_idx += cuda.blockDim.x cuda.syncthreads() - # # Project from line to points (go across the line) ################ + # Project from line to points (go across the line) ################ for (phi01_idx, potential) in enumerate(potential_grid[L][R][:, 0, 0]): array_out[L][R][0] = potential_grid[L][R][0][0][0] if potential < potential_grid[L][R][0][0][0]: diff --git a/potential_python.py b/potential_python.py index 5162c5a..f735ed3 100644 --- a/potential_python.py +++ b/potential_python.py @@ -5,7 +5,6 @@ import numpy as np from scipy import optimize -NUMBA_TUPLE_TYPE = nb.typeof((0.0, 0.0, 0.0, 0.0)) FLUX = float FLUX_NUMBER = int cos = np.cos @@ -61,8 +60,8 @@ def minimize(L: FLUX, R: FLUX, alpha: float, number_of_phi_points: int = 100): ############################################################################### # Common parameters # ############################################################################### -NUMBER_OF_PHI_POINTS = 50 -NROWSCOLS = 2 +NUMBER_OF_PHI_POINTS = 10 +NROWSCOLS = 10 ALPHA = 1 LOWER = -0.5 UPPER = 1.5 diff --git a/tests/test_potential_minimum_search.py b/tests/test_potential_minimum_searcher.py similarity index 94% rename from tests/test_potential_minimum_search.py rename to tests/test_potential_minimum_searcher.py index fc4b5a4..0805eda 100644 --- a/tests/test_potential_minimum_search.py +++ b/tests/test_potential_minimum_searcher.py @@ -2,12 +2,12 @@ from unittest.mock import Mock from unittest.mock import patch -from kernels.potential_minimum_search import PotentialMinimumSearcher +from kernels.potential_minimum_searcher import PotentialMinimumSearcher import numpy as np from numba import cuda -class TestPotentialEvaluator(unittest.TestCase): +class TestPotentialMinimumSearcher(unittest.TestCase): def setUp(self): self.NUMBER_OF_PHI_POINTS = 2 diff --git a/utils/array_stacker.py b/utils/array_stacker.py index ebc63e0..14110ad 100644 --- a/utils/array_stacker.py +++ b/utils/array_stacker.py @@ -4,6 +4,12 @@ class ArrayStacker: + @staticmethod + def extract_ith_entry(arrays_to_extract: List[List[np.ndarray]]): + """Extract the ith entry of an array""" + + pass + @classmethod def stack_into_square(cls, arrays_to_stack: List[List[np.ndarray]]) -> np.ndarray: cls.square_check(arrays_to_stack) diff --git a/utils/info.py b/utils/info.py index d18c2b7..fc0d851 100644 --- a/utils/info.py +++ b/utils/info.py @@ -15,14 +15,14 @@ def gpu_check(): "max_grid_dim_y": device.MAX_GRID_DIM_Y, "max_grid_dim_z": device.MAX_GRID_DIM_Z, } - print(f"šŸ¦‘ Found device {str(device)}") - print(parameters) + # print(f"šŸ¦‘ Found device {str(device)}") + # print(parameters) - print( - f"šŸ¦‘ Max shared memory cells for int16: {device.MAX_SHARED_MEMORY_PER_BLOCK / nb.int16.bitwidth}" - ) - print( - f"šŸ¦‘ Max shared memory cells for float32: {device.MAX_SHARED_MEMORY_PER_BLOCK / nb.float32.bitwidth}" - ) + # print( + # f"šŸ¦‘ Max shared memory cells for int16: {device.MAX_SHARED_MEMORY_PER_BLOCK / nb.int16.bitwidth}" + # ) + # print( + # f"šŸ¦‘ Max shared memory cells for float32: {device.MAX_SHARED_MEMORY_PER_BLOCK / nb.float32.bitwidth}" + # ) return parameters raise RuntimeError("Missing GPU")