From 4a64a1a0db97653e24f053aa0a4804d650151fab Mon Sep 17 00:00:00 2001
From: Maja Warlich <maja@warlich.name>
Date: Sun, 12 Sep 2021 19:09:04 +0200
Subject: [PATCH] Seperate inner-list working.

---
 lbmpy/sparse/mapping.py           | 125 ++++++++++++++--
 lbmpy_tests/test_sparse_lbm.ipynb | 232 ++++++++++++++----------------
 2 files changed, 225 insertions(+), 132 deletions(-)

diff --git a/lbmpy/sparse/mapping.py b/lbmpy/sparse/mapping.py
index 0d639cc..899fa68 100644
--- a/lbmpy/sparse/mapping.py
+++ b/lbmpy/sparse/mapping.py
@@ -191,11 +191,7 @@ class SparseLbPeriodicityMapper:
         self.no_slip_flag = mapping.no_slip_flag
         self.density_flag = mapping.density_flag
         self.ubb_flag = mapping.ubb_flag
-    
-    def get_fluid_border_coord(self):
-        fluid_border_coord = []
-        for coord in self.mapping.fluid_coordinates:
-            print(coord)
+        
     
     def get_read_idx(self, read, write_idx, direction_idx):  
         if self.flag_arr[tuple(read)] & self.no_slip_flag: # Read cell is no-slip: flip PDF!
@@ -205,23 +201,126 @@ class SparseLbPeriodicityMapper:
         else:
             return pdf_index(self.mapping.cell_idx(tuple(read)), direction_idx, len(self.mapping))
             #periodic_idx_array.append([direction_idx, write, read]) #nur zu debug Zwecken
+    
+    def get_assignment(self, direction_idx, direction, own_cell_idx, cell):
+        inv_neighbor_cell = [(cell_i - dir_i)%ds_i for cell_i, dir_i, ds_i in zip(cell, direction, self.domain_size)]
+        write_idx = pdf_index(own_cell_idx, direction_idx, len(self.mapping))
+        read_idx = self.get_read_idx(inv_neighbor_cell, own_cell_idx, direction_idx)
+        print("write:", cell, "read:", inv_neighbor_cell)
+        return [direction_idx, write_idx, read_idx]
         
+    
+    def create_inner_index_arr(self):
+        stencil = self.method.stencil
+        fluid_border_coord = []
+        for cell_idx, cell in enumerate(self.mapping.fluid_coordinates):
+            if (cell[0] == 0 or cell[0] == self.domain_size[0]-1 or cell[1] == 0 or cell[1] == self.domain_size[1]-1):
+                fluid_border_coord.append((cell_idx, cell))
+        result = []
+        fluid_boundary_mask = self.fluid_flag | self.ubb_flag | self.density_flag
+        for direction_idx, direction in enumerate(self.method.stencil):
+            if all(d_i == 0 for d_i in direction):# direction (0,0) irrelevant
+                continue
+            print("\n New direction:", direction, ", ", direction_idx)
+            naughty = [[int((ds_i-1)*(1-dir_i)/2)] if dir_i != 0 else [] for i, (dir_i, ds_i) in enumerate(zip(direction, self.domain_size))]
+            print(naughty)
+            for cell_description in fluid_border_coord:
+                cell = cell_description[1]
+                own_cell_idx = cell_description[0]
+                if cell[0] not in naughty[0] and cell[1] not in naughty[1]:
+                    result.append(self.get_assignment(direction_idx, direction, own_cell_idx, cell))
+        return result
         
     def create_index_arr(self): # erstellt index arrays für ALLE fluid Zellen, die sich am Rand der domain befinden.
         # ein index array für alle Werte, die innerhalb des Blocks verschickt werden
         # jeweils ein index array für Werte, die zu jeweils verschiedenen benachbarten Blocks geschickt werden (wenn verschiedene Kerne verschiedene Blöcke innerhalb einer Domain bearbeiten)
         stencil = self.method.stencil
         print("domain_size:", self.domain_size)
+        fluid_border_coord = []
+        for cell_idx, cell in enumerate(self.mapping.fluid_coordinates):
+            if (cell[0] == 0 or cell[0] == self.domain_size[0]-1 or cell[1] == 0 or cell[1] == self.domain_size[1]-1):
+                fluid_border_coord.append((cell_idx, cell))
         result = []
+        print(fluid_border_coord)
         inner_idx_array = []
