ContinuumSimulation3D.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib import cm\n",
    "import random\n",
    "import time\n",
    "import warnings\n",
    "import gc\n",
    "import tracemalloc\n",
    "import cProfile\n",
    "import pstats\n",
    "import sys\n",
    "import pptk\n",
    "import scipy.ndimage\n",
    "from sortedcontainers import SortedSet\n",
    "\n",
    "import json\n",
    "import copy\n",
    "\n",
    "from utils import *\n",
    "#from lib.AcceleratorMethods.AcceleratorMethods import *\n",
    "\n",
    "plt.rcParams[\"figure.figsize\"] = (20,10)\n",
    "plt.rcParams[\"figure.dpi\"] = 160\n",
    "\n",
    "cmap = cm.get_cmap('viridis', 101)\n",
    "viridis = np.ndarray((101, 4))\n",
    "for i in range(0, 101):\n",
    "    viridis[i] = cmap(i/100)\n",
    "    \n",
    "cmap = cm.get_cmap('magma', 101)\n",
    "magma = np.ndarray((101, 4))\n",
    "for i in range(0, 101):\n",
    "    magma[i] = cmap(i/100)\n",
    "    \n",
    "cmap = cm.get_cmap('inferno', 101)\n",
    "inferno = np.ndarray((101, 4))\n",
    "for i in range(0, 101):\n",
    "    inferno[i] = cmap(i/100)\n",
    "    \n",
    "cmap = cm.get_cmap('prism', 101)\n",
    "prism = np.ndarray((101, 4))\n",
    "for i in range(0, 101):\n",
    "    prism[i] = cmap(i/100)\n",
    "    \n",
    "cmap = cm.get_cmap('flag', 101)\n",
    "flag = np.ndarray((101, 4))\n",
    "for i in range(0, 101):\n",
    "    flag[i] = cmap(i/100)\n",
    "    \n",
    "cmap = cm.get_cmap('ocean', 101)\n",
    "ocean = np.ndarray((101, 4))\n",
    "for i in range(0, 101):\n",
    "    ocean[i] = cmap(i/100)\n",
    "    \n",
    "cmap = cm.get_cmap('tab10', 10)\n",
    "tab10 = np.ndarray((10, 4))\n",
    "for i in range(0, 10):\n",
    "    tab10[i] = cmap(i/10)\n",
    "    \n",
    "cmap = cm.get_cmap('Set1', 9)\n",
    "set1 = np.ndarray((9, 4))\n",
    "for i in range(0, 9):\n",
    "    set1[i] = cmap(i/9)\n",
    "    \n",
    "    \n",
    "import warnings\n",
    "warnings.filterwarnings('error', category=RuntimeWarning)\n",
    "warnings.filterwarnings('ignore', category=DeprecationWarning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# taken from https://github.com/grantjenks/python-sortedcontainers/issues/53\n",
    "class FasterSortedSet(SortedSet):\n",
    "    def union(self, *iterables):\n",
    "        if (self and len(iterables) == 1\n",
    "                and isinstance(iterables[0], SortedSet)\n",
    "                and iterables[0]\n",
    "                and self._list._lists[-1][-1] < iterables[0]._list._lists[0][0]):\n",
    "            that = iterables[0]\n",
    "            result = FasterSortedSet()\n",
    "            _set = result._set\n",
    "            _set.update(self)\n",
    "            _set.update(that)\n",
    "            _list = result._list\n",
    "            _list._lists.extend(list(sublist) for sublist in self._list._lists)\n",
    "            _list._maxes.extend(self._list._maxes)\n",
    "            _list._lists.extend(list(sublist) for sublist in that._list._lists)\n",
    "            _list._maxes.extend(that._list._maxes)\n",
    "            _list._len = len(_set)\n",
    "            return result\n",
    "        else:\n",
    "            return self.__class__(\n",
    "                chain(iter(self), *iterables),\n",
    "                key=self._key,\n",
    "                load=self._load\n",
    "            )\n",
    "\n",
    "    __or__ = union\n",
    "    __ror__ = __or__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import Cython\n",
    "%load_ext Cython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "cimport cython\n",
    "import numpy as np\n",
    "cimport numpy as np\n",
    "\n",
    "\n",
    "@cython.boundscheck(False)\n",
    "@cython.wraparound(False)\n",
    "def superimpose_potential(np.float32_t[:,:,:,:] pot_field, np.float64_t[:] center, unsigned long scale, double radius, np.float32_t[:,:,:,:] template, unsigned long diameter):\n",
    "    cdef int[:] scaled_center = np.array([0,0,0], dtype=np.int32)\n",
    "    scaled_center[0] = np.round(center[0] * scale).astype(np.int32) % pot_field.shape[0]\n",
    "    scaled_center[1] = np.round(center[1] * scale).astype(np.int32) % pot_field.shape[1]\n",
    "    scaled_center[2] = np.round(center[2] * scale).astype(np.int32) % pot_field.shape[2]\n",
    "    #print(\"Scaled center {}\".format(scaled_center))\n",
    "    #Vmin is at r=2^(1/6)*zero_pot\n",
    "    cdef np.float32_t zero_pot = radius / 2**(1/5) * scale # in indices\n",
    "    cdef int low = -((diameter-1)//2)\n",
    "    cdef int high = (diameter+1)//2\n",
    "    cdef Py_ssize_t x = (pot_field.shape[0])\n",
    "    cdef Py_ssize_t y = (pot_field.shape[1])\n",
    "    cdef Py_ssize_t z = (pot_field.shape[2])\n",
    "    \n",
    "    cdef np.float32_t[:,:,:,:] pot_view = pot_field\n",
    "    cdef np.float32_t[:,:,:,:] tmp_view = template\n",
    "    \n",
    "    cdef Py_ssize_t i, ii, j, jj, k, kk\n",
    "    for i in range(low, high):\n",
    "        ii = (scaled_center[0] + i) % x\n",
    "        idist = (i)**2\n",
    "        for j in range(low, high):\n",
    "            jj = (scaled_center[1] + j) % y\n",
    "            jdist = (j)**2\n",
    "            for k in range(low, high):\n",
    "                kk = scaled_center[2] + k\n",
    "                if kk < 0 or kk > z-1:\n",
    "                    continue\n",
    "                if i == 0 and j == 0 and k == 0:\n",
    "                    pot_view[ii,jj,kk,0] = 0\n",
    "                    pot_view[ii,jj,kk,1] = 0\n",
    "                    pot_view[ii,jj,kk,2] = 0\n",
    "                    pot_view[ii,jj,kk,3] = np.inf\n",
    "                \n",
    "                #r = np.sqrt(idist + jdist + (k)**2)\n",
    "                #magnitude = tmp_view[i-low,j-low,k-low,3]#(zero_pot/r)**12 - (zero_pot/r)**6\n",
    "                #direction = tmp_view[i-low,j-low,k-low,:3]#np.array([i,j,k]) / distance3D([i,j,k], [0,0,0]) * magnitude/np.abs(magnitude) # get direction\n",
    "                #magnitude = np.abs(magnitude) # set magnitude to the absolute value\n",
    "                \n",
    "                pot_view[ii,jj,kk,0] = pot_view[ii,jj,kk,3]*pot_view[ii,jj,kk,0] + tmp_view[i-low,j-low,k-low,3]*tmp_view[i-low,j-low,k-low,0]\n",
    "                pot_view[ii,jj,kk,1] = pot_view[ii,jj,kk,3]*pot_view[ii,jj,kk,1] + tmp_view[i-low,j-low,k-low,3]*tmp_view[i-low,j-low,k-low,1]\n",
    "                pot_view[ii,jj,kk,2] = pot_view[ii,jj,kk,3]*pot_view[ii,jj,kk,2] + tmp_view[i-low,j-low,k-low,3]*tmp_view[i-low,j-low,k-low,2]\n",
    "                #pot_view[ii,jj,kk,3] = np.sqrt(pot_view[ii,jj,kk,0]**2 + pot_view[ii,jj,kk,1]**2 + pot_view[ii,jj,kk,2]**2)\n",
    "                pot_view[ii,jj,kk,3] = pot_view[ii,jj,kk,3] + tmp_view[i-low, j-low, k-low, 3]\n",
    "                if pot_view[ii,jj,kk,3] == 0.0:\n",
    "                    pot_view[ii,jj,kk,0] = 0.0\n",
    "                    pot_view[ii,jj,kk,1] = 0.0\n",
    "                    pot_view[ii,jj,kk,2] = 0.0\n",
    "                else:\n",
    "                    pot_view[ii,jj,kk,0] = pot_view[ii,jj,kk,0]/pot_view[ii,jj,kk,3]\n",
    "                    pot_view[ii,jj,kk,1] = pot_view[ii,jj,kk,1]/pot_view[ii,jj,kk,3]\n",
    "                    pot_view[ii,jj,kk,2] = pot_view[ii,jj,kk,2]/pot_view[ii,jj,kk,3]\n",
    "#     ii = scaled_center[0] + low\n",
    "#     jj = scaled_center[1] + low\n",
    "#     kk = scaled_center[2] + low\n",
    "#     vectors = [0, 1, 2]\n",
    "#     if scaled_center[0] > -low and scaled_center[0] + high < x-1:\n",
    "#         if scaled_center[1] > -low and scaled_center[1] + high < y-1:\n",
    "#             if scaled_center[2] > -low and scaled_center[2] + high < z-1:\n",
    "#                 # easy case: entire added field doesn't cross boundaries\n",
    "#                 region = pot_field[ii:ii+diameter,jj:jj+diameter,kk:kk+diameter,:]\n",
    "#                 print(region.shape, template.shape)\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,:,:,3]*template[:,:,:,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "#             elif scaled_center[2] <= -low:\n",
    "#                 # 0<x<L, 0<y<L, 0=z<h\n",
    "#                 region = pot_field[ii:ii+diameter,jj:jj+diameter,0:kk+diameter,:]\n",
    "#                 t = template[:,:,-kk-diameter:,:]\n",
    "#                 print(scaled_center, region.shape, template[:,:,-kk-diameter:,:].shape, low, kk)\n",
    "#                 cs = [region[:,:,:,3]*region[:,:,:,i] + t[:,:,:,3]*t[:,:,:,i] for i in vectors]\n",
    "#                 region[:,:,:,:3] = np.stack(cs, axis=3)\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.stack([region[:,:,:,0]/region[:,:,:,3], region[:,:,:,1]/region[:,:,:,3], region[:,:,:,2]/region[:,:,:,3], region[:,:,:,3]], axis=3)\n",
    "#                 region = np.where(region==np.nan, 0, region)\n",
    "#             else:\n",
    "#                 # 0<x<L, 0<y<L, 0<z=h\n",
    "#                 region = pot_field[ii:ii+diameter,jj:jj+diameter,kk:-1,:]\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,:,:low,3]*template[:,:,:low,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "#         elif scaled_center[0] <= -low:\n",
    "#             if scaled_center[2] > -low and scaled_center[2] + high < z-1:\n",
    "#                 # 0<x<L, 0=y<L, 0<z<h\n",
    "#                 region = pot_field[ii:ii+diameter,0:jj+diameter,kk:kk+diameter,:]\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,-low:,:,3]*template[:,-low:,:,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "                \n",
    "#                 #0<x<L, y<0, 0<z<h\n",
    "#                 region = pot_field[ii:ii+diameter,low:,kk:kk+diameter,:]\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,:low,:,3]*template[:,:low,:,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "#             elif scaled_center[2] <= -low:\n",
    "#                 # 0<x<L, 0=y<L, 0=z<h\n",
    "#                 region = pot_field[ii:ii+diameter,0:jj+diameter,0:kk+diameter,:]\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,-low:,-low:,3]*template[:,-low:,-low:,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "                \n",
    "#                 #0<x<L, y<0, 0=z<h\n",
    "#                 region = pot_field[ii:ii+diameter,low:,0:kk+diameter,:]\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,:low,:low,3]*template[:,:low,:low,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "#             else:\n",
    "#                 # 0<x<L, 0=y<L, 0<z=h\n",
    "#                 region = pot_field[ii:ii+diameter,0:jj+diameter,kk:-1,:]\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,-low:,:low,3]*template[:,-low:,:low,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "                \n",
    "#                 # 0<x<L, y<0, 0<z=h\n",
    "#                 region = pot_field[ii:ii+diameter,low:,kk:-1,:]\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,:low,:low,3]*template[:,:low,:low,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "#         else:\n",
    "#             if scaled_center[2] > -low and scaled_center[2] + high < z-1:\n",
    "#                 # 0<x<L, 0<y=L, 0<z<h\n",
    "#                 region = pot_field[ii:ii+diameter,jj:,kk:kk+diameter,:]\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,low:,:,3]*template[:,low:,:,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "                \n",
    "#                 #0<x<L, y>L, 0<z<h\n",
    "#                 region = pot_field[ii:ii+diameter,low:,kk:kk+diameter,:]\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,:low,:,3]*template[:,:low,:,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "#             elif scaled_center[2] <= -low:\n",
    "#                 # 0<x<L, 0=y<L, 0=z<h\n",
    "#                 region = pot_field[ii:ii+diameter,0:jj+diameter,0:kk+diameter,:]\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,-low:,-low:,3]*template[:,-low:,-low:,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "                \n",
    "#                 #0<x<L, y<0, 0=z<h\n",
    "#                 region = pot_field[ii:ii+diameter,low:,0:kk+diameter,:]\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,:low,:low,3]*template[:,:low,:low,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "#             else:\n",
    "#                 # 0<x<L, 0=y<L, 0<z=h\n",
    "#                 region = pot_field[ii:ii+diameter,0:jj+diameter,kk:-1,:]\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,-low:,:low,3]*template[:,-low:,:low,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "                \n",
    "#                 # 0<x<L, y<0, 0<z=h\n",
    "#                 region = pot_field[ii:ii+diameter,low:,kk:-1,:]\n",
    "#                 region[:,:,:,:3] = region[:,:,:,3]*region[:,:,:,:3] + template[:,:low,:low,3]*template[:,:low,:low,:3]\n",
    "#                 region[:,:,:,3] = np.sqrt(region[:,:,:,0]**2 + region[:,:,:,1]**2 + region[:,:,:,2]**2)\n",
    "#                 region = np.where(region[:,:,:,3]==0.0, [0,0,0,0], [region[:,:,:,:3]/region[:,:,:,3], region[:,:,:,3]])\n",
    "    return\n",
    "\n",
    "@cython.boundscheck(False)\n",
    "@cython.wraparound(False)\n",
    "def shortest_distance_line_to_point(double[:] line_1, double[:] line_2, np.float32_t[:] point):\n",
    "    x = np.array([line_1[0] - line_2[0], line_1[1] - line_2[1], line_1[2] - line_2[2]])\n",
    "    pmq = np.array([point[0] - line_2[0], point[1] - line_2[1], point[2] - line_2[2]])\n",
    "    t = np.dot(pmq, x)/np.dot(x, x)\n",
    "    r = np.linalg.norm(t*x - pmq)\n",
    "    return r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def distance3D(p1, p2):\n",
    "    return np.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2 + (p1[2] - p2[2])**2)\n",
    "\n",
    "def distance3DPBC(p1, p2, L):\n",
    "    # distance in x considering PBC\n",
    "    if (p1[0] - p2[0]) > L/2:\n",
    "        dx = p1[0] - p2[0] - L\n",
    "    elif p1[0] - p2[0] < -L/2:\n",
    "        dx = p1[0] - p2[0] + L\n",
    "    else:\n",
    "        dx = p1[0] - p2[0]\n",
    "    # distance in y considering PBC\n",
    "    if (p1[1] - p2[1]) > L/2:\n",
    "        dy = p1[1] - p2[1] - L\n",
    "    elif p1[1] - p2[1] < -L/2:\n",
    "        dy = p1[1] - p2[1] + L\n",
    "    else:\n",
    "        dy = p1[1] - p2[1]\n",
    "    return np.sqrt(dx**2 + dy**2 + (p1[2] - p2[2])**2)\n",
    "\n",
    "# returns distance^2 (for faster comparisons)\n",
    "def distance3D2PBC(p1, p2, L):\n",
    "    # distance in x considering PBC\n",
    "    if (p1[0] - p2[0]) > L/2:\n",
    "        dx = p1[0] - p2[0] - L\n",
    "    elif p1[0] - p2[0] < -L/2:\n",
    "        dx = p1[0] - p2[0] + L\n",
    "    else:\n",
    "        dx = p1[0] - p2[0]\n",
    "    # distance in y considering PBC\n",
    "    if (p1[1] - p2[1]) > L/2:\n",
    "        dy = p1[1] - p2[1] - L\n",
    "    elif p1[1] - p2[1] < -L/2:\n",
    "        dy = p1[1] - p2[1] + L\n",
    "    else:\n",
    "        dy = p1[1] - p2[1]\n",
    "    return dx**2 + dy**2 + (p1[2] - p2[2])**2\n",
    "\n",
    "def distance2D2PBC(p1, p2, L):\n",
    "    # distance in x considering PBC\n",
    "    if (p1[0] - p2[0]) > L/2:\n",
    "        dx = p1[0] - p2[0] - L\n",
    "    elif p1[0] - p2[0] < -L/2:\n",
    "        dx = p1[0] - p2[0] + L\n",
    "    else:\n",
    "        dx = p1[0] - p2[0]\n",
    "    # distance in y considering PBC\n",
    "    if (p1[1] - p2[1]) > L/2:\n",
    "        dy = p1[1] - p2[1] - L\n",
    "    elif p1[1] - p2[1] < -L/2:\n",
    "        dy = p1[1] - p2[1] + L\n",
    "    else:\n",
    "        dy = p1[1] - p2[1]\n",
    "    return dx**2 + dy**2\n",
    "\n",
    "# p is the current point position, n the unit vector, and step_size the magnitude\n",
    "def step_along_line(p, n, step_size):\n",
    "    return p + n * step_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SpatialBins:\n",
    "    def __init__(self, length, height, bin_size, cython=False, *args, **kwargs):\n",
    "        self.length = length\n",
    "        self.height = height\n",
    "        self.bin_size = bin_size\n",
    "        self.bins_side = int(length / bin_size)\n",
    "        self.bins_vertical = int(height / bin_size)\n",
    "        \n",
    "        self.bins_in_layer = int(self.bins_side**2)\n",
    "        self.bin_nums = int(self.bins_in_layer * self.bins_vertical)\n",
    "        self.bins = [[] for _ in range(self.bin_nums)]\n",
    "        print(\"Total number of bins: {}\\n\\tBins in x-y: {}\\n\\tBins to top: {} \".format(len(self.bins), self.bins_in_layer, self.bins_vertical))\n",
    "    \n",
    "    def find_bin(self, position):\n",
    "        if position[2] > self.bin_size * self.bins_vertical:\n",
    "            for i in range(self.bins_in_layer):\n",
    "                self.bins.append([])\n",
    "            self.bins_vertical += 1\n",
    "        spacex = int(np.floor((position[0] % self.length)//self.bin_size))\n",
    "        spacey = int(np.floor((position[1] % self.length)//self.bin_size))\n",
    "        spacez = int(np.floor(position[2]//self.bin_size))\n",
    "        \n",
    "        idx = spacex + spacey*self.bins_side + spacez*self.bins_in_layer\n",
    "        #print(position % (self.length, self.length, np.inf), idx, spacex, spacey, spacez, bin_size)\n",
    "        \n",
    "        return self.bins[idx]\n",
    "    \n",
    "    # over-inclusive as it assumes a cube with side length 2x radius\n",
    "    def find_bins(self, center, radius):\n",
    "        center_bin = self.find_bin(center)\n",
    "        temp = [center_bin]\n",
    "        \n",
    "        left_back_lower_bin = self.find_bin((center + np.array(([-radius, -radius, -radius]))) % [self.length, self.length, self.height])\n",
    "        if left_back_lower_bin not in temp:\n",
    "            temp.append(left_back_lower_bin)\n",
    "            \n",
    "        left_front_lower_bin = self.find_bin((center + np.array([-radius, radius, -radius])) % [self.length, self.length, self.height])\n",
    "        if left_front_lower_bin not in temp:\n",
    "            temp.append(left_front_lower_bin)\n",
    "        \n",
    "        left_back_upper_bin = self.find_bin((center + np.array([-radius, -radius, radius])) % [self.length, self.length, self.height])\n",
    "        if left_back_upper_bin not in temp:\n",
    "            temp.append(left_back_upper_bin)\n",
    "            \n",
    "        left_front_upper_bin = self.find_bin((center + np.array([-radius, radius, radius])) % [self.length, self.length, self.height])\n",
    "        if left_front_upper_bin not in temp:\n",
    "            temp.append(left_front_upper_bin)\n",
    "            \n",
    "        right_back_lower_bin = self.find_bin((center + np.array([radius, -radius, -radius])) % [self.length, self.length, self.height])\n",
    "        if right_back_lower_bin not in temp:\n",
    "            temp.append(right_back_lower_bin)\n",
    "            \n",
    "        right_front_lower_bin = self.find_bin((center + np.array([radius, radius, -radius])) % [self.length, self.length, self.height])\n",
    "        if right_front_lower_bin not in temp:\n",
    "            temp.append(right_front_lower_bin)\n",
    "            \n",
    "        right_back_upper_bin = self.find_bin((center + np.array([radius, -radius, radius])) % [self.length, self.length, self.height])\n",
    "        if right_back_upper_bin not in temp:\n",
    "            temp.append(right_back_upper_bin)\n",
    "            \n",
    "        right_front_upper_bin = self.find_bin(center + np.array([radius, radius, radius]))\n",
    "        if right_front_upper_bin not in temp:\n",
    "            temp.append(right_front_upper_bin)\n",
    "            \n",
    "        return temp\n",
    "    \n",
    "    def find_bin_idx(self, position):\n",
    "        if position[2] > self.bin_size * self.bins_vertical:\n",
    "            for i in range(self.bins_in_layer):\n",
    "                self.bins.append([])\n",
    "            self.bins_vertical+= 1\n",
    "        spacex = int(np.floor((position[0] % self.length)//self.bin_size))\n",
    "        spacey = int(np.floor((position[1] % self.length)//self.bin_size))\n",
    "        spacez = int(np.floor(position[2]//bin_size))\n",
    "        \n",
    "        idx = spacex + spacey*self.bins_side + spacez*self.bins_in_layer\n",
    "        \n",
    "        return idx\n",
    "    \n",
    "    # over-inclusive as it assumes a cube with side length 2x radius\n",
    "    def find_bins_idx(self, center, radius):\n",
    "        center_bin = self.find_bin_idx(center)\n",
    "        \n",
    "        temp = [center_bin]\n",
    "        \n",
    "        #for i in [-1, 0, 1]:\n",
    "        #    for j in [-1, 0, 1]:\n",
    "        #        for k in [-1, 0, 1]:\n",
    "        #            if i == 0 and j == 0 and k == 0:\n",
    "        #                continue           \n",
    "        \n",
    "        left_back_lower_bin = self.find_bin_idx((center + np.array(([-radius, -radius, -radius]))) % [self.length, self.length, self.height])\n",
    "        if left_back_lower_bin not in temp:\n",
    "            temp.append(left_back_lower_bin)\n",
    "            \n",
    "        left_front_lower_bin = self.find_bin_idx((center + np.array([-radius, radius, -radius])) % [self.length, self.length, self.height])\n",
    "        if left_front_lower_bin not in temp:\n",
    "            temp.append(left_front_lower_bin)\n",
    "        \n",
    "        left_back_upper_bin = self.find_bin_idx((center + np.array([-radius, -radius, radius])) % [self.length, self.length, self.height])\n",
    "        if left_back_upper_bin not in temp:\n",
    "            temp.append(left_back_upper_bin)\n",
    "            \n",
    "        left_front_upper_bin = self.find_bin_idx((center + np.array([-radius, radius, radius])) % [self.length, self.length, self.height])\n",
    "        if left_front_upper_bin not in temp:\n",
    "            temp.append(left_front_upper_bin)\n",
    "            \n",
    "        right_back_lower_bin = self.find_bin_idx((center + np.array([radius, -radius, -radius])) % [self.length, self.length, self.height])\n",
    "        if right_back_lower_bin not in temp:\n",
    "            temp.append(right_back_lower_bin)\n",
    "            \n",
    "        right_front_lower_bin = self.find_bin_idx((center + np.array([radius, radius, -radius])) % [self.length, self.length, self.height])\n",
    "        if right_front_lower_bin not in temp:\n",
    "            temp.append(right_front_lower_bin)\n",
    "            \n",
    "        right_back_upper_bin = self.find_bin_idx((center + np.array([radius, -radius, radius])) % [self.length, self.length, self.height])\n",
    "        if right_back_upper_bin not in temp:\n",
    "            temp.append(right_back_upper_bin)\n",
    "            \n",
    "        right_front_upper_bin = self.find_bin_idx(center + np.array([radius, radius, radius]))\n",
    "        if right_front_upper_bin not in temp:\n",
    "            temp.append(right_front_upper_bin)\n",
    "            \n",
    "        return temp\n",
    "    \n",
    "    # return particles that share bins\n",
    "    def get_nearby_particles(self, center, radius):\n",
    "        bins = self.find_bins(center, radius)\n",
    "        \n",
    "        if bins is []:\n",
    "            return [] # should never happen\n",
    "        \n",
    "        temp = []\n",
    "        for b in bins:\n",
    "            if len(b) > 0:\n",
    "                for i in b:\n",
    "                    if i not in temp:\n",
    "                        temp.append(i)\n",
    "        return temp\n",
    "        \n",
    "    def check_collision(self, center, radius, atoms):\n",
    "        if(center[2] - radius < 0):\n",
    "            return 2 # collision with substrate\n",
    "        potential_collisions = self.get_nearby_particles(center, radius)\n",
    "        if potential_collisions == []:\n",
    "            return 0 # no nearby atoms\n",
    "        for c in potential_collisions:\n",
    "            if distance3D2PBC(atoms[c,:3], center, self.length) < (atoms[c,4] + radius)**2:\n",
    "                return 3 + c # collision\n",
    "        return 1 # no collision but atoms nearby\n",
    "    \n",
    "    def are_nearby_bins_empty(self, center, radius):\n",
    "        bins = self.find_bins(center, radius)\n",
    "        if bins is []:\n",
    "            return []\n",
    "        for b in bins:\n",
    "            if len(b) > 0:\n",
    "                return False\n",
    "        return True\n",
    "    \n",
    "    # over-inclusive as it assumes a cube with side length 2x radius\n",
    "    def add_to_bins(self, center, radius, idx):\n",
    "        bins = self.find_bins(center, radius)\n",
    "        for b in bins:\n",
    "            b.append(idx)\n",
    "        return\n",
    "    \n",
    "    \n",
    "    # get position at edge of current bin given direction and radius such that the particle is still entirely within the bin\n",
    "    # could be optimized more in the case where it's within multiple bins, careful then with nonzero phi because it might pass into another \n",
    "    #   bin in the interim\n",
    "    # currently works only in +x direction\n",
    "    def bin_edge(self, center, radius, direction):\n",
    "        bins = self.find_bins_idx(center, radius)\n",
    "        \n",
    "        if len(bins) > 1:\n",
    "            return np.array((np.nan, np.nan, np.nan))\n",
    "        \n",
    "        if bins is []: \n",
    "            return np.array((np.nan, np.nan, np.nan)) # should never happen\n",
    "        \n",
    "        \n",
    "        candidates = np.zeros((len(bins), 3)) + np.inf\n",
    "        \n",
    "        for i in range(len(bins)):\n",
    "            #spacex = int(np.floor(position[0]//bin_size))\n",
    "            #spacey = int(np.floor((position[1] % self.length)//bin_size))\n",
    "            #spacez = int(np.floor(position[2]//bin_size))\n",
    "            \n",
    "            if direction[0] > 0:\n",
    "                x = (center[0] % self.length) // bin_size * bin_size + bin_size\n",
    "            else:\n",
    "                x = (center[0] % self.length) // bin_size * bin_size\n",
    "#             if direction[1] > 0:\n",
    "#                 y = center[1] // bin_size * bin_size + bin_size\n",
    "#             else:\n",
    "#                 y = center[1] // bin_size * bin_size\n",
    "            z = center[2] // bin_size * bin_size\n",
    "            \n",
    "            manhattan = np.array([x-radius-center[0] % self.length/direction[0], 0, z - radius - center[2]/direction[2]])\n",
    "            side = (np.abs(manhattan[0]) < np.abs(manhattan[2])) # true if it collides at the side rather than the bottom\n",
    "            #print(center, manhattan, np.abs(x-radius-center[0] % self.length), np.abs(z-radius-center[2]))\n",
    "            if side:\n",
    "                candidates[i,:] = np.array([x-radius, center[1], center[2] + manhattan[0]*direction[2]])\n",
    "            else:\n",
    "                candidates[i,:] = np.array([center[0] + manhattan[2]*direction[0], center[1], z-radius])\n",
    "        return candidates[0,:]\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "class Corridors:\n",
    "    def __init__(self, length, bin_size, cython=False, *args, **kwargs):\n",
    "        self.length = length\n",
    "        self.bin_size = bin_size\n",
    "        self.bins_side = int(length / bin_size)\n",
    "        \n",
    "        self.bin_nums = int(self.bins_side**2)\n",
    "        #self.bins = [[] for _ in range(self.bin_nums)]\n",
    "        #for b in self.bins:\n",
    "        #    b = SortedSet(key=lambda position: position[1])\n",
    "        self.bins = [SortedSet(key=lambda position: position[1])] * self.bin_nums\n",
    "        print(\"Total number of bins: {}\".format(len(self.bins)))\n",
    "        \n",
    "    def find_bin(self, position):\n",
    "        spacex = int(np.floor((position[0] % self.length)//self.bin_size))\n",
    "        spacey = int(np.floor((position[1] % self.length)//self.bin_size))\n",
    "        \n",
    "        idx = spacex + spacey*self.bins_side\n",
    "        #print(position % (self.length, self.length, np.inf), idx, spacex, spacey, spacez, bin_size)\n",
    "        \n",
    "        return self.bins[idx]\n",
    "    \n",
    "    # over-inclusive as it assumes a square with side length 2x radius\n",
    "    def add_to_bins(self, center, radius, idx):\n",
    "        bins = self.find_bins(center, radius)\n",
    "        for b in bins:\n",
    "            b.add((idx, center[2]))\n",
    "        return\n",
    "    \n",
    "    # over-inclusive as it assumes a cube with side length 2x radius\n",
    "    def find_bins(self, center, radius):\n",
    "        center_bin = self.find_bin(center)\n",
    "        print(center_bin)\n",
    "        temp = [center_bin]\n",
    "        \n",
    "        left_back_lower_bin = self.find_bin((center[:1] + np.array(([-radius, -radius]))) % [self.length, self.length])\n",
    "        if left_back_lower_bin not in temp:\n",
    "            temp.append(left_back_lower_bin)\n",
    "            \n",
    "        left_front_lower_bin = self.find_bin((center[:1] + np.array([-radius, radius])) % [self.length, self.length])\n",
    "        if left_front_lower_bin not in temp:\n",
    "            temp.append(left_front_lower_bin)\n",
    "        \n",
    "        right_back_lower_bin = self.find_bin((center[:1] + np.array([radius, -radius])) % [self.length, self.length])\n",
    "        if right_back_lower_bin not in temp:\n",
    "            temp.append(right_back_lower_bin)\n",
    "            \n",
    "        right_front_lower_bin = self.find_bin((center[:1] + np.array([radius, radius])) % [self.length, self.length])\n",
    "        if right_front_lower_bin not in temp:\n",
    "            temp.append(right_front_lower_bin)\n",
    "        \n",
    "        return temp\n",
    "    \n",
    "    def find_bin_idx(self, position):\n",
    "        spacex = int(np.floor((position[0] % self.length)//self.bin_size))\n",
    "        spacey = int(np.floor((position[1] % self.length)//self.bin_size))\n",
    "        \n",
    "        idx = spacex + spacey*self.bins_side\n",
    "        \n",
    "        return idx\n",
    "    \n",
    "    # over-inclusive as it assumes a cube with side length 2x radius\n",
    "    def find_bins_idx(self, center, radius):\n",
    "        center_bin = self.find_bin_idx(center)\n",
    "        temp = [center_bin]\n",
    "        \n",
    "        left_back_lower_bin = self.find_bin_idx((center[:1] + np.array(([-radius, -radius]))) % [self.length, self.length])\n",
    "        if left_back_lower_bin not in temp:\n",
    "            temp.append(left_back_lower_bin)\n",
    "            \n",
    "        left_front_lower_bin = self.find_bin_idx((center[:1] + np.array([-radius, radius])) % [self.length, self.length])\n",
    "        if left_front_lower_bin not in temp:\n",
    "            temp.append(left_front_lower_bin)\n",
    "        \n",
    "        right_back_lower_bin = self.find_bin_idx((center[:1] + np.array([radius, -radius])) % [self.length, self.length])\n",
    "        if right_back_lower_bin not in temp:\n",
    "            temp.append(right_back_lower_bin)\n",
    "            \n",
    "        right_front_lower_bin = self.find_bin_idx((center[:1] + np.array([radius, radius])) % [self.length, self.length])\n",
    "        if right_front_lower_bin not in temp:\n",
    "            temp.append(right_front_lower_bin)\n",
    "            \n",
    "        return temp\n",
    "    \n",
    "    # return particles that share bins\n",
    "    def get_nearby_particles(self, center, radius):\n",
    "        bins = self.find_bins(center, radius)\n",
    "        \n",
    "        if bins is []:\n",
    "            return [] # should never happen\n",
    "        \n",
    "        temp = []\n",
    "        for b in bins:\n",
    "            if len(b) > 0:\n",
    "                for i in b:\n",
    "                    if i not in temp:\n",
    "                        temp.append(i)\n",
    "        return temp\n",
    "    \n",
    "    def drop_particle(self, center, radius, atoms):\n",
    "        bins = SortedSet(key=lambda position: position[2])\n",
    "        # combine the bins into one larger bin\n",
    "        fbins = self.find_bins(center, radius)\n",
    "        for b in fbins:\n",
    "            bins |= b\n",
    "        for i in range(len(bins)-1, 0, -1):\n",
    "            # check collision with bins[i][0]-th particle\n",
    "            particle = atoms[bins[i][0],:]\n",
    "            xy_distance2 = distance2D2PBC(particle[:3], center, self.length)\n",
    "            radii2 = (particle[4] + radius)**2\n",
    "            if xy_distance2 < radii2:\n",
    "                z = np.sqrt(radii2 - xy_distance2) + particle[2]\n",
    "                return z, bins[i][0]\n",
    "        return 0, -1\n",
    "        \n",
    "    def check_collision(self, center, radius, atoms):\n",
    "        if(center[2] - radius < 0):\n",
    "            return 2 # collision with substrate\n",
    "        potential_collisions = self.get_nearby_particles(center, radius)\n",
    "        if potential_collisions == []:\n",
    "            return 0 # no nearby atoms\n",
    "        for c in potential_collisions:\n",
    "            if distance3D2PBC(atoms[c,:3], center, self.length) < (atoms[c,4] + radius)**2:\n",
    "                return 3 + c # collision\n",
    "        return 1 # no collision but atoms nearby"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sortedcontainers import SortedSet\n",
    "\n",
    "class SlantedCorridors:\n",
    "    def __init__(self, length, bin_size, theta, height, verbose=False, *args, **kwargs):\n",
    "        self.length = length\n",
    "        self.theta = theta\n",
    "        self.tantheta = tand(theta)\n",
    "        self.cos1theta = cosd(theta)\n",
    "        self.sin1theta = sind(theta)\n",
    "        self.height = height\n",
    "        self.bin_size = bin_size\n",
    "        self.bins_side = int(length / bin_size)\n",
    "        \n",
    "        self.bin_nums = int(self.bins_side**2)\n",
    "        self.bins = []\n",
    "        #self.bins = [[] for _ in range(self.bin_nums)]\n",
    "        #for b in self.bins:\n",
    "        #    b = SortedSet(key=lambda position: position[1])\n",
    "        #self.bins = [FasterSortedSet(key=lambda position: position[1])] * self.bin_nums\n",
    "        for i in range(self.bin_nums):\n",
    "            self.bins.append(FasterSortedSet(key=lambda position: position[1]))\n",
    "        self.bins = [FasterSortedSet(key=lambda position: position[1])] * self.bin_nums\n",
    "        print(\"Total number of bins: {}\".format(len(self.bins)))\n",
    "        \n",
    "        self.verbose = verbose\n",
    "        \n",
    "    def find_bin(self, position):\n",
    "        try:\n",
    "            adjusted_x = position[2] * self.tantheta + position[0]\n",
    "            spacex = int(np.floor((adjusted_x % self.length)//self.bin_size))\n",
    "            spacey = int(np.floor((position[1] % self.length)//self.bin_size))\n",
    "        except FloatingPointError:\n",
    "            raise FloatingPointError(\"\\n*\\tposition: {}\\n*\\tself.tantheta: {}\\n*\\tself.length: {}\\n*\\tself.bin_size: {}\".format(position, self.tantheta, self.length, self.bin_size))\n",
    "        \n",
    "        idx = spacex + spacey*self.bins_side\n",
    "        #print(position % (self.length, self.length, np.inf), idx, spacex, spacey, spacez, bin_size)\n",
    "        \n",
    "        return self.bins[idx]\n",
    "    \n",
    "    # over-inclusive as it assumes a square with side length 2x radius\n",
    "    def add_to_bins(self, center, radius, idx):\n",
    "        bins = self.find_bins(center, radius)\n",
    "        priority = self.calc_priority(center)\n",
    "        for b in bins:\n",
    "            b.add((idx, priority))\n",
    "        return\n",
    "    \n",
    "    # over-inclusive as it assumes a cube with side length 2x radius\n",
    "    def find_bins(self, center, radius):\n",
    "        center_bin = self.find_bin(center)\n",
    "        temp = [center_bin]\n",
    "        \n",
    "        left_back_lower_bin = self.find_bin((center + np.array(([-radius, -radius, -radius]))) % [self.length, self.length, np.inf])\n",
    "        if left_back_lower_bin not in temp:\n",
    "            temp.append(left_back_lower_bin)\n",
    "            \n",
    "        left_front_lower_bin = self.find_bin((center + np.array([-radius, radius, -radius])) % [self.length, self.length, np.inf])\n",
    "        if left_front_lower_bin not in temp:\n",
    "            temp.append(left_front_lower_bin)\n",
    "        \n",
    "        left_back_upper_bin = self.find_bin((center + np.array([-radius, -radius, radius])) % [self.length, self.length, np.inf])\n",
    "        if left_back_upper_bin not in temp:\n",
    "            temp.append(left_back_upper_bin)\n",
    "            \n",
    "        left_front_upper_bin = self.find_bin((center + np.array([-radius, radius, radius])) % [self.length, self.length, np.inf])\n",
    "        if left_front_upper_bin not in temp:\n",
    "            temp.append(left_front_upper_bin)\n",
    "            \n",
    "        right_back_lower_bin = self.find_bin((center + np.array([radius, -radius, -radius])) % [self.length, self.length, np.inf])\n",
    "        if right_back_lower_bin not in temp:\n",
    "            temp.append(right_back_lower_bin)\n",
    "            \n",
    "        right_front_lower_bin = self.find_bin((center + np.array([radius, radius, -radius])) % [self.length, self.length, np.inf])\n",
    "        if right_front_lower_bin not in temp:\n",
    "            temp.append(right_front_lower_bin)\n",
    "            \n",
    "        right_back_upper_bin = self.find_bin((center + np.array([radius, -radius, radius])) % [self.length, self.length, np.inf])\n",
    "        if right_back_upper_bin not in temp:\n",
    "            temp.append(right_back_upper_bin)\n",
    "            \n",
    "        right_front_upper_bin = self.find_bin((center + np.array([radius, radius, radius])) % [self.length, self.length, np.inf])\n",
    "        if right_front_upper_bin not in temp:\n",
    "            temp.append(right_front_upper_bin)\n",
    "        \n",
    "        return temp\n",
    "    \n",
    "    def find_bin_idx(self, position):\n",
    "        adjusted_x = position[2] * self.tantheta + position[0]\n",
    "        spacex = int(np.floor((adjusted_x % self.length)//self.bin_size))\n",
    "        spacey = int(np.floor((position[1] % self.length)//self.bin_size))\n",
    "        \n",
    "        idx = spacex + spacey*self.bins_side\n",
    "        if self.verbose:\n",
    "            print(\"Position: {}\".format(position))\n",
    "            #print(\"self.tandtheta: {}, {}\".format(self.tantheta, tand(self.theta)))\n",
    "            print(\"adjusted_x: {}\".format(adjusted_x))\n",
    "            print(\"Indices: {}, {}, {}\".format(spacex, spacey, idx))\n",
    "        return idx\n",
    "    \n",
    "    # over-inclusive as it assumes a cube with side length 2x radius\n",
    "    def find_bins_idx(self, center, radius):\n",
    "        center_bin = self.find_bin_idx(center)\n",
    "        temp = [center_bin]\n",
    "        \n",
    "        left_back_lower_bin = self.find_bin_idx((center + np.array(([-radius, -radius, -radius]))) % [self.length, self.length, self.height])\n",
    "        if left_back_lower_bin not in temp:\n",
    "            temp.append(left_back_lower_bin)\n",
    "            \n",
    "        left_front_lower_bin = self.find_bin_idx((center + np.array([-radius, radius, -radius])) % [self.length, self.length, self.height])\n",
    "        if left_front_lower_bin not in temp:\n",
    "            temp.append(left_front_lower_bin)\n",
    "        \n",
    "        left_back_upper_bin = self.find_bin_idx((center + np.array([-radius, -radius, radius])) % [self.length, self.length, self.height])\n",
    "        if left_back_upper_bin not in temp:\n",
    "            temp.append(left_back_upper_bin)\n",
    "            \n",
    "        left_front_upper_bin = self.find_bin_idx((center + np.array([-radius, radius, radius])) % [self.length, self.length, self.height])\n",
    "        if left_front_upper_bin not in temp:\n",
    "            temp.append(left_front_upper_bin)\n",
    "            \n",
    "        right_back_lower_bin = self.find_bin_idx((center + np.array([radius, -radius, -radius])) % [self.length, self.length, self.height])\n",
    "        if right_back_lower_bin not in temp:\n",
    "            temp.append(right_back_lower_bin)\n",
    "            \n",
    "        right_front_lower_bin = self.find_bin_idx((center + np.array([radius, radius, -radius])) % [self.length, self.length, self.height])\n",
    "        if right_front_lower_bin not in temp:\n",
    "            temp.append(right_front_lower_bin)\n",
    "            \n",
    "        right_back_upper_bin = self.find_bin_idx((center + np.array([radius, -radius, radius])) % [self.length, self.length, self.height])\n",
    "        if right_back_upper_bin not in temp:\n",
    "            temp.append(right_back_upper_bin)\n",
    "            \n",
    "        right_front_upper_bin = self.find_bin_idx(center + np.array([radius, radius, radius]))\n",
    "        if right_front_upper_bin not in temp:\n",
    "            temp.append(right_front_upper_bin)\n",
    "            \n",
    "        return temp\n",
    "    \n",
    "    # return particles that share bins\n",
    "    def get_nearby_particles(self, center, radius):\n",
    "        bins = self.find_bins(center, radius)\n",
    "        \n",
    "        if bins is []:\n",
    "            return [] # should never happen\n",
    "        \n",
    "        temp = []\n",
    "        for b in bins:\n",
    "            if len(b) > 0:\n",
    "                for i in b:\n",
    "                    if i not in temp:\n",
    "                        temp.append(i)\n",
    "        return temp\n",
    "    \n",
    "    def drop_particle(self, center, radius, atoms, profile=False):\n",
    "        if profile:\n",
    "            pr = cProfile.Profile()\n",
    "            pr.enable()\n",
    "        bins = FasterSortedSet(key=lambda position: position[1])\n",
    "        # combine the bins into one larger bin\n",
    "        fbins = self.find_bins(center, radius)\n",
    "        for b in fbins:\n",
    "            bins |= b\n",
    "        adjusted_x = center[2] * self.tantheta + center[0]\n",
    "        factor = adjusted_x // self.length\n",
    "        adjusted_x %= self.length\n",
    "        center_float = center.astype(float)\n",
    "        \n",
    "        \n",
    "        for i in range(0, len(bins)):\n",
    "            # check collision with bins[i][0]-th particle\n",
    "            particle = atoms[bins[len(bins) - i-1][0],:]\n",
    "            rs = radius + particle[4]\n",
    "                \n",
    "            x_on_particle_z = (center[2] - particle[2]) * self.tantheta + center[0] # x coordinate on z=particle[2] plane\n",
    "            factor = x_on_particle_z // self.length                   # get multiple of self.length to shift by\n",
    "            x_on_particle_z %= self.length                            # restrict x coordinate within PBC\n",
    "            \n",
    "            #center_proj_sub = np.array([x_on_particle_z, center[1], particle[2]])\n",
    "            #center_proj_height = center_float - [factor*self.length, 0, 0]\n",
    "            \n",
    "            offset = [0,0,0]\n",
    "            # offset_x, shift center nearer to account for PBC\n",
    "            #if particle[0] < rs and center_proj_sub[0] > self.length - rs:\n",
    "            if particle[0] - x_on_particle_z < -self.length/2:\n",
    "                offset[0] = -self.length\n",
    "            #elif particle[0] > self.length - rs and center_proj_sub[0] < rs:\n",
    "            elif particle[0] - x_on_particle_z > self.length/2:\n",
    "                offset[0] = self.length\n",
    "            # offset_y, shift center nearer to account for PBC\n",
    "            #if particle[1] < rs and center_proj_sub[1] > self.length - rs:\n",
    "            if particle[1] - center[1] < -self.length/2:\n",
    "                offset[1] = -self.length\n",
    "            #elif particle[1] > self.length - rs and center_proj_sub[1] < rs:\n",
    "            elif particle[1] - center[1] > self.length/2:\n",
    "                offset[1] = self.length\n",
    "            \n",
    "            #proj_x = particle[2] * self.tantheta + center[0]\n",
    "            #print('\\t{}'.format(particle[:3]))\n",
    "            \n",
    "            #d = shortest_distance_line_to_point(center_proj_height + offset, center_proj_sub+offset, particle)\n",
    "            radii2 = rs**2\n",
    "            \n",
    "            \n",
    "                \n",
    "            # rotate axes by theta degrees about y-axis into new coordinate system so that z' axis is unimportant\n",
    "            #rotx = (center_proj_height[0] - particle[0] + offset[0])*self.cos1theta + (center_proj_height[2] - particle[2])*self.sin1theta\n",
    "            #d2 = rotx**2 + (center_proj_height[1] - particle[1] + offset[1])**2\n",
    "            rotx = (center_float[0] - factor*self.length - particle[0] + offset[0])*self.cos1theta + (center_float[2] - particle[2])*self.sin1theta\n",
    "            d2 = rotx**2 + (center_float[1] - particle[1] + offset[1])**2\n",
    "            \n",
    "            if self.verbose:\n",
    "                print(\"Generated position: {}\".format(center))\n",
    "                print(\"x-coordinate in new coordinate system: {}\".format(rotx))\n",
    "                print(\"Offset: {}\".format(offset))\n",
    "                #print(\"center_proj_height + offset: {}\".format(center_proj_height+offset))\n",
    "                #print(\"center_proj_sub + offset: {}\".format(center_proj_sub+offset))\n",
    "                #print(\"Adjusted generated position: {}\".format(center_proj_height))\n",
    "                print(\"Existing particle position being considered: {}\".format(particle[:3]))\n",
    "                #print(\"Offset (if any): {}\".format(offset))\n",
    "                print(\"Minimum distance^2 between: {}\".format(d2))\n",
    "                print(\"Radii added together: {}\".format(rs))\n",
    "                \n",
    "            if radii2 > d2:\n",
    "                # it collides, calculate the new position\n",
    "                rotz = np.sqrt(radii2 - d2)\n",
    "                z = rotx*self.sin1theta + rotz*self.cos1theta + particle[2]\n",
    "                x = rotx*self.cos1theta - rotz*self.sin1theta + particle[0]\n",
    "\n",
    "                if z < radius:\n",
    "                    # if it would collide with the surface below the substrate for this particle then we can skip this particle\n",
    "                    continue\n",
    "                if self.verbose:\n",
    "                    print(\"Particles collide.\")\n",
    "                    print(\"Coordinates in new coordinate system: {}\".format([rotx, center[1], rotz]))\n",
    "                    print(\"Distance: {}\".format(np.sqrt((x - particle[0])**2 + (center[1] - particle[1])**2 + (z - particle[2])**2)))\n",
    "#                     print(\"Start: {}\".format(center_proj_height))\n",
    "#                     print(\"Start (reprojected): {}\".format(center_proj_height + offset))\n",
    "#                     print(\"Target: {}\".format(center_proj_sub))\n",
    "#                     print(\"Target (reprojected): {}\".format(center_proj_sub+offset))\n",
    "                    print(\"Collision position: {}\".format([x, center[1], z]))\n",
    "                    print(\"Colliding atom position: {}\\n\".format(particle[:3]))\n",
    "                #print(\"Hit particle: {} -> {}\".format(center, [x, center[1], z]))\n",
    "                if profile:\n",
    "                    pr.disable()\n",
    "                    p = pstats.Stats(pr)\n",
    "                    p.sort_stats('time').print_stats()\n",
    "                    #pr.print_stats()\n",
    "                return np.array([x, center[1], z]), bins[len(bins) - i-1][0]\n",
    "        x = adjusted_x - radius*self.tantheta\n",
    "        #print(\"Didn't hit particle: {} -> {}\".format(center, [x, center[1], radius]))\n",
    "        if self.verbose:\n",
    "            print(\"Particle did not collide with existing surface; landing at {}.\\n\".format([x, center[1], radius]))\n",
    "        if profile:\n",
    "            pr.disable()\n",
    "            pr.print_stats()\n",
    "        return np.array([x, center[1], radius]), -1\n",
    "        \n",
    "    def check_collision(self, center, radius, atoms):\n",
    "        if(center[2] - radius < 0):\n",
    "            return 2 # collision with substrate\n",
    "        potential_collisions = self.get_nearby_particles(center, radius)\n",
    "        if potential_collisions == []:\n",
    "            return 0 # no nearby atoms\n",
    "        for c in potential_collisions:\n",
    "            if distance3D2PBC(atoms[c,:3], center, self.length) < (atoms[c,4] + radius)**2:\n",
    "                return 3 + c # collision\n",
    "        return 1 # no collision but atoms nearby\n",
    "    \n",
    "    def calc_priority(self, position):\n",
    "        #dx = position[0] % self.bin_size\n",
    "        return position[2]#-(dx * self.sin1theta - position[2] * self.cos1theta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def follow_potential(pot_field, center, scale, L, h, distance, current_atom, lennardjones=True, deterministic=False):\n",
    "    if distance == 0:\n",
    "        return center\n",
    "    if lennardjones:\n",
    "        steps = int(round(scale*distance))\n",
    "        position = center\n",
    "        scaled_position = np.round(position * scale).astype(np.int32) % pot_field.shape[:3]\n",
    "        \n",
    "        if deterministic:\n",
    "            remaining_distance = steps\n",
    "            rads = int(round(scale*2*radius))\n",
    "            while remaining_distance > 0:\n",
    "                it = np.max([remaining_distance, rads])\n",
    "                remaining_distance -= it\n",
    "            \n",
    "                minx = scaled_position[0]-it#steps\n",
    "                if minx < 0:\n",
    "                    minx = 0\n",
    "                miny = scaled_position[1]-it#steps\n",
    "                if miny < 0:\n",
    "                    miny = 0\n",
    "                minz = scaled_position[2]-it#steps\n",
    "                if minz < int(np.ceil(scale*radius)):\n",
    "                    minz = int(np.ceil(scale*radius))\n",
    "                maxx = scaled_position[0]+it+1#steps+1\n",
    "                if maxx > pot_field.shape[0]-1:\n",
    "                    maxx = pot_field.shape[0]-1\n",
    "                maxy = scaled_position[1]+it+1#steps+1\n",
    "                if maxy > pot_field.shape[1]-1:\n",
    "                    maxy = pot_field.shape[1]-1\n",
    "                maxz = scaled_position[2]+it+1#steps+1\n",
    "\n",
    "                region = pot_field[minx:maxx, miny:maxy, minz:maxz, 3]\n",
    "                if 0 in region.shape:\n",
    "                    print(\"steps: {}\".format(steps))\n",
    "                    print(\"real position: {}\".format(position))\n",
    "                    print(\"scaled_position: {}\".format(scaled_position))\n",
    "                    print(\"pot_field.shape: {}\".format(pot_field.shape))\n",
    "                    print(\"region.shape: {}\".format(region.shape))\n",
    "                    print(\"{}->{}, {}->{}, {}->{}\".format(minx, maxx, miny, maxy, minz, maxz))\n",
    "                minimum = np.argmin(region)\n",
    "                minimum_i = np.unravel_index(minimum, region.shape)\n",
    "\n",
    "                #print(pot_field[scaled_position[0], scaled_position[1], scaled_position[2], 3], minimum_i, region[minimum_i])\n",
    "                if pot_field[scaled_position[0], scaled_position[1], scaled_position[2], 3] == region[minimum_i]:\n",
    "                    return position\n",
    "                minimum_i = np.array(minimum_i) + (minx, miny, minz)\n",
    "            return np.array(minimum_i)/np.array((scale,scale,scale)) % (L,L,np.inf)\n",
    "        \n",
    "        for i in range(steps):\n",
    "            try:\n",
    "                direction = pot_field[scaled_position[0], scaled_position[1], scaled_position[2], :3]\n",
    "            except IndexError:\n",
    "                print(position, scaled_position)\n",
    "                return position\n",
    "            # check if all zero because we stop there\n",
    "            if not np.any(direction):\n",
    "                return position % (L,L,h)\n",
    "            position = position + direction / scale\n",
    "            if position[2] < 0:\n",
    "                position[2] = 0\n",
    "            elif position[2] > h:\n",
    "                position[2] = h\n",
    "            #print(direction, position, position % (L,L,h))\n",
    "            position = position % (L,L,h)\n",
    "            scaled_position = np.round(position * scale).astype(np.int32) % pot_field.shape[:3]\n",
    "        return position % (L,L,h)\n",
    "    else:\n",
    "        k = 1\n",
    "        diameter = 1\n",
    "        position = center\n",
    "        L2 = L**2\n",
    "        step_size = 0.01\n",
    "        for d in np.arange(0, distance, step_size):\n",
    "            # get nearest neighbors within diameter radius\n",
    "            displacementx = position[0] - atom_pos[:current_atom,0]\n",
    "            displacementx = np.where(displacementx > L/2, -displacementx + L/2, displacementx)\n",
    "            displacementx = np.where(displacementx < -L/2, -displacementx - L/2, displacementx)\n",
    "            displacementy = position[1] - atom_pos[:current_atom,1]\n",
    "            displacementy = np.where(displacementy > L/2, -displacementy + L/2, displacementy)\n",
    "            displacementy = np.where(displacementy < -L/2, -displacementy - L/2, displacementy)\n",
    "            displacementz = position[2] - atom_pos[:current_atom,2]\n",
    "            distances = np.sqrt((displacementx)**2 + (displacementy)**2 + displacementz**2)\n",
    "            idx = np.argwhere(np.where(distances < diameter, distances, 0)) # indices of nearest neighbor\n",
    "            #print(d, distances.shape, distances[idx].shape)\n",
    "            distances = distances[idx]\n",
    "            displacement = np.hstack([displacementx[idx], displacementy[idx], displacementz[idx]])\n",
    "            #print(displacement.shape)\n",
    "            f = -np.sum(k * (distances - radius*2) * displacement/np.hstack([distances, distances, distances]), axis=0)\n",
    "            if not ((f[0] == -0.0 and f[1] == -0.0 and f[2] == -0.0) or np.any(np.isnan(f))):\n",
    "                position += step_size * f/np.linalg.norm(f)\n",
    "                position = position % (L,L,np.inf)\n",
    "            #print(position)\n",
    "        #print(center)\n",
    "        #print(position)\n",
    "        #print(np.hstack([displacement, atom_pos[:,0][idx], atom_pos[:,1][idx], atom_pos[:,2][idx]]))\n",
    "        return position % (L,L,np.inf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of bins: 262144\n",
      "\tBins in x-y: 4096\n",
      "\tBins to top: 64 \n",
      "Total number of bins: 64\n",
      "\tBins in x-y: 16\n",
      "\tBins to top: 4 \n",
      "Scaled:\tZero-potential point: 5.345392308842036\n",
      "\tMinimum-potential point: 6.0\n",
      "Real:\tZero-potential point: 0.2672696154421018\n",
      "\tMinimum-potential point: 0.3\n",
      "[-360.047   -0.      31.5  ] 361.4219672386004 [ 0.996  0.    -0.087]\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-13c61de2a708>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m    149\u001b[0m         \u001b[1;31m# if no collision has occured keep on flying\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    150\u001b[0m         \u001b[0mposition\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mstep_size\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0munit_vector\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 151\u001b[1;33m         \u001b[0mposition\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mposition\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m%\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mL\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mL\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    152\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    153\u001b[0m     \u001b[1;31m# time to try diffusing\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# unit length is 1 nm\n",
    "# diffusion remains to be solved\n",
    "# need both a tree (to store roots/fiber IDs) and a spacial container (to improve collision detection)\n",
    "# PBC\n",
    "np.set_printoptions(precision=3)\n",
    "reps = 8192*16\n",
    "L = 32\n",
    "height = 32\n",
    "theta = 85\n",
    "phi = 0\n",
    "turns = 0\n",
    "species = 1\n",
    "bin_size = .5\n",
    "radius = 0.15\n",
    "D = 0.45\n",
    "R = 1\n",
    "A = 1\n",
    "\n",
    "\"\"\"\n",
    "    PROCESS:\n",
    "        1) generate particle with transport angle\n",
    "        2) send towards substrate\n",
    "        3) during travel check that all particle centers in area are R1+R2 away at least\n",
    "        4) once that isn't true a collision occurred: move the particle back until there isn't a collision\n",
    "        5) diffuse the particle with a pseudo-Lennard Jones potential\n",
    "        6) add particle to particle list, tree, and spacial container\n",
    "        7) repeat a large number of times\n",
    "        \n",
    "    VISUALIZATION:\n",
    "        1) It's a point list with float locations; use any point cloud viewer to view it\n",
    "\"\"\"\n",
    "\n",
    "# setup\n",
    "atom_pos = np.zeros((reps, 6), dtype=np.float32) # x,y,z,sp,radius,fiber\n",
    "genh = height - bin_size\n",
    "bins = SpatialBins(L, height, bin_size)\n",
    "bins_big = SpatialBins(L, height, bin_size * 16)\n",
    "scale = 20\n",
    "potentials = np.zeros((L*scale, L*scale, height*scale, 4), dtype=np.float32)\n",
    "\n",
    "Vm = scale*(2*radius)\n",
    "zero_pot = Vm / 2**(1/6)\n",
    "\n",
    "if R != 1.0 and A != 1.0:\n",
    "    print(\"Scaled:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format((R/A)**(1/6)*zero_pot, (2*R/A)**(1/6)*Vm))\n",
    "    print(\"Real:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format((R/A)**(1/6)*zero_pot/scale, (2*R/A)**(1/6)*Vm/scale))\n",
    "else:\n",
    "    print(\"Scaled:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format(zero_pot, Vm))\n",
    "    print(\"Real:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format(zero_pot/scale, Vm/scale))\n",
    "diameter = 2 * scale\n",
    "if diameter % 2 == 0:\n",
    "    diameter += 1\n",
    "template = np.zeros((diameter, diameter, diameter, 4), dtype=np.float32)\n",
    "for i in range(diameter):\n",
    "    ii = i - (diameter-1) // 2\n",
    "    for j in range(diameter):\n",
    "        jj = j - (diameter-1) // 2\n",
    "        for k in range(diameter):\n",
    "            kk = k - (diameter-1) // 2\n",
    "            if ii == 0 and jj == 0 and kk == 0:\n",
    "                template[i,j,k,:] = [0,0,0,np.inf]\n",
    "            else:\n",
    "                r = np.sqrt((ii)**2 + (jj)**2 + (kk)**2)\n",
    "                magnitude = A*(zero_pot/r)**12 - R*(zero_pot/r)**6\n",
    "                direction = np.array([ii,jj,kk])/r# * magnitude/np.abs(magnitude)\n",
    "                template[i,j,k, 3] = magnitude\n",
    "                template[i,j,k,:3] = direction\n",
    "                if r > Vm:\n",
    "                    template[i,j,k,:3] *= -1\n",
    "# magnitude2 = scipy.ndimage.gaussian_gradient_magnitude(template[:,:,:,3], .9)#np.gradient(template[:,:,:,3])[2]\n",
    "# print(magnitude2.shape)\n",
    "# for i in range(diameter):\n",
    "#     for j in range(diameter):\n",
    "#         for k in range(diameter):\n",
    "#             m = magnitude2[i,j,k]\n",
    "#             if m == 0:\n",
    "#                 template[i,j,k,:] = [0,0,0,0]\n",
    "#                 pass\n",
    "#             else:\n",
    "#                 #template[i,j,k,:3] *= m/np.abs(m)\n",
    "#                 template[i,j,k, 3] = np.abs(m)\n",
    "\n",
    "\n",
    "                \n",
    "\n",
    "\n",
    "rng = np.random.default_rng()\n",
    "dests = np.hstack([rng.random(size=(reps, 2), dtype=np.float32)*L, np.zeros((reps,1), dtype=np.float32)])\n",
    "src = np.array([genh/tand(theta-90)*cosd(phi), genh/tand(theta-90)*sind(phi), genh])\n",
    "distance = distance3D(src, [0,0,0]) # distance from src to destination\n",
    "unit_vector = -src / distance # unit vector in travel direction\n",
    "print(src, distance, unit_vector)\n",
    "\n",
    "update = max((int(reps / 128), 1)) # frequency of printed updates\n",
    "current_fiber_id = 0\n",
    "\n",
    "# each particle must be treated in sequence\n",
    "#print(\"Beginning simulation\")\n",
    "endsurf = 0\n",
    "endpot = 0\n",
    "endretreat = 0\n",
    "endfly = 0\n",
    "start = time.time()\n",
    "for i in range(reps):\n",
    "    #print(\"Particle {}\".format(i+1))\n",
    "    # get destination and source point\n",
    "    startfly = time.time()\n",
    "    dest = dests[i]\n",
    "    shift = src + [dest[0], dest[1], dest[2]]\n",
    "    \n",
    "    traversed_distance = 0\n",
    "    position = shift\n",
    "    #print(\"Traversing\")\n",
    "    step_size = 0.025\n",
    "    while traversed_distance < distance:\n",
    "        # check collision with other particles first\n",
    "#         collision_b = bins_big.check_collision(position, 0.1, atom_pos)\n",
    "#         if collision_b == 0:#bins_big.are_nearby_bins_empty(position, 0.1):#0 == 0:\n",
    "#             bin_edge = bins_big.bin_edge(position, 0.1, unit_vector)\n",
    "#             if not np.any(np.isnan(bin_edge)):\n",
    "#                 position = bin_edge\n",
    "#                 step_size = 0.0250\n",
    "#         else:\n",
    "        collision = bins.check_collision(position, radius, atom_pos)\n",
    "        if collision == 0:\n",
    "            # zoop forward\n",
    "            bin_edge = bins.bin_edge(position, radius, unit_vector)\n",
    "            if not np.any(np.isnan(bin_edge)):\n",
    "                position =  bin_edge\n",
    "                step_size = 0.0250\n",
    "                #print(i, position)\n",
    "            else:\n",
    "                step_size = radius*2\n",
    "        elif collision == 1:\n",
    "            step_size = 0.0250#radius/4\n",
    "        else:\n",
    "            #print(\"\\tCOLLISION at {}\".format(position))\n",
    "            endfly += time.time() - startfly\n",
    "            startretreat = time.time()\n",
    "            collision = bins.check_collision(position, radius, atom_pos)\n",
    "            while collision > 1:\n",
    "                collision_val = collision\n",
    "                position -= 0.005 * unit_vector\n",
    "                position[:2] = position[:2] % [L,L]\n",
    "                collision = bins.check_collision(position, radius, atom_pos)\n",
    "            # we are now at the point of collision\n",
    "            endretreat += time.time() - startretreat\n",
    "            break\n",
    "        # if no collision has occured keep on flying\n",
    "        position += step_size * unit_vector\n",
    "        position[:2] = position[:2] % [L,L]\n",
    "    \n",
    "    # time to try diffusing\n",
    "    #print(\"Following potential\")\n",
    "    if D > 0.0:\n",
    "        startsurf = time.time()\n",
    "        position = follow_potential(potentials, position, scale, L, height, D, current_atom=i, lennardjones=True, deterministic=True)\n",
    "        endsurf += time.time() - startsurf\n",
    "        #print(\"Adding potential\")\n",
    "        startpot = time.time()\n",
    "        superimpose_potential(potentials, position, scale, radius, template, diameter)\n",
    "        endpot += time.time() - startpot\n",
    "    \n",
    "    #print(\"Settling atom\")\n",
    "    if not np.any(np.isnan(position)):\n",
    "        atom_pos[i,:3] = position\n",
    "        #print(\"\\tSettled at {}\".format(position))\n",
    "        atom_pos[i,3] = species\n",
    "        atom_pos[i,4] = radius\n",
    "        if collision_val == 2:\n",
    "            atom_pos[i,5] = current_fiber_id\n",
    "            current_fiber_id += 1\n",
    "        else:\n",
    "            atom_pos[i,5] = atom_pos[collision_val - 3, 5]\n",
    "        bins.add_to_bins(position, radius, i)\n",
    "        bins_big.add_to_bins(position, radius, i)\n",
    "    else:\n",
    "        print(position)\n",
    "    \n",
    "        \n",
    "    if i % update == update - 1:\n",
    "        up_time = time.time() - start\n",
    "        if i+1 > up_time:\n",
    "            print(\"{}/{} complete; {:.3f} seconds taken; {:.3f} reps per second.\".format(i+1, reps, up_time, (i+1)/up_time))\n",
    "        else:\n",
    "            print(\"{}/{} complete; {:.3f} seconds taken; {:.3f} seconds per rep.\".format(i+1, reps, up_time, up_time/(i+1)))\n",
    "end = time.time() - start\n",
    "if reps > end:\n",
    "    print(\"{} reps completed in {} seconds;\\n{} reps per second.\".format(reps, end, reps/end))\n",
    "else:\n",
    "    print(\"{} reps completed in {} seconds;\\n{} seconds per rep.\".format(reps, end, end/reps))\n",
    "print(\"{} seconds were traversal before collision.\".format(endfly))\n",
    "print(\"{} seconds were backing up from collision.\".format(endretreat))\n",
    "print(\"{} seconds were potential following.\".format(endsurf))\n",
    "print(\"{} seconds were potential addition.\".format(endpot))\n",
    "\n",
    "#warnings.filterwarnings('default', category=RuntimeWarning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "361.4219672386004\n",
      "0\n",
      "0\n",
      "[nan nan nan]\n",
      "0.3\n",
      "[30.688 11.402  0.124]\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "print(distance)\n",
    "print(traversed_distance)\n",
    "print(collision)\n",
    "print(bin_edge)\n",
    "print(step_size)\n",
    "print(position)\n",
    "print(endretreat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "''' Deposition with no flux deviation '''\n",
    "# unit length is 1 nm\n",
    "# diffusion remains to be solved\n",
    "# need both a tree (to store roots/fiber IDs) and a spacial container (to improve collision detection)\n",
    "# PBC\n",
    "np.set_printoptions(precision=3)\n",
    "reps = 8192\n",
    "L = 32\n",
    "theta = 85\n",
    "phi = 0\n",
    "turns = 0\n",
    "species = 1\n",
    "bin_size = 0.5\n",
    "radius = 0.25\n",
    "height = 64\n",
    "genh = height\n",
    "D = 3\n",
    "R = 1\n",
    "A = 1\n",
    "\n",
    "\"\"\"\n",
    "    PROCESS:\n",
    "        1) generate particle with transport angle\n",
    "        2) send towards substrate\n",
    "        3) during travel check that all particle centers in area are R1+R2 away at least\n",
    "        4) once that isn't true a collision occurred: move the particle back until there isn't a collision\n",
    "        5) diffuse the particle with a pseudo-Lennard Jones potential\n",
    "        6) add particle to particle list, tree, and spacial container\n",
    "        7) repeat a large number of times\n",
    "        \n",
    "    VISUALIZATION:\n",
    "        1) It's a point list with float locations; use any point cloud viewer to view it\n",
    "\"\"\"\n",
    "\n",
    "# setup\n",
    "atom_pos = np.zeros((reps, 6), dtype=np.float32) # x,y,z,sp,radius,fiber\n",
    "bins = Corridors(L, bin_size)\n",
    "print(bins.bins[0].clear())\n",
    "scale = 20\n",
    "potentials = np.zeros((L*scale, L*scale, height*scale, 4), dtype=np.float32)\n",
    "\n",
    "Vm = scale*(2*radius)\n",
    "zero_pot = Vm / 2**(1/6)\n",
    "\n",
    "if R != 1.0 and A != 1.0:\n",
    "    print(\"Scaled:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format((R/A)**(1/6)*zero_pot, (2*R/A)**(1/6)*Vm))\n",
    "    print(\"Real:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format((R/A)**(1/6)*zero_pot/scale, (2*R/A)**(1/6)*Vm/scale))\n",
    "else:\n",
    "    print(\"Scaled:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format(zero_pot, Vm))\n",
    "    print(\"Real:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format(zero_pot/scale, Vm/scale))\n",
    "diameter = 2 * scale\n",
    "if diameter % 2 == 0:\n",
    "    diameter += 1\n",
    "template = np.zeros((diameter, diameter, diameter, 4), dtype=np.float32)\n",
    "for i in range(diameter):\n",
    "    ii = i - (diameter-1) // 2\n",
    "    for j in range(diameter):\n",
    "        jj = j - (diameter-1) // 2\n",
    "        for k in range(diameter):\n",
    "            kk = k - (diameter-1) // 2\n",
    "            if ii == 0 and jj == 0 and kk == 0:\n",
    "                template[i,j,k,:] = [0,0,0,np.inf]\n",
    "            else:\n",
    "                r = np.sqrt((ii)**2 + (jj)**2 + (kk)**2)\n",
    "                magnitude = A*(zero_pot/r)**12 - R*(zero_pot/r)**6\n",
    "                direction = np.array([ii,jj,kk])/r# * magnitude/np.abs(magnitude)\n",
    "                template[i,j,k, 3] = magnitude\n",
    "                template[i,j,k,:3] = direction\n",
    "                if r > Vm:\n",
    "                    template[i,j,k,:3] *= -1\n",
    "                \n",
    "rng = np.random.default_rng()\n",
    "dests = np.hstack([rng.random(size=(reps, 2), dtype=np.float32)*L, np.zeros((reps,1), dtype=np.float32)])\n",
    "src = np.array([genh/tand(theta-90)*cosd(phi), genh/tand(theta-90)*sind(phi), 0])\n",
    "#distance = distance3D(src, [0,0,0]) # distance from src to destination\n",
    "#unit_vector = -src / distance # unit vector in travel direction\n",
    "#print(src, distance, unit_vector)\n",
    "\n",
    "update = max((int(reps / 128), 1)) # frequency of printed updates\n",
    "current_fiber_id = 0\n",
    "\n",
    "# each particle must be treated in sequence\n",
    "#print(\"Beginning simulation\")\n",
    "endsurf = 0\n",
    "endpot = 0\n",
    "endretreat = 0\n",
    "endfly = 0\n",
    "start = time.time()\n",
    "for i in range(reps):\n",
    "    #print(\"Particle {}\".format(i+1))\n",
    "    # get destination and source point\n",
    "    startfly = time.time()\n",
    "    dest = dests[i]\n",
    "    #shift = src + [dest[0], dest[1], dest[2]]\n",
    "    \n",
    "    #traversed_distance = 0\n",
    "    #position = shift\n",
    "    #print(\"Traversing\")\n",
    "    z, c = bins.drop_particle(dest, radius, atom_pos)\n",
    "    if z > 0:\n",
    "        position = np.array([dest[0], dest[1], z])\n",
    "    else:\n",
    "        position = np.array([dest[0], dest[1], radius])\n",
    "    \n",
    "    # time to try diffusing\n",
    "    #print(\"Following potential\")\n",
    "    if D > 0.0:\n",
    "        startsurf = time.time()\n",
    "        position = follow_potential(potentials, position, scale, L, height, D, current_atom=i, lennardjones=True, deterministic=True)\n",
    "        endsurf += time.time() - startsurf\n",
    "        #print(\"Adding potential\")\n",
    "        startpot = time.time()\n",
    "        superimpose_potential(potentials, position, scale, radius, template, diameter)\n",
    "        endpot += time.time() - startpot\n",
    "    \n",
    "    #print(\"Settling atom\")\n",
    "    if not np.any(np.isnan(position)):\n",
    "        atom_pos[i,:3] = position\n",
    "        #print(\"\\tSettled at {}\".format(position))\n",
    "        atom_pos[i,3] = species\n",
    "        atom_pos[i,4] = radius\n",
    "        if c == -1:\n",
    "            atom_pos[i,5] = current_fiber_id\n",
    "            current_fiber_id += 1\n",
    "        else:\n",
    "            atom_pos[i,5] = atom_pos[c, 5]\n",
    "        bins.add_to_bins(position, radius, i)\n",
    "    else:\n",
    "        print(position)\n",
    "    \n",
    "        \n",
    "    if i % update == update - 1:\n",
    "        up_time = time.time() - start\n",
    "        if i+1 > up_time:\n",
    "            print(\"{}/{} complete; {:.3f} seconds taken; {:.3f} reps per second.\".format(i+1, reps, up_time, (i+1)/up_time))\n",
    "        else:\n",
    "            print(\"{}/{} complete; {:.3f} seconds taken; {:.3f} seconds per rep.\".format(i+1, reps, up_time, up_time/(i+1)))\n",
    "end = time.time() - start\n",
    "if reps > end:\n",
    "    print(\"{} reps completed in {} seconds;\\n{} reps per second.\".format(reps, end, reps/end))\n",
    "else:\n",
    "    print(\"{} reps completed in {} seconds;\\n{} seconds per rep.\".format(reps, end, end/reps))\n",
    "print(\"{} seconds were traversal before collision.\".format(endfly))\n",
    "print(\"{} seconds were backing up from collision.\".format(endretreat))\n",
    "print(\"{} seconds were potential following.\".format(endsurf))\n",
    "print(\"{} seconds were potential addition.\".format(endpot))\n",
    "\n",
    "#warnings.filterwarnings('default', category=RuntimeWarning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of bins: 16\n",
      "Scaled:\tZero-potential point: 2.672696154421018\n",
      "\tMinimum-potential point: 3.0\n",
      "Real:\tZero-potential point: 0.2672696154421018\n",
      "\tMinimum-potential point: 0.3\n",
      "1024/131072 complete; 12.288 seconds taken; 83.334 reps per second.\n",
      "2048/131072 complete; 31.185 seconds taken; 65.673 reps per second.\n",
      "3072/131072 complete; 53.007 seconds taken; 57.954 reps per second.\n",
      "4096/131072 complete; 77.443 seconds taken; 52.891 reps per second.\n",
      "5120/131072 complete; 102.549 seconds taken; 49.927 reps per second.\n",
      "6144/131072 complete; 130.373 seconds taken; 47.126 reps per second.\n",
      "7168/131072 complete; 161.982 seconds taken; 44.252 reps per second.\n",
      "8192/131072 complete; 196.996 seconds taken; 41.585 reps per second.\n",
      "9216/131072 complete; 237.720 seconds taken; 38.768 reps per second.\n",
      "10240/131072 complete; 278.325 seconds taken; 36.792 reps per second.\n",
      "11264/131072 complete; 318.888 seconds taken; 35.323 reps per second.\n",
      "12288/131072 complete; 365.763 seconds taken; 33.596 reps per second.\n",
      "13312/131072 complete; 413.468 seconds taken; 32.196 reps per second.\n",
      "14336/131072 complete; 463.020 seconds taken; 30.962 reps per second.\n",
      "15360/131072 complete; 519.091 seconds taken; 29.590 reps per second.\n",
      "16384/131072 complete; 579.229 seconds taken; 28.286 reps per second.\n",
      "17408/131072 complete; 640.295 seconds taken; 27.187 reps per second.\n",
      "18432/131072 complete; 702.953 seconds taken; 26.221 reps per second.\n",
      "19456/131072 complete; 763.492 seconds taken; 25.483 reps per second.\n",
      "20480/131072 complete; 833.764 seconds taken; 24.563 reps per second.\n",
      "21504/131072 complete; 905.303 seconds taken; 23.753 reps per second.\n",
      "22528/131072 complete; 979.221 seconds taken; 23.006 reps per second.\n",
      "23552/131072 complete; 1053.591 seconds taken; 22.354 reps per second.\n",
      "24576/131072 complete; 1126.677 seconds taken; 21.813 reps per second.\n",
      "25600/131072 complete; 1204.846 seconds taken; 21.248 reps per second.\n",
      "26624/131072 complete; 1284.919 seconds taken; 20.720 reps per second.\n",
      "27648/131072 complete; 1364.402 seconds taken; 20.264 reps per second.\n",
      "28672/131072 complete; 1447.909 seconds taken; 19.802 reps per second.\n",
      "29696/131072 complete; 1533.840 seconds taken; 19.361 reps per second.\n",
      "30720/131072 complete; 1619.880 seconds taken; 18.964 reps per second.\n",
      "31744/131072 complete; 1708.433 seconds taken; 18.581 reps per second.\n",
      "32768/131072 complete; 1799.091 seconds taken; 18.214 reps per second.\n",
      "33792/131072 complete; 1891.905 seconds taken; 17.861 reps per second.\n",
      "34816/131072 complete; 1982.914 seconds taken; 17.558 reps per second.\n",
      "35840/131072 complete; 2069.470 seconds taken; 17.318 reps per second.\n",
      "36864/131072 complete; 2151.956 seconds taken; 17.130 reps per second.\n",
      "37888/131072 complete; 2236.392 seconds taken; 16.942 reps per second.\n",
      "38912/131072 complete; 2333.132 seconds taken; 16.678 reps per second.\n",
      "39936/131072 complete; 2430.457 seconds taken; 16.431 reps per second.\n",
      "40960/131072 complete; 2523.157 seconds taken; 16.234 reps per second.\n",
      "41984/131072 complete; 2614.257 seconds taken; 16.060 reps per second.\n",
      "43008/131072 complete; 2706.125 seconds taken; 15.893 reps per second.\n",
      "44032/131072 complete; 2805.407 seconds taken; 15.695 reps per second.\n",
      "45056/131072 complete; 2902.281 seconds taken; 15.524 reps per second.\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-5df63ebe0cee>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m    140\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0mD\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m0.0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    141\u001b[0m         \u001b[0mstartsurf\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 142\u001b[1;33m         \u001b[0mposition_new\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfollow_potential\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpotentials\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mposition\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mscale\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mL\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mheight\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mD\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcurrent_atom\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlennardjones\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdeterministic\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    143\u001b[0m         \u001b[0md\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdistance3DPBC\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mposition\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mposition_new\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mL\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    144\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0md\u001b[0m \u001b[1;33m>\u001b[0m \u001b[0mdmax\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-9-ec0d6e98b0e5>\u001b[0m in \u001b[0;36mfollow_potential\u001b[1;34m(pot_field, center, scale, L, h, distance, current_atom, lennardjones, deterministic)\u001b[0m\n\u001b[0;32m     39\u001b[0m                     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"region.shape: {}\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mregion\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     40\u001b[0m                     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"{}->{}, {}->{}, {}->{}\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mminx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmaxx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mminy\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmaxy\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mminz\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmaxz\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 41\u001b[1;33m                 \u001b[0mminimum\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0margmin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mregion\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     42\u001b[0m                 \u001b[0mminimum_i\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0munravel_index\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mminimum\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mregion\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     43\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<__array_function__ internals>\u001b[0m in \u001b[0;36margmin\u001b[1;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[1;32mF:\\Programs\\Anaconda3_2020.11\\envs\\pptk\\lib\\site-packages\\numpy\\core\\fromnumeric.py\u001b[0m in \u001b[0;36margmin\u001b[1;34m(a, axis, out)\u001b[0m\n\u001b[0;32m   1267\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1268\u001b[0m     \"\"\"\n\u001b[1;32m-> 1269\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0m_wrapfunc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'argmin'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mout\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1270\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1271\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mF:\\Programs\\Anaconda3_2020.11\\envs\\pptk\\lib\\site-packages\\numpy\\core\\fromnumeric.py\u001b[0m in \u001b[0;36m_wrapfunc\u001b[1;34m(obj, method, *args, **kwds)\u001b[0m\n\u001b[0;32m     56\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     57\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 58\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mbound\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     59\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     60\u001b[0m         \u001b[1;31m# A TypeError occurs if the object does have such a method in its\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "import tracemalloc\n",
    "import cProfile\n",
    "\n",
    "#tracemalloc.start()\n",
    "#pr = cProfile.Profile()\n",
    "#pr.enable()\n",
    "\n",
    "\n",
    "''' Slanted columns (no flux distribution) '''\n",
    "# unit length is 1 nm\n",
    "# diffusion remains to be solved\n",
    "# need both a tree (to store roots/fiber IDs) and a spacial container (to improve collision detection)\n",
    "# PBC\n",
    "np.set_printoptions(precision=4)\n",
    "np.seterr(all='raise')\n",
    "reps = 8192*6#32*4\n",
    "L = 32\n",
    "theta = 85\n",
    "phi = 0\n",
    "turns = 0\n",
    "species = 1\n",
    "bin_size = 8\n",
    "radius = 0.15\n",
    "height = 32\n",
    "D = 0.45\n",
    "R = 1\n",
    "A = 1\n",
    "\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "    PROCESS:\n",
    "        1) generate particle with transport angle\n",
    "        2) send towards substrate\n",
    "        3) during travel check that all particle centers in area are R1+R2 away at least\n",
    "        4) once that isn't true a collision occurred: move the particle back until there isn't a collision\n",
    "        5) diffuse the particle with a pseudo-Lennard Jones potential\n",
    "        6) add particle to particle list, tree, and spacial container\n",
    "        7) repeat a large number of times\n",
    "        \n",
    "    VISUALIZATION:\n",
    "        1) It's a point list with float locations; use any point cloud viewer to view it\n",
    "\"\"\"\n",
    "\n",
    "# setup\n",
    "atom_pos = np.zeros((reps, 7), dtype=np.float32) # x,y,z,sp,radius,fiber\n",
    "bins = SlantedCorridors(L, bin_size, theta, height, verbose=False)\n",
    "scale = 10\n",
    "potentials = np.zeros((L*scale, L*scale, height*scale, 4), dtype=np.float32)\n",
    "p = [{'L': L, \n",
    "    'theta': theta, \n",
    "    'phi': phi, \n",
    "    'H': height, \n",
    "    'D': D, \n",
    "    'R': R,\n",
    "    'A': A,\n",
    "    'turns': turns, \n",
    "    'stepper resolution': 0,\n",
    "    'species': species,\n",
    "    'radius': radius,\n",
    "    'weights': None, \n",
    "    'repetition': reps, \n",
    "    'spread': 0}]\n",
    "\n",
    "Vm = scale*(2*radius)\n",
    "zero_pot = Vm / 2**(1/6)\n",
    "\n",
    "if R != 1.0 and A != 1.0:\n",
    "    print(\"Scaled:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format((R/A)**(1/6)*zero_pot, (2*R/A)**(1/6)*Vm))\n",
    "    print(\"Real:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format((R/A)**(1/6)*zero_pot/scale, (2*R/A)**(1/6)*Vm/scale))\n",
    "else:\n",
    "    print(\"Scaled:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format(zero_pot, Vm))\n",
    "    print(\"Real:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format(zero_pot/scale, Vm/scale))\n",
    "diameter = 2 * scale\n",
    "if diameter % 2 == 0:\n",
    "    diameter += 1\n",
    "template = np.zeros((diameter, diameter, diameter, 4), dtype=np.float32)\n",
    "for i in range(diameter):\n",
    "    ii = i - (diameter-1) // 2\n",
    "    for j in range(diameter):\n",
    "        jj = j - (diameter-1) // 2\n",
    "        for k in range(diameter):\n",
    "            kk = k - (diameter-1) // 2\n",
    "            if ii == 0 and jj == 0 and kk == 0:\n",
    "                template[i,j,k,:] = [0,0,0,np.inf]\n",
    "            else:\n",
    "                r = np.sqrt((ii)**2 + (jj)**2 + (kk)**2)\n",
    "                magnitude = A*(zero_pot/r)**12 - R*(zero_pot/r)**6\n",
    "                direction = np.array([ii,jj,kk])/r# * magnitude/np.abs(magnitude)\n",
    "                template[i,j,k, 3] = magnitude\n",
    "                template[i,j,k,:3] = direction\n",
    "                if r > Vm:\n",
    "                    template[i,j,k,:3] *= -1\n",
    "                \n",
    "rng = np.random.default_rng()\n",
    "dests = np.hstack([rng.random(size=(reps, 2), dtype=np.float32)*L, np.zeros((reps,1), dtype=np.float32)+height])\n",
    "#src = np.array([genh/tand(theta-90)*cosd(phi), genh/tand(theta-90)*sind(phi), 0])\n",
    "#distance = distance3D(src, [0,0,0]) # distance from src to destination\n",
    "#unit_vector = -src / distance # unit vector in travel direction\n",
    "#print(src, distance, unit_vector)\n",
    "\n",
    "update = max((int(reps / 128), 1)) # frequency of printed updates\n",
    "current_fiber_id = 0\n",
    "\n",
    "# each particle must be treated in sequence\n",
    "#print(\"Beginning simulation\")\n",
    "endsurf = 0\n",
    "endpot = 0\n",
    "endretreat = 0\n",
    "endfly = 0\n",
    "endsettle = 0\n",
    "start = time.time()\n",
    "dmax = 0\n",
    "for i in range(reps):\n",
    "    #print(\"Particle {}\".format(i+1))\n",
    "    # get destination and source point\n",
    "    startfly = time.time()\n",
    "    dest = dests[i]\n",
    "    #shift = src + [dest[0], dest[1], dest[2]]\n",
    "    \n",
    "    #print(\"Traversing\")\n",
    "    startfly = time.time()\n",
    "    if i < reps - 1:\n",
    "        pos, c = bins.drop_particle(dest, radius, atom_pos)\n",
    "    else:\n",
    "        #pr = cProfile.Profile()\n",
    "        #pr.enable()\n",
    "        pos, c = bins.drop_particle(dest, radius, atom_pos, profile=True)\n",
    "        #pr.disable()\n",
    "    \n",
    "    position = pos % [L,L,np.inf]\n",
    "    \n",
    "    if np.any(np.isnan(position)):\n",
    "        print(position)\n",
    "    endfly += time.time() - startfly\n",
    "    #print(\"{} -> {}\".format(dest, pos))\n",
    "    \n",
    "    # time to try diffusing\n",
    "    #print(\"Following potential\")\n",
    "    if D > 0.0:\n",
    "        startsurf = time.time()\n",
    "        position_new = follow_potential(potentials, position, scale, L, height, D/2, current_atom=i, lennardjones=True, deterministic=True)\n",
    "        d = distance3DPBC(position, position_new, L)\n",
    "        if d > dmax:\n",
    "            dmax = d\n",
    "#         if d > D:\n",
    "#             print(\"Former position: {}\".format(position))\n",
    "#             print(\"New position: {}\".format(position_new))\n",
    "#             print(\"Distance: {}\".format(d))\n",
    "        position = position_new\n",
    "        endsurf += time.time() - startsurf\n",
    "        #print(\"Adding potential\")\n",
    "        startpot = time.time()\n",
    "        superimpose_potential(potentials, position, scale, radius, template, diameter)\n",
    "        endpot += time.time() - startpot\n",
    "    \n",
    "    #print(\"Settling atom\")\n",
    "    startsettle = time.time()\n",
    "    if not np.any(np.isnan(position)):\n",
    "        atom_pos[i,:3] = position\n",
    "        #print(\"\\tSettled at {}\".format(position))\n",
    "        atom_pos[i,3] = species\n",
    "        atom_pos[i,4] = radius\n",
    "        \n",
    "#         atom_pos[i+reps//2,:3] = dest / np.array([1,1,2])\n",
    "#         atom_pos[i+reps//2,3] = species\n",
    "#         atom_pos[i,4] = radius\n",
    "#         atom_pos[i+reps,:3] = dest / np.array([1,1,4])\n",
    "#         atom_pos[i+reps,3] = species\n",
    "#         atom_pos[i,4] = radius\n",
    "        \n",
    "        if c == -1:\n",
    "            atom_pos[i,5] = current_fiber_id\n",
    "            current_fiber_id += 1\n",
    "        else:\n",
    "            atom_pos[i,5] = atom_pos[c, 5]\n",
    "        #print(position, radius, i)\n",
    "        bins.add_to_bins(position, radius, i)\n",
    "    else:\n",
    "        print(position)\n",
    "    endsettle += time.time() - startsettle\n",
    "    \n",
    "        \n",
    "    if i % update == update - 1:\n",
    "        up_time = time.time() - start\n",
    "        if i+1 > up_time:\n",
    "            print(\"{}/{} complete; {:.3f} seconds taken; {:.3f} reps per second.\".format(i+1, reps, up_time, (i+1)/up_time))\n",
    "        else:\n",
    "            print(\"{}/{} complete; {:.3f} seconds taken; {:.3f} seconds per rep.\".format(i+1, reps, up_time, up_time/(i+1)))\n",
    "end = time.time() - start\n",
    "if reps > end:\n",
    "    print(\"{} reps completed in {} seconds;\\n{} reps per second.\".format(reps, end, reps/end))\n",
    "else:\n",
    "    print(\"{} reps completed in {} seconds;\\n{} seconds per rep.\".format(reps, end, end/reps))\n",
    "print(\"{} seconds were traversal and collision.\".format(endfly))\n",
    "print(\"{} seconds were potential following.\".format(endsurf))\n",
    "print(\"{} seconds were potential addition.\".format(endpot))\n",
    "print(\"{} seconds were adding to collections.\".format(endsettle))\n",
    "for i in range(atom_pos.shape[0]):\n",
    "    atom_pos[i, 6] = bins.find_bin_idx(atom_pos[i, :3])\n",
    "#warnings.filterwarnings('default', category=RuntimeWarning)\n",
    "print(\"Maximum diffusion distance: {}\".format(dmax))\n",
    "\n",
    "p[0]['time'] = end\n",
    "#pr.disable()\n",
    "saveContinuum(atom_pos, p, \"Si\", zipped=True)\n",
    "\n",
    "# snapshot = tracemalloc.take_snapshot()\n",
    "# top_stats = snapshot.statistics('lineno')\n",
    "# for stat in top_stats[:10]:\n",
    "#     print(stat)\n",
    "# pr.print_stats()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12288, 7)\n",
      "Scaled:\tZero-potential point: 8.908987181403393\n",
      "\tMinimum-potential point: 10.0\n",
      "Real:\tZero-potential point: 0.8908987181403394\n",
      "\tMinimum-potential point: 1.0\n",
      "Scaled:\tZero-potential point: 2.672696154421018\n",
      "\tMinimum-potential point: 3.0\n",
      "Real:\tZero-potential point: 0.2672696154421018\n",
      "\tMinimum-potential point: 0.3\n",
      "32/4096 complete; 4.625 seconds taken; 6.919 reps per second.\n",
      "64/4096 complete; 7.388 seconds taken; 8.663 reps per second.\n",
      "96/4096 complete; 10.676 seconds taken; 8.992 reps per second.\n",
      "128/4096 complete; 14.701 seconds taken; 8.707 reps per second.\n",
      "160/4096 complete; 18.321 seconds taken; 8.733 reps per second.\n",
      "192/4096 complete; 22.199 seconds taken; 8.649 reps per second.\n",
      "224/4096 complete; 26.410 seconds taken; 8.482 reps per second.\n",
      "256/4096 complete; 30.200 seconds taken; 8.477 reps per second.\n",
      "288/4096 complete; 33.099 seconds taken; 8.701 reps per second.\n",
      "320/4096 complete; 37.261 seconds taken; 8.588 reps per second.\n",
      "352/4096 complete; 41.073 seconds taken; 8.570 reps per second.\n",
      "384/4096 complete; 43.948 seconds taken; 8.738 reps per second.\n",
      "416/4096 complete; 47.441 seconds taken; 8.769 reps per second.\n",
      "448/4096 complete; 50.513 seconds taken; 8.869 reps per second.\n",
      "480/4096 complete; 54.674 seconds taken; 8.779 reps per second.\n",
      "512/4096 complete; 57.836 seconds taken; 8.853 reps per second.\n",
      "544/4096 complete; 61.440 seconds taken; 8.854 reps per second.\n",
      "576/4096 complete; 64.539 seconds taken; 8.925 reps per second.\n",
      "608/4096 complete; 68.740 seconds taken; 8.845 reps per second.\n",
      "640/4096 complete; 71.515 seconds taken; 8.949 reps per second.\n",
      "672/4096 complete; 74.944 seconds taken; 8.967 reps per second.\n",
      "704/4096 complete; 79.252 seconds taken; 8.883 reps per second.\n",
      "736/4096 complete; 84.576 seconds taken; 8.702 reps per second.\n",
      "768/4096 complete; 88.128 seconds taken; 8.715 reps per second.\n",
      "800/4096 complete; 92.222 seconds taken; 8.675 reps per second.\n",
      "832/4096 complete; 95.623 seconds taken; 8.701 reps per second.\n",
      "864/4096 complete; 98.747 seconds taken; 8.750 reps per second.\n",
      "896/4096 complete; 102.602 seconds taken; 8.733 reps per second.\n",
      "928/4096 complete; 105.186 seconds taken; 8.822 reps per second.\n",
      "960/4096 complete; 108.424 seconds taken; 8.854 reps per second.\n",
      "992/4096 complete; 111.840 seconds taken; 8.870 reps per second.\n",
      "1024/4096 complete; 115.685 seconds taken; 8.852 reps per second.\n",
      "1056/4096 complete; 118.781 seconds taken; 8.890 reps per second.\n",
      "1088/4096 complete; 122.921 seconds taken; 8.851 reps per second.\n",
      "1120/4096 complete; 126.966 seconds taken; 8.821 reps per second.\n",
      "1152/4096 complete; 130.932 seconds taken; 8.798 reps per second.\n",
      "1184/4096 complete; 134.136 seconds taken; 8.827 reps per second.\n",
      "1216/4096 complete; 138.974 seconds taken; 8.750 reps per second.\n",
      "1248/4096 complete; 142.580 seconds taken; 8.753 reps per second.\n",
      "1280/4096 complete; 146.555 seconds taken; 8.734 reps per second.\n",
      "1312/4096 complete; 149.686 seconds taken; 8.765 reps per second.\n",
      "1344/4096 complete; 153.948 seconds taken; 8.730 reps per second.\n",
      "1376/4096 complete; 158.799 seconds taken; 8.665 reps per second.\n",
      "1408/4096 complete; 163.490 seconds taken; 8.612 reps per second.\n",
      "1440/4096 complete; 167.293 seconds taken; 8.608 reps per second.\n",
      "1472/4096 complete; 171.450 seconds taken; 8.586 reps per second.\n",
      "1504/4096 complete; 174.456 seconds taken; 8.621 reps per second.\n",
      "1536/4096 complete; 178.613 seconds taken; 8.600 reps per second.\n",
      "1568/4096 complete; 183.943 seconds taken; 8.524 reps per second.\n",
      "1600/4096 complete; 188.688 seconds taken; 8.480 reps per second.\n",
      "1632/4096 complete; 192.841 seconds taken; 8.463 reps per second.\n",
      "1664/4096 complete; 196.748 seconds taken; 8.458 reps per second.\n",
      "1696/4096 complete; 200.992 seconds taken; 8.438 reps per second.\n",
      "1728/4096 complete; 205.948 seconds taken; 8.390 reps per second.\n",
      "1760/4096 complete; 209.263 seconds taken; 8.410 reps per second.\n",
      "1792/4096 complete; 214.398 seconds taken; 8.358 reps per second.\n",
      "1824/4096 complete; 219.131 seconds taken; 8.324 reps per second.\n",
      "1856/4096 complete; 222.068 seconds taken; 8.358 reps per second.\n",
      "1888/4096 complete; 226.093 seconds taken; 8.351 reps per second.\n",
      "1920/4096 complete; 230.442 seconds taken; 8.332 reps per second.\n",
      "1952/4096 complete; 234.529 seconds taken; 8.323 reps per second.\n",
      "1984/4096 complete; 240.100 seconds taken; 8.263 reps per second.\n",
      "2016/4096 complete; 243.464 seconds taken; 8.280 reps per second.\n",
      "2048/4096 complete; 247.832 seconds taken; 8.264 reps per second.\n",
      "2080/4096 complete; 252.677 seconds taken; 8.232 reps per second.\n",
      "2112/4096 complete; 258.801 seconds taken; 8.161 reps per second.\n",
      "2144/4096 complete; 263.491 seconds taken; 8.137 reps per second.\n",
      "2176/4096 complete; 269.088 seconds taken; 8.087 reps per second.\n",
      "2208/4096 complete; 275.153 seconds taken; 8.025 reps per second.\n",
      "2240/4096 complete; 279.517 seconds taken; 8.014 reps per second.\n",
      "2272/4096 complete; 283.667 seconds taken; 8.009 reps per second.\n",
      "2304/4096 complete; 287.439 seconds taken; 8.016 reps per second.\n",
      "2336/4096 complete; 292.344 seconds taken; 7.991 reps per second.\n",
      "2368/4096 complete; 297.011 seconds taken; 7.973 reps per second.\n",
      "2400/4096 complete; 301.277 seconds taken; 7.966 reps per second.\n",
      "2432/4096 complete; 306.184 seconds taken; 7.943 reps per second.\n",
      "2464/4096 complete; 312.332 seconds taken; 7.889 reps per second.\n",
      "2496/4096 complete; 317.076 seconds taken; 7.872 reps per second.\n",
      "2528/4096 complete; 322.338 seconds taken; 7.843 reps per second.\n",
      "2560/4096 complete; 327.949 seconds taken; 7.806 reps per second.\n",
      "2592/4096 complete; 332.166 seconds taken; 7.803 reps per second.\n",
      "2624/4096 complete; 335.482 seconds taken; 7.822 reps per second.\n",
      "2656/4096 complete; 339.196 seconds taken; 7.830 reps per second.\n",
      "2688/4096 complete; 344.599 seconds taken; 7.800 reps per second.\n",
      "2720/4096 complete; 348.965 seconds taken; 7.794 reps per second.\n",
      "2752/4096 complete; 352.933 seconds taken; 7.798 reps per second.\n",
      "2784/4096 complete; 359.310 seconds taken; 7.748 reps per second.\n",
      "2816/4096 complete; 363.923 seconds taken; 7.738 reps per second.\n",
      "2848/4096 complete; 370.931 seconds taken; 7.678 reps per second.\n",
      "2880/4096 complete; 375.022 seconds taken; 7.680 reps per second.\n",
      "2912/4096 complete; 378.926 seconds taken; 7.685 reps per second.\n",
      "2944/4096 complete; 384.254 seconds taken; 7.662 reps per second.\n",
      "2976/4096 complete; 389.493 seconds taken; 7.641 reps per second.\n",
      "3008/4096 complete; 394.040 seconds taken; 7.634 reps per second.\n",
      "3040/4096 complete; 399.347 seconds taken; 7.612 reps per second.\n",
      "3072/4096 complete; 405.277 seconds taken; 7.580 reps per second.\n",
      "3104/4096 complete; 410.160 seconds taken; 7.568 reps per second.\n",
      "3136/4096 complete; 414.668 seconds taken; 7.563 reps per second.\n",
      "3168/4096 complete; 419.975 seconds taken; 7.543 reps per second.\n",
      "3200/4096 complete; 424.880 seconds taken; 7.532 reps per second.\n",
      "3232/4096 complete; 430.597 seconds taken; 7.506 reps per second.\n",
      "3264/4096 complete; 435.036 seconds taken; 7.503 reps per second.\n",
      "3296/4096 complete; 439.424 seconds taken; 7.501 reps per second.\n",
      "3328/4096 complete; 444.993 seconds taken; 7.479 reps per second.\n",
      "3360/4096 complete; 448.880 seconds taken; 7.485 reps per second.\n",
      "3392/4096 complete; 454.950 seconds taken; 7.456 reps per second.\n",
      "3424/4096 complete; 458.951 seconds taken; 7.460 reps per second.\n",
      "3456/4096 complete; 464.519 seconds taken; 7.440 reps per second.\n",
      "3488/4096 complete; 471.841 seconds taken; 7.392 reps per second.\n",
      "3520/4096 complete; 476.953 seconds taken; 7.380 reps per second.\n",
      "3552/4096 complete; 482.575 seconds taken; 7.361 reps per second.\n",
      "3584/4096 complete; 486.550 seconds taken; 7.366 reps per second.\n",
      "3616/4096 complete; 491.424 seconds taken; 7.358 reps per second.\n",
      "3648/4096 complete; 497.009 seconds taken; 7.340 reps per second.\n",
      "3680/4096 complete; 501.830 seconds taken; 7.333 reps per second.\n",
      "3712/4096 complete; 506.544 seconds taken; 7.328 reps per second.\n",
      "3744/4096 complete; 511.334 seconds taken; 7.322 reps per second.\n",
      "3776/4096 complete; 515.990 seconds taken; 7.318 reps per second.\n",
      "3808/4096 complete; 521.049 seconds taken; 7.308 reps per second.\n",
      "3840/4096 complete; 526.368 seconds taken; 7.295 reps per second.\n",
      "3872/4096 complete; 532.044 seconds taken; 7.278 reps per second.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3904/4096 complete; 539.021 seconds taken; 7.243 reps per second.\n",
      "3936/4096 complete; 544.917 seconds taken; 7.223 reps per second.\n",
      "3968/4096 complete; 550.915 seconds taken; 7.203 reps per second.\n",
      "4000/4096 complete; 556.014 seconds taken; 7.194 reps per second.\n",
      "4032/4096 complete; 561.204 seconds taken; 7.185 reps per second.\n",
      "4064/4096 complete; 565.684 seconds taken; 7.184 reps per second.\n",
      "4096/4096 complete; 572.365 seconds taken; 7.156 reps per second.\n",
      "4096 reps completed in 572.3645122051239 seconds;\n",
      "7.156278757080027 reps per second.\n",
      "568.0283143520355 seconds were traversal before collision.\n",
      "0 seconds were backing up from collision.\n",
      "1.417893648147583 seconds were potential following.\n",
      "1.127650260925293 seconds were potential addition.\n",
      "Maximum diffusion distance: 1.39283042306373\n",
      "<ipython-input-19-f41945e94c79>:21: size=500 MiB, count=2, average=250 MiB\n",
      "<ipython-input-17-8a5290a39cf2>:48: size=500 MiB, count=2, average=250 MiB\n",
      "F:\\Programs\\Anaconda3_2020.11\\envs\\pptk\\lib\\site-packages\\sortedcontainers\\sortedset.py:685: size=8192 KiB, count=4, average=2048 KiB\n",
      "<__array_function__ internals>:6: size=4131 KiB, count=29, average=142 KiB\n",
      "F:\\Programs\\Anaconda3_2020.11\\envs\\pptk\\lib\\site-packages\\numpy\\lib\\format.py:754: size=3584 KiB, count=2, average=1792 KiB\n",
      "F:\\Programs\\Anaconda3_2020.11\\envs\\pptk\\lib\\site-packages\\numpy\\core\\fromnumeric.py:55: size=1309 KiB, count=20942, average=64 B\n",
      "F:\\Programs\\Anaconda3_2020.11\\envs\\pptk\\lib\\site-packages\\sortedcontainers\\sortedlist.py:1895: size=1235 KiB, count=346, average=3654 B\n",
      "F:\\Programs\\Anaconda3_2020.11\\envs\\pptk\\lib\\site-packages\\sortedcontainers\\sortedlist.py:1894: size=1164 KiB, count=316, average=3771 B\n",
      "<ipython-input-8-146cd9f2c46b>:253: size=672 KiB, count=28672, average=24 B\n",
      "F:\\Programs\\Anaconda3_2020.11\\envs\\pptk\\lib\\site-packages\\sortedcontainers\\sortedset.py:358: size=512 KiB, count=4, average=128 KiB\n",
      "         126222647 function calls (121617432 primitive calls) in 630.479 seconds\n",
      "\n",
      "   Ordered by: standard name\n",
      "\n",
      "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)\n",
      "     8193    0.014    0.000    0.248    0.000 <__array_function__ internals>:2(amax)\n",
      "    16384    0.031    0.000    0.358    0.000 <__array_function__ internals>:2(any)\n",
      "     8192    0.012    0.000    0.324    0.000 <__array_function__ internals>:2(argmin)\n",
      "    32768    0.031    0.000    0.610    0.000 <__array_function__ internals>:2(around)\n",
      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:2(atleast_1d)\n",
      "        2    0.000    0.000    0.000    0.000 <__array_function__ internals>:2(concatenate)\n",
      "        1    0.000    0.000    0.000    0.000 <__array_function__ internals>:2(hstack)\n",
      "    32768    0.033    0.000    0.702    0.000 <__array_function__ internals>:2(round_)\n",
      "     8192    0.012    0.000    0.133    0.000 <__array_function__ internals>:2(unravel_index)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:101(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:102(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:106(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:107(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:108(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:109(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:110(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:111(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:112(<module>)\n",
      "        1    1.580    1.580  629.758  629.758 <ipython-input-18-ee85edcb3c11>:113(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:13(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:14(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:15(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:16(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:17(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:18(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:181(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:182(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:186(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:187(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:188(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:189(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:19(<module>)\n",
      "        1    0.026    0.026    0.334    0.334 <ipython-input-18-ee85edcb3c11>:190(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:193(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:195(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:196(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:20(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:21(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:22(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:23(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:24(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:25(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:26(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:42(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:45(<module>)\n",
      "        1    0.001    0.001    0.001    0.001 <ipython-input-18-ee85edcb3c11>:46(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:47(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:48(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:49(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:64(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:65(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:67(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:73(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:74(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:76(<module>)\n",
      "        1    0.327    0.327    0.379    0.379 <ipython-input-18-ee85edcb3c11>:77(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:8(<module>)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-18-ee85edcb3c11>:94(<module>)\n",
      "        1    0.000    0.000    0.001    0.001 <ipython-input-18-ee85edcb3c11>:95(<module>)\n",
      "     8192    0.264    0.000    0.264    0.000 <ipython-input-5-5e597418988a>:4(distance3DPBC)\n",
      "     8192  501.190    0.061  619.855    0.076 <ipython-input-8-146cd9f2c46b>:150(drop_particle)\n",
      " 67100672    5.239    0.000    5.239    0.000 <ipython-input-8-146cd9f2c46b>:151(<lambda>)\n",
      "     8192    0.003    0.000    0.003    0.000 <ipython-input-8-146cd9f2c46b>:18(<lambda>)\n",
      "   147456    3.668    0.000    3.668    0.000 <ipython-input-8-146cd9f2c46b>:23(find_bin)\n",
      "     8192    0.008    0.000    0.008    0.000 <ipython-input-8-146cd9f2c46b>:251(calc_priority)\n",
      "     8192    0.031    0.000    3.404    0.000 <ipython-input-8-146cd9f2c46b>:37(add_to_bins)\n",
      "        1    0.000    0.000    0.000    0.000 <ipython-input-8-146cd9f2c46b>:4(__init__)\n",
      "    16384    2.234    0.000    6.639    0.000 <ipython-input-8-146cd9f2c46b>:45(find_bins)\n",
      "     8192    0.308    0.000    0.308    0.000 <ipython-input-8-146cd9f2c46b>:83(find_bin_idx)\n",
      "     8192    0.937    0.000    1.952    0.000 <ipython-input-9-ec0d6e98b0e5>:1(follow_potential)\n",
      "    24576    0.011    0.000    0.100    0.000 _asarray.py:14(asarray)\n",
      "        2    0.000    0.000    0.000    0.000 _asarray.py:86(asanyarray)\n",
      "        3    0.000    0.000    0.000    0.000 _ufunc_config.py:132(geterr)\n",
      "        3    0.000    0.000    0.000    0.000 _ufunc_config.py:32(seterr)\n",
      "        1    0.000    0.000    0.000    0.000 _ufunc_config.py:433(__enter__)\n",
      "        1    0.000    0.000    0.000    0.000 _ufunc_config.py:438(__exit__)\n",
      "        2    0.000    0.000    0.000    0.000 _weakrefset.py:70(__contains__)\n",
      "        1    0.000    0.000    0.000    0.000 abc.py:180(__instancecheck__)\n",
      "        1    0.000    0.000    0.000    0.000 arrayprint.py:60(_make_options_dict)\n",
      "        1    0.000    0.000    0.000    0.000 arrayprint.py:65(<dictcomp>)\n",
      "        1    0.000    0.000    0.000    0.000 arrayprint.py:91(set_printoptions)\n",
      "       50    0.000    0.000    0.003    0.000 codeop.py:132(__call__)\n",
      "      100    0.000    0.000    0.000    0.000 compilerop.py:138(extra_flags)\n",
      "       50    0.000    0.000    0.000    0.000 contextlib.py:157(helper)\n",
      "        1    0.000    0.000    0.000    0.000 contextlib.py:36(_recreate_cm)\n",
      "        1    0.000    0.000    0.000    0.000 contextlib.py:49(inner)\n",
      "       50    0.000    0.000    0.000    0.000 contextlib.py:59(__init__)\n",
      "       50    0.000    0.000    0.000    0.000 contextlib.py:79(__enter__)\n",
      "       50    0.000    0.000    0.000    0.000 contextlib.py:85(__exit__)\n",
      "     8192    0.002    0.000    0.002    0.000 fromnumeric.py:1191(_argmin_dispatcher)\n",
      "     8192    0.011    0.000    0.301    0.000 fromnumeric.py:1195(argmin)\n",
      "    16384    0.005    0.000    0.005    0.000 fromnumeric.py:2245(_any_dispatcher)\n",
      "    16384    0.035    0.000    0.303    0.000 fromnumeric.py:2249(any)\n",
      "     8193    0.002    0.000    0.002    0.000 fromnumeric.py:2584(_amax_dispatcher)\n",
      "     8193    0.021    0.000    0.223    0.000 fromnumeric.py:2589(amax)\n",
      "    65536    0.011    0.000    0.011    0.000 fromnumeric.py:3164(_around_dispatcher)\n",
      "    32768    0.034    0.000    0.552    0.000 fromnumeric.py:3168(around)\n",
      "    32768    0.029    0.000    0.639    0.000 fromnumeric.py:3628(round_)\n",
      "    24576    0.118    0.000    0.329    0.000 fromnumeric.py:39(_wrapit)\n",
      "    40960    0.077    0.000    0.807    0.000 fromnumeric.py:52(_wrapfunc)\n",
      "    24577    0.134    0.000    0.470    0.000 fromnumeric.py:70(_wrapreduction)\n",
      "    24577    0.023    0.000    0.023    0.000 fromnumeric.py:71(<dictcomp>)\n",
      "       50    0.000    0.000    0.000    0.000 hooks.py:103(__call__)\n",
      "       50    0.000    0.000    0.000    0.000 hooks.py:168(pre_run_code_hook)\n",
      "       50    0.000    0.000    0.000    0.000 interactiveshell.py:117(<lambda>)\n",
      "       50    0.000    0.000    0.000    0.000 interactiveshell.py:1276(user_global_ns)\n",
      "       50    0.000    0.000    0.000    0.000 interactiveshell.py:3244(compare)\n",
      "       50    0.000    0.000  630.475   12.610 interactiveshell.py:3302(run_code)\n",
      "      404    0.002    0.000    0.011    0.000 iostream.py:195(schedule)\n",
      "      274    0.000    0.000    0.001    0.000 iostream.py:308(_is_master_process)\n",
      "      274    0.000    0.000    0.002    0.000 iostream.py:321(_schedule_flush)\n",
      "      274    0.002    0.000    0.014    0.000 iostream.py:384(write)\n",
      "      404    0.000    0.000    0.000    0.000 iostream.py:91(_event_pipe)\n",
      "       50    0.000    0.000    0.000    0.000 ipstruct.py:125(__getattr__)\n",
      "        2    0.000    0.000    0.000    0.000 multiarray.py:143(concatenate)\n",
      "     8192    0.004    0.000    0.004    0.000 multiarray.py:990(unravel_index)\n",
      "        1    0.000    0.000    0.000    0.000 random.py:680(getrandbits)\n",
      "        1    0.000    0.000    0.000    0.000 shape_base.py:20(_atleast_1d_dispatcher)\n",
      "        1    0.000    0.000    0.000    0.000 shape_base.py:208(_arrays_for_stack_dispatcher)\n",
      "        1    0.000    0.000    0.000    0.000 shape_base.py:219(_vhstack_dispatcher)\n",
      "        1    0.000    0.000    0.000    0.000 shape_base.py:24(atleast_1d)\n",
      "        1    0.000    0.000    0.000    0.000 shape_base.py:286(hstack)\n",
      "      404    0.008    0.000    0.008    0.000 socket.py:480(send)\n",
      "     8193    0.037    0.000    0.216    0.000 sortedlist.py:1716(__init__)\n",
      "     8193    0.009    0.000    0.019    0.000 sortedlist.py:174(__new__)\n",
      "     8191    0.020    0.000    0.020    0.000 sortedlist.py:1763(clear)\n",
      "     8192    0.052    0.000    0.121    0.000 sortedlist.py:1778(add)\n",
      "     8191    0.018    0.000    0.022    0.000 sortedlist.py:1822(_expand)\n",
      "    16384    0.195    0.000   25.322    0.002 sortedlist.py:1861(update)\n",
      "    54103    0.152    0.000    0.152    0.000 sortedlist.py:1893(<genexpr>)\n",
      "    54103    5.728    0.000    8.385    0.000 sortedlist.py:1895(<genexpr>)\n",
      "    54103    0.010    0.000    0.010    0.000 sortedlist.py:1896(<genexpr>)\n",
      "  4045987   15.272    0.000   17.287    0.000 sortedlist.py:601(_pos)\n",
      "     7191    0.196    0.000    0.248    0.000 sortedlist.py:695(_build_index)\n",
      "  4564253   12.327    0.000   34.032    0.000 sortedlist.py:816(__getitem__)\n",
      "     8192    0.011    0.000    0.023    0.000 sortedlist.py:920(__iter__)\n",
      "     8193    0.094    0.000    0.348    0.000 sortedset.py:108(__init__)\n",
      "  4564253    5.996    0.000   40.028    0.000 sortedset.py:212(__getitem__)\n",
      "  4572445    1.727    0.000    3.798    0.000 sortedset.py:306(__len__)\n",
      "     8192    0.004    0.000    0.035    0.000 sortedset.py:317(__iter__)\n",
      "     8192    0.028    0.000    0.153    0.000 sortedset.py:341(add)\n",
      "     8192    3.996    0.000   29.769    0.004 sortedset.py:664(update)\n",
      "      404    0.000    0.000    0.001    0.000 threading.py:1062(_wait_for_tstate_lock)\n",
      "      404    0.001    0.000    0.002    0.000 threading.py:1104(is_alive)\n",
      "      404    0.000    0.000    0.000    0.000 threading.py:506(is_set)\n",
      "       50    0.000    0.000    0.000    0.000 traitlets.py:526(get)\n",
      "       50    0.000    0.000    0.000    0.000 traitlets.py:545(__get__)\n",
      "        1    0.000    0.000    0.000    0.000 utils.py:13(sind)\n",
      "        1    0.000    0.000    0.000    0.000 utils.py:17(tand)\n",
      "        1    0.000    0.000    0.000    0.000 utils.py:9(cosd)\n",
      "     8192    1.745    0.000    2.313    0.000 {_cython_magic_043324f90284f01e4f6f52929c21adec.superimpose_potential}\n",
      "     8193    0.010    0.000    0.010    0.000 {built-in method __new__ of type object at 0x0000000052CD2A00}\n",
      "    16230    0.026    0.000    0.026    0.000 {built-in method _bisect.bisect_right}\n",
      "     6191    0.016    0.000    0.016    0.000 {built-in method _functools.reduce}\n",
      "       50    0.002    0.000    0.002    0.000 {built-in method builtins.compile}\n",
      "       50    0.000    0.000  630.475   12.609 {built-in method builtins.exec}\n",
      "    73828    0.096    0.000    0.096    0.000 {built-in method builtins.getattr}\n",
      "     8194    0.019    0.000    0.019    0.000 {built-in method builtins.hasattr}\n",
      "  4564528    1.358    0.000    1.358    0.000 {built-in method builtins.isinstance}\n",
      "    43720    0.022    0.000    0.045    0.000 {built-in method builtins.iter}\n",
      "25962746/21390301   12.422    0.000   14.149    0.000 {built-in method builtins.len}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method builtins.locals}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method builtins.max}\n",
      "      100    0.000    0.000    0.000    0.000 {built-in method builtins.next}\n",
      "      137    0.001    0.000    0.015    0.000 {built-in method builtins.print}\n",
      "    16384    0.040    0.000    0.040    0.000 {built-in method builtins.round}\n",
      "    16384   13.886    0.001   16.468    0.001 {built-in method builtins.sorted}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method from_bytes}\n",
      "     8192    0.012    0.000    0.012    0.000 {built-in method from_iterable}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method math.cos}\n",
      "     6191    0.008    0.000    0.008    0.000 {built-in method math.log}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method math.sin}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method math.tan}\n",
      "      274    0.000    0.000    0.000    0.000 {built-in method nt.getpid}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method nt.urandom}\n",
      "  4753568   29.350    0.000   29.350    0.000 {built-in method numpy.array}\n",
      "106501/73731    0.201    0.000    1.644    0.000 {built-in method numpy.core._multiarray_umath.implement_array_function}\n",
      "        1    0.000    0.000    0.000    0.000 {built-in method numpy.core._multiarray_umath.set_legacy_print_mode}\n",
      "        6    0.000    0.000    0.000    0.000 {built-in method numpy.geterrobj}\n",
      "        3    0.000    0.000    0.000    0.000 {built-in method numpy.seterrobj}\n",
      "        4    0.000    0.000    0.000    0.000 {built-in method numpy.zeros}\n",
      "    73858    0.017    0.000    0.017    0.000 {built-in method time.time}\n",
      "      404    0.000    0.000    0.000    0.000 {method 'acquire' of '_thread.lock' objects}\n",
      "     8192    0.004    0.000    0.004    0.000 {method 'add' of 'set' objects}\n",
      "      404    0.000    0.000    0.000    0.000 {method 'append' of 'collections.deque' objects}\n",
      "    14073    0.005    0.000    0.005    0.000 {method 'append' of 'list' objects}\n",
      "     8192    0.279    0.000    0.279    0.000 {method 'argmin' of 'numpy.ndarray' objects}\n",
      "  4564865    7.463    0.000    7.463    0.000 {method 'astype' of 'numpy.ndarray' objects}\n",
      "        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}\n",
      "    55343    0.104    0.000    8.651    0.000 {method 'extend' of 'list' objects}\n",
      "      137    0.001    0.000    0.001    0.000 {method 'format' of 'str' objects}\n",
      "    16093    0.016    0.000    0.016    0.000 {method 'insert' of 'list' objects}\n",
      "    24578    0.014    0.000    0.014    0.000 {method 'items' of 'dict' objects}\n",
      "        1    0.001    0.001    0.001    0.001 {method 'random' of 'numpy.random._generator.Generator' objects}\n",
      "    24577    0.281    0.000    0.281    0.000 {method 'reduce' of 'numpy.ufunc' objects}\n",
      "    32768    0.155    0.000    0.155    0.000 {method 'round' of 'numpy.ndarray' objects}\n",
      "        1    0.000    0.000    0.000    0.000 {method 'update' of 'dict' objects}\n",
      "     8191    0.569    0.000    0.569    0.000 {method 'update' of 'set' objects}\n",
      "        1    0.000    0.000    0.000    0.000 {numpy.random._generator.default_rng}\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import tracemalloc\n",
    "import cProfile\n",
    "\n",
    "tracemalloc.start()\n",
    "\n",
    "pr = cProfile.Profile()\n",
    "pr.enable()\n",
    "\n",
    "atoms, deposited, p = loadContinuum('STF_Si_L48_Th85_D0.45_N131072_1672876042' + '.npz')\n",
    "reps2 = 8192//2#reps//8\n",
    "atom_pos = np.vstack([atom_pos[:reps,:], np.zeros((reps2, atom_pos.shape[1]), dtype=np.float32)])\n",
    "print(atom_pos.shape)\n",
    "species = 2\n",
    "radius = 0.15\n",
    "\n",
    "D = 1.5\n",
    "p.append(p[0])\n",
    "p[1]['repetition'] = reps2\n",
    "p[1]['D'] = D\n",
    "p[1]['species'] = species\n",
    "p[1]['radius'] = radius\n",
    "\n",
    "''' Do potentials twice, once for each species '''\n",
    "potentials = np.zeros((L*scale, L*scale, height*scale, 4), dtype=np.float32)\n",
    "\n",
    "for Vm in [scale*(2*.5), scale*(2*radius)]:\n",
    "    R = 1.0\n",
    "    A = 1.0\n",
    "    zero_pot = Vm / 2**(1/6)\n",
    "    if R != 1.0 or A != 1.0:\n",
    "        print(\"Scaled:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format((R/A)**(1/6)*zero_pot, (2*R/A)**(1/6)*Vm))\n",
    "        print(\"Real:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format((R/A)**(1/6)*zero_pot/scale, (2*R/A)**(1/6)*Vm/scale))\n",
    "    else:\n",
    "        print(\"Scaled:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format(zero_pot, Vm))\n",
    "        print(\"Real:\\tZero-potential point: {}\\n\\tMinimum-potential point: {}\".format(zero_pot/scale, Vm/scale))\n",
    "    diameter = 2 * scale\n",
    "    if diameter % 2 == 0:\n",
    "        diameter += 1\n",
    "    template = np.zeros((diameter, diameter, diameter, 4), dtype=np.float32)\n",
    "    for i in range(diameter):\n",
    "        ii = i - (diameter-1) // 2\n",
    "        for j in range(diameter):\n",
    "            jj = j - (diameter-1) // 2\n",
    "            for k in range(diameter):\n",
    "                kk = k - (diameter-1) // 2\n",
    "                if ii == 0 and jj == 0 and kk == 0:\n",
    "                    template[i,j,k,:] = [0,0,0,np.inf]\n",
    "                else:\n",
    "                    r = np.sqrt((ii)**2 + (jj)**2 + (kk)**2)\n",
    "                    magnitude = A*(zero_pot/r)**12 - R*(zero_pot/r)**6\n",
    "                    direction = np.array([ii,jj,kk])/r# * magnitude/np.abs(magnitude)\n",
    "                    template[i,j,k, 3] = magnitude\n",
    "                    template[i,j,k,:3] = direction\n",
    "                    if r > Vm:\n",
    "                        template[i,j,k,:3] *= -1\n",
    "                        \n",
    "rng = np.random.default_rng()\n",
    "dests = np.hstack([rng.random(size=(reps2, 2), dtype=np.float32)*L, np.zeros((reps2,1), dtype=np.float32)+height])\n",
    "\n",
    "update = max((int(reps2 / 128), 1)) # frequency of printed updates\n",
    "current_fiber_id = np.max(atom_pos[:,5] + 1)\n",
    "\n",
    "# each particle must be treated in sequence\n",
    "#print(\"Beginning simulation\")\n",
    "endsurf = 0\n",
    "endpot = 0\n",
    "endretreat = 0\n",
    "endfly = 0\n",
    "start = time.time()\n",
    "dmax = 0\n",
    "for i in range(reps, reps + reps2):\n",
    "    #print(\"Particle {}\".format(i+1))\n",
    "    # get destination and source point\n",
    "    startfly = time.time()\n",
    "    dest = dests[i-reps]\n",
    "    #shift = src + [dest[0], dest[1], dest[2]]\n",
    "    \n",
    "    #print(\"Traversing\")\n",
    "    \n",
    "    pos, c = bins.drop_particle(dest, radius, atom_pos)\n",
    "    \n",
    "    position = pos % [L,L,np.inf]\n",
    "    if np.any(np.isnan(position)):\n",
    "        print(position)\n",
    "    #print(\"{} -> {}\".format(dest, pos))\n",
    "    endfly += time.time() - startfly\n",
    "    \n",
    "    # time to try diffusing\n",
    "    #print(\"Following potential\")\n",
    "    if D > 0.0:\n",
    "        startsurf = time.time()\n",
    "        position_new = follow_potential(potentials, position, scale, L, height, D/2, current_atom=i, lennardjones=True, deterministic=True)\n",
    "        d = distance3DPBC(position, position_new, L)\n",
    "        if d > dmax:\n",
    "            dmax = d\n",
    "        if d > D:\n",
    "            print(\"Former position: {}\".format(position))\n",
    "            print(\"New position: {}\".format(position_new))\n",
    "            print(\"Distance: {}\".format(d))\n",
    "        position = position_new\n",
    "        endsurf += time.time() - startsurf\n",
    "        #print(\"Adding potential\")\n",
    "        startpot = time.time()\n",
    "        superimpose_potential(potentials, position, scale, radius, template, diameter)\n",
    "        endpot += time.time() - startpot\n",
    "    \n",
    "    #print(\"Settling atom\")\n",
    "    if not np.any(np.isnan(position)):\n",
    "        atom_pos[i,:3] = position\n",
    "        #print(\"\\tSettled at {}\".format(position))\n",
    "        atom_pos[i,3] = species\n",
    "        atom_pos[i,4] = radius\n",
    "        \n",
    "#         atom_pos[i+reps//2,:3] = dest / np.array([1,1,2])\n",
    "#         atom_pos[i+reps//2,3] = species\n",
    "#         atom_pos[i,4] = radius\n",
    "#         atom_pos[i+reps,:3] = dest / np.array([1,1,4])\n",
    "#         atom_pos[i+reps,3] = species\n",
    "#         atom_pos[i,4] = radius\n",
    "        \n",
    "        if c == -1:\n",
    "            atom_pos[i,5] = current_fiber_id\n",
    "            current_fiber_id += 1\n",
    "        else:\n",
    "            atom_pos[i,5] = atom_pos[c, 5]\n",
    "        #print(position, radius, i)\n",
    "        bins.add_to_bins(position, radius, i)\n",
    "    else:\n",
    "        print(position)\n",
    "    \n",
    "        \n",
    "    if i % update == update - 1:\n",
    "        up_time = time.time() - start\n",
    "        if i+1-reps > up_time:\n",
    "            print(\"{}/{} complete; {:.3f} seconds taken; {:.3f} reps per second.\".format(i+1-reps, reps2, up_time, (i+1-reps)/up_time))\n",
    "        else:\n",
    "            print(\"{}/{} complete; {:.3f} seconds taken; {:.3f} seconds per rep.\".format(i+1-reps, reps, up_time, up_time/(i+1-reps)))\n",
    "end = time.time() - start\n",
    "if reps > end:\n",
    "    print(\"{} reps completed in {} seconds;\\n{} reps per second.\".format(reps2, end, reps2/end))\n",
    "else:\n",
    "    print(\"{} reps completed in {} seconds;\\n{} seconds per rep.\".format(reps2, end, end/reps2))\n",
    "print(\"{} seconds were traversal before collision.\".format(endfly))\n",
    "print(\"{} seconds were backing up from collision.\".format(endretreat))\n",
    "print(\"{} seconds were potential following.\".format(endsurf))\n",
    "print(\"{} seconds were potential addition.\".format(endpot))\n",
    "for i in range(atom_pos.shape[0]):\n",
    "    atom_pos[i, 6] = bins.find_bin_idx(atom_pos[i, :3])\n",
    "#warnings.filterwarnings('default', category=RuntimeWarning)\n",
    "print(\"Maximum diffusion distance: {}\".format(dmax))\n",
    "\n",
    "p[1]['time'] = end\n",
    "saveContinuum(atom_pos, p, \"Si_Ag\", zipped=True)\n",
    "\n",
    "snapshot = tracemalloc.take_snapshot()\n",
    "top_stats = snapshot.statistics('lineno')\n",
    "for stat in top_stats[:10]:\n",
    "    print(stat)\n",
    "\n",
    "pr.print_stats()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.where(np.round(atom_pos[:,:], 3)==5.956, 1, 0)\n",
    "print(sum(x))\n",
    "print(np.argmax(x[:,0]))\n",
    "print(atom_pos[7636,:])\n",
    "fib1 = np.where(atom_pos[:,5] == 1, 1, 0)\n",
    "print(sum(fib1))\n",
    "\n",
    "num_of_fibers = int(np.max(atom_pos[:,5]))\n",
    "fibers = np.zeros((num_of_fibers))\n",
    "for i in range(num_of_fibers):\n",
    "    x = np.where(atom_pos[:,5] == i, 1, 0)\n",
    "    fibers[i] = sum(x)\n",
    "\n",
    "print(np.mean(fibers))\n",
    "\n",
    "# fig, ax = plt.subplots()\n",
    "# ax = plt.hist(fibers, bins=num_of_fibers)\n",
    "# plt.show()\n",
    "\n",
    "# density calculation\n",
    "m = np.amax(atom_pos[:,:3], axis=0)\n",
    "volume = m[0] * m[1] * (m[2] + radius)\n",
    "matter = atom_pos.shape[0] * 4/3*np.pi*radius**3\n",
    "density = matter/volume\n",
    "print(\"Density: {:.3f}\".format(density))\n",
    "\n",
    "volume2 = m[0] * m[1] * 53\n",
    "x = np.where(atom_pos[:,2] < 53, 1, 0)\n",
    "matter2 = np.sum(x) * 4/3*np.pi*radius**3\n",
    "density2 = matter2/volume2\n",
    "print(\"Density (restricted): {:.3f}\".format(density2))\n",
    "\n",
    "density3 = np.zeros((int(np.ceil(m[2] + radius)), 2))\n",
    "# for i in range(0, int(np.ceil(m[2]+radius))):\n",
    "#     for j in range(atom_pos.shape[0]):\n",
    "#         center = atom_pos[j,:3]\n",
    "#         r = atom_pos[j, 4]\n",
    "#         delta = [abs(i - center[2]), abs(i+1 - center[2])]\n",
    "#         if center[2] - r > i and center[2] + r < i+1:\n",
    "#             density3[i] += 4/3*np.pi*r**3\n",
    "#         elif center[2] - r < i and center[2] + r > i:\n",
    "#             if center[2] < i:\n",
    "#                 density3[i] += 1/3*np.pi*(r-delta[0])**2*(2*r-delta[0]) # easier case\n",
    "#                 print(delta[0])\n",
    "#             else:\n",
    "#                 density3[i] += 4/3*np.pi*r**3 - 1/3*np.pi*(r-delta[0])**2*(2*r-delta[0]) \n",
    "#         elif center[2] - r > i and center[2] + r > i+1:\n",
    "#             if center[2] > i+1:\n",
    "#                 density3[i] += 1/3*np.pi*(r-delta[1])**2*(2*r-delta[1]) # easier case\n",
    "#             else:\n",
    "#                 density3[i] += 4/3*np.pi*r**3 - 1/3*np.pi*(r-delta[1])**2*(2*r-delta[1])\n",
    "#     density3[i] /= m[0]*m[1]\n",
    "    \n",
    "for i in range(0, atom_pos.shape[0]):\n",
    "    center = atom_pos[i,2]\n",
    "    r = atom_pos[i,4]\n",
    "    low = int(np.floor(center - radius))\n",
    "    cint = int(np.floor(center))\n",
    "    high = int(np.floor(center + radius))\n",
    "    \n",
    "    if low == high:\n",
    "        density3[low, 0] += 4/3*np.pi*r**3\n",
    "        density3[low, 1] += 1\n",
    "    elif low < cint:\n",
    "        d = center - low\n",
    "        if low > -1:\n",
    "            density3[low] += 1/3*np.pi*(r - d)*(2*r+d)\n",
    "        density3[high] += 4/3*np.pi*r**3 - 1/3*np.pi*(r - d)*(2*r+d)\n",
    "        if low > -1:\n",
    "            density3[low, 1] += d/2/r\n",
    "        density3[high, 1] += d/r\n",
    "    elif high > cint:\n",
    "        d = high - center\n",
    "        density3[high] += 1/3*np.pi*(r - d)*(2*r+d)\n",
    "        density3[low] += 4/3*np.pi*r**3 - 1/3*np.pi*(r - d)*(2*r+d)\n",
    "        density3[low, 1] += d/r\n",
    "        density3[high, 1] += d/2/r\n",
    "    if d < 0:\n",
    "        print(i)\n",
    "for dd in density3:\n",
    "    dd[0] /= L*L\n",
    "\n",
    "fig, ax = plt.subplots(2)\n",
    "ax[0].plot(range(1, int(np.ceil(m[2]+radius)+1)), 100*(1-density3[:,0]), 'k.', linewidth=0, markersize=15)\n",
    "ax[1].plot(range(1, int(np.ceil(m[2]+radius)+1)), density3[:,1], 'k.', linewidth=0, markersize=15)\n",
    "ax[0].set_xlabel(\"$z$-position (nm)\")\n",
    "ax[1].set_ylabel(\"Void fraction\")\n",
    "ax[1].set_xlabel(\"$z$-position (nm)\")\n",
    "ax[1].set_ylabel(\"Rough number of atoms in slice from $z$ to $z+1$\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.trapz(density3[:,1]))\n",
    "print(d)\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(range(1, int(np.ceil(m[2]+radius)+1)), density3[:,0], 'k.', linewidth=0, markersize=15)\n",
    "plt.show()\n",
    "for i in density3:\n",
    "    print(\"{}\".format(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of bins: 16\n"
     ]
    }
   ],
   "source": [
    "''' Bin demonstration '''\n",
    "l = 32\n",
    "h = 32\n",
    "t = 85\n",
    "corridors = SlantedCorridors(l, 8, t, h)\n",
    "atom_pos = np.zeros((l * l * 4, 7), dtype=np.float32)\n",
    "for i in range(l):\n",
    "    for j in range(l):\n",
    "        for k in range(4):\n",
    "            idx = i+j*l+k*l*4\n",
    "            atom_pos[idx,:3] = [i, j, k*4]\n",
    "            atom_pos[idx, 6] = corridors.find_bin_idx(atom_pos[idx,:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "''' Bin test '''\n",
    "l = 16\n",
    "h = 8\n",
    "t = 85\n",
    "reps = 10\n",
    "radius = 0.25\n",
    "species = 1\n",
    "corridors = SlantedCorridors(l, 4, t, h, verbose=True)\n",
    "atom_pos = np.zeros((reps+1, 7), dtype=np.float32)\n",
    "atom_pos[reps,:] = [0,0,h, 5, radius, 0, 0]\n",
    "current_fiber_id = 1\n",
    "for i in range(reps):\n",
    "    #print(\"\\nRep {}\".format(i))\n",
    "    pos, c = corridors.drop_particle(np.array([(i/1+9)%l,0*(i/10)%l,h]), radius, atom_pos)\n",
    "    position = pos\n",
    "    #print(\"{} -> {}\".format([0,0,h], pos))\n",
    "    \n",
    "    #print(\"Settling atom\")\n",
    "    if not np.any(np.isnan(position)):\n",
    "        atom_pos[i,:3] = position % (l,l,np.inf)\n",
    "        #print(\"\\tSettled at {}\".format(position))\n",
    "        atom_pos[i,3] = species\n",
    "        atom_pos[i,4] = radius\n",
    "        \n",
    "        if c == -1:\n",
    "            atom_pos[i,5] = current_fiber_id\n",
    "            current_fiber_id += 1\n",
    "        else:\n",
    "            atom_pos[i,5] = atom_pos[c, 5]\n",
    "        corridors.add_to_bins(position % (l, l, np.inf), radius, i)\n",
    "    \n",
    "for i in range(atom_pos.shape[0]):\n",
    "    atom_pos[i, 6] = corridors.find_bin_idx(atom_pos[i, :3])\n",
    "print(atom_pos)\n",
    "for a in corridors.bins[0]:\n",
    "    print(\"Position: {}\\tPriority: {}\".format(atom_pos[a[0],:3], a[1]))\n",
    "print(corridors.bins[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = 45\n",
    "l = 16\n",
    "h = 8\n",
    "reps = 10\n",
    "corridors = SlantedCorridors(l, 2, t, h)\n",
    "src = np.array([5, 5, 8])\n",
    "src2 = np.array([0, 0, 8])\n",
    "adjusted_x = (src[2] * tand(t) + src[0])\n",
    "adjusted_x2 = (src2[2] * tand(t) + src2[0])\n",
    "proj = np.array([adjusted_x, src[1], 0])\n",
    "proj2 = np.array([adjusted_x2, src2[1], 0])\n",
    "n = np.divide(proj - src, np.linalg.norm(proj - src))\n",
    "n2 = np.divide(proj2 - src2, np.linalg.norm(proj2 - src2))\n",
    "print(n, n2)\n",
    "atom_pos = np.zeros((reps*2, 7), dtype=np.float32)\n",
    "for i in range(reps):\n",
    "    pos = step_along_line(src, n, i) % (l,l,np.inf)\n",
    "    atom_pos[i,:3] = pos\n",
    "    pos = step_along_line(src2, n2, i) % (l,l,np.inf)\n",
    "    atom_pos[i+reps,:3] = pos\n",
    "    \n",
    "for i in range(atom_pos.shape[0]):\n",
    "    atom_pos[i, 6] = corridors.find_bin_idx(atom_pos[i, :3])\n",
    "print(atom_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "''' Collision test '''\n",
    "l = 16\n",
    "h = 16\n",
    "t = 45\n",
    "reps = 16\n",
    "radius = 0.25\n",
    "species = 1\n",
    "corridors = SlantedCorridors(l, 2, t, h)\n",
    "atom_pos = np.zeros((2+reps, 7), dtype=np.float32)\n",
    "atom_pos[0,:] = [2.072, 2.979, 0.25 , 5, radius, 0, 0]\n",
    "corridors.add_to_bins(atom_pos[0,:3], radius, 0)\n",
    "current_fiber_id = 1\n",
    "\n",
    "src = np.array([1.785, 2.621, 16.0])\n",
    "adjusted_x = (src[2] * tand(t) + src[0])\n",
    "proj = np.array([adjusted_x, src[1], 0])\n",
    "n = np.divide(proj - src, np.linalg.norm(proj - src))\n",
    "\n",
    "pos, c = corridors.drop_particle(src, radius, atom_pos)\n",
    "atom_pos[1,:3] = pos % (l,l,np.inf)\n",
    "atom_pos[1,3] = species\n",
    "atom_pos[1,4] = radius\n",
    "#print(\"{} -> {}\".format([0,0,h], pos))\n",
    "for i in range(2, reps+2):\n",
    "    pos = step_along_line(src, n, i) % (l,l,np.inf)\n",
    "    atom_pos[i,:3] = pos\n",
    "\n",
    "    atom_pos[i,3] = species\n",
    "    atom_pos[i,4] = radius\n",
    "\n",
    "    corridors.add_to_bins(pos, radius, i)\n",
    "    \n",
    "for i in range(atom_pos.shape[0]):\n",
    "    atom_pos[i, 6] = corridors.find_bin_idx(atom_pos[i, :3])\n",
    "    \n",
    "print(atom_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No JSON file paired with data.\n",
      "[[2.3622e+01 8.9394e+00 1.5000e-01 ... 1.5000e-01 0.0000e+00 7.0000e+00]\n",
      " [1.8964e+00 2.8168e+01 1.5000e-01 ... 1.5000e-01 1.0000e+00 1.2000e+01]\n",
      " [2.8636e+01 1.6183e+01 1.5000e-01 ... 1.5000e-01 2.0000e+00 1.1000e+01]\n",
      " ...\n",
      " [1.6300e+01 2.2900e+01 1.2800e+01 ... 1.5000e-01 3.0300e+02 8.0000e+00]\n",
      " [1.9400e+01 1.2900e+01 1.1800e+01 ... 1.5000e-01 3.7100e+02 7.0000e+00]\n",
      " [3.0900e+01 2.3000e+00 1.2600e+01 ... 1.5000e-01 2.1300e+02 1.0000e+00]]\n",
      "Total number of bins: 16\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "filename = 'STF_Si_Ag_L32_Th85_D1.5_N73728_1666813526'\n",
    "\n",
    "atom_pos, deposited, params = loadContinuum(filename + '.npz')\n",
    "print(atom_pos)\n",
    "bins = SlantedCorridors(L, bin_size, theta, height, verbose=False)\n",
    "for i in range(atom_pos.shape[0]):\n",
    "    bins.add_to_bins(atom_pos[i,:3], atom_pos[i,4], i)\n",
    "print(params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum: [31.9982 31.9597 16.5   ]\n",
      "Minimum: [0.   0.   0.15]\n",
      "Started viewer process: F:\\Programs\\Anaconda3_2020.11\\envs\\pptk\\lib\\site-packages\\pptk\\viewer\\viewer\n"
     ]
    }
   ],
   "source": [
    "#mask = np.any(np.isnan(atom_pos), axis=1)\n",
    "#atom_pos = atom_pos[~mask]\n",
    "bb = np.zeros([atom_pos.shape[0]])\n",
    "pr = np.zeros([atom_pos.shape[0]])\n",
    "for i in range(atom_pos.shape[0]):\n",
    "    pr[i] = bins.calc_priority(atom_pos[i,:3])\n",
    "    bb[i] = bins.find_bin_idx(atom_pos[i,:3])\n",
    "m = np.amax(atom_pos[:,:3], axis=0)\n",
    "print(\"Maximum: {}\\nMinimum: {}\".format(m, np.amin(atom_pos[:,:3], axis=0)))\n",
    "\n",
    "sp = np.zeros([atom_pos.shape[0], 3])\n",
    "fi = np.zeros([atom_pos.shape[0], 3])\n",
    "if atom_pos.shape[1] == 7:\n",
    "    bin_ids = np.zeros([atom_pos.shape[0], 3])\n",
    "    rng_bins = np.random.rand(int(np.max(atom_pos[:,6]))+1, 3)\n",
    "num_of_fibers = int(np.max(atom_pos[:,5]))+1\n",
    "rng_labels = np.random.rand(num_of_fibers, 3)\n",
    "for i in range(atom_pos.shape[0]):\n",
    "    x = atom_pos[i,:4]\n",
    "    sp[i] = set1[int(x[3]-1)][0:3]*(x[2]*.9/m[2]+.1)\n",
    "    fi[i] = rng_labels[int(atom_pos[i, 5]),:]\n",
    "    bin_ids[i] = rng_bins[int(bb[i]),:]\n",
    "    \n",
    "\n",
    "#print(atom_pos[:,:3])\n",
    "v = pptk.viewer(atom_pos[:,:3], debug=True)\n",
    "v.set(point_size=radius)\n",
    "v.set(lookat=(m[0]/2, m[1]/2, m[2]/2))\n",
    "if atom_pos.shape[1] < 7:\n",
    "    v.attributes(atom_pos[:,2], atom_pos[:,1], atom_pos[:,0], sp, fi) #, points[:,1], points_nn, species, energy)\n",
    "else:\n",
    "    v.attributes(atom_pos[:,2], atom_pos[:,1], atom_pos[:,0], sp, fi, pr, bin_ids) #, points[:,1], points_nn, species, energy)\n",
    "v.color_map(magma) # magma and ocean work best"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16000.000137329102 16000.0\n",
      "5\n",
      "inf -4.1447783\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d1460cc60a50469786a4301f67101a18",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=319, description='x', max=639), Output()), _dom_classes=('widget-interac…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 3200x1600 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(potentials.__sizeof__()/1024/1024, potentials.nbytes/1024/1024)\n",
    "#plt.imshow((template[:,:,-1, 3]))\n",
    "print(np.argmax(np.sum(np.abs(potentials[:,:,:,3]), axis=(0,1))))\n",
    "#print((np.sum(np.abs(potentials[:,:,:,3]), axis=(0,1))))\n",
    "#plt.colorbar()\n",
    "print(np.amax(potentials[:,:,:,3]), np.amin(potentials[:,:,:,3]))\n",
    "#print(potentials[:,:,5,3])\n",
    "\n",
    "from ipywidgets import interact\n",
    "\n",
    "@interact(x=(0,potentials.shape[2]-1))\n",
    "def show_slice(x):\n",
    "    fig, ax = plt.subplots(2,2)\n",
    "    ax[0,0].imshow(potentials[:,:,x, 0])\n",
    "    ax[0,1].imshow(potentials[:,:,x, 1])\n",
    "    ax[1,0].imshow(potentials[:,:,x, 2])\n",
    "    im = ax[1,1].imshow(potentials[:,:,x,3]/np.abs(potentials[:,:,x,3]) * np.log10(1+np.abs(potentials[:,:,x, 3]*np.log(10))))\n",
    "    fig.colorbar(im, ax=ax[1,1])\n",
    "    #for i in [0,1]:\n",
    "    #    for j in [0,1]:\n",
    "    #        ax[i,j].colorbar()\n",
    "    fig.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "backup_atoms = atom_pos\n",
    "backup_spc = atom_spc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.371  3.656  7.841 26.999 15.484  3.378 22.545 12.721 18.961 18.624]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 3200x1600 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(dests[:10,0])\n",
    "n, b, p = plt.hist(dests[:,0], 128)\n",
    "\n",
    "plt.xlabel(\"X-coordinate\")\n",
    "plt.ylabel(\"Number\")\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot Lennard-Jones potential\n",
    "r = np.arange(0.5,5,0.01)\n",
    "p1 = (zero_pot/r)**12 - (zero_pot/r)**6\n",
    "p2 = A*(zero_pot/r)**12 - R*(zero_pot/r)**6\n",
    "\n",
    "fig, ax = plt.subplots(2)\n",
    "ax[0].plot(r, p1)\n",
    "ax[1].plot(r, p2)\n",
    "\n",
    "fig.tight_layout()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pptk",
   "language": "python",
   "name": "pptk"
  },
  "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.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}