diff --git a/lbmpy/sparse/mapping.py b/lbmpy/sparse/mapping.py
index 21e775bb5377ec5cffa0de518004aaf9dbf99753..f5f116ca1d8f0a77edbc90ac66849a56fbdafbd1 100644
--- a/lbmpy/sparse/mapping.py
+++ b/lbmpy/sparse/mapping.py
@@ -31,7 +31,7 @@ class SparseLbMapper:
           flag_arr: integer array where each bit corresponds to a boundary or 'fluid'
     """
 
-    def __init__(self, stencil, flag_arr, fluid_flag, no_slip_flag, ubb_flag, density_flag):
+    def __init__(self, stencil, domain_size, flag_arr, fluid_flag, no_slip_flag, ubb_flag, density_flag):
         self._flag_arr = flag_arr
         self._coordinate_arr = None
         self._sorter = None  # array of indices that sort _coordinate_arr
@@ -43,6 +43,7 @@ class SparseLbMapper:
         self.boundary_mask = density_flag | ubb_flag
         self._num_fluid_cells = None
         self.stencil = stencil
+        self.domain_size = domain_size
         
 
     @property
@@ -129,11 +130,15 @@ class SparseLbMapper:
         fluid_boundary_mask = self.ubb_flag | self.fluid_flag | self.density_flag
         result = []
         print("flag:", self.flag_array)
+        fucking_counter = 0
         for direction_idx, direction in enumerate(stencil):
             if all(d_i == 0 for d_i in direction):
                 assert direction_idx == 0
                 continue
             for own_cell_idx, cell in enumerate(self.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):
+                    fucking_counter += 1
+                    continue #ignore fluid cells at the border ... 
                 domain_size = (len(self.flag_array), len(self.flag_array[0]))
                 test = []
                 inv_neighbor_cell = np.array([cell_i - dir_i for cell_i, dir_i in zip(cell, direction)])
@@ -166,7 +171,7 @@ class SparseLbMapper:
                 #print(test)
 
         index_array = np.array(result, dtype=np.uint32)
-        index_arr = index_array.reshape([len(stencil) - 1, self.num_fluid_cells])
+        index_arr = index_array.reshape([len(stencil) - 1, self.num_fluid_cells-fucking_counter])
         index_arr = index_arr.swapaxes(0, 1)
         return index_arr
 
@@ -174,10 +179,16 @@ class SparseLbMapper:
 class SparseLbPeriodicityMapper:
 
 
-    def __init__(self, method, mapping: SparseLbMapper, domain_size, periodicity):
+    def __init__(self, method, mapping: SparseLbMapper, dh):
         self.method = method
         self.mapping = mapping
-        self.domain_size = domain_size
+        self.domain_size = dh.shape
+        self.periodicity = dh.periodicity
+        self.flag_arr = mapping._flag_arr
+        self.fluid_flag = mapping.fluid_flag
+        self.no_slip_flag = mapping.no_slip_flag
+        self.density_flag = mapping.density_flag
+        self.ubb_flag = mapping.ubb_flag
     
     def cell_idx(self, coordinate: Tuple[int, ...]) -> np.uint32:
         """Maps from coordinates (x,y,z) or (x,y) tuple to the list index. Raises ValueError if coordinate not found."""
@@ -190,6 +201,117 @@ class SparseLbPeriodicityMapper:
             return self.mapping._sorter[left]
         
     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)
+        result = []
+        inner = []
+        write = [0,0]
+        fluid_boundary_mask = self.fluid_flag | self.ubb_flag | self.density_flag
+        for direction_idx, direction in enumerate(stencil):
+            if all(d_i == 0 for d_i in direction) or direction_idx < 5:#(direction_idx != 5 and direction_idx != 1) or direction_idx < 5: # 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
+                if direction[pos] != 0:
+                    # periodic/parallel: wird an anderen Block geschickt/periodisch gewrappt
+                    print("(periodic:)")
+                    index_array = []
+                    coord = int((self.domain_size[pos]-1)*(1-direction[pos])/2)
+                    print("first")
+                    start = 1 if direction[sop] == 1 else 0
+                    end = self.domain_size[sop]-1 if direction[sop] == -1 else self.domain_size[sop]
+                    for i in range(start, end):
+                        write = [0,0]
+                        write[pos] = coord
+                        write[sop] = i
+                        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)]
+                        if self.flag_arr[tuple(read)] & self.no_slip_flag:
+                            print("Read cell is a no_slip. Hmpf.")
+                        # "Die Zelle "write" bekommt ihren neuen Wert der jeweiligen direction von der Zelle "read"
+                        print("write:", write, "read:", read) 
+                        #write_idx = self.cell_idx(tuple(write))
+                        #read_idx = self.cell_idx(tuple(read))
+                        #index_array.append((direction_idx, pdf_index(write_idx, direction_idx, len(self.mapping)), pdf_index(read_idx, direction_idx, len(self.mapping))))
+                        index_array.append([direction_idx, write, read]) #nur zu debug Zwecken
+                    result.append(tuple(index_array))
+                    # inner: wird zwischen benachbarten Zellen *im gleichen Block* geschickt
+                    print("(inner:)")
+                    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]
+                    #print("pos_bound:", pos_bound, "pos_mid", pos_mid, "sop_position:", sop_position)
+                    print("second")
+                    for b in sop_position:
+                        for i in range(pos_bound, pos_mid, -direction[pos]):
+                            write = [0,0]
+                            write[pos] = i
+                            write[sop] = b
+                            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)]
+                            if self.flag_arr[tuple(read)] & self.no_slip_flag:
+                                print("Read cell is a no_slip. Hmpf.")
+                            print("write:", write, "read:", read)
+                            inner.append([direction_idx, write, read])
+                if direction[pos] == 0: #spricht directions 1, 2, 3 und 4 an
+                    # inner: wird zwischen benachbarte Zellen *im gleichen Block* geschickt
+                    print("(inner:)")
+                    print("third")
+                    pos_low = 1
+                    pos_high = self.domain_size[pos]-1
+                    sop_position = int((self.domain_size[sop]-1)*(1+direction[sop])/2)
+                    #print("pos_low:", pos_low, "pos_high:", pos_high, "sop_position:", sop_position)
+                    for i in range(pos_low, pos_high):
+                        write = [0,0]
+                        write[pos] = i
+                        write[sop] = sop_position
+                        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)]
+                        if self.flag_arr[tuple(read)] & self.no_slip_flag:
+                            print("Read cell is a no_slip. Hmpf.")
+                        print("write:", write, "read:", read)
+                        inner.append([direction_idx, write, read])
+            write = [int((self.domain_size[0]-1)*(1-direction[0])/2),int((self.domain_size[1]-1)*(1-direction[1])/2)]
+            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)]
+            #write_idx = self.cell_idx(tuple(write))
+            #read_idx = self.cell_idx(tuple(read))
+            #index_array.append((direction_idx, pdf_index(write_idx, direction_idx, len(self.mapping)), pdf_index(read_idx, direction_idx, len(self.mapping))))
+            index_array = []
+            index_array.append([direction_idx, write, read]) #nur zu debug Zwecken
+            result.append(tuple(index_array))
+            print("(Ecke) write:", write, "read:", read)
+            
+        # result enthält *mehrere* index arrays
+        #result = list(dict.fromkeys(result)) # entferne doppelte index_arrays: speziell Ecken der Domain
+        # result ist eine liste von tuples von tuples --> [((...), (...)), ((...), (...), (...))]
+        #print(result)
+        # wandel result in list_result (liste von liste von listen) um: -->[[[...], [...]], [[...], [...], [...]]]
+        list_result = [] 
+        for index_array in result:
+            list_index_array = []
+            for write_read_pair in index_array:
+                list_index_array.append(list(write_read_pair))
+            list_result.append(list_index_array)
+        
+        # zu den periodischen/parralel-orientierten index_arrays kommt noch der index array für die Werte, die nur innerhalb des Blocks verschickt werden:
+        list_result.append(inner)
+        print("start")
+        for index_array in list_result:
+            print(index_array)
+        print("end")
+        return list_result
+    
+    
+    def create_index_arr_old(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
@@ -372,8 +494,9 @@ class SparseLbBoundaryMapper:
                 assert direction_idx == 0
                 continue
             for own_cell_idx, cell in enumerate(mapping.fluid_coordinates):
-                inv_neighbor_cell = np.array([cell_i - dir_i for cell_i, dir_i in zip(cell, direction)])
-                if mapping.flag_array[tuple(inv_neighbor_cell)] & boundary_mask:
+                #inv_neighbor_cell = np.array([cell_i - dir_i for cell_i, dir_i in zip(cell, direction)])
+                inv_neighbor_cell = [(write_i - dir_i)%ds_i for write_i, dir_i, ds_i in zip(cell, direction, mapping.domain_size)]
+                if mapping.flag_array[tuple(inv_neighbor_cell)] & boundary_mask: 
                     write = pdf_index(own_cell_idx, direction_idx, len(mapping))
                     read = pdf_index(own_cell_idx, inverse_idx(stencil, direction_idx), len(mapping))
                     result.append([direction_idx, write, read])
diff --git a/lbmpy_tests/test_sparse_lbm.ipynb b/lbmpy_tests/test_sparse_lbm.ipynb
index d7d903ef853e1cecc40f066994e715ac46d280e0..2edec78b9d3ed6c17eccd3f37fc786a80a588db6 100644
--- a/lbmpy_tests/test_sparse_lbm.ipynb
+++ b/lbmpy_tests/test_sparse_lbm.ipynb
@@ -53,7 +53,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "domain_size = (4,3)\n",
+    "domain_size = (20,15)\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,11 +171,15 @@
     "    flag_arr[-1, :] = 0   \n",
     "    flag_arr[:, 0] = flags[noslip]\n",
     "    flag_arr[:, -1] = flags[noslip]\n",
-    "#else:\n",
-    "#    flag_arr[0, :] = flags[ubb]\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[density]\n",
-    "#    flag_arr[:, -1] = flags[noslip]\n",
-    "#    flag_arr[:, 0] = flags[noslip]\n",
+    "    flag_arr[:, -1] = flags[noslip]\n",
+    "    flag_arr[:, 0] = flags[noslip]\n",
     "\n",
     "def set_obstacle(size, obstacle_flag):\n",
     "    #left = domain_size[0] // size\n",
@@ -216,12 +220,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "flag: [[8 1 8]\n",
+      " [8 1 8]\n",
+      " [8 1 8]\n",
+      " [8 1 8]]\n"
+     ]
+    }
+   ],
    "source": [
-    "mapping = SparseLbMapper(method.stencil, flag_arr, flags['fluid'], flags[noslip], 0, 0) #Warum müssen (dürfen!) hier Nullen stehen?\n",
-    "#index_arr = mapping.create_index_array(ghost_layers) # funktioniert nicht solange am Rand fluid Zellen sind!\n",
+    "mapping = SparseLbMapper(method.stencil, domain_size, flag_arr, flags['fluid'], flags[noslip], flags[ubb], flags[density]) #Warum müssen (dürfen!) hier Nullen stehen?\n",
+    "index_arr = mapping.create_index_array(ghost_layers) # funktioniert nicht solange am Rand fluid Zellen sind!\n",
     "#print(index_arr)\n",
     "\n",
     "# Arrays\n",
@@ -240,6 +255,19 @@
    "execution_count": 9,
    "metadata": {},
    "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[8, 1, 8],\n",
+       "       [8, 1, 8],\n",
+       "       [8, 1, 8],\n",
+       "       [8, 1, 8]], dtype=uint16)"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
     {
      "data": {
       "image/png": "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\n",
@@ -261,7 +289,8 @@
     "                                               )\n",
     "pdf_field.field_type = FieldType.CUSTOM\n",
     "pdf_field.pdf_field_tmp = FieldType.CUSTOM\n",
-    "ps.stencil.plot_2d(stencil)"
+    "ps.stencil.plot_2d(stencil)\n",
+    "flag_arr"
    ]
   },
   {
@@ -275,230 +304,92 @@
      "text": [
       "domain_size: (4, 3)\n",
       "\n",
-      " New direction: (0, 1) ,  1\n",
-      "(inner)\n",
-      "write: [1, 2] read: [1, 1]\n",
-      "write: [2, 2] read: [2, 1]\n",
-      "(periodic)\n",
-      "write: [0, 0] read: [0, 2]\n",
-      "write: [1, 0] read: [1, 2]\n",
-      "write: [2, 0] read: [2, 2]\n",
-      "write: [3, 0] read: [3, 2]\n",
-      "(inner)\n",
-      "write: [0, 2] read: [0, 1]\n",
-      "write: [0, 1] read: [0, 0]\n",
-      "write: [3, 2] read: [3, 1]\n",
-      "write: [3, 1] read: [3, 0]\n",
-      "\n",
-      " New direction: (0, -1) ,  2\n",
-      "(inner)\n",
-      "write: [1, 0] read: [1, 1]\n",
-      "write: [2, 0] read: [2, 1]\n",
-      "(periodic)\n",
-      "write: [0, 2] read: [0, 0]\n",
-      "write: [1, 2] read: [1, 0]\n",
-      "write: [2, 2] read: [2, 0]\n",
-      "write: [3, 2] read: [3, 0]\n",
-      "(inner)\n",
-      "write: [0, 0] read: [0, 1]\n",
-      "write: [0, 1] read: [0, 2]\n",
-      "write: [3, 0] read: [3, 1]\n",
-      "write: [3, 1] read: [3, 2]\n",
-      "\n",
-      " New direction: (-1, 0) ,  3\n",
-      "(periodic)\n",
-      "write: [3, 0] read: [0, 0]\n",
-      "write: [3, 1] read: [0, 1]\n",
-      "write: [3, 2] read: [0, 2]\n",
-      "(inner)\n",
-      "write: [0, 0] read: [1, 0]\n",
-      "write: [1, 0] read: [2, 0]\n",
-      "write: [2, 0] read: [3, 0]\n",
-      "write: [0, 2] read: [1, 2]\n",
-      "write: [1, 2] read: [2, 2]\n",
-      "write: [2, 2] read: [3, 2]\n",
-      "(inner)\n",
-      "write: [0, 1] read: [1, 1]\n",
-      "\n",
-      " New direction: (1, 0) ,  4\n",
-      "(periodic)\n",
-      "write: [0, 0] read: [3, 0]\n",
-      "write: [0, 1] read: [3, 1]\n",
-      "write: [0, 2] read: [3, 2]\n",
-      "(inner)\n",
-      "write: [3, 0] read: [2, 0]\n",
-      "write: [2, 0] read: [1, 0]\n",
-      "write: [1, 0] read: [0, 0]\n",
-      "write: [3, 2] read: [2, 2]\n",
-      "write: [2, 2] read: [1, 2]\n",
-      "write: [1, 2] read: [0, 2]\n",
-      "(inner)\n",
-      "write: [3, 1] read: [2, 1]\n",
-      "\n",
       " New direction: (-1, 1) ,  5\n",
-      "(periodic)\n",
-      "write: [3, 0] read: [0, 2]\n",
-      "--cut--\n",
+      "pos is  0\n",
+      "(periodic:)\n",
+      "first\n",
+      "Read cell is a no_slip. Hmpf.\n",
       "write: [3, 1] read: [0, 0]\n",
-      "write: [3, 2] read: [0, 1]\n",
-      "(inner)\n",
-      "write: [0, 2] read: [1, 1]\n",
-      "write: [1, 2] read: [2, 1]\n",
-      "write: [2, 2] read: [3, 1]\n",
-      "(periodic)\n",
-      "write: [0, 0] read: [1, 2]\n",
-      "write: [1, 0] read: [2, 2]\n",
-      "write: [2, 0] read: [3, 2]\n",
-      "--cut--\n",
-      "write: [3, 0] read: [0, 2]\n",
-      "(inner)\n",
-      "write: [0, 2] read: [1, 1]\n",
+      "(inner:)\n",
+      "second\n",
+      "pos is  1\n",
+      "(periodic:)\n",
+      "first\n",
+      "(inner:)\n",
+      "second\n",
+      "Read cell is a no_slip. Hmpf.\n",
       "write: [0, 1] read: [1, 0]\n",
       "\n",
       " New direction: (1, 1) ,  6\n",
-      "(periodic)\n",
-      "write: [0, 0] read: [3, 2]\n",
-      "--cut--\n",
+      "pos is  0\n",
+      "(periodic:)\n",
+      "first\n",
+      "Read cell is a no_slip. Hmpf.\n",
       "write: [0, 1] read: [3, 0]\n",
-      "write: [0, 2] read: [3, 1]\n",
-      "(inner)\n",
-      "write: [3, 2] read: [2, 1]\n",
-      "write: [2, 2] read: [1, 1]\n",
-      "write: [1, 2] read: [0, 1]\n",
-      "(periodic)\n",
-      "write: [0, 0] read: [3, 2]\n",
-      "--cut--\n",
-      "write: [1, 0] read: [0, 2]\n",
-      "write: [2, 0] read: [1, 2]\n",
-      "write: [3, 0] read: [2, 2]\n",
-      "(inner)\n",
-      "write: [3, 2] read: [2, 1]\n",
+      "(inner:)\n",
+      "second\n",
+      "pos is  1\n",
+      "(periodic:)\n",
+      "first\n",
+      "(inner:)\n",
+      "second\n",
+      "Read cell is a no_slip. Hmpf.\n",
       "write: [3, 1] read: [2, 0]\n",
       "\n",
       " New direction: (-1, -1) ,  7\n",
-      "(periodic)\n",
-      "write: [3, 0] read: [0, 1]\n",
+      "pos is  0\n",
+      "(periodic:)\n",
+      "first\n",
+      "Read cell is a no_slip. Hmpf.\n",
       "write: [3, 1] read: [0, 2]\n",
-      "--cut--\n",
-      "write: [3, 2] read: [0, 0]\n",
-      "(inner)\n",
-      "write: [0, 0] read: [1, 1]\n",
-      "write: [1, 0] read: [2, 1]\n",
-      "write: [2, 0] read: [3, 1]\n",
-      "(periodic)\n",
-      "write: [0, 2] read: [1, 0]\n",
-      "write: [1, 2] read: [2, 0]\n",
-      "write: [2, 2] read: [3, 0]\n",
-      "--cut--\n",
-      "write: [3, 2] read: [0, 0]\n",
-      "(inner)\n",
-      "write: [0, 0] read: [1, 1]\n",
+      "(inner:)\n",
+      "second\n",
+      "pos is  1\n",
+      "(periodic:)\n",
+      "first\n",
+      "(inner:)\n",
+      "second\n",
+      "Read cell is a no_slip. Hmpf.\n",
       "write: [0, 1] read: [1, 2]\n",
       "\n",
       " New direction: (1, -1) ,  8\n",
-      "(periodic)\n",
-      "write: [0, 0] read: [3, 1]\n",
+      "pos is  0\n",
+      "(periodic:)\n",
+      "first\n",
+      "Read cell is a no_slip. Hmpf.\n",
       "write: [0, 1] read: [3, 2]\n",
-      "--cut--\n",
-      "write: [0, 2] read: [3, 0]\n",
-      "(inner)\n",
-      "write: [3, 0] read: [2, 1]\n",
-      "write: [2, 0] read: [1, 1]\n",
-      "write: [1, 0] read: [0, 1]\n",
-      "(periodic)\n",
-      "write: [0, 2] read: [3, 0]\n",
-      "--cut--\n",
-      "write: [1, 2] read: [0, 0]\n",
-      "write: [2, 2] read: [1, 0]\n",
-      "write: [3, 2] read: [2, 0]\n",
-      "(inner)\n",
-      "write: [3, 0] read: [2, 1]\n",
+      "(inner:)\n",
+      "second\n",
+      "pos is  1\n",
+      "(periodic:)\n",
+      "first\n",
+      "(inner:)\n",
+      "second\n",
+      "Read cell is a no_slip. Hmpf.\n",
       "write: [3, 1] read: [2, 2]\n",
-      "[((1, 12, 14), (1, 15, 17), (1, 18, 20), (1, 21, 23)), ((2, 26, 24), (2, 29, 27), (2, 32, 30), (2, 35, 33)), ((3, 45, 36), (3, 46, 37), (3, 47, 38)), ((4, 48, 57), (4, 49, 58), (4, 50, 59)), ((5, 69, 62),), ((5, 70, 60), (5, 71, 61)), ((5, 60, 65), (5, 63, 68), (5, 66, 71)), ((6, 72, 83),), ((6, 73, 81), (6, 74, 82)), ((6, 75, 74), (6, 78, 77), (6, 81, 80)), ((7, 93, 85), (7, 94, 86)), ((7, 95, 84),), ((7, 86, 87), (7, 89, 90), (7, 92, 93)), ((8, 96, 106), (8, 97, 107)), ((8, 98, 105),), ((8, 101, 96), (8, 104, 99), (8, 107, 102))]\n",
-      "[[1, 12, 14], [1, 15, 17], [1, 18, 20], [1, 21, 23]]\n",
-      "[[2, 26, 24], [2, 29, 27], [2, 32, 30], [2, 35, 33]]\n",
-      "[[3, 45, 36], [3, 46, 37], [3, 47, 38]]\n",
-      "[[4, 48, 57], [4, 49, 58], [4, 50, 59]]\n",
-      "[[5, 69, 62]]\n",
-      "[[5, 70, 60], [5, 71, 61]]\n",
-      "[[5, 60, 65], [5, 63, 68], [5, 66, 71]]\n",
-      "[[6, 72, 83]]\n",
-      "[[6, 73, 81], [6, 74, 82]]\n",
-      "[[6, 75, 74], [6, 78, 77], [6, 81, 80]]\n",
-      "[[7, 93, 85], [7, 94, 86]]\n",
-      "[[7, 95, 84]]\n",
-      "[[7, 86, 87], [7, 89, 90], [7, 92, 93]]\n",
-      "[[8, 96, 106], [8, 97, 107]]\n",
-      "[[8, 98, 105]]\n",
-      "[[8, 101, 96], [8, 104, 99], [8, 107, 102]]\n",
-      "[[1, [1, 2], [1, 1]], [1, [2, 2], [2, 1]], [1, [0, 2], [0, 1]], [1, [0, 1], [0, 0]], [1, [3, 2], [3, 1]], [1, [3, 1], [3, 0]], [2, [1, 0], [1, 1]], [2, [2, 0], [2, 1]], [2, [0, 0], [0, 1]], [2, [0, 1], [0, 2]], [2, [3, 0], [3, 1]], [2, [3, 1], [3, 2]], [3, [0, 0], [1, 0]], [3, [1, 0], [2, 0]], [3, [2, 0], [3, 0]], [3, [0, 2], [1, 2]], [3, [1, 2], [2, 2]], [3, [2, 2], [3, 2]], [3, [0, 1], [1, 1]], [4, [3, 0], [2, 0]], [4, [2, 0], [1, 0]], [4, [1, 0], [0, 0]], [4, [3, 2], [2, 2]], [4, [2, 2], [1, 2]], [4, [1, 2], [0, 2]], [4, [3, 1], [2, 1]], [5, [0, 2], [1, 1]], [5, [1, 2], [2, 1]], [5, [2, 2], [3, 1]], [5, [0, 2], [1, 1]], [5, [0, 1], [1, 0]], [6, [3, 2], [2, 1]], [6, [2, 2], [1, 1]], [6, [1, 2], [0, 1]], [6, [3, 2], [2, 1]], [6, [3, 1], [2, 0]], [7, [0, 0], [1, 1]], [7, [1, 0], [2, 1]], [7, [2, 0], [3, 1]], [7, [0, 0], [1, 1]], [7, [0, 1], [1, 2]], [8, [3, 0], [2, 1]], [8, [2, 0], [1, 1]], [8, [1, 0], [0, 1]], [8, [3, 0], [2, 1]], [8, [3, 1], [2, 2]]]\n"
+      "start\n",
+      "[[5, [3, 1], [0, 0]]]\n",
+      "[]\n",
+      "[[6, [0, 1], [3, 0]]]\n",
+      "[]\n",
+      "[[7, [3, 1], [0, 2]]]\n",
+      "[]\n",
+      "[[8, [0, 1], [3, 2]]]\n",
+      "[]\n",
+      "[[5, [0, 1], [1, 0]], [6, [3, 1], [2, 0]], [7, [0, 1], [1, 2]], [8, [3, 1], [2, 2]]]\n",
+      "end\n"
      ]
     },
     {
      "data": {
+      "image/png": "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\n",
+      "text/latex": [
+       "$\\displaystyle \\left[ \\left[ \\left[ 5, \\  \\left[ 3, \\  1\\right], \\  \\left[ 0, \\  0\\right]\\right]\\right], \\  \\left[ \\right], \\  \\left[ \\left[ 6, \\  \\left[ 0, \\  1\\right], \\  \\left[ 3, \\  0\\right]\\right]\\right], \\  \\left[ \\right], \\  \\left[ \\left[ 7, \\  \\left[ 3, \\  1\\right], \\  \\left[ 0, \\  2\\right]\\right]\\right], \\  \\left[ \\right], \\  \\left[ \\left[ 8, \\  \\left[ 0, \\  1\\right], \\  \\left[ 3, \\  2\\right]\\right]\\right], \\  \\left[ \\right], \\  \\left[ \\left[ 5, \\  \\left[ 0, \\  1\\right], \\  \\left[ 1, \\  0\\right]\\right], \\  \\left[ 6, \\  \\left[ 3, \\  1\\right], \\  \\left[ 2, \\  0\\right]\\right], \\  \\left[ 7, \\  \\left[ 0, \\  1\\right], \\  \\left[ 1, \\  2\\right]\\right], \\  \\left[ 8, \\  \\left[ 3, \\  1\\right], \\  \\left[ 2, \\  2\\right]\\right]\\right]\\right]$"
+      ],
       "text/plain": [
-       "[[[1, 12, 14], [1, 15, 17], [1, 18, 20], [1, 21, 23]],\n",
-       " [[2, 26, 24], [2, 29, 27], [2, 32, 30], [2, 35, 33]],\n",
-       " [[3, 45, 36], [3, 46, 37], [3, 47, 38]],\n",
-       " [[4, 48, 57], [4, 49, 58], [4, 50, 59]],\n",
-       " [[5, 69, 62]],\n",
-       " [[5, 70, 60], [5, 71, 61]],\n",
-       " [[5, 60, 65], [5, 63, 68], [5, 66, 71]],\n",
-       " [[6, 72, 83]],\n",
-       " [[6, 73, 81], [6, 74, 82]],\n",
-       " [[6, 75, 74], [6, 78, 77], [6, 81, 80]],\n",
-       " [[7, 93, 85], [7, 94, 86]],\n",
-       " [[7, 95, 84]],\n",
-       " [[7, 86, 87], [7, 89, 90], [7, 92, 93]],\n",
-       " [[8, 96, 106], [8, 97, 107]],\n",
-       " [[8, 98, 105]],\n",
-       " [[8, 101, 96], [8, 104, 99], [8, 107, 102]],\n",
-       " [[1, [1, 2], [1, 1]],\n",
-       "  [1, [2, 2], [2, 1]],\n",
-       "  [1, [0, 2], [0, 1]],\n",
-       "  [1, [0, 1], [0, 0]],\n",
-       "  [1, [3, 2], [3, 1]],\n",
-       "  [1, [3, 1], [3, 0]],\n",
-       "  [2, [1, 0], [1, 1]],\n",
-       "  [2, [2, 0], [2, 1]],\n",
-       "  [2, [0, 0], [0, 1]],\n",
-       "  [2, [0, 1], [0, 2]],\n",
-       "  [2, [3, 0], [3, 1]],\n",
-       "  [2, [3, 1], [3, 2]],\n",
-       "  [3, [0, 0], [1, 0]],\n",
-       "  [3, [1, 0], [2, 0]],\n",
-       "  [3, [2, 0], [3, 0]],\n",
-       "  [3, [0, 2], [1, 2]],\n",
-       "  [3, [1, 2], [2, 2]],\n",
-       "  [3, [2, 2], [3, 2]],\n",
-       "  [3, [0, 1], [1, 1]],\n",
-       "  [4, [3, 0], [2, 0]],\n",
-       "  [4, [2, 0], [1, 0]],\n",
-       "  [4, [1, 0], [0, 0]],\n",
-       "  [4, [3, 2], [2, 2]],\n",
-       "  [4, [2, 2], [1, 2]],\n",
-       "  [4, [1, 2], [0, 2]],\n",
-       "  [4, [3, 1], [2, 1]],\n",
-       "  [5, [0, 2], [1, 1]],\n",
-       "  [5, [1, 2], [2, 1]],\n",
-       "  [5, [2, 2], [3, 1]],\n",
-       "  [5, [0, 2], [1, 1]],\n",
-       "  [5, [0, 1], [1, 0]],\n",
-       "  [6, [3, 2], [2, 1]],\n",
-       "  [6, [2, 2], [1, 1]],\n",
-       "  [6, [1, 2], [0, 1]],\n",
-       "  [6, [3, 2], [2, 1]],\n",
-       "  [6, [3, 1], [2, 0]],\n",
-       "  [7, [0, 0], [1, 1]],\n",
-       "  [7, [1, 0], [2, 1]],\n",
-       "  [7, [2, 0], [3, 1]],\n",
-       "  [7, [0, 0], [1, 1]],\n",
-       "  [7, [0, 1], [1, 2]],\n",
-       "  [8, [3, 0], [2, 1]],\n",
-       "  [8, [2, 0], [1, 1]],\n",
-       "  [8, [1, 0], [0, 1]],\n",
-       "  [8, [3, 0], [2, 1]],\n",
-       "  [8, [3, 1], [2, 2]]]]"
+       "[[[5, [3, 1], [0, 0]]], [], [[6, [0, 1], [3, 0]]], [], [[7, [3, 1], [0, 2]]], \n",
+       "[], [[8, [0, 1], [3, 2]]], [], [[5, [0, 1], [1, 0]], [6, [3, 1], [2, 0]], [7, \n",
+       "[0, 1], [1, 2]], [8, [3, 1], [2, 2]]]]"
       ]
      },
      "execution_count": 10,
@@ -507,7 +398,7 @@
     }
    ],
    "source": [
-    "periodic_mapper = SparseLbPeriodicityMapper(method, mapping, domain_size, (True, True))\n",
+    "periodic_mapper = SparseLbPeriodicityMapper(method, mapping, dh)\n",
     "periodic_mapper.create_index_arr()\n",
     "#periodic_index_array"
    ]
@@ -565,19 +456,7 @@
    "cell_type": "code",
    "execution_count": 12,
    "metadata": {},
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'index_arr' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-12-01d3d1672fc2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#index_field = ps.Field.create_from_numpy_array(\"idx\", index_arr, index_dimensions=1)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mindex_field\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mps\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mField\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcreate_generic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"idx\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mspatial_dimensions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindex_dimensions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mindex_arr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mcollision_rule\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_collision_rule\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'index_arr' is not defined"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "#index_field = ps.Field.create_from_numpy_array(\"idx\", index_arr, index_dimensions=1)\n",
     "index_field = ps.Field.create_generic(\"idx\", spatial_dimensions=1, index_dimensions=1, dtype=index_arr.dtype)\n",
@@ -595,7 +474,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -613,9 +492,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "domain: (4, 3)\n",
+      "pdf size in bytes: 288\n",
+      "pdf size: 36\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: 352\n"
+     ]
+    }
+   ],
    "source": [
     "if not channel:\n",
     "    if target == 'gpu':\n",
@@ -663,7 +556,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -701,7 +594,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {
     "scrolled": true
    },
@@ -716,7 +609,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -742,7 +635,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -756,7 +649,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -765,9 +658,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.quiver.Quiver at 0x7faf4a2b9910>"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "plt.vector_field(reference.velocity[:, :], step=1)"
    ]