From 3c9ba6edfe03a94f01c63bce72ecb33d53ba7602 Mon Sep 17 00:00:00 2001
From: Maja Warlich <maja@warlich.name>
Date: Mon, 1 Nov 2021 13:19:14 +0100
Subject: [PATCH] Send done.
---
lbmpy/sparse/mapping.py | 148 ++++++----
.../test_sparse_lbm_parallel_only.ipynb | 253 ++++++++----------
.../test_sparse_lbm_peridocity_only.ipynb | 21 +-
.../test_sparse_with_obstacles_lbm.ipynb | 72 +++--
4 files changed, 272 insertions(+), 222 deletions(-)
diff --git a/lbmpy/sparse/mapping.py b/lbmpy/sparse/mapping.py
index b6a8c2a..a87c19b 100644
--- a/lbmpy/sparse/mapping.py
+++ b/lbmpy/sparse/mapping.py
@@ -202,8 +202,8 @@ class SparseLbPeriodicityMapper:
self.periodicity = dh.periodicity
self.flag_arr = mapping._flag_arr
self.domain_size = self.flag_arr.shape
- self.fluid_flag = mapping.fluid_flag
self.no_slip_flag = mapping.no_slip_flag
+ self._ghost_cells = None
self._index_arrays = None
self._kernel = None
self._dirty = True
@@ -225,11 +225,11 @@ class SparseLbPeriodicityMapper:
def ghost_cells(self):
border_bool = [self.at_border(cell) for cell in self.mapping._coordinate_arr[:self.mapping.num_fluid_cells]]
- fluid_border_coord = self.mapping._coordinate_arr[:self.mapping.num_fluid_cells][border_bool]
- return fluid_border_coord
+ self._ghost_cells = self.mapping._coordinate_arr[:self.mapping.num_fluid_cells][border_bool]
+ return
- def get_pdf_read_idx(self, read, write, direction, direction_idx):
- if self.flag_arr[tuple(read)] & self.no_slip_flag: # Read cell is no-slip!
+ def get_pdf_read_idx(self, read, ghost, write, direction, direction_idx):
+ if (self.flag_arr[tuple(read)] | self.flag_arr[tuple(ghost)]) & self.no_slip_flag: # Read cell is no-slip!
# Change read cell to that cell that later wants to pull from the solid cell, get inverse PDF from it
read = [cell_i + dir_i for cell_i, dir_i in zip(write, direction)]
if self.flag_arr[tuple(read)] & self.no_slip_flag:
@@ -245,21 +245,22 @@ class SparseLbPeriodicityMapper:
cell_idx = self.mapping.cell_idx(cell)
direction_idx = self.mapping.stencil.index(direction)
inv_neighbor_cell = [(cell_i - 2*dir_i*int(bs_i))%ds_i for cell_i, dir_i, ds_i, bs_i in zip(cell, direction, self.domain_size, bool_slice)]
+ inv_ghost_cell = [(cell_i - dir_i*int(bs_i))%ds_i for cell_i, dir_i, ds_i, bs_i in zip(cell, direction, self.domain_size, bool_slice)]
#print("write:", cell, "read:", tuple(inv_neighbor_cell))
+ pdf_read_idx = self.get_pdf_read_idx(inv_neighbor_cell, inv_ghost_cell, cell, direction, direction_idx)
pdf_write_idx = pdf_index(cell_idx, direction_idx, len(self.mapping))
- pdf_read_idx = self.get_pdf_read_idx(inv_neighbor_cell, cell, direction, direction_idx)
return [pdf_write_idx, pdf_read_idx]
def create_periodic_index_array(self):
+ self.ghost_cells()
stencil = self.mapping.stencil
- fluid_border_coord = self.ghost_cells()
result = [[[] for j in range(0, len(stencil)-1)] for i in range(0, len(stencil)-1)]
for direction_idx, direction in enumerate(stencil):
if all(d_i == 0 for d_i in direction): # Direction (0,0) irrelevant
continue
#print("\n New direction:", direction, ", ", direction_idx)
periodic_slice_coord = [[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))]
- for cell in fluid_border_coord: # Only fluid ghost cells
+ for i, cell in enumerate(self._ghost_cells): # Only fluid ghost cells
bool_slice = [cell_i in slice_i for i, (cell_i, slice_i) in enumerate(zip(cell, periodic_slice_coord))]
periodic_coord_range = [[1 - dir_i, ds_i - 2 - dir_i] for dir_i, ds_i in zip(direction, self.domain_size)]
bool_range = [pcr_i[0] <= cell_i <= pcr_i[1] for pcr_i, cell_i in zip(periodic_coord_range, cell)]
@@ -302,81 +303,124 @@ class SparseLbCommunicationMapper:
self.mapping = mapping
self.flag_arr = mapping._flag_arr
self.domain_size = self.flag_arr.shape
- self.fluid_flag = mapping.fluid_flag
self.no_slip_flag = mapping.no_slip_flag
- self._index_arrays = None
+ self._send_packages = None
+ self._receive_here = None
+ self._received_packages = None
self._kernel = None
self._dirty = True
+
+ def _assemble(self):
+ self._coordinates_all = np.argwhere(np.bitwise_or(self.mapping._flag_arr, 1)).astype(np.uint32)
+
+
+ def _at_border(self, cell):
+ return True in [cell_i == 0 or cell_i == ds_i-1 for cell_i, ds_i in zip(cell, self.domain_size)]
+
+ def _ghost_cells(self):
+ if self._dirty:
+ self._assemble()
+ border_bool = [self._at_border(cell) for cell in self._coordinates_all]
+ return self._coordinates_all[border_bool]
- def at_border_not_ghost(self, cell):
- if True in [cell_i == 0 or cell_i == ds_i-1 for cell_i, ds_i in zip(cell, self.domain_size)]:
+ def _at_border_not_ghost(self, cell):
+ if self._at_border(cell):
return False
return True in [cell_i == 1 or cell_i == ds_i-2 for cell_i, ds_i in zip(cell, self.domain_size)]
- def border_cells(self):
- border_bool = [self.at_border_not_ghost(cell) for cell in self._coordinates_all]
- fluid_border_coord = self._coordinates_all[border_bool]
- return fluid_border_coord
-
- #def get_pdf_read_idx(self, read, write, direction, direction_idx):
- # if self.flag_arr[tuple(read)] & self.no_slip_flag: # Read cell is no-slip!
- # # Change read cell to that cell that later wants to pull from the solid cell, get inverse PDF from it
- # read = [cell_i + dir_i for cell_i, dir_i in zip(write, direction)]
- # if self.flag_arr[tuple(read)] & self.no_slip_flag:
- # # New read cell is no-slip as well! This can be a problem if pdf_index ends up being out-of-bounds, so the only operation is to pull read from the same place as write, changing nothing
- # read = write
- # else:
- # # Direction has to be flipped
- # direction_idx = inverse_idx(self.mapping.stencil, direction_idx)
- # #print("Neighbor is solid, new read is", tuple(read), "at dir", direction_idx)
- # return pdf_index(self.mapping.cell_idx(tuple(read)), direction_idx, len(self.mapping))
+ def _border_cells(self):
+ if self._dirty:
+ self._assemble()
+ border_bool = [self._at_border_not_ghost(cell) for cell in self._coordinates_all]
+ return self._coordinates_all[border_bool]
- def get_assignment(self, direction, cell, bool_slice):
+ def _get_assignment(self, direction, cell, neighbor, bool_slice):
cell = tuple(cell)
- if self.flag_arr[cell] & self.no_slip_flag:
- #print("pack:", cell, "is solid")
+ #print("pack:", cell, "neighbor:", tuple(neighbor))
+ if (self.flag_arr[cell] | self.flag_arr[tuple(neighbor)]) & self.no_slip_flag :
+ #print("is solid")
return -1
cell_idx = self.mapping.cell_idx(cell)
direction_idx = self.mapping.stencil.index(direction)
- #Maybe check n_ghost_cell later for solid?? Dunno???
- neighbor_ghost_cell = [(cell_i + dir_i*int(bs_i)) for cell_i, dir_i, bs_i in zip(cell, direction, bool_slice)]
- #print("pack:", cell, "ghost:", tuple(neighbor_ghost_cell))
pdf_cell_idx = pdf_index(cell_idx, direction_idx, len(self.mapping))
return pdf_cell_idx
def create_packages(self):
stencil = self.mapping.stencil
- self._coordinates_all = np.argwhere(np.bitwise_or(self.mapping._flag_arr, 1)).astype(np.uint32)
result = [[[] for j in range(0, len(stencil)-1)] for i in range(0, len(stencil)-1)]
for direction_idx, direction in enumerate(stencil):
if all(d_i == 0 for d_i in direction): # Direction (0,0) irrelevant
continue
#print("\n New direction:", direction, ", ", direction_idx)
periodic_slice_coord = [[int((ds_i-1)*(1+dir_i)/2-dir_i)] if dir_i != 0 else [] for i, (dir_i, ds_i) in enumerate(zip(direction, self.domain_size))]
- for cell in self.border_cells():
+ for cell in self._border_cells():
bool_slice = [cell_i in slice_i for (cell_i, slice_i) in zip(cell, periodic_slice_coord)]
- #periodic_coord_range = [[1 - dir_i, ds_i - 2 - dir_i] for dir_i, ds_i in zip(direction, self.domain_size)]
- #bool_range = [pcr_i[0] <= cell_i <= pcr_i[1] for pcr_i, cell_i in zip(periodic_coord_range, cell)]
- #print(cell, ", range", periodic_coord_range, "bool", bool_range)
- #print(cell, "per slice:", periodic_slice_coord, bool_slice)
if True in bool_slice: # This ghost cell needs this direction value
# block_direction: where to put this part of index_array (which block to send to...)
block_direction = [int(bp_i)*dir_i for dir_i, bp_i in zip(direction, bool_slice)]
block_index = self.mapping.stencil.index(tuple(block_direction))
- result[block_index-1][direction_idx-1].append(self.get_assignment(direction, cell, bool_slice))
+ neighbor_ghost_cell = [(cell_i + dir_i*int(bs_i)) for cell_i, dir_i, bs_i in zip(cell, direction, bool_slice)]
+ result[block_index-1][direction_idx-1].append(self._get_assignment(direction, cell, neighbor_ghost_cell, bool_slice))
#print("Goes into", block_index-1, direction_idx-1)
- # Flatten result array:
+ self._send_packages = np.array(result)
return result
- flattened_result = []
- for block in result:
- for i_a in block:
- if (i_a):
- flattened_result.append(np.array(i_a))
- flattened_result = np.array(flattened_result)
- self._index_arrays = flattened_result
- self._dirty = False
- return flattened_result
+
+ def receive_here(self):
+ stencil = self.mapping.stencil
+ result = [[[] for j in range(0, len(stencil)-1)] for i in range(0, len(stencil)-1)]
+ for direction_idx, direction in enumerate(stencil):
+ if all(d_i == 0 for d_i in direction): # Direction (0,0) irrelevant
+ continue
+ #print("\n New direction:", direction, ", ", direction_idx)
+ periodic_slice_coord = [[int((ds_i-1)*(1-dir_i)/2)] if dir_i != 0 else [] for (dir_i, ds_i) in zip(direction, self.domain_size)]
+ for cell in self._ghost_cells(): # Fluid and solid ghost cells
+ bool_slice = [cell_i in slice_i for (cell_i, slice_i) in zip(cell, periodic_slice_coord)]
+ periodic_coord_range = [[1 - dir_i, ds_i - 2 - dir_i] for dir_i, ds_i in zip(direction, self.domain_size)]
+ bool_range = [pcr_i[0] <= cell_i <= pcr_i[1] for pcr_i, cell_i in zip(periodic_coord_range, cell)]
+ #print(cell, ", range", periodic_coord_range, "bool", bool_range)
+ if all(bool_range): # This ghost cell needs this direction value
+ # block_direction: where to put this part of index_array (which block to send to...)
+ block_direction = [int(bp_i)*dir_i for dir_i, bp_i in zip(direction, bool_slice)]
+ block_index = self.mapping.stencil.index(tuple(block_direction))
+ future_pull_cell = [(cell_i + dir_i) for cell_i, dir_i, bs_i in zip(cell, direction, bool_slice)]
+ result[block_index-1][direction_idx-1].append(self._get_assignment(direction, cell, future_pull_cell, bool_slice))
+ #print("Goes into", block_index-1, direction_idx-1)
+ self._receive_here = np.array(result)
+ return result
+
+ def send(self):
+ stencil = self.mapping.stencil
+ send = []
+ for block in self._send_packages:
+ block_array = []
+ for direction in block:
+ if (direction):
+ for val in direction:
+ if val != -1:
+ block_array.append(val)
+ send.append(block_array)
+ return send
+
+ def create_index_array(self):
+ #During initialization, somehow receive packages ...
+ self._received_packages = self._send_packages #tmp
+ result = []
+ for block_rec, block_here in zip(self._received_packages, self._receive_here):
+ i = 0
+ for dir_rec, dir_here in zip(block_rec, block_here):
+ for val_rec, val_here in zip(dir_rec, dir_here):
+ print(val_rec, val_here)
+ if val_here == -1:
+ continue
+ elif val_rec == -1:
+ #Problem: Wie komme ich jetzt an die reverse direction der ersatzzelle????
+ return
+
+
+
+
+
diff --git a/lbmpy_tests/test_sparse_lbm_parallel_only.ipynb b/lbmpy_tests/test_sparse_lbm_parallel_only.ipynb
index 38b0808..db2f871 100644
--- a/lbmpy_tests/test_sparse_lbm_parallel_only.ipynb
+++ b/lbmpy_tests/test_sparse_lbm_parallel_only.ipynb
@@ -92,14 +92,14 @@
},
{
"cell_type": "code",
- "execution_count": 18,
+ "execution_count": 6,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
- "image/png": "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\n",
+ "image/png": "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\n",
"text/plain": [
"<Figure size 1152x432 with 2 Axes>"
]
@@ -118,9 +118,9 @@
"}\n",
"flag_arr = np.zeros(arr_size, dtype=np.uint16)\n",
"flag_arr.fill(flags['fluid'])\n",
- "#flag_arr[1][2] = 2\n",
- "flag_arr[2][1] = 3\n",
- "flag_arr[2:, 0] = 2\n",
+ "#flag_arr[1,4] = 2\n",
+ "#flag_arr[0,4] = 2\n",
+ "flag_arr[:, 0] = 2\n",
"plt.scalar_field(flag_arr)\n",
"plt.colorbar();"
]
@@ -183,124 +183,107 @@
"metadata": {},
"outputs": [
{
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "\n",
- " New direction: (0, 1) , 1\n",
- "pack: (1, 3) ghost: (1, 4)\n",
- "Goes into 0 0\n",
- "pack: (2, 3) ghost: (2, 4)\n",
- "Goes into 0 0\n",
- "pack: (3, 3) ghost: (3, 4)\n",
- "Goes into 0 0\n",
- "pack: (4, 3) ghost: (4, 4)\n",
- "Goes into 0 0\n",
- "\n",
- " New direction: (0, -1) , 2\n",
- "pack: (1, 1) ghost: (1, 0)\n",
- "Goes into 1 1\n",
- "pack: (2, 1) nowhere\n",
- "Goes into 1 1\n",
- "pack: (3, 1) ghost: (3, 0)\n",
- "Goes into 1 1\n",
- "pack: (4, 1) ghost: (4, 0)\n",
- "Goes into 1 1\n",
- "\n",
- " New direction: (-1, 0) , 3\n",
- "pack: (1, 1) ghost: (0, 1)\n",
- "Goes into 2 2\n",
- "pack: (1, 2) nowhere\n",
- "Goes into 2 2\n",
- "pack: (1, 3) ghost: (0, 3)\n",
- "Goes into 2 2\n",
- "\n",
- " New direction: (1, 0) , 4\n",
- "pack: (4, 1) ghost: (5, 1)\n",
- "Goes into 3 3\n",
- "pack: (4, 2) ghost: (5, 2)\n",
- "Goes into 3 3\n",
- "pack: (4, 3) ghost: (5, 3)\n",
- "Goes into 3 3\n",
- "\n",
- " New direction: (-1, 1) , 5\n",
- "pack: (1, 1) ghost: (0, 1)\n",
- "Goes into 2 4\n",
- "pack: (1, 2) nowhere\n",
- "Goes into 2 4\n",
- "pack: (1, 3) ghost: (0, 4)\n",
- "Goes into 4 4\n",
- "pack: (2, 3) ghost: (2, 4)\n",
- "Goes into 0 4\n",
- "pack: (3, 3) ghost: (3, 4)\n",
- "Goes into 0 4\n",
- "pack: (4, 3) ghost: (4, 4)\n",
- "Goes into 0 4\n",
- "\n",
- " New direction: (1, 1) , 6\n",
- "pack: (1, 3) ghost: (1, 4)\n",
- "Goes into 0 5\n",
- "pack: (2, 3) ghost: (2, 4)\n",
- "Goes into 0 5\n",
- "pack: (3, 3) ghost: (3, 4)\n",
- "Goes into 0 5\n",
- "pack: (4, 1) ghost: (5, 1)\n",
- "Goes into 3 5\n",
- "pack: (4, 2) ghost: (5, 2)\n",
- "Goes into 3 5\n",
- "pack: (4, 3) ghost: (5, 4)\n",
- "Goes into 5 5\n",
- "\n",
- " New direction: (-1, -1) , 7\n",
- "pack: (1, 1) ghost: (0, 0)\n",
- "Goes into 6 6\n",
- "pack: (1, 2) nowhere\n",
- "Goes into 2 6\n",
- "pack: (1, 3) ghost: (0, 3)\n",
- "Goes into 2 6\n",
- "pack: (2, 1) nowhere\n",
- "Goes into 1 6\n",
- "pack: (3, 1) ghost: (3, 0)\n",
- "Goes into 1 6\n",
- "pack: (4, 1) ghost: (4, 0)\n",
- "Goes into 1 6\n",
- "\n",
- " New direction: (1, -1) , 8\n",
- "pack: (1, 1) ghost: (1, 0)\n",
- "Goes into 1 7\n",
- "pack: (2, 1) nowhere\n",
- "Goes into 1 7\n",
- "pack: (3, 1) ghost: (3, 0)\n",
- "Goes into 1 7\n",
- "pack: (4, 1) ghost: (5, 0)\n",
- "Goes into 7 7\n",
- "pack: (4, 2) ghost: (5, 2)\n",
- "Goes into 3 7\n",
- "pack: (4, 3) ghost: (5, 3)\n",
- "Goes into 3 7\n"
- ]
+ "data": {
+ "text/plain": [
+ "[[[30, 34, 38, 42], [], [], [], [130, 134, 138], [150, 154, 158], [], []],\n",
+ " [[], [-1, -1, -1, -1], [], [], [], [], [-1, -1, -1], [-1, -1, -1]],\n",
+ " [[], [], [76, 77, 78], [], [124, 125], [], [173, 174], []],\n",
+ " [[], [], [], [112, 113, 114], [], [160, 161], [], [209, 210]],\n",
+ " [[], [], [], [], [126], [], [], []],\n",
+ " [[], [], [], [], [], [162], [], []],\n",
+ " [[], [], [], [], [], [], [-1], []],\n",
+ " [[], [], [], [], [], [], [], [-1]]]"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "[[30, 34, 38, 42, 130, 134, 138, 150, 154, 158],\n",
+ " [],\n",
+ " [76, 77, 78, 124, 125, 173, 174],\n",
+ " [112, 113, 114, 160, 161, 209, 210],\n",
+ " [126],\n",
+ " [162],\n",
+ " [],\n",
+ " []]"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
},
{
"data": {
"text/plain": [
- "[[[35, 39, 44, 49], [], [], [], [151, 156, 161], [175, 179, 184], [], []],\n",
- " [[], [62, -1, 70, 75], [], [], [], [], [-1, 210, 215], [230, -1, 238]],\n",
- " [[], [], [90, -1, 91], [], [146, -1], [], [-1, 203], []],\n",
- " [[], [], [], [131, 132, 133], [], [187, 188], [], [244, 245]],\n",
- " [[], [], [], [], [147], [], [], []],\n",
- " [[], [], [], [], [], [189], [], []],\n",
- " [[], [], [], [], [], [], [202], []],\n",
- " [[], [], [], [], [], [], [], [243]]]"
+ "[[[-1, -1, -1, -1], [], [], [], [-1, -1, -1], [-1, -1, -1], [], []],\n",
+ " [[], [55, 59, 63, 67], [], [], [], [], [179, 183, 187], [199, 203, 207]],\n",
+ " [[], [], [92, 93, 94], [], [140, 141], [], [189, 190], []],\n",
+ " [[], [], [], [96, 97, 98], [], [144, 145], [], [193, 194]],\n",
+ " [[], [], [], [], [-1], [], [], []],\n",
+ " [[], [], [], [], [], [-1], [], []],\n",
+ " [[], [], [], [], [], [], [191], []],\n",
+ " [[], [], [], [], [], [], [], [195]]]"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "30 -1\n",
+ "34 -1\n",
+ "38 -1\n",
+ "42 -1\n",
+ "130 -1\n",
+ "134 -1\n",
+ "138 -1\n",
+ "150 -1\n",
+ "154 -1\n",
+ "158 -1\n",
+ "-1 55\n",
+ "-1 59\n",
+ "-1 63\n",
+ "-1 67\n",
+ "-1 179\n",
+ "-1 183\n",
+ "-1 187\n",
+ "-1 199\n",
+ "-1 203\n",
+ "-1 207\n",
+ "76 92\n",
+ "77 93\n",
+ "78 94\n",
+ "124 140\n",
+ "125 141\n",
+ "173 189\n",
+ "174 190\n",
+ "112 96\n",
+ "113 97\n",
+ "114 98\n",
+ "160 144\n",
+ "161 145\n",
+ "209 193\n",
+ "210 194\n",
+ "126 -1\n",
+ "162 -1\n",
+ "-1 191\n",
+ "-1 195\n"
+ ]
}
],
"source": [
"parallel_mapper = SparseLbCommunicationMapper(mapping, dh, pdf_field)\n",
- "parallel_mapper.create_packages()"
+ "parallel_mapper.create_packages()\n",
+ "parallel_mapper.send()\n",
+ "parallel_mapper.receive_here()\n",
+ "parallel_mapper.create_index_array()"
]
},
{
@@ -348,11 +331,7 @@
" [180., 181., 182., 183., 184., 185., 186., 187., 188.],\n",
" [189., 190., 191., 192., 193., 194., 195., 196., 197.],\n",
" [198., 199., 200., 201., 202., 203., 204., 205., 206.],\n",
- " [207., 208., 209., 210., 211., 212., 213., 214., 215.],\n",
- " [216., 217., 218., 219., 220., 221., 222., 223., 224.],\n",
- " [225., 226., 227., 228., 229., 230., 231., 232., 233.],\n",
- " [234., 235., 236., 237., 238., 239., 240., 241., 242.],\n",
- " [243., 244., 245., 246., 247., 248., 249., 250., 251.]])"
+ " [207., 208., 209., 210., 211., 212., 213., 214., 215.]])"
]
},
"execution_count": 12,
@@ -372,34 +351,30 @@
{
"data": {
"text/plain": [
- "array([[ 0., 1., 2., 3., 4., 5., 195., 7., 8.],\n",
- " [ 9., 10., 11., 12., 175., 14., 177., 16., 17.],\n",
- " [ 18., 19., 20., 21., 184., 23., 186., 25., 188.],\n",
- " [ 27., 28., 29., 30., 193., 32., 33., 34., 197.],\n",
- " [ 36., 37., 38., 39., 40., 41., 42., 43., 179.],\n",
- " [ 45., 64., 47., 48., 49., 50., 69., 52., 53.],\n",
+ "array([[ 0., 1., 2., 3., 148., 5., 150., 7., 8.],\n",
+ " [ 9., 10., 11., 12., 157., 14., 159., 16., 161.],\n",
+ " [ 18., 19., 20., 21., 166., 23., 24., 25., 170.],\n",
+ " [ 27., 28., 29., 30., 31., 32., 33., 34., 59.],\n",
+ " [ 36., 37., 38., 39., 40., 41., 42., 43., 44.],\n",
+ " [ 45., 46., 47., 48., 49., 50., 51., 52., 53.],\n",
" [ 54., 55., 56., 57., 58., 59., 60., 61., 62.],\n",
- " [ 63., 64., 65., 66., 67., 68., 69., 70., 71.],\n",
- " [ 72., 73., 56., 75., 76., 77., 78., 79., 62.],\n",
- " [ 81., 100., 83., 84., 85., 104., 105., 88., 89.],\n",
+ " [ 63., 64., 55., 66., 67., 68., 69., 70., 95.],\n",
+ " [ 72., 73., 74., 75., 76., 77., 78., 79., 80.],\n",
+ " [ 81., 82., 83., 84., 85., 86., 87., 88., 89.],\n",
" [ 90., 91., 92., 93., 94., 95., 96., 97., 98.],\n",
- " [ 99., 100., 101., 102., 103., 104., 105., 106., 107.],\n",
- " [108., 109., 100., 111., 112., 113., 114., 69., 149.],\n",
- " [117., 145., 119., 120., 121., 149., 150., 124., 125.],\n",
+ " [ 99., 100., 91., 102., 103., 104., 105., 60., 131.],\n",
+ " [108., 109., 110., 111., 112., 113., 114., 115., 116.],\n",
+ " [117., 118., 119., 120., 121., 122., 123., 124., 125.],\n",
" [126., 127., 128., 129., 130., 131., 132., 133., 134.],\n",
- " [135., 136., 137., 138., 139., 140., 141., 142., 143.],\n",
+ " [135., 136., 127., 138., 139., 140., 141., 96., 167.],\n",
" [144., 145., 146., 147., 148., 149., 150., 151., 152.],\n",
- " [153., 154., 128., 156., 157., 158., 159., 133., 134.],\n",
- " [162., 190., 164., 165., 166., 194., 168., 169., 170.],\n",
- " [171., 172., 173., 174., 175., 176., 177., 178., 179.],\n",
- " [180., 181., 182., 183., 184., 185., 186., 187., 188.],\n",
- " [189., 190., 191., 192., 193., 194., 195., 196., 197.],\n",
- " [198., 199., 173., 201., 202., 203., 204., 178., 206.],\n",
- " [207., 208., 209., 210., 211., 68., 213., 214., 215.],\n",
- " [216., 217., 218., 57., 220., 59., 222., 223., 224.],\n",
- " [225., 226., 227., 184., 229., 197., 231., 177., 233.],\n",
- " [234., 235., 236., 66., 238., 239., 240., 70., 242.],\n",
- " [243., 244., 245., 246., 247., 248., 249., 61., 251.]])"
+ " [153., 154., 155., 156., 157., 158., 159., 160., 161.],\n",
+ " [162., 163., 164., 165., 166., 167., 168., 169., 170.],\n",
+ " [171., 172., 163., 174., 175., 176., 177., 132., 179.],\n",
+ " [180., 181., 182., 39., 184., 41., 186., 187., 188.],\n",
+ " [189., 190., 191., 48., 193., 50., 195., 52., 197.],\n",
+ " [198., 199., 200., 57., 202., 203., 204., 61., 206.],\n",
+ " [207., 208., 209., 210., 211., 212., 213., 168., 215.]])"
]
},
"execution_count": 13,
diff --git a/lbmpy_tests/test_sparse_lbm_peridocity_only.ipynb b/lbmpy_tests/test_sparse_lbm_peridocity_only.ipynb
index 7b2f095..cef3976 100644
--- a/lbmpy_tests/test_sparse_lbm_peridocity_only.ipynb
+++ b/lbmpy_tests/test_sparse_lbm_peridocity_only.ipynb
@@ -2,7 +2,7 @@
"cells": [
{
"cell_type": "code",
- "execution_count": 1,
+ "execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
@@ -12,7 +12,7 @@
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
@@ -38,7 +38,7 @@
},
{
"cell_type": "code",
- "execution_count": 3,
+ "execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
@@ -53,7 +53,7 @@
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
@@ -70,7 +70,7 @@
},
{
"cell_type": "code",
- "execution_count": 5,
+ "execution_count": 7,
"metadata": {},
"outputs": [
{
@@ -92,14 +92,14 @@
},
{
"cell_type": "code",
- "execution_count": 13,
+ "execution_count": 19,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
- "image/png": "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\n",
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1IAAAFpCAYAAACWBBlAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3df6ymZ3kf+O+VYVxS48bbmh+OfwBVRk1pGgw7MkauGjshxHZJvVmlkt0spDTRKJFZQUS6S1IJVFWqVoqW3SATrBG4jlV+KAKcWOmA7XRJCc2aeOwa/8AmO+vSena8GRsHg0MKmplr/zjvsC/H59cz7/ucd857Ph/p0Xmf577f577PoxlrLl/3fT3V3QEAAGDrvm/REwAAANhpBFIAAAADCaQAAAAGEkgBAAAMJJACAAAYSCAFAAAw0MyBVFW9uKr+pKq+VFWPVtW/WKPPVVX1XFU9ODneO+u4AAAAyZZjkqqqD1TVkap6qKpeP9V2TVV9ZdL2nq2M+aI5zPvbSX68u5+vqr1JvlBVn+nue1f1+6PufsscxgMAAJi2lZjk2iT7JscbknwoyRuqak+SDyb5ySRHk9xXVXd295c3GnDmjFSveH5yundyeMsvAACwLbYYk1yf5PZJ33uTnF9VFya5PMmR7n6iu7+T5BOTvhuayx6pqtpTVQ8mOZ7knu7+4hrd3jhJtX2mqv7OPMYFAABIthSTXJTkyanzo5Nr613f0DyW9qW7Tya5rKrOT3JHVf1Idz8y1eWBJK+cpNquS/K7WUmpvUBVHUhyIEnOPffc//aHf/iH5zFFWNPDx/9s0VPY8f7Kk3+x6CkshW9fcu6ipwDM0d992csXPQWW3P333/9Md7900fPYqp+6+tz+2rMnZ7rH/Q99+9Ek/3Xq0sHuPnj6ZAsxSa1x297g+obmEkh9d7Tur1fVHya5JskjU9e/MfX5UFX9VlVd0N3PrHGPg0kOJsn+/fv78OHD85wifI9X/+b/uugp7Hg/9Curt0NyJo68+4pFTwGYo8PvfPeip8CSq6r/vOg5DPHMsyfzxbsunukeey/8v/9rd+/frN96MUlWMk2XTJ1fnORYknPWub6heVTte+kk6ktVfX+SNyV5fFWfV1RVTT5fPhn3a7OODQAAsJWYJMmdSd42qd53RZLnuvupJPcl2VdVr66qc5LcMOm7oXlkpC5M8tuTahffl+R3uvv3q+qXkqS7b0nys0l+uapOJPnLJDd0t4IUAACwK3RO9qkxB9hKTHIoyXVJjiT5VpK3T9pOVNU7ktyVZE+SW7v70c0GnDmQ6u6Hkrxujeu3TH2+OcnNs44FAADsPJ3k1IiFvbcYk3SSm9b5/qGsBFpbNtc9UgAAAGs5lVEzUttuLuXPAQAAdhMZKQAAYFSdzsklK5EgkAIAAEY35h6pRRBIAQAAo+okJwVSAAAAwyxbRkqxCQAAgIFkpAAAgFF1otgEAADAUMv1FimBFAAAMLJOKzYBAAAwSCcnlyuOUmwCAABgKBkpAABgVB17pAAAAAaqnEwtehJzJZACAABG1UlO2SMFAACwu8lIAQAAo7O0DwAAYICOQAoAAGCwUy2QAgAA2LJlzEgpNgEAADCQjBQAADCqTuXkkuVwBFIAAMDo7JECAAAYYBn3SAmkAACAkVVO9nIt7Vuu3wYAAGAbyEgBAACj6iSnliyHI5ACAABGZ48UAADAAN32SAEAAOx6MlIAAMDoTlnaBwAAsHUr75FarsVwMwdSVfXiJJ9P8lcm9/tkd79vVZ9K8ptJrkvyrST/pLsfmHVsAABgJxh/j1RVXZLk9iSvSHIqycHu/s1Vff5Zkp+bnL4oyd9O8tLufraqvprkm0lOJjnR3fs3Gm8eGalvJ/nx7n6+qvYm+UJVfaa7753qc22SfZPjDUk+NPkJAAAsuW0qf34iybu7+4GqOi/J/VV1T3d/+bvz6P6NJL+RJFX100l+pbufnbrH1d39zFYGm/m36RXPT073To5e1e36JLdP+t6b5PyqunDWsQEAAJKku586veqtu7+Z5LEkF23wlRuTfPxMx5tLWFhVe6rqwSTHk9zT3V9c1eWiJE9OnR/NOr9UVR2oqsNVdfjpp5+ex/QAAIAFO9k105HkgtNxwuQ4sN5YVfWqJK9LsjouOd3+V5Nck+RTU5c7yd1Vdf9G9z5tLsUmuvtkksuq6vwkd1TVj3T3I9NzXetr69zrYJKDSbJ///41+wAAADtHp+ZRbOKZzfYtJUlVvSQrAdK7uvsb63T76ST/YdWyviu7+1hVvSzJPVX1eHd/fr1x5rpQsbu/nuQPsxLdTTua5JKp84uTHJvn2AAAwNnrVH/fTMdWTGo2fCrJR7v70xt0vSGrlvV197HJz+NJ7khy+UZjzRxIVdVLJ5moVNX3J3lTksdXdbszydtqxRVJnuvup2YdGwAAOPudLn8+y7GZSaXwjyR5rLvfv0G/H0jyY0l+b+rauZMCFamqc5O8Ockja99hxTyW9l2Y5Lerak9WArPf6e7fr6pfSpLuviXJoayUPj+SlfLnb5/DuAAAAKddmeStSR6e1G9Ikl9Pcmny3bgkSX4myd3d/RdT3315VrYoJSsx0se6+7MbDTZzINXdD2VlI9fq67dMfe4kN806FgAAsPN0vlswYrwxur+QtWszrO53W5LbVl17Islrh4w3l2ITAAAAG9mG90htK4EUAAAwqu7k5BYLRuwUy/XbAAAAbAMZKQAAYGSVU5tvX9pRBFIAAMCoOsu3tE8gBQAAjG4r74LaSQRSAADAqDqVUyOXP99uyxUWAgAAbAMZKQAAYHSW9gEAAAzQSU4pNgEAADBE5aTy5wAAAFu3jBmp5fptAAAAtoGMFAAAMDpL+wAAAAborqVb2ieQAgAARndyyQKp5fptAAAAtoGMFAAAMKpOcsoeKQAAgCFq6Zb2CaQAAIBRrbxHSkYKAABgkJNLVp5huX4bAACAbSAjBQAAjKpTlvYBAAAMdWrJFsMJpAAAgFF1JydlpAAAAIZZtqV9y5VfAwAA2AYyUgAAwKhWik0sVw5HIAUAAIzuZJZraZ9ACgAAGFXHHikAAIBdT0YKAAAY2fLtkZr5t6mqS6rqc1X1WFU9WlXvXKPPVVX1XFU9ODneO+u4AADAznEqNdOxmVnjkqq6pqq+UlVHquo9m403j4zUiSTv7u4Hquq8JPdX1T3d/eVV/f6ou98yh/EAAIAdZJteyHvGcUlV7UnywSQ/meRokvuq6s41vvtdMwdS3f1Ukqcmn79ZVY8luSjJuoMCAAC7y9hL+2aMSy5PcqS7n0iSqvpEkus3+u5c90hV1auSvC7JF9dofmNVfSnJsSS/2t2PrnOPA0kOJMmll146z+nBC/zQr9y76CnseHcde3DRU1gKP/WDi54BMFcvWFAEzMEFVXV46vxgdx9cq+MZxCUXJXlyqs/RJG/YaDJzC6Sq6iVJPpXkXd39jVXNDyR5ZXc/X1XXJfndJPvWus/kYRxMkv379/e85gcAACzGygt5Z17a90x379+s0xnGJWtNbsNYZC75taraO5nsR7v70y+YQfc3uvv5yedDSfZW1QXzGBsAADj7jV1sIpkpLjma5JKprhdnJWO1rpkzUlVVST6S5LHufv86fV6R5M+6u6vq8qwEcF+bdWwAAODstx0v5J0xLvl6kn1V9eok/0+SG5L8443Gm8fSviuTvDXJw1V1erPErye5NEm6+5YkP5vkl6vqRJK/THJDd1u2BwAAzMssccmJqnpHkruS7Ely63o1HU6bR9W+L2TtNYXTfW5OcvOsYwEAADvTNlTtmykumSz1O7TV8eZatQ8AAOAFei7FJs4qAikAAGBUnWy5YMROIZACAABGt2wZqXEXKgIAACwhGSkAAGBU21H+fLsJpAAAgNEJpAAAAAboqNoHAAAw2LJV7VNsAgAAYCAZKQAAYFxtjxQAAMAgqvYBAACcgWULpOyRAgAAGEhGCgAAGJXy5wAAAGegBVIAAADDLNt7pARSAADAqHoJy58rNgEAADCQjBQAADA6e6QAAAAGUbUPAABgMBkpAACAATqKTQAAAOx6MlIAAMC4eqUE+jIRSAEAAKPzQl4AAIABOstXbMIeKQAAgIFkpAAAgJF5jxQAAMBgik0AAAAMtGx7pARSAADAqLqXL5BSbAIAAGCgmQOpqrqkqj5XVY9V1aNV9c41+lRVfaCqjlTVQ1X1+lnHBQAAdo5TXTMdm9liXPJzk3jkoar646p67VTbV6vq4ap6sKoObzbePJb2nUjy7u5+oKrOS3J/Vd3T3V+e6nNtkn2T4w1JPjT5CQAA7ALbUGxiK3HJf0ryY93951V1bZKD+d645OrufmYrg80cSHX3U0memnz+ZlU9luSiJNMTvj7J7d3dSe6tqvOr6sLJdwEAgCU39h6prcQl3f3HU1+5N8nFZzreXPdIVdWrkrwuyRdXNV2U5Mmp86OTa2vd40BVHa6qw08//fQ8pwcAACxAp9I925HkgtNxwuQ4sN54G8Ql034hyWe+Z5rJ3VV1/0b3Pm1uVfuq6iVJPpXkXd39jdXNa3xlzeRedx/MSoot+/fvX7Jq8wAAwBl6prv3b9Zpk7jkdJ+rsxJI/b2py1d297GqelmSe6rq8e7+/HrjzCUjVVV7J5P9aHd/eo0uR5NcMnV+cZJj8xgbAAA4+/WMx1ZsIS5JVf1okg8nub67v/bd+XUfm/w8nuSOJJdvNNY8qvZVko8keay7379OtzuTvG1Sve+KJM/ZHwUAALvE5D1SMy7t29BW4pKqujTJp5O8tbv/dOr6uZMCFamqc5O8OckjG403j6V9VyZ5a5KHq+rBybVfT3JpknT3LUkOJbkuyZEk30ry9jmMCwAA7BTjb9rZSlzy3iR/I8lvrcRdOTFZLvjyJHdMrr0oyce6+7MbDTaPqn1fyNp7oKb7dJKbZh0LAABgLVuMS34xyS+ucf2JJK994TfWN7diEwAAAOsZu/z5dhNIAQAAo9uGF/JuK4EUAAAwqo6MFAAAwDCdZMkCqbm8RwoAAGA3kZECAABGZ48UAADAUAIpAACAIUqxCQAAgMGWLCOl2AQAAMBAMlIAAMC42nukAAAAhluypX0CKQAAYBssV0bKHikAAICBZKQAAIDxWdoHAAAwkEAKAABggE6iah8AAMAwvWQZKcUmAAAABpKRAgAAxrdkGSmBFAAAMD57pAAAAIYpGSkAAIABOku3tE+xCQAAgIFkpAAAgJGVPVIAAACDLdnSPoEUAAAwviULpOyRAgAAGEhGCgAAGN+SZaQEUgAAwLg6ik0AAAAMtWwv5J3LHqmqurWqjlfVI+u0X1VVz1XVg5PjvfMYFwAA2CF6xmMTVXVJVX2uqh6rqker6p1r9Kmq+kBVHamqh6rq9VNt11TVVyZt79lsvHllpG5LcnOS2zfo80fd/ZY5jQcAADDtRJJ3d/cDVXVekvur6p7u/vJUn2uT7Jscb0jyoSRvqKo9ST6Y5CeTHE1yX1Xdueq732MuGanu/nySZ+dxLwAAgKG6+6nufmDy+ZtJHkty0apu1ye5vVfcm+T8qrowyeVJjnT3E939nSSfmPRd13aWP39jVX2pqj5TVX9nG8cFAAAWrHq2Y9BYVa9K8rokX1zVdFGSJ6fOj06urXd9XdtVbOKBJK/s7uer6rokv5uVdNoLVNWBJAeS5NJLL92m6QFn6qd+8LJFTwEA2Almr9p3QVUdnjo/2N0HV3eqqpck+VSSd3X3N1Y3rzWzDa6va1sCqelfoLsPVdVvVdUF3f3MGn0PJjmYJPv371+y2h4AALALbbFgxCae6e79G3Woqr1ZCaI+2t2fXqPL0SSXTJ1fnORYknPWub6ubVnaV1WvqKqafL58Mu7XtmNsAABg+U3ijY8keay7379OtzuTvG1Sve+KJM9191NJ7kuyr6peXVXnJLlh0nddc8lIVdXHk1yVlXTb0STvS7I3Sbr7liQ/m+SXq+pEkr9MckN3yzYBAMBuMf6//q9M8tYkD1fVg5Nrv57k0uS7ccmhJNclOZLkW0nePmk7UVXvSHJXkj1Jbu3uRzcabC6BVHffuEn7zVkpjw4AAOxCY7+Qt7u/kLX3Ok336SQ3rdN2KCuB1pZsV7EJAABgN1uy9WjbWf4cAABgKchIAQAA41uyjJRACgAAGNWZvFT3bCeQAgAAxjf7C3nPKgIpAABgfEuWkVJsAgAAYCAZKQAAYHT2SAEAAAwlkAIAABhgCav22SMFAAAwkIwUAAAwviXLSAmkAACA8QmkAAAAhrFHCgAAYJcTSAEAAAxkaR8AADC+JVvaJ5ACAADGtYTvkRJIAQAA4xNIAQAADLRkgZRiEwAAAAPJSAEAAKOq2CMFAAAwnEAKAABggCWs2mePFAAAwEAyUgAAwPiWLCMlkAIAAMYnkAIAABhm2fZICaQAAIDxLVkgpdgEAADAQDJSAADAuDpLl5ESSAEAAKNbtj1Sc1naV1W3VtXxqnpknfaqqg9U1ZGqeqiqXj+PcQEAgB2iZzw2sYWY5J9V1YOT45GqOllVf33S9tWqenjSdngrv8689kjdluSaDdqvTbJvchxI8qE5jQsAAOwA1bMdW3BbNohJuvs3uvuy7r4sya8l+ffd/exUl6sn7fu3MthcAqnu/nySZzfocn2S23vFvUnOr6oL5zE2AADAFmKSaTcm+fgs421X1b6Lkjw5dX50cu0FqupAVR2uqsNPP/30tkwOAAAY2exL+y44HSdMjgNnMo2q+qtZyVx9atXs7q6q+7d63+0qNlFrXFszQdfdB5McTJL9+/cv2ZY0AADYheZTte+ZrS6728RPJ/kPq5b1Xdndx6rqZUnuqarHJxmudW1XRupokkumzi9OcmybxgYAABao5nDM0Q1Ztayvu49Nfh5PckeSyze7yXYFUncmeduket8VSZ7r7qe2aWwAAIBU1Q8k+bEkvzd17dyqOu/05yRvTrJm5b9pc1naV1UfT3JVVtYtHk3yviR7k6S7b0lyKMl1SY4k+VaSt89jXAAAYIcYedPOFmKSJPmZJHd3919MffXlSe6oqmQlPvpYd392s/HmEkh1942btHeSm+YxFgAAsPOM/ULezWKSSZ/bslImffraE0leO3S87So2AQAA7GZLVkZOIAUAAIxvyQKp7So2AQAAsDRkpAAAgHH1+HuktptACgAAGJ9ACgAAYBgZKQAAgKGWLJBSbAIAAGAgGSkAAGB0lvYBAAAM0Vm6pX0CKQAAYHxLFkjZIwUAADCQjBQAADCqij1SAAAAwwmkAAAAhqlerkhKIAUAAIxrCav2KTYBAAAwkIwUAAAwOsUmAAAAhhJIAQAADCMjBQAAMNSSBVKKTQAAAAwkIwUAAIyrLe0DAAAYTiAFAACwdZXly0jZIwUAADCQjBQAADC+Xq6UlEAKAAAY3bIt7RNIAQAA4+ooNgEAADBUnVr0DOZLsQkAAICBZKQAAIDxLdnSvrlkpKrqmqr6SlUdqar3rNF+VVU9V1UPTo73zmNcAABgZ6ie7dj0/lW3VtXxqnpknfZ1Y5LN4pm1zJyRqqo9ST6Y5CeTHE1yX1Xd2d1fXtX1j7r7LbOOBwAA7DCd7Sh/fluSm5PcvkGfF8QkA+KZ7zGPjNTlSY509xPd/Z0kn0hy/RzuCwAALImxM1Ld/fkkz57B1M4onpnHHqmLkjw5dX40yRvW6PfGqvpSkmNJfrW7H13rZlV1IMmBJLn00kvnMD1Y35H/7YpFT2HH+6FfuXfRU1gK/iwCwKYuqKrDU+cHu/vgwHusFZNsNZ75HvMIpGqNa6tjxgeSvLK7n6+q65L8bpJ9a91s8jAOJsn+/fuXbEsaAADsUrP/y/6Z7t4/w/fXi0m2Es+8wDyW9h1NcsnU+cVZifD+/1l0f6O7n598PpRkb1VdMIexAQCAs1xl/KV9m9kgJtk0nlnLPAKp+5Lsq6pXV9U5SW5Icud0h6p6RVXV5PPlk3G/NoexAQCAs1337MeMNohJNo1n1jLz0r7uPlFV70hyV5I9SW7t7ker6pcm7bck+dkkv1xVJ5L8ZZIbuscv2wEAAOwOVfXxJFdlZS/V0STvS7I32TQmWTOe2Wy8ubyQd5IaO7Tq2i1Tn2/OSilCAABgF5rH8ryNdPeNm7SvG5OsFc9sZi6BFAAAwIaWbD2aQAoAABjd2Bmp7SaQAgAAxtVJTi1XJDWPqn0AAAC7iowUAAAwvuVKSAmkAACA8dkjBQAAMNSSvUZWIAUAAIxu2TJSik0AAAAMJCMFAACMq6PYBAAAwBCVpOyRAgAAGOjUoicwX/ZIAQAADCQjBQAAjM7SPgAAgCEUmwAAABiqvZAXAABgKC/kBQAA2OVkpAAAgPFZ2gcAADBAJ7Vk75ESSAEAAONbsoyUPVIAAAADyUgBAADjW66ElEAKAAAYXy3Z0j6BFAAAMD6BFAAAwACdZMmq9ik2AQAAMJCMFAAAMKpK2yMFAAAwmEAKAABgIIEUAADAAIpNAAAAMJdAqqquqaqvVNWRqnrPGu1VVR+YtD9UVa+fx7gAAMDOUN0zHZvev+rWqjpeVY+s0/5zk1jkoar646p67VTbV6vq4ap6sKoOb+X3mTmQqqo9ST6Y5Nokr0lyY1W9ZlW3a5PsmxwHknxo1nEBAIAdpHu2Y3O3Jblmg/b/lOTHuvtHk/zLJAdXtV/d3Zd19/6tDDaPjNTlSY509xPd/Z0kn0hy/ao+1ye5vVfcm+T8qrpwDmMDAABnvRmDqC0EUt39+STPbtD+x93955PTe5NcPMtvNI9A6qIkT06dH51cG9onSVJVB6rqcFUdfvrpp+cwPQAAYAlccDpOmBwHZrjXLyT5zNR5J7m7qu7f6n3nUbWv1ri2OmTcSp+Vi90HM0mz7d+/f7lqJAIAwG7UmUf582e2uuxuI1V1dVYCqb83dfnK7j5WVS9Lck9VPT7JcK1rHhmpo0kumTq/OMmxM+gDAAAsq1MzHnNQVT+a5MNJru/ur52+3t3HJj+PJ7kjK9uXNjSPQOq+JPuq6tVVdU6SG5LcuarPnUneNqned0WS57r7qTmMDQAA7ABjV+3bdPyqS5N8Oslbu/tPp66fW1Xnnf6c5M1J1qz8N23mpX3dfaKq3pHkriR7ktza3Y9W1S9N2m9JcijJdUmOJPlWkrfPOi4AALCDzCEY2khVfTzJVVnZS3U0yfuS7F0Zum9J8t4kfyPJb1VVkpyYLBV8eZI7JtdelORj3f3Zzcabxx6pdPehrARL09dumfrcSW6ax1gAAACrdfeNm7T/YpJfXOP6E0le+8JvbGwugRQAAMC6Osmp5aojJ5ACAABGtuWX6u4YAikAAGB8AikAAICBliyQmkf5cwAAgF1FRgoAABiXYhMAAABDddKnFj2JuRJIAQAA47NHCgAAYHeTkQIAAMZljxQAAMAZWLKlfQIpAABgfAIpAACAIXrpAinFJgAAAAaSkQIAAMbVSU55jxQAAMAwS7a0TyAFAACMTyAFAAAwRC/de6QUmwAAABhIRgoAABhXJ92KTQAAAAyzZEv7BFIAAMD4lqzYhD1SAAAAA8lIAQAA4+r2Ql4AAIDBlmxpn0AKAAAYXctIAQAADNFLl5FSbAIAAGAgGSkAAGBcHe+RAgAAGKztkQIAANiyTtJLlpGaaY9UVf31qrqnqv6vyc//Zp1+X62qh6vqwao6PMuYAADADtO9kpGa5dhEVd1aVcer6pF12quqPlBVR6rqoap6/VTbNVX1lUnbe7byK81abOI9Sf5dd+9L8u8m5+u5ursv6+79M44JAACw2m1Jrtmg/dok+ybHgSQfSpKq2pPkg5P21yS5sapes9lgswZS1yf57cnn307y3814PwAAYAn1qZ7p2PT+3Z9P8uwGXa5PcnuvuDfJ+VV1YZLLkxzp7ie6+ztJPjHpu6FZA6mXd/dTk4k/leRl6/TrJHdX1f1VdWDGMQEAgJ1m5KV9W3BRkienzo9Orq13fUObFpuoqj9I8oo1mv75Zt+dcmV3H6uqlyW5p6oen0SMa413ICuptiR5vqq+MmCcebogyTMLGntZeIbzcVY/x68uegJbc1Y/wyTJuz656Blsxdn/HM9+nuF8nPXPsd71q4uewmbO+me4QyzyOb5yQeOekW/mz+/6g/7kBTPe5sWr6i0c7O6DA75fa1zrDa5vaNNAqrvftO5Mqv6sqi7s7qcmabHj69zj2OTn8aq6IyvpszUDqcnDGPJARlFVh+3nmo1nOB+e4+w8w/nwHGfnGc6H5zg7z3A+PMet6+6N9i5tl6NJLpk6vzjJsSTnrHN9Q7Mu7bszyc9PPv98kt9b3aGqzq2q805/TvLmJGtW0gAAABjJnUneNqned0WS5ybbk+5Lsq+qXl1V5yS5YdJ3Q7O+R+p/SfI7VfULSf5Lkn+UJFX1g0k+3N3XJXl5kjuq6vR4H+vuz844LgAAwHdV1ceTXJXkgqo6muR9SfYmSXffkuRQkuuSHEnyrSRvn7SdqKp3JLkryZ4kt3b3o5uNN1Mg1d1fS/ITa1w/NplkuvuJJK+dZZwFWfjywiXgGc6H5zg7z3A+PMfZeYbz4TnOzjOcD8/xLNLdN27S3kluWqftUFYCrS2rlfsBAACwVbPukQIAANh1BFLrqKrfqKrHq+qhqrqjqs5f9Jx2oqr6R1X1aFWdqipVbQaoqmuq6itVdaSq3rPo+exEVXVrVR2vKgVuzlBVXVJVn6uqxyZ/l9+56DntRFX14qr6k6r60uQ5/otFz2mnqqo9VfUfq+r3Fz2XnaqqvlpVD1fVg6tKSbNFVXV+VX1y8m/Fx6rqjYueE9tPILW+e5L8SHf/aJI/TfJrC57PTvVIkv8+65S7Z21VtSfJB5Ncm+Q1SW6sqtcsdlY70m1JzoZyqzvZiSTv7u6/neSKJDf5s3hGvp3kx7v7tUkuS3LNpGIUw70zyWOLnsQSuLq7L1O6+4z9ZpLPdvcPZ6UWgD+Tu5BAah3dfXd3n5ic3puVevIM1N2PdfeiXqq8k12e5Eh3P9Hd30nyiSTXL3hOO87kxd/PLnoeO1l3P9XdD0w+fzMr/1jY9G3vfK9e8fzkdO/ksEl5oKq6OMk/SC+9XpgAAAKnSURBVPLhRc+F3auq/lqSv5/kI0nS3d/p7q8vdlYsgkBqa/5pks8sehLsKhcleXLq/Gj845UFq6pXJXldki8udiY702RJ2oNZeXn9Pd3tOQ73vyf5n5KcWvREdrhOcndV3V9VBxY9mR3obyZ5Osm/niwz/fDkXansMrs6kKqqP6iqR9Y4rp/q88+zsrTlo4ub6dltK8+RwWqNa/7vNQtTVS9J8qkk7+rubyx6PjtRd5/s7suyssLh8qr6kUXPaSepqrckOd7d9y96Lkvgyu5+fVaWj99UVX9/0RPaYV6U5PVJPtTdr0vyF0nsZd6FZn0h747W3W/aqL2qfj7JW5L8RKsTv67NniNn5GiSS6bOL05ybEFzYZerqr1ZCaI+2t2fXvR8drru/npV/WFW9u8phLJ1Vyb5h1V1XZIXJ/lrVfVvuvt/WPC8dpzJ+z7T3cer6o6sLCe3l3nrjiY5OpVV/mQEUrvSrs5IbaSqrknyPyf5h939rUXPh13nviT7qurVVXVOkhuS3LngObELVVVlZR/AY939/kXPZ6eqqpeerv5aVd+f5E1JHl/srHaW7v617r64u1+Vlf8m/h+CqOGq6tyqOu/05yRvjoB+kO7+f5M8WVV/a3LpJ5J8eYFTYkEEUuu7Ocl5Se6ZlAe9ZdET2omq6meq6miSNyb5t1V116LntBNMCp28I8ldWdnc/zvd/ehiZ7XzVNXHk/yfSf5WVR2tql9Y9Jx2oCuTvDXJj0/+W/jgJCPAMBcm+VxVPZSV/1FyT3cr380ivDzJF6rqS0n+JMm/7e7PLnhOO9H/mOSjk7/TlyX5VwueDwtQVqwBAAAMIyMFAAAwkEAKAABgIIEUAADAQAIpAACAgQRSAAAAAwmkAAAABhJIAQAADCSQAgAAGOj/Ax0EVP4Xa7ZEAAAAAElFTkSuQmCC\n",
"text/plain": [
"<Figure size 1152x432 with 2 Axes>"
]
@@ -118,8 +118,11 @@
"}\n",
"flag_arr = np.zeros(arr_size, dtype=np.uint16)\n",
"flag_arr.fill(flags['fluid'])\n",
- "flag_arr[1][2] = 2\n",
- "flag_arr[2][1] = 2\n",
+ "flag_arr[2:,0] = 2\n",
+ "flag_arr[1, 2] = 3\n",
+ "flag_arr[:1, 0] = 2\n",
+ "flag_arr[2:,3] = 2\n",
+ "flag_arr[:1, 3] = 2\n",
"plt.scalar_field(flag_arr)\n",
"plt.colorbar();"
]
diff --git a/lbmpy_tests/test_sparse_with_obstacles_lbm.ipynb b/lbmpy_tests/test_sparse_with_obstacles_lbm.ipynb
index f4abe81..2834325 100644
--- a/lbmpy_tests/test_sparse_with_obstacles_lbm.ipynb
+++ b/lbmpy_tests/test_sparse_with_obstacles_lbm.ipynb
@@ -130,16 +130,16 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"def set_sphere(x, y, *_):\n",
" c = -1\n",
" mid = list()\n",
- " factor = 1\n",
- " start = math.ceil(domain_size[0]*2/9)\n",
- " end = math.ceil(domain_size[0]*13/18)\n",
+ " factor = 0.5\n",
+ " start = math.ceil(domain_size[0]*1/9)\n",
+ " end = math.ceil(domain_size[0]*17/18)\n",
" radius = math.ceil(domain_size[1]*1/12*factor)\n",
" d = math.ceil(radius*0.8)\n",
" dist_x = 3*radius\n",
@@ -156,7 +156,7 @@
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
@@ -169,12 +169,12 @@
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
- "image/png": "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\n",
+ "image/png": "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\n",
"text/plain": [
"<Figure size 1152x432 with 2 Axes>"
]
@@ -203,6 +203,34 @@
"plt.colorbar();"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/latex": [
+ "$\\displaystyle 0.7211303323974277$"
+ ],
+ "text/plain": [
+ "0.7211303323974277"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "#Get porosity\n",
+ "def porosity(flag_arr):\n",
+ " return flag_arr[flag_arr == flags['fluid']].size/flag_arr.size\n",
+ "\n",
+ "porosity(flag_arr)"
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
@@ -212,7 +240,7 @@
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": 11,
"metadata": {},
"outputs": [
{
@@ -225,7 +253,7 @@
"(34900, 8)"
]
},
- "execution_count": 10,
+ "execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
@@ -246,7 +274,7 @@
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
@@ -261,7 +289,7 @@
},
{
"cell_type": "code",
- "execution_count": 12,
+ "execution_count": 13,
"metadata": {},
"outputs": [
{
@@ -274,7 +302,7 @@
"(u₀, u₁)"
]
},
- "execution_count": 12,
+ "execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
@@ -292,7 +320,7 @@
},
{
"cell_type": "code",
- "execution_count": 13,
+ "execution_count": 14,
"metadata": {
"scrolled": true
},
@@ -307,7 +335,7 @@
"(34900, 2)"
]
},
- "execution_count": 13,
+ "execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
@@ -357,7 +385,7 @@
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
@@ -377,7 +405,7 @@
},
{
"cell_type": "code",
- "execution_count": 15,
+ "execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
@@ -395,7 +423,7 @@
},
{
"cell_type": "code",
- "execution_count": 16,
+ "execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
@@ -435,7 +463,7 @@
},
{
"cell_type": "code",
- "execution_count": 17,
+ "execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
@@ -470,7 +498,7 @@
},
{
"cell_type": "code",
- "execution_count": 18,
+ "execution_count": 19,
"metadata": {},
"outputs": [
{
@@ -485,7 +513,7 @@
"<IPython.core.display.HTML object>"
]
},
- "execution_count": 18,
+ "execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
@@ -515,7 +543,7 @@
},
{
"cell_type": "code",
- "execution_count": 19,
+ "execution_count": 20,
"metadata": {},
"outputs": [
{
@@ -525,7 +553,7 @@
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
- "\u001b[0;32m<ipython-input-19-580a42c05a1e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m reference = create_lid_driven_cavity(domain_size, relaxation_rate=omega, lid_velocity=lid_velocity,\n\u001b[1;32m 5\u001b[0m compressible=False)\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mreference\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimesteps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+ "\u001b[0;32m<ipython-input-20-580a42c05a1e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m reference = create_lid_driven_cavity(domain_size, relaxation_rate=omega, lid_velocity=lid_velocity,\n\u001b[1;32m 5\u001b[0m compressible=False)\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mreference\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtimesteps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mNameError\u001b[0m: name 'timesteps' is not defined"
]
}
--
GitLab