"""grid interpolation routines"""
import os
if os.environ.get('__USE_CUDA', '0') == '1':
import cupy as np
from cupy import ndarray
else:
import numpy as np
from numpy import ndarray
""" OBS! needs to be updated """
[docs]
class BoundaryInterp:
"""
"""
# boundary cell-2-node, not used when creating grid.
def __init__(self) -> None:
self.__n_list = 0
self.__l_list = []
self.__i_list = []
self.__np = 0
self.__n_loc = 0
self.__ip_loc = np.zeros(self.__n_list, dtype=np.int64)
self.__i_loc = np.zeros(self.__n_list, dtype=np.int64)
self.__l_loc = np.zeros(self.__n_list, dtype=np.int64)
self.__mov_x = np.zeros(self.__n_list, dtype=np.int64)
self.__id = [0, 1, -1, 0, 0, 0, 0]
self.__jd = [0, 0, 0, 1, -1, 0, 0]
self.__kd = [0, 0, 0, 0, 0, 1, -1]
[docs]
def interfaces(self, mesh):
"""
:param mesh:
"""
for intf in mesh.intfs:
imA, i0A, j0A, k0A, idA, jdA, niA, njA = intf[0]
imB, i0B, j0B, k0B, idB, jdB, niB, njB = intf[1]
ikd = self.__kd[idA]
jkd = self.__kd[jdA]
ijd = self.__jd[idA]
jjd = self.__jd[jdA]
iid = self.__id[idA]
jid = self.__id[jdA]
bA = mesh.blocks[imA - 1]
ldja = jkd * bA.ni * bA.nj + jjd * bA.ni + jid
ldia = ikd * bA.ni * bA.nj + ijd * bA.ni + iid
l0a = mesh.nmp[imA - 1] + (k0A - 1) * bA.ni * bA.nj + (j0A - 1) * bA.ni + i0A - 1
ikd = self.__kd[idB]
jkd = self.__kd[jdB]
ijd = self.__jd[idB]
jjd = self.__jd[jdB]
iid = self.__id[idB]
jid = self.__id[jdB]
bB = mesh.blocks[imB - 1]
ldjb = jkd * bB.ni * bB.nj + jjd * bB.ni + jid
ldib = ikd * bB.ni * bB.nj + ijd * bB.ni + iid
l0b = mesh.nmp[imB - 1] + (k0B - 1) * bB.ni * bB.nj + (j0B - 1) * bB.ni + i0B - 1
for j in range(njA):
for i in range(niA):
self.__n_list += 1
self.__i_list.append(2)
self.__np += 2
self.__l_list.append(l0a + j * ldja + i * ldia)
self.__l_list.append(l0b + j * ldjb + i * ldib)
if self.__n_list:
self.work()
[docs]
def work(self):
"""
:return:
"""
self.__ip_loc = np.zeros(self.__n_list + 1, dtype=np.int64)
self.__i_loc = np.zeros(self.__n_list, dtype=np.int64)
self.__l_loc = np.zeros(self.__n_list * 2, dtype=np.int64)
self.__mov_x = np.zeros(self.__n_list, dtype=np.int64)
while True:
# initialize l_loc & i_poc
self.__n_loc = self.__n_list
ip = 0
self.__ip_loc[0] = 0
for i in range(self.__n_list):
self.__i_loc[i] = self.__i_list[i]
self.__ip_loc[i + 1] = self.__ip_loc[i] + self.__i_list[i]
for j in range(self.__i_list[i]):
self.__l_loc[ip] = self.__l_list[ip]
ip += 1
# create mov_x list
ipA = -1
self.__mov_x.fill(0)
for iA in range(self.__n_list):
for jA in range(self.__i_list[iA]):
ipA += 1
ipB = -1
for iB in range(iA):
for jB in range(self.__i_list[iB]):
ipB += 1
f_tag = True if self.__mov_x[iA] == 0 else False
f_test = True if self.__l_list[ipA] == self.__l_list[ipB] else False
if f_tag and f_test:
self.__mov_x[iA] = iB
# make room in l_loc
for iA in range(self.__n_loc):
if self.__mov_x[iA]:
self.__i_loc[iA] -= self.__i_list[iA]
self.__i_loc[self.__mov_x[iA]] += self.__i_list[iA]
for iB in range(self.__mov_x[iA] + 1, iA + 1):
self.__ip_loc[iB] += self.__i_list[iA]
# modify l_loc according to mov_x
ipA = -1
for i in range(self.__n_loc):
if self.__mov_x[i]:
for j in range(self.__i_list[i]):
ipA += 1
ipB = self.__ip_loc[self.__mov_x[i]] + j
self.__l_loc[ipB] = self.__l_list[ipA]
self.__ip_loc[self.__mov_x[i]] += self.__i_list[i]
else:
for j in range(self.__i_list[i]):
ipA += 1
ipB = self.__ip_loc[i] + j
self.__l_loc[ipB] = self.__l_list[ipA]
self.__ip_loc[i] += self.__i_list[i]
ipA = 0
ipB = 0
self.__n_list = 0
for i in range(self.__n_loc):
self.__i_list[self.__n_list] = 0
for jA in range(self.__i_loc[i]):
self.__l_list[ipB + jA] = 0
for jA in range(self.__i_loc[i]):
f_test = False
for jB in range(self.__i_list[self.__n_list]):
f_test = f_test or (self.__l_loc[ipA + jA] == self.__l_list[ipB + jB])
if not f_test:
self.__l_list[ipB + self.__i_list[self.__n_list]] = self.__l_loc[ipA + jA]
self.__i_list[self.__n_list] += 1
ipA += self.__i_loc[i]
ipB += self.__i_list[self.__n_list]
if self.__i_list[self.__n_list]:
self.__n_list += 1
f_new_s = False
for i in range(self.__n_loc):
f_new_s = f_new_s or not (self.__i_loc[i] == self.__i_list[i])
if not f_new_s:
return
[docs]
def apply(self, data: ndarray):
"""
:param data:
"""
if self.__n_list:
ip0 = 0
for i in range(self.__n_list):
tot = 0
if self.__i_list[i] > 5:
pass
for j in range(self.__i_list[i]):
ip = ip0 + j
tot += data[self.__l_list[ip]]
for j in range(self.__i_list[i]):
ip = ip0 + j
data[self.__l_list[ip]] = tot / float(self.__i_list[i])
ip0 += self.__i_list[i]