Seperate inner-list working.

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)]