def ABPW(self, r):
x, y = sp.symbols("x y")
P = np.array([
h.cut(np.linalg.norm(np.array(d) - self.point),
r,
[0 for _ in self.basis],
self.preP[i])
for i, d in enumerate(self.data)], dtype=np.float64)
W = num.Diagonal([
h.cut(np.linalg.norm(np.array([xj, yj]) - self.point),
r,
num.Function(sp.Integer(0),name = "0"),
num.Function(self.weight_function.sympy(), {
'xj': xj,
'yj': yj,
'r': r
}, name="g"))
for xj, yj in self.data])
Pt = num.Constant(np.transpose(P))
B = num.Product([Pt, W])
A = num.Product([B, num.Constant(P)])
return A, B, P, W
def template(self, method_class, model_class, region):
data = region.all_points
model = model_class(region=region)
method = method_class(model=model, basis=quadratic_2d)
result = method.solve()
print("result", result.shape)
region.plot()
if model.coordinate_system == "polar":
plt.scatter(data[:, 0], data[:, 1])
x = data[:, 0]
y = data[:, 1]
norm = np.sqrt(x * x + y * y)
x_norm = x / norm
y_norm = y / norm
r = result.reshape(int(result.size / model.num_dimensions),
model.num_dimensions)[:, 0]
plt.scatter(data[:, 0] + r * x_norm, data[:, 1] + y_norm * r)
for index, point in enumerate(data):
analytical_r = num.Function(
model.analytical[0], name="analytical ux(%s)").eval(point)
x = point[0]
y = point[1]
norm = np.sqrt(x * x + y * y)
x_norm = x / norm
y_norm = y / norm
plt.plot(point[0] + analytical_r * x_norm,
point[1] + y_norm * analytical_r, "r^")
elif model.coordinate_system == "rectangular":
plt.scatter(data[:, 0], data[:, 1], "s")
computed = result.reshape(int(result.size / 2), 2)
plt.scatter((data + computed)[:, 0], (data + computed)[:, 1])
for index, point in enumerate(data):
analytical_x = num.Function(
model.analytical[0], name="analytical u(%s)").eval(point)
analytical_y = num.Function(
model.analytical[1], name="analytical v(%s)").eval(point)
plt.plot(point[0] + analytical_x, point[1] + analytical_y,
"r^")
plt.show()
# test if system makes sense
print("stiffness", method.stiffness)
print(
"np.matmul(method.stiffness,np.transpose([corrects])) - method.b",
np.matmul(method.stiffness, corrects) - method.b)
result = result.reshape(model.num_dimensions * len(data))
diff = corrects - result
print('diff', diff)
self.assertAlmostEqual(np.linalg.norm(diff) / len(corrects), 0, 3)
def petrov_galerkin_independent_boundary(self, w, integration_point):
nx, ny = self.region.normal(integration_point)
N = np.array([[nx, 0, ny], [0, ny, nx]])
u = num.Function(self.analytical[0], name="u(%s)" % integration_point)
v = num.Function(self.analytical[1], name="v(%s)" % integration_point)
ux = u.derivate("x").eval(integration_point)
uy = u.derivate("y").eval(integration_point)
vx = v.derivate("x").eval(integration_point)
vy = v.derivate("y").eval(integration_point)
time_points = self.D.shape[2]
D = np.moveaxis(self.D, 2, 0)
Ltu = np.moveaxis(
np.array([[ux.ravel()], [vy.ravel()], [(uy + vx).ravel()]]), 2, 0)
# return -w.eval(integration_point)*np.tensordot(N, np.tensordot(self.D, Ltu, axes=(1,0)), axes=(1,0)).reshape((2,self.D.shape[2]))
return np.moveaxis(-w.eval(integration_point) * N @ D @ Ltu, 0,
2).reshape(2, time_points)
def petrov_galerkin_independent_boundary(self, w, integration_point):
nx, ny = self.region.normal(integration_point)
N = np.array([[nx, ny]])
u = num.Function(self.analytical, name="u(%s)"%integration_point)
ux = u.derivate("x").eval(integration_point)
uy = u.derivate("y").eval(integration_point)
du = np.array([[ux],
[uy]])
return w.eval(integration_point)*N@du
def test_invese_derivate(self):
x = sp.var("x")
self.assertEqual(
num.Inverse(num.Diagonal([num.Function(x**2)
])).derivate('x').eval([3, 0])[0, 0],
-2 * 3**(-3))
def visco_template(self, method_class, model_class, region):
# region.plot()
# plt.show()
data = region.all_points
model = model_class(region=region)
method = method_class(model=model, basis=quadratic_2d)
# cache_path = "result.npy"
# if os.path.exists(cache_path):
# result = np.load(cache_path)
# else:
# result = method.solve()
# np.save(cache_path, result)
result = method.solve()
print("result", result)
def nearest_indices(t):
print(".", end="")
return np.abs(model.s - t).argmin()
fts = np.array([[
mp.invertlaplace(lambda t: result[nearest_indices(t)][i][0],
x,
method='stehfest',
degree=model.iterations)
for x in range(1, model.time + 1)
] for i in range(result.shape[1])],
dtype=np.float64)
for point_index, point in enumerate(data):
analytical_x = num.Function(model.analytical[0],
name="analytical ux(%s)").eval(
point)[::model.iterations].ravel()
analytical_y = num.Function(model.analytical[1],
name="analytical uy(%s)").eval(
point)[::model.iterations].ravel()
calculated_x = fts[2 * point_index].ravel()
calculated_y = fts[2 * point_index + 1].ravel()
print('point', point)
print('calculated_x, point diff, analytical', [
calculated_x,
np.diff(calculated_x),
analytical_x,
])
print('calculated_y', calculated_y)
plt.plot(point[0], point[1], "r^-")
plt.plot(point[0] + np.diff(calculated_x),
point[1] + np.diff(calculated_y), "b^-")
plt.plot(point[0] + analytical_x, point[1] + analytical_y, "gs-")
region.plot()
plt.show()
for point_index, point in enumerate(data):
analytical_x = num.Function(model.analytical[0],
name="analytical ux(%s)").eval(
point)[::model.iterations].ravel()
calculated_x = fts[2 * point_index].ravel()
print(point)
t = np.arange(0.5, calculated_x.size - 1)
# plt.plot(t, 1.5*np.diff(np.diff(calculated_x))[0]+np.diff(calculated_x), "b^-")
plt.plot(calculated_x, "r^-")
# plt.plot(np.diff(calculated_x), "b^-")
plt.plot(analytical_x, "gs-")
plt.show()
def numeric(self, extra={}):
return num.Function(self.sympy(), extra)
def domain_function(self, point):
return self.domain_operator(num.Function(self.analytical, name="domain"), point)