-        write = [0,0]
         fluid_boundary_mask = self.fluid_flag | self.ubb_flag | self.density_flag
-        for i in range(1, 4, 1):
-            print(i)
         for direction_idx, direction in enumerate(self.method.stencil):
             if all(d_i == 0 for d_i in direction):# direction (0,0) irrelevant
                 continue
             print("\n New direction:", direction, ", ", direction_idx)
+            for pos in range(0,2):
+                print("new periodic_index_array")
+                periodic_idx_array = []
+                sop = (pos+1)%2
+                print("first iteration over cells")
+                for cell_description in fluid_border_coord:
+                    cell = cell_description[1]
+                    own_cell_idx = cell_description[0]
+                    #print(cell)
+                    if direction[pos] != 0:
+                        slice_coord = int((self.domain_size[pos]-1)*(1-direction[pos])/2) #0 oder d_s-1
+                        start = 1 if direction[sop] == 1 else 0
+                        stop = self.domain_size[sop]-1 if direction[sop] == -1 else self.domain_size[sop]
+                        if cell[pos] == slice_coord and cell[sop] >= start and cell[sop] < stop:
+                            inv_neighbor_cell = [(cell_i - dir_i)%ds_i for cell_i, dir_i, ds_i in zip(cell, direction, self.domain_size)]
+                            write_idx = pdf_index(own_cell_idx, direction_idx, len(self.mapping))
+                            read_idx = self.get_read_idx(inv_neighbor_cell, own_cell_idx, direction_idx)
+                            print("(p  ) write:", cell)
+                            periodic_idx_array.append([direction_idx, write_idx, read_idx])
+                        slice_coord = [int((self.domain_size[sop]-1)*(1+direction[sop])/2)] if direction[sop] != 0 else [0, self.domain_size[sop]-1]
+                        if cell[sop] in slice_coord and cell[pos] >= 1 and cell[pos] < self.domain_size[pos]-1:
+                            inv_neighbor_cell = [(cell_i - dir_i)%ds_i for cell_i, dir_i, ds_i in zip(cell, direction, self.domain_size)]
+                            write_idx = pdf_index(own_cell_idx, direction_idx, len(self.mapping))
+                            read_idx = self.get_read_idx(inv_neighbor_cell, own_cell_idx, direction_idx)
+                            print("(i_1) write:", cell)
+                            inner_idx_array.append([direction_idx, write_idx, read_idx])
+                    else: #if direction[pos] == 0
+                        slice_coord = int((self.domain_size[sop]-1)*(1+direction[sop])/2)
+                        if cell[sop] == slice_coord:
+                            inv_neighbor_cell = [(cell_i - dir_i)%ds_i for cell_i, dir_i, ds_i in zip(cell, direction, self.domain_size)]
+                            write_idx = pdf_index(own_cell_idx, direction_idx, len(self.mapping))
+                            read_idx = self.get_read_idx(inv_neighbor_cell, own_cell_idx, direction_idx)
+                            print("(i_2) write:", cell)
+                            inner_idx_array.append([direction_idx, write_idx, read_idx])
+                print("feed result")
+                result.append(periodic_idx_array)
+            #Ecken
+            if (direction[0] == 0 or direction[1] == 0):
+                continue
+            print("second iteration over cells")
+            for cell_description in fluid_border_coord:
+                cell = cell_description[1]
+                own_cell_idx = cell_description[0]
+                corner = [int((ds_i-1)*(1-dir_i)/2) for dir_i, ds_i in zip(direction, self.domain_size)]
+                if cell[0] == corner[0] and cell[1] == corner[1]:
+                    inv_neighbor_cell = [(cell_i - dir_i)%ds_i for cell_i, dir_i, ds_i in zip(cell, direction, self.domain_size)]
+                    write_idx = pdf_index(own_cell_idx, direction_idx, len(self.mapping))
+                    read_idx = self.get_read_idx(inv_neighbor_cell, own_cell_idx, direction_idx)
+                    print("(c_p) write:", cell)
+                    result.append([[direction_idx, write_idx, read_idx]])
+                corner = [int((ds_i-1)*(1+dir_i)/2) for dir_i, ds_i in zip(direction, self.domain_size)]
+                if cell[0] == corner[0] and cell[1] == corner[1]:
+                    inv_neighbor_cell = [(cell_i - dir_i)%ds_i for cell_i, dir_i, ds_i in zip(cell, direction, self.domain_size)]
+                    write_idx = pdf_index(own_cell_idx, direction_idx, len(self.mapping))
+                    read_idx = self.get_read_idx(inv_neighbor_cell, own_cell_idx, direction_idx)
+                    print("(c_i) write:", cell)
+                    inner_idx_array.append([direction_idx, write_idx, read_idx])
+        print("End of Code")
+            
+                
+            
+                        
+        for direction_idx, direction in enumerate(self.method.stencil):
+            if all(d_i == 0 for d_i in direction):# direction (0,0) irrelevant
+                continue
+            print("\n New direction:", direction, ", ", direction_idx)
+                        
+                        
+                        
+                        
+            
+            
+            
             for pos in range(0,2): # einmal für x, einmal für y Richtung ... 
                 print("pos is ", pos)
                 sop = (pos+1)%2
