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)