@@ -239,13 +338,14 @@ class SparseLbPeriodicityMapper:
                         if not (self.flag_arr[tuple(write)] & self.fluid_flag):
                             continue
                         read = [(write_i - dir_i)%ds_i for write_i, dir_i, ds_i in zip(write, direction, self.domain_size)]
+                        print("write:", write)
                         write_idx = pdf_index(self.mapping.cell_idx(tuple(write)), direction_idx, len(self.mapping))
-                        read_idx = self.get_read_idx(read, write_idx, direction_idx)
+                        read_idx = self.get_read_idx(read, self.mapping.cell_idx(tuple(write)), direction_idx)
                         periodic_idx_array.append([direction_idx, write_idx, read_idx])
                         # "Die Zelle "write" bekommt ihren neuen Wert der jeweiligen direction von der Zelle "read"
                     result.append(tuple(periodic_idx_array))
                     # inner: wird zwischen benachbarten Zellen *im gleichen Block* geschickt
-                    print("(inner:)")
+                    print("(inner1:)")
                     pos_bound = int((self.domain_size[pos]-1)*(1+direction[pos])/2)
                     pos_mid = pos_bound+direction[pos]*(-self.domain_size[pos]+1)
                     sop_position = [int((self.domain_size[sop]-1)*(1+direction[sop])/2)] if direction[sop] != 0 else [0, self.domain_size[sop]-1]
@@ -254,6 +354,7 @@ class SparseLbPeriodicityMapper:
                             write = [0,0]
                             write[pos] = i
                             write[sop] = b
+                            print("write:", write)
                             if not (self.flag_arr[tuple(write)] & self.fluid_flag):
                                 continue
                             read = [write_i - dir_i for write_i, dir_i in zip(write, direction)]
@@ -262,7 +363,7 @@ class SparseLbPeriodicityMapper:
                             inner_idx_array.append([direction_idx, write_idx, read_idx])
                 if direction[pos] == 0: #spricht directions 1, 2, 3 und 4 an
                     # inner: wird zwischen benachbarte Zellen *im gleichen Block* geschickt
-                    print("(inner:)")
+                    print("(inner2:)")
                     pos_low = 1
                     pos_high = self.domain_size[pos]-1
                     sop_position = int((self.domain_size[sop]-1)*(1+direction[sop])/2)
@@ -270,6 +371,7 @@ class SparseLbPeriodicityMapper:
                         write = [0,0]
                         write[pos] = i
                         write[sop] = sop_position
+                        print("write:", write)
                         if not (self.flag_arr[tuple(write)] & self.fluid_flag):
                             continue
                         read = [write_i - dir_i for write_i, dir_i in zip(write, direction)]
@@ -279,6 +381,7 @@ class SparseLbPeriodicityMapper:
             #Four corners: extra periodic_idx_array for each direction 5, 6, 7, 8
             if (direction[0]*direction[1] != 0):
                 write = [int((self.domain_size[0]-1)*(1-direction[0])/2),int((self.domain_size[1]-1)*(1-direction[1])/2)]
+                print("write:", write)
                 if not (self.flag_arr[tuple(write)] & self.fluid_flag):
                     continue
                 read = [(write_i - dir_i)%ds_i for write_i, dir_i, ds_i in zip(write, direction, self.domain_size)]
diff --git a/lbmpy_tests/test_sparse_lbm.ipynb b/lbmpy_tests/test_sparse_lbm.ipynb
index 6b5769d..80a0b10 100644
--- a/lbmpy_tests/test_sparse_lbm.ipynb
+++ b/lbmpy_tests/test_sparse_lbm.ipynb
@@ -53,7 +53,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "domain_size = (5,3)\n",
+    "domain_size = (4,3)\n",
     "omega = 1.8\n",
     "target = 'cpu'\n",
     "\n",
@@ -142,7 +142,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1152x432 with 2 Axes>"
       ]
@@ -171,13 +171,13 @@
     "    flag_arr[-1, :] = 0   \n",
     "    flag_arr[:, 0] = flags[noslip]\n",
     "    flag_arr[:, -1] = flags[noslip]\n",
-    "else:\n",
+    "#else:\n",
     "#    flag_arr[0, :] = 0\n",
     "#    flag_arr[-1, :] = 0   \n",
     "#    flag_arr[:, 0] = 0\n",
     "#    flag_arr[:, -1] = 0\n",
-    "    flag_arr[0, :] = flags[noslip]\n",
-    "    flag_arr[-1, :] = flags[noslip]\n",
+    "#    flag_arr[0, :] = flags[noslip]\n",
+    "#    flag_arr[-1, :] = flags[noslip]\n",
     "#    flag_arr[:, -1] = flags[noslip]\n",
     "#    flag_arr[:, 0] = flags[noslip]\n",
     "\n",
@@ -227,11 +227,10 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "flag: [[8 8 8]\n",
-      " [1 1 1]\n",
+      "flag: [[1 1 1]\n",
       " [1 1 1]\n",
       " [1 1 1]\n",
-      " [8 8 8]]\n",
+      " [1 1 1]]\n",
       "dir: 0\n",
       "dir: 1\n",
       "dir: 2\n",
@@ -241,7 +240,7 @@
       "dir: 6\n",
       "dir: 7\n",
       "dir: 8\n",
-      "number of fluid: 9 counter: 6\n"
+      "number of fluid: 12 counter: 10\n"
      ]
     }
    ],
@@ -293,136 +292,127 @@
   {
    "cell_type": "code",
    "execution_count": 10,
-   "metadata": {},
+   "metadata": {
+    "scrolled": false
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "domain_size: (5, 3)\n",
-      "1\n",
-      "2\n",
-      "3\n",
       "\n",
       " New direction: (0, 1) ,  1\n",
-      "pos is  0\n",
-      "(inner:)\n",
-      "pos is  1\n",
-      "(periodic:)\n",
-      "(inner:)\n",
+      "[[], [0]]\n",
+      "write: (0, 1) read: [0, 0]\n",
+      "write: (0, 2) read: [0, 1]\n",
+      "write: (1, 2) read: [1, 1]\n",
+      "write: (2, 2) read: [2, 1]\n",
+      "write: (3, 1) read: [3, 0]\n",
+      "write: (3, 2) read: [3, 1]\n",
       "\n",
       " New direction: (0, -1) ,  2\n",
-      "pos is  0\n",
-      "(inner:)\n",
-      "pos is  1\n",
-      "(periodic:)\n",
-      "(inner:)\n",
+      "[[], [2]]\n",
+      "write: (0, 0) read: [0, 1]\n",
+      "write: (0, 1) read: [0, 2]\n",
+      "write: (1, 0) read: [1, 1]\n",
+      "write: (2, 0) read: [2, 1]\n",
+      "write: (3, 0) read: [3, 1]\n",
+      "write: (3, 1) read: [3, 2]\n",
       "\n",
       " New direction: (-1, 0) ,  3\n",
-      "pos is  0\n",
-      "(periodic:)\n",
-      "(inner:)\n",
-      "pos is  1\n",
-      "(inner:)\n",
+      "[[3], []]\n",
+      "write: (0, 0) read: [1, 0]\n",
+      "write: (0, 1) read: [1, 1]\n",
+      "write: (0, 2) read: [1, 2]\n",
+      "write: (1, 0) read: [2, 0]\n",
+      "write: (1, 2) read: [2, 2]\n",
+      "write: (2, 0) read: [3, 0]\n",
+      "write: (2, 2) read: [3, 2]\n",
       "\n",
       " New direction: (1, 0) ,  4\n",
-      "pos is  0\n",
-      "(periodic:)\n",
-      "(inner:)\n",
-      "pos is  1\n",
-      "(inner:)\n",
+      "[[0], []]\n",
+      "write: (1, 0) read: [0, 0]\n",
+      "write: (1, 2) read: [0, 2]\n",
+      "write: (2, 0) read: [1, 0]\n",
+      "write: (2, 2) read: [1, 2]\n",
+      "write: (3, 0) read: [2, 0]\n",
+      "write: (3, 1) read: [2, 1]\n",
+      "write: (3, 2) read: [2, 2]\n",
       "\n",
       " New direction: (-1, 1) ,  5\n",
-      "pos is  0\n",
-      "(periodic:)\n",
-      "(inner:)\n",
-      "pos is  1\n",
-      "(periodic:)\n",
-      "(inner:)\n",
+      "[[3], [0]]\n",
+      "write: (0, 1) read: [1, 0]\n",
+      "write: (0, 2) read: [1, 1]\n",
+      "write: (1, 2) read: [2, 1]\n",
+      "write: (2, 2) read: [3, 1]\n",
       "\n",
       " New direction: (1, 1) ,  6\n",
-      "pos is  0\n",
-      "(periodic:)\n",
-      "(inner:)\n",
-      "pos is  1\n",
-      "(periodic:)\n",
-      "(inner:)\n",
+      "[[0], [0]]\n",
+      "write: (1, 2) read: [0, 1]\n",
+      "write: (2, 2) read: [1, 1]\n",
+      "write: (3, 1) read: [2, 0]\n",
+      "write: (3, 2) read: [2, 1]\n",
       "\n",
       " New direction: (-1, -1) ,  7\n",
-      "pos is  0\n",
-      "(periodic:)\n",
-      "(inner:)\n",
-      "pos is  1\n",
-      "(periodic:)\n",
-      "(inner:)\n",
+      "[[3], [2]]\n",
+      "write: (0, 0) read: [1, 1]\n",
+      "write: (0, 1) read: [1, 2]\n",
+      "write: (1, 0) read: [2, 1]\n",
+      "write: (2, 0) read: [3, 1]\n",
       "\n",
       " New direction: (1, -1) ,  8\n",
-      "pos is  0\n",
-      "(periodic:)\n",
-      "(inner:)\n",
-      "pos is  1\n",
-      "(periodic:)\n",
-      "(inner:)\n",
-      "[[1, 9, 11], [1, 12, 14], [1, 15, 17]]\n",
-      "[[2, 20, 18], [2, 23, 21], [2, 26, 24]]\n",
-      "[]\n",
-      "[]\n",
-      "[]\n",
-      "[[5, 45, 50], [5, 48, 53], [5, 51, 123]]\n",
-      "[]\n",
-      "[[6, 54, 117], [6, 57, 56], [6, 60, 59]]\n",
-      "[]\n",
-      "[[7, 65, 66], [7, 68, 69], [7, 71, 125]]\n",
-      "[]\n",
-      "[[8, 74, 119], [8, 77, 72], [8, 80, 75]]\n",
-      "[[1, [1, 2], [1, 1]], [1, [2, 2], [2, 1]], [1, [3, 2], [3, 1]], [2, [1, 0], [1, 1]], [2, [2, 0], [2, 1]], [2, [3, 0], [3, 1]], [3, 27, 30], [3, 30, 33], [3, 33, 69], [3, 29, 32], [3, 32, 35], [3, 35, 71], [4, 42, 39], [4, 39, 36], [4, 36, 63], [4, 44, 41], [4, 41, 38], [4, 38, 65], [5, 47, 49], [5, 50, 52], [5, 53, 125], [6, 62, 58], [6, 59, 55], [6, 56, 119], [7, 63, 67], [7, 66, 70], [7, 69, 123], [8, 78, 76], [8, 75, 73], [8, 72, 117]]\n"
+      "[[0], [2]]\n",
+      "write: (1, 0) read: [0, 1]\n",
+      "write: (2, 0) read: [1, 1]\n",
+      "write: (3, 0) read: [2, 1]\n",
+      "write: (3, 1) read: [2, 2]\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "[[[1, 9, 11], [1, 12, 14], [1, 15, 17]],\n",
-       " [[2, 20, 18], [2, 23, 21], [2, 26, 24]],\n",
-       " [],\n",
-       " [],\n",
-       " [],\n",
-       " [[5, 45, 50], [5, 48, 53], [5, 51, 123]],\n",
-       " [],\n",
-       " [[6, 54, 117], [6, 57, 56], [6, 60, 59]],\n",
-       " [],\n",
-       " [[7, 65, 66], [7, 68, 69], [7, 71, 125]],\n",
-       " [],\n",
-       " [[8, 74, 119], [8, 77, 72], [8, 80, 75]],\n",
-       " [[1, [1, 2], [1, 1]],\n",
-       "  [1, [2, 2], [2, 1]],\n",
-       "  [1, [3, 2], [3, 1]],\n",
-       "  [2, [1, 0], [1, 1]],\n",
-       "  [2, [2, 0], [2, 1]],\n",
-       "  [2, [3, 0], [3, 1]],\n",
-       "  [3, 27, 30],\n",
-       "  [3, 30, 33],\n",
-       "  [3, 33, 69],\n",
-       "  [3, 29, 32],\n",
-       "  [3, 32, 35],\n",
-       "  [3, 35, 71],\n",
-       "  [4, 42, 39],\n",
-       "  [4, 39, 36],\n",
-       "  [4, 36, 63],\n",
-       "  [4, 44, 41],\n",
-       "  [4, 41, 38],\n",
-       "  [4, 38, 65],\n",
-       "  [5, 47, 49],\n",
-       "  [5, 50, 52],\n",
-       "  [5, 53, 125],\n",
-       "  [6, 62, 58],\n",
-       "  [6, 59, 55],\n",
-       "  [6, 56, 119],\n",
-       "  [7, 63, 67],\n",
-       "  [7, 66, 70],\n",
-       "  [7, 69, 123],\n",
-       "  [8, 78, 76],\n",
-       "  [8, 75, 73],\n",
-       "  [8, 72, 117]]]"
+       "[[1, 13, 12],\n",
+       " [1, 14, 13],\n",
+       " [1, 17, 16],\n",
+       " [1, 20, 19],\n",
+       " [1, 22, 21],\n",
+       " [1, 23, 22],\n",
+       " [2, 24, 25],\n",
+       " [2, 25, 26],\n",
+       " [2, 27, 28],\n",
+       " [2, 30, 31],\n",
+       " [2, 33, 34],\n",
+       " [2, 34, 35],\n",
+       " [3, 36, 39],\n",
+       " [3, 37, 40],\n",
+       " [3, 38, 41],\n",
+       " [3, 39, 42],\n",
+       " [3, 41, 44],\n",
+       " [3, 42, 45],\n",
+       " [3, 44, 47],\n",
+       " [4, 51, 48],\n",
+       " [4, 53, 50],\n",
+       " [4, 54, 51],\n",
+       " [4, 56, 53],\n",
+       " [4, 57, 54],\n",
+       " [4, 58, 55],\n",
+       " [4, 59, 56],\n",
+       " [5, 61, 63],\n",
+       " [5, 62, 64],\n",
+       " [5, 65, 67],\n",
+       " [5, 68, 70],\n",
+       " [6, 77, 73],\n",
+       " [6, 80, 76],\n",
+       " [6, 82, 78],\n",
+       " [6, 83, 79],\n",
+       " [7, 84, 88],\n",
+       " [7, 85, 89],\n",
+       " [7, 87, 91],\n",
+       " [7, 90, 94],\n",
+       " [8, 99, 97],\n",
+       " [8, 102, 100],\n",
+       " [8, 105, 103],\n",
+       " [8, 106, 104]]"
       ]
      },
      "execution_count": 10,
@@ -432,7 +422,7 @@
    ],
    "source": [
     "periodic_mapper = SparseLbPeriodicityMapper(method, mapping, dh)\n",
-    "periodic_mapper.create_index_arr()\n",
+    "periodic_mapper.create_inner_index_arr()\n",
     "#periodic_index_array"
    ]
   },
@@ -532,13 +522,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "domain: (5, 3)\n",
-      "pdf size in bytes: 648\n",
-      "pdf size: 81\n",
-      "index array size in bytes: 96\n",
+      "domain: (4, 3)\n",
+      "pdf size in bytes: 864\n",
+      "pdf size: 108\n",
+      "index array size in bytes: 64\n",
       "density index array size in bytes: 0\n",
       "ubb index array size in bytes: 0\n",
-      "sum: 744\n"
+      "sum: 928\n"
      ]
     }
    ],
@@ -697,7 +687,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.quiver.Quiver at 0x7f943ffa12e0>"
+       "<matplotlib.quiver.Quiver at 0x7f941b6d7310>"
       ]
      },
      "execution_count": 20,
@@ -706,7 +696,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1152x432 with 1 Axes>"
       ]
-- 
GitLab