def main(): C1 = tf.Variable(1.0) C2 = tf.Variable(1.0) C3 = tf.Variable(1.0) def Lorenz_system(x, y): """Lorenz system. dy1/dx = 10 * (y2 - y1) dy2/dx = y1 * (28 - y3) - y2 dy3/dx = y1 * y2 - 8/3 * y3 """ y1, y2, y3 = y[:, 0:1], y[:, 1:2], y[:, 2:] dy1_x = dde.grad.jacobian(y, x, i=0) dy2_x = dde.grad.jacobian(y, x, i=1) dy3_x = dde.grad.jacobian(y, x, i=2) return [ dy1_x - C1 * (y2 - y1), dy2_x - y1 * (C2 - y3) + y2, dy3_x - y1 * y2 + C3 * y3, ] def boundary(_, on_initial): return on_initial geom = dde.geometry.TimeDomain(0, 3) # Initial conditions ic1 = dde.IC(geom, lambda X: -8, boundary, component=0) ic2 = dde.IC(geom, lambda X: 7, boundary, component=1) ic3 = dde.IC(geom, lambda X: 27, boundary, component=2) # Get the train data observe_t, ob_y = gen_traindata() observe_y0 = dde.PointSetBC(observe_t, ob_y[:, 0:1], component=0) observe_y1 = dde.PointSetBC(observe_t, ob_y[:, 1:2], component=1) observe_y2 = dde.PointSetBC(observe_t, ob_y[:, 2:3], component=2) data = dde.data.PDE( geom, Lorenz_system, [ic1, ic2, ic3, observe_y0, observe_y1, observe_y2], num_domain=400, num_boundary=2, anchors=observe_t, ) net = dde.maps.FNN([1] + [40] * 3 + [3], "tanh", "Glorot uniform") model = dde.Model(data, net) model.compile("adam", lr=0.001) variable = dde.callbacks.VariableValue([C1, C2, C3], period=600, filename="variables.dat") losshistory, train_state = model.train(epochs=60000, callbacks=[variable]) dde.saveplot(losshistory, train_state, issave=True, isplot=True)
def main(): geom = dde.geometry.Disk([0, 0], 1) observe_x = geom.random_points(30) observe_y = dde.PointSetBC(observe_x, func(observe_x)) data = dde.data.FPDE( geom, fpde, alpha, observe_y, [8, 100], num_domain=64, anchors=observe_x, solution=func, ) net = dde.maps.FNN([2] + [20] * 4 + [1], "tanh", "Glorot normal") net.apply_output_transform( lambda x, y: (1 - tf.reduce_sum(x**2, axis=1, keepdims=True)) * y) model = dde.Model(data, net) model.compile("adam", lr=1e-3, loss_weights=[1, 100]) variable = dde.callbacks.VariableValue(alpha, period=1000) losshistory, train_state = model.train(epochs=10000, callbacks=[variable]) dde.saveplot(losshistory, train_state, issave=True, isplot=True)
def IC_func(self, observe_train, v_train): T_ic = observe_train[:, -1].reshape(-1, 1) idx_init = np.where(np.isclose(T_ic, 1))[0] v_init = v_train[idx_init] observe_init = observe_train[idx_init] return dde.PointSetBC(observe_init, v_init, component=0)
def main(): alpha0 = 1.8 alpha = tf.Variable(1.5) def fpde(x, y, int_mat): """(D_{0+}^alpha + D_{1-}^alpha) u(x) """ if isinstance(int_mat, (list, tuple)) and len(int_mat) == 3: int_mat = tf.SparseTensor(*int_mat) lhs = tf.sparse_tensor_dense_matmul(int_mat, y) else: lhs = tf.matmul(int_mat, y) lhs /= 2 * tf.cos(alpha * np.pi / 2) rhs = gamma(alpha0 + 2) * x return lhs - rhs[: tf.size(lhs)] def func(x): return x * (np.abs(1 - x ** 2)) ** (alpha0 / 2) geom = dde.geometry.Interval(-1, 1) observe_x = np.linspace(-1, 1, num=20)[:, None] observe_y = dde.PointSetBC(observe_x, func(observe_x)) # Static auxiliary points # data = dde.data.FPDE( # geom, # fpde, # alpha, # observe_y, # [101], # meshtype="static", # anchors=observe_x, # solution=func, # ) # Dynamic auxiliary points data = dde.data.FPDE( geom, fpde, alpha, observe_y, [100], meshtype="dynamic", num_domain=20, anchors=observe_x, solution=func, num_test=100, ) net = dde.maps.FNN([1] + [20] * 4 + [1], "tanh", "Glorot normal") net.apply_output_transform(lambda x, y: (1 - x ** 2) * y) model = dde.Model(data, net) model.compile("adam", lr=1e-3, loss_weights=[1, 100]) variable = dde.callbacks.VariableValue(alpha, period=1000) losshistory, train_state = model.train(epochs=10000, callbacks=[variable]) dde.saveplot(losshistory, train_state, issave=True, isplot=True)
def main(): alpha0 = 1.8 alpha = tf.Variable(1.5) def fpde(x, y, int_mat): """\int_theta D_theta^alpha u(x) """ if isinstance(int_mat, (list, tuple)) and len(int_mat) == 3: int_mat = tf.SparseTensor(*int_mat) lhs = tf.sparse_tensor_dense_matmul(int_mat, y) else: lhs = tf.matmul(int_mat, y) lhs = lhs[:, 0] lhs *= -tf.exp( tf.lgamma((1 - alpha) / 2) + tf.lgamma( (2 + alpha) / 2)) / (2 * np.pi**1.5) x = x[:tf.size(lhs)] rhs = (2**alpha0 * gamma(2 + alpha0 / 2) * gamma(1 + alpha0 / 2) * (1 - (1 + alpha0 / 2) * tf.reduce_sum(x**2, axis=1))) return lhs - rhs def func(x): return (1 - np.linalg.norm(x, axis=1, keepdims=True)**2)**(1 + alpha0 / 2) geom = dde.geometry.Disk([0, 0], 1) observe_x = geom.random_points(30) observe_y = dde.PointSetBC(observe_x, func(observe_x)) data = dde.data.FPDE( geom, fpde, alpha, observe_y, [8, 100], num_domain=64, anchors=observe_x, solution=func, ) net = dde.maps.FNN([2] + [20] * 4 + [1], "tanh", "Glorot normal") net.apply_output_transform( lambda x, y: (1 - tf.reduce_sum(x**2, axis=1, keepdims=True)) * y) model = dde.Model(data, net) model.compile("adam", lr=1e-3, loss_weights=[1, 100]) variable = dde.callbacks.VariableValue(alpha, period=1000) losshistory, train_state = model.train(epochs=10000, callbacks=[variable]) dde.saveplot(losshistory, train_state, issave=True, isplot=True)
def main(): C = tf.Variable(2.0) def pde(x, y): dy_t = dde.grad.jacobian(y, x, i=0, j=1) dy_xx = dde.grad.hessian(y, x, i=0, j=0) return ( dy_t - C * dy_xx + tf.exp(-x[:, 1:]) * (tf.sin(np.pi * x[:, 0:1]) - np.pi**2 * tf.sin(np.pi * x[:, 0:1]))) def func(x): return np.sin(np.pi * x[:, 0:1]) * np.exp(-x[:, 1:]) geom = dde.geometry.Interval(-1, 1) timedomain = dde.geometry.TimeDomain(0, 1) geomtime = dde.geometry.GeometryXTime(geom, timedomain) bc = dde.DirichletBC(geomtime, func, lambda _, on_boundary: on_boundary) ic = dde.IC(geomtime, func, lambda _, on_initial: on_initial) observe_x = np.vstack((np.linspace(-1, 1, num=10), np.full((10), 1))).T observe_y = dde.PointSetBC(observe_x, func(observe_x), component=0) data = dde.data.TimePDE( geomtime, pde, [bc, ic, observe_y], num_domain=40, num_boundary=20, num_initial=10, anchors=observe_x, solution=func, num_test=10000, ) layer_size = [2] + [32] * 3 + [1] activation = "tanh" initializer = "Glorot uniform" net = dde.maps.FNN(layer_size, activation, initializer) model = dde.Model(data, net) model.compile("adam", lr=0.001, metrics=["l2 relative error"]) variable = dde.callbacks.VariableValue(C, period=1000) losshistory, train_state = model.train(epochs=50000, callbacks=[variable]) dde.saveplot(losshistory, train_state, issave=True, isplot=True)
def main(): geom = dde.geometry.Interval(-1, 1) observe_x = np.linspace(-1, 1, num=20)[:, None] observe_y = dde.PointSetBC(observe_x, func(observe_x)) # Static auxiliary points # data = dde.data.FPDE( # geom, # fpde, # alpha, # observe_y, # [101], # meshtype="static", # anchors=observe_x, # solution=func, # ) # Dynamic auxiliary points data = dde.data.FPDE( geom, fpde, alpha, observe_y, [100], meshtype="dynamic", num_domain=20, anchors=observe_x, solution=func, num_test=100, ) net = dde.maps.FNN([1] + [20] * 4 + [1], "tanh", "Glorot normal") net.apply_output_transform(lambda x, y: (1 - x**2) * y) model = dde.Model(data, net) model.compile("adam", lr=1e-3, loss_weights=[1, 100]) variable = dde.callbacks.VariableValue(alpha, period=1000) losshistory, train_state = model.train(epochs=10000, callbacks=[variable]) dde.saveplot(losshistory, train_state, issave=True, isplot=True)
def main(train=True, test=True): # case name case_name = "easy_slope_05" case_name_title = r'_' set_directory(case_name) #domain vertices ends = [0, 1] Nx = int((ends[1] - ends[0]) * 500) + 1 print('Nx', Nx) figsize = (7, 5) # geometry specification geom = dde.geometry.Interval(ends[0], ends[1]) # BC specification # boundaries functions def boundary_in(x, on_boundary): return on_boundary and np.isclose(x[0], -0.5) # def boundary(x, on_boundary): # return on_boundary and not ( # np.isclose(x[0], v_ld[0]) # or np.isclose(x[0], v_ru[0]) # or np.isclose(x[1], v_ld[1]) # or np.isclose(x[1], v_ru[1]) # ) # BC objects left_point = dde.PointSetBC(np.array([0]).reshape(-1, 1), np.array([0]).reshape(-1, 1), component=0) # pde and physics compilation pde = easy_eq(0.5) if train: data = dde.data.PDE(geom, pde, [left_point], 1000, 1, solution=None, num_test=100, train_distribution="sobol") plot_train_points(data, [1], ["left"], case_name, title=case_name_title, figsize=figsize) else: data = dde.data.PDE(geom, pde, [left_point], 100, 100, solution=None, num_test=100) # NN model definition layer_size = [1] + [100] * 5 + [1] activation = "tanh" initializer = "Glorot uniform" net = dde.maps.FNN(layer_size, activation, initializer) # PINN definition model = dde.Model(data, net) if train: # Adam optimization loss_weights = [100, 1000] model.compile("adam", lr=0.001, loss_weights=loss_weights) checkpointer = dde.callbacks.ModelCheckpoint( f"{case_name}/models/model_{case_name}.ckpt", verbose=1, save_better_only=True, ) # loss_update = dde.callbacks.LossUpdateCheckpoint( # momentum=0.7, # verbose=1, period=1, report_period=100, # base_range=[0], # update_range=[1] # ) print('Training for 1000 epochs') losshistory, train_state = model.train(epochs=1000, callbacks=[checkpointer], display_every=100) model.save(f"{case_name}/models/model-adam-last") # L-BFGS-B optimization model.compile("L-BFGS-B", loss_weights=loss_weights) losshistory, train_state = model.train() model.save(f"{case_name}/models/model-bfgs-last") if test: model.compile("adam", lr=0.001) model.compile("L-BFGS-B") last_epoch = model.train_state.epoch if not train: last_epoch = 1047 model.restore(f"{case_name}/models/model-bfgs-last-{last_epoch}") x_plot = np.linspace(ends[0], ends[1], Nx) f_plot = 0.5 * x_plot y = model.predict(x_plot.reshape(-1, 1)) f_star = y[:, 0] print(f_star.shape) data_dict = { "f_star": f_star, } scipy.io.savemat(f"{case_name}/results.mat", data_dict) plt.figure(figsize=figsize) # plt.title(f'regressed u field for {case_name_title}') plt.plot(x_plot, f_star, label='prediction') plt.plot(x_plot, f_plot, ':', label='true') plt.xlabel('x/c') plt.title(r'$u$') plt.legend() axes = plt.gca() plt.grid() axes.set_aspect(1) print("limits", axes.get_ylim()) plt.ylim([-0.025000017881393433, 2.933020759374183e-05 * 20000]) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'f_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed u field for {case_name_title}') plt.plot(x_plot, np.abs(f_star - f_plot)) plt.xlabel('x/c') plt.title(r'$u$ abs error') axes = plt.gca() plt.grid() axes.set_aspect(20000) print("limits", axes.get_ylim()) # plt.ylim([-0.025000017881393433/20000, 0.525000375509262/20000]) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'f_err.png'), dpi=400) plt.close() e = model.predict(x_plot.reshape(-1, 1), operator=pde) e_err = e[0] plt.figure(figsize=figsize) # plt.title(f'regressed u field for {case_name_title}') plt.plot(x_plot, e_err) plt.xlabel('x/c') plt.ylabel('pde abs error') plt.grid() axes = plt.gca() # axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'pde_err.png'), dpi=400) plt.close() def derivatives(X, V): u_x = dde.grad.jacobian(V, X, i=0, j=0) u_xx = dde.grad.jacobian(u_x, X, i=0, j=0) u_xxx = dde.grad.jacobian(u_xx, X, i=0, j=0) return [u_x, u_xx, u_xxx] e = model.predict(x_plot.reshape(-1, 1), operator=derivatives) f_x = e[0] f_xx = e[1] f_xxx = e[2] data_dict.update({"dfx": f_x, "dfxx": f_xx, "dfxxx": f_xxx}) scipy.io.savemat(f"{case_name}/results.mat", data_dict) plt.figure(figsize=(12, 5)) # plt.title(f'regressed u field for {case_name_title}') plt.plot(x_plot, f_x - 0.5, label=r'$u_x-0.5$') plt.plot(x_plot, f_xx, label=r'$u_{xx}$') plt.plot(x_plot, f_xxx, label=r'$u_{xxx}$') plt.legend(loc=(1.05, 0.4)) plt.grid() plt.xlabel('x/c') # plt.ylabel(r'$u_x$') axes = plt.gca() # axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'derivatives.png'), dpi=400) plt.close()
def main(train=True, test=True): # case name case_name = "unCylinder_2nd_order_superresolutions_with_pressure_anchor" case_name_title = r'PIV superresolution second order 0.5 by 0.5' set_directory(case_name) x_data, y_data, u_data, v_data, p_data, uu_data, uv_data, vv_data, x_domain, y_domain = read_data() #domain vertices v_ld = [-1, -1.5] v_ru = [3, 1.5] figsize = (10, 10*(v_ru[1]-v_ld[1])/(v_ru[0]-v_ld[0])) figsize=(8,5) Nx = int((v_ru[0]-v_ld[0])*500)+1 Ny = int((v_ru[1]-v_ld[1])*500)+1 print('Nx', Nx, 'Ny', Ny) # geometry specification geom1 = dde.geometry.Disk(0,0.5) geom2 = dde.geometry.Rectangle(v_ld, v_ru) geom = geom2 - geom1 [x_piv, y_piv, u_piv, uu_piv, v_piv, vv_piv, uv_piv] = \ generate_PIV_points(x_data, y_data, [u_data, uu_data, v_data, vv_data, uv_data], 250, 250, v_ld, v_ru, geom) piv_points = np.hstack((x_piv, y_piv)) [x_p, y_p, p_p] = \ generate_PIV_points(x_data, y_data, [p_data], 3, 3, [-0.55, -0.55], [0.55, 0.55], geom) for i in range(x_data.shape[0]): if x_data[i,0]==0 and y_data[i,0]==0.5: p1 = p_data[i,0] print(p1) elif x_data[i,0]==0 and y_data[i,0]==-0.5: p2 = p_data[i,0] print(p2) pressure_coors = np.array([[0, 0.5], [0,-0.5]]) pressure_vals = np.array([[p1], [p2]]) # BC specification # boundaries functions def boundary(x, on_boundary): return on_boundary and not ( np.isclose(x[0], v_ld[0]) or np.isclose(x[0], v_ru[0]) or np.isclose(x[1], v_ld[1]) or np.isclose(x[1], v_ru[1]) ) def boundary_left_free(x, on_boundary): return on_boundary and (np.isclose(x[0], v_ld[0]) or (np.isclose(x[1], v_ru[1]) and x[0]<-0.5) or (np.isclose(x[1], v_ld[1]) and x[0]<-0.5)) def boundary_left_full(x, on_boundary): return on_boundary and not (np.isclose(x[0], v_ru[0]) or (np.isclose(x[1], v_ru[1]) and x[0]>-0.5) or (np.isclose(x[1], v_ld[1]) and x[0]>-0.5)) # BC objects # p_pressure_points = dde.PointSetBC(pressure_points, p_pressure, component=2) bc_wall_u = dde.DirichletBC(geom, func_zeros, boundary, component=0) bc_wall_v = dde.DirichletBC(geom, func_zeros, boundary, component=1) bc_wall_uu = dde.DirichletBC(geom, func_zeros, boundary, component=3) bc_wall_uv = dde.DirichletBC(geom, func_zeros, boundary, component=4) bc_wall_vv = dde.DirichletBC(geom, func_zeros, boundary, component=5) u_piv_points = dde.PointSetBC(piv_points, u_piv, component=0) uu_piv_points = dde.PointSetBC(piv_points, uu_piv, component=3) v_piv_points = dde.PointSetBC(piv_points, v_piv, component=1) vv_piv_points = dde.PointSetBC(piv_points, vv_piv, component=5) uv_piv_points = dde.PointSetBC(piv_points, uv_piv, component=4) pressure_points = dde.PointSetBC(pressure_coors, pressure_vals, component=2) # custom domain points domain_points = generate_domain_points(x_domain, y_domain, geometry=geom) # pde and physics compilation pde = RANSReStresses2D(150) if train: data = dde.data.PDE( geom, pde, [bc_wall_u, bc_wall_v, bc_wall_uu, bc_wall_uv, bc_wall_vv, u_piv_points, uu_piv_points, v_piv_points, vv_piv_points, uv_piv_points, pressure_points], 100, 1600, solution=None, num_test=100, train_distribution="custom", custom_train_points=domain_points, ) plot_train_points(data, [2,5,10, 11], ["u,v wall BC", "uu,uv,vv wall BC", "PIV data", "surface pressure"], case_name, title=case_name_title, figsize=(10,5)) else: data = dde.data.PDE( geom, pde, [bc_wall_u, bc_wall_v, bc_wall_uu, bc_wall_uv, bc_wall_vv, u_piv_points, uu_piv_points, v_piv_points, vv_piv_points, uv_piv_points, pressure_points], 100, 100, solution=None, num_test=100 ) dde.backend.tf.logging.set_verbosity(20) print(dde.backend.tf.logging.get_verbosity()) # exit(0) # NN model definition layer_size = [2] + [100] * 7 + [6] activation = "tanh" initializer = "Glorot uniform" net = dde.maps.FNN(layer_size, activation, initializer) # PINN definition model = dde.Model(data, net) if train: # Adam optimization loss_weights = [1, 1, 1, 1, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10] model.compile("adam", lr=0.001, loss_weights=loss_weights) checkpointer = dde.callbacks.ModelCheckpoint( f"{case_name}/models/model_{case_name}.ckpt", verbose=1, save_better_only=True, ) loss_update = dde.callbacks.LossUpdateCheckpoint( momentum=0.7, verbose=1, period=1, report_period=100, base_range=[0, 1, 2, 3], update_range=[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] ) print('Training for 20000 epochs') losshistory, train_state = model.train( epochs=20000, callbacks=[checkpointer, loss_update], display_every=100 ) model.save(f"{case_name}/models/model-adam-last") # L-BFGS-B optimization model.compile("L-BFGS-B", loss_weights=loss_weights) losshistory, train_state = model.train() model.save(f"{case_name}/models/model-bfgs-last") if test: model.compile("adam", lr=0.001) model.compile("L-BFGS-B") last_epoch = model.train_state.epoch if not train: last_epoch=80001 model.restore(f"{case_name}/models/model-bfgs-last-{last_epoch}") x_plot = np.linspace(v_ld[0], v_ru[0], Nx) y_plot = np.linspace(v_ld[1], v_ru[1], Ny) print(x_plot.shape) print(y_plot.shape) # domain data x_data = x_data.reshape(2001,1501).T y_data = y_data.reshape(2001,1501).T u_data = u_data.reshape(2001,1501).T v_data = v_data.reshape(2001,1501).T p_data = p_data.reshape(2001,1501).T x_dom = np.linspace(-1, 3, 2001) y_dom = np.linspace(-1, 1, 1501) x_min = np.argmin(np.abs(x_dom-v_ld[0])) x_max = np.argmin(np.abs(x_dom-v_ru[0])) y_min = np.argmin(np.abs(y_dom-v_ld[1])) y_max = np.argmin(np.abs(y_dom-v_ru[1])) print(x_min, x_max, y_min, y_max) x_data = x_data[y_min:y_max+1, x_min:x_max+1] print(x_data.shape) x_data = x_data.T.reshape(-1,1) y_data = y_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) u_data = u_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) v_data = v_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) p_data = p_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) z = np.array([np.array([i, j]) for i in x_plot for j in y_plot]) y = model.predict(z) u_star = y[:, 0][:, None] v_star = y[:, 1][:, None] p_star = y[:, 2][:, None] uu_star = y[:, 3][:,None] uv_star = y[:, 4][:,None] vv_star = y[:, 5][:,None] data_dict = { "x_data": x_data, "y_data": y_data, "u_star": u_star, "v_star": v_star, "p_star": p_star, "uu_star": uu_star, "uv_star": uv_star, "vv_star": vv_star, } scipy.io.savemat(f"{case_name}/results.mat", data_dict) zero_index = (x_data < 0) & (x_data > 0) zero_index = zero_index | ((u_data == 0) & (v_data == 0)) no_data_index = zero_index u_star_data = deepcopy(u_star) v_star_data = deepcopy(v_star) p_star_data = deepcopy(p_star) uu_star_data = deepcopy(uu_star) uv_star_data = deepcopy(uv_star) vv_star_data = deepcopy(vv_star) u_star_data[no_data_index] = u_star[no_data_index]*0 v_star_data[no_data_index] = v_star[no_data_index]*0 p_star_data[no_data_index] = p_star[no_data_index]*0 uu_star_data[no_data_index] = uu_star[no_data_index]*0 uv_star_data[no_data_index] = uv_star[no_data_index]*0 vv_star_data[no_data_index] = vv_star[no_data_index]*0 u_star_data = u_star_data.reshape(Nx, Ny).T v_star_data = v_star_data.reshape(Nx, Ny).T p_star_data = p_star_data.reshape(Nx, Ny).T uu_star_data = uu_star_data.reshape(Nx, Ny).T uv_star_data = uv_star_data.reshape(Nx, Ny).T vv_star_data = vv_star_data.reshape(Nx, Ny).T X, Y = np.meshgrid(x_plot, y_plot) plt.figure(figsize=figsize) # plt.title(f'regressed u field for {case_name_title}') plt.pcolor(X, Y, u_star_data) plt.colorbar(label='u') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'u_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed v field for {case_name_title}') plt.pcolor(X, Y, v_star_data) plt.colorbar(label='v') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'v_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed p field for {case_name_title}') plt.pcolor(X, Y, p_star_data) plt.colorbar(label='p') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'p_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed uu field for {case_name_title}') plt.pcolor(X, Y, uu_star_data) plt.colorbar(label='uu') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'uu_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed uv field for {case_name_title}') plt.pcolor(X, Y, uv_star_data) plt.colorbar(label='uv') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'uv_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed vv field for {case_name_title}') plt.pcolor(X, Y, vv_star_data) plt.colorbar(label='vv') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'vv_plot.png'), dpi=400) plt.close() # data error u_star_data = deepcopy(u_star) v_star_data = deepcopy(v_star) p_star_data = deepcopy(p_star) u_star_data[no_data_index] = u_star[no_data_index]*0 v_star_data[no_data_index] = v_star[no_data_index]*0 p_star_data[no_data_index] = p_star[no_data_index]*0 u_star_data = u_star_data.reshape(Nx, Ny).T v_star_data = v_star_data.reshape(Nx, Ny).T p_star_data = p_star_data.reshape(Nx, Ny).T u_true = None v_true = None p_true = None u_true = deepcopy(u_data) v_true = deepcopy(v_data) p_true = deepcopy(p_data) u_true = u_true.reshape(Nx, Ny).T v_true = v_true.reshape(Nx, Ny).T p_true = p_true.reshape(Nx, Ny).T u_err = np.abs(u_true-u_star_data) v_err = np.abs(v_true-v_star_data) p_err = np.abs(p_true-p_star_data) plt.figure(figsize=figsize) # plt.title(f'u field abs error for {case_name_title}') plt.pcolor(X, Y, u_err) plt.colorbar(label='u') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'u_err_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'v field abs error for {case_name_title}') plt.pcolor(X, Y, v_err) plt.colorbar(label='v') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'v_err_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'p field abs error for {case_name_title}') plt.pcolor(X, Y, p_err) plt.colorbar(label='p') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'p_err_plot.png'), dpi=400) plt.close() e = model.predict(z, operator=pde) e_mass = e[0] e_u_momentum = e[1] e_v_momentum = e[2] data_dict.update({ "e_mass": e_mass, "e_u_momentum": e_u_momentum, "e_v_momentum": e_v_momentum, }) scipy.io.savemat(f"{case_name}/results.mat", data_dict) e_mass[no_data_index] = e_mass[no_data_index] * 0 e_u_momentum[no_data_index] = e_u_momentum[no_data_index] * 0 e_v_momentum[no_data_index] = e_v_momentum[no_data_index] * 0 e_mass = e_mass.reshape(Nx, Ny).T e_u_momentum = e_u_momentum.reshape(Nx, Ny).T e_v_momentum = e_v_momentum.reshape(Nx, Ny).T plt.figure(figsize=figsize) # plt.title(f'mass conservation residual for {case_name_title}') plt.pcolor(X, Y, e_mass, vmin=-1, vmax=1) plt.colorbar(label='e_mass') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'e_mass_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'u momentum conservation residual for {case_name_title}') plt.pcolor(X, Y, e_u_momentum, vmin=-1, vmax=1) plt.colorbar(label='e_u_momentum') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join( f'{case_name}', 'plots', 'e_u_momentum_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'v momentum conservation residual for {case_name_title}') plt.pcolor(X, Y, e_v_momentum, vmin=-1, vmax=1) plt.colorbar(label='e_v_momentum') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join( f'{case_name}', 'plots', 'e_v_momentum_plot.png'), dpi=400) plt.close()
def main(train=True, test=True): # case name case_name = "unCylinder_piv_superresolution_0.7_no_pressure" case_name_title = r'PIV stride $0.7 \times 0.7$ f=0' set_directory(case_name) x_data, y_data, u_data, v_data, p_data, uu_data, uv_data, vv_data, x_domain, y_domain = read_data() #domain vertices v_ld = [-1, -1.5] v_ru = [3, 1.5] figsize = (10, 10*(v_ru[1]-v_ld[1])/(v_ru[0]-v_ld[0])) figsize=(8,5) Nx = int((v_ru[0]-v_ld[0])*500)+1 Ny = int((v_ru[1]-v_ld[1])*500)+1 print('Nx', Nx, 'Ny', Ny) # geometry specification geom1 = dde.geometry.Disk(0,0.5) geom2 = dde.geometry.Rectangle(v_ld, v_ru) geom = geom2 - geom1 [x_piv, y_piv, u_piv, v_piv, p_piv] = \ generate_PIV_points(x_data, y_data, u_data, v_data, p_data, 350, 350, v_ld, v_ru, geom, True) piv_points = np.hstack((x_piv, y_piv)) # BC specification # boundaries functions def boundary(x, on_boundary): return on_boundary and not ( np.isclose(x[0], v_ld[0]) or np.isclose(x[0], v_ru[0]) or np.isclose(x[1], v_ld[1]) or np.isclose(x[1], v_ru[1]) ) # BC objects u_piv_points = dde.PointSetBC(piv_points, u_piv, component=0) v_piv_points = dde.PointSetBC(piv_points, v_piv, component=1) bc_wall_u = dde.DirichletBC(geom, func_zeros, boundary, component=0) bc_wall_v = dde.DirichletBC(geom, func_zeros, boundary, component=1) bc_wall_fx = dde.DirichletBC(geom, func_zeros, boundary, component=3) bc_wall_fy = dde.DirichletBC(geom, func_zeros, boundary, component=4) # custom domain points domain_points = generate_domain_points(x_domain, y_domain, geometry=geom) # pde and physics compilation pde = RANSf02D(150) if train: data = dde.data.PDE( geom, pde, [bc_wall_u, bc_wall_v, bc_wall_fx, bc_wall_fy, u_piv_points, v_piv_points], 100, 1600, solution=None, num_test=100, train_distribution="custom", custom_train_points=domain_points, ) plot_train_points(data, [4,6], ["airfoil", "piv"], case_name, title=case_name_title, figsize=(10,5)) else: data = dde.data.PDE( geom, pde, [bc_wall_u, bc_wall_v, bc_wall_fx, bc_wall_fy, u_piv_points, v_piv_points], 100, 100, solution=None, num_test=100 ) # exit(0) # NN model definition layer_size = [2] + [100] * 7 + [5] activation = "tanh" initializer = "Glorot uniform" net = dde.maps.FNN(layer_size, activation, initializer) # PINN definition model = dde.Model(data, net) if train: # Adam optimization loss_weights = [1, 1, 1, 1, 10, 10, 10, 10, 10, 10] model.compile("adam", lr=0.001, loss_weights=loss_weights) checkpointer = dde.callbacks.ModelCheckpoint( f"{case_name}/models/model_{case_name}.ckpt", verbose=1, save_better_only=True, ) loss_update = dde.callbacks.LossUpdateCheckpoint( momentum=0.7, verbose=1, period=1, report_period=100, base_range=[0, 1, 2, 3], update_range=[ 4, 5, 6, 7, 8, 9] ) print('Training for 20000 epochs') losshistory, train_state = model.train( epochs=20000, callbacks=[checkpointer, loss_update], display_every=100 ) model.save(f"{case_name}/models/model-adam-last") # L-BFGS-B optimization model.compile("L-BFGS-B", loss_weights=loss_weights) losshistory, train_state = model.train() model.save(f"{case_name}/models/model-bfgs-last") if test: model.compile("adam", lr=0.001) model.compile("L-BFGS-B") last_epoch = model.train_state.epoch if not train: last_epoch=80001 model.restore(f"{case_name}/models/model-bfgs-last-{last_epoch}") x_plot = np.linspace(v_ld[0], v_ru[0], Nx) y_plot = np.linspace(v_ld[1], v_ru[1], Ny) print(x_plot.shape) print(y_plot.shape) # domain data x_data = x_data.reshape(2001,1501).T y_data = y_data.reshape(2001,1501).T u_data = u_data.reshape(2001,1501).T v_data = v_data.reshape(2001,1501).T p_data = p_data.reshape(2001,1501).T x_dom = np.linspace(-1, 3, 2001) y_dom = np.linspace(-1.5, 1.5, 1501) x_min = np.argmin(np.abs(x_dom-v_ld[0])) x_max = np.argmin(np.abs(x_dom-v_ru[0])) y_min = np.argmin(np.abs(y_dom-v_ld[1])) y_max = np.argmin(np.abs(y_dom-v_ru[1])) print(x_min, x_max, y_min, y_max) x_data = x_data[y_min:y_max+1, x_min:x_max+1] print(x_data.shape) x_data = x_data.T.reshape(-1,1) y_data = y_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) u_data = u_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) v_data = v_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) p_data = p_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) z = np.array([np.array([i, j]) for i in x_plot for j in y_plot]) y = model.predict(z) u_star = y[:, 0][:, None] v_star = y[:, 1][:, None] p_star = y[:, 2][:, None] fx_star = y[:, 3][:,None] fy_star = y[:, 4][:,None] data_dict = { # "x": x_data, # "y": y_data, "u_star": u_star, "v_star": v_star, "p_star": p_star, "fx_star": fx_star, "fy_star": fy_star } scipy.io.savemat(f"{case_name}/results.mat", data_dict) zero_index = (x_data < 0) & (x_data > 0) zero_index = zero_index | ((u_data == 0) & (v_data == 0)) no_data_index = zero_index u_star_data = deepcopy(u_star) v_star_data = deepcopy(v_star) p_star_data = deepcopy(p_star) fx_star_data = deepcopy(fx_star) fy_star_data = deepcopy(fy_star) u_star_data[no_data_index] = u_star[no_data_index]*0 v_star_data[no_data_index] = v_star[no_data_index]*0 p_star_data[no_data_index] = p_star[no_data_index]*0 fx_star_data[no_data_index] = fx_star[no_data_index]*0 fy_star_data[no_data_index] = fy_star[no_data_index]*0 u_star_data = u_star_data.reshape(Nx, Ny).T v_star_data = v_star_data.reshape(Nx, Ny).T p_star_data = p_star_data.reshape(Nx, Ny).T fx_star_data = fx_star_data.reshape(Nx, Ny).T fy_star_data = fy_star_data.reshape(Nx, Ny).T X, Y = np.meshgrid(x_plot, y_plot) plt.figure(figsize=figsize) # plt.title(f'regressed u field for {case_name_title}') plt.pcolor(X, Y, u_star_data) plt.colorbar(label='u') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'u_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed v field for {case_name_title}') plt.pcolor(X, Y, v_star_data) plt.colorbar(label='v') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'v_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed p field for {case_name_title}') plt.pcolor(X, Y, p_star_data) plt.colorbar(label='p') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'p_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed fx field for {case_name_title}') plt.pcolor(X, Y, fx_star_data) plt.colorbar(label='fx') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'fx_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed fy field for {case_name_title}') plt.pcolor(X, Y, fy_star_data) plt.colorbar(label='fy') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'fy_plot.png'), dpi=400) plt.close() # data error u_star_data = deepcopy(u_star) v_star_data = deepcopy(v_star) p_star_data = deepcopy(p_star) u_star_data[no_data_index] = u_star[no_data_index]*0 v_star_data[no_data_index] = v_star[no_data_index]*0 p_star_data[no_data_index] = p_star[no_data_index]*0 u_star_data = u_star_data.reshape(Nx, Ny).T v_star_data = v_star_data.reshape(Nx, Ny).T p_star_data = p_star_data.reshape(Nx, Ny).T u_true = None v_true = None p_true = None u_true = deepcopy(u_data) v_true = deepcopy(v_data) p_true = deepcopy(p_data) u_true = u_true.reshape(Nx, Ny).T v_true = v_true.reshape(Nx, Ny).T p_true = p_true.reshape(Nx, Ny).T u_err = np.abs(u_true-u_star_data) v_err = np.abs(v_true-v_star_data) p_err = np.abs(p_true-p_star_data) U_true = np.sqrt(np.power(u_true,2)+np.power(v_true,2)) U_star_data = np.sqrt(np.power(u_star_data,2)+np.power(v_star_data,2)) U_err = np.abs(U_true-U_star_data) # l2 errors u_errors = u_err.flatten() v_errors = v_err.flatten() U_errors = U_err.flatten() print(u_errors.shape) N_non_zero = np.count_nonzero(u_errors) print(N_non_zero) velo_errors = u_errors**2+v_errors**2 l2_error = np.sum(velo_errors)/N_non_zero print('L2 error!: ', l2_error) print('Linf error!: ', np.max(U_errors)) plt.figure(figsize=figsize) # plt.title(f'u field abs error for {case_name_title}') plt.pcolor(X, Y, u_err) plt.colorbar(label='u') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'u_err_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'v field abs error for {case_name_title}') plt.pcolor(X, Y, v_err) plt.colorbar(label='v') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'v_err_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'p field abs error for {case_name_title}') plt.pcolor(X, Y, p_err) plt.colorbar(label='p') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'p_err_plot.png'), dpi=400) plt.close() e = model.predict(z, operator=pde) e_mass = e[0] e_u_momentum = e[1] e_v_momentum = e[2] f_divergence = e[3] data_dict.update({ "e_mass": e_mass, "e_u_momentum": e_u_momentum, "e_v_momentum": e_v_momentum, "f_divergence": f_divergence }) scipy.io.savemat(f"{case_name}/results.mat", data_dict) e_mass[no_data_index] = e_mass[no_data_index] * 0 e_u_momentum[no_data_index] = e_u_momentum[no_data_index] * 0 e_v_momentum[no_data_index] = e_v_momentum[no_data_index] * 0 f_divergence[no_data_index] = f_divergence[no_data_index] * 0 e_mass = e_mass.reshape(Nx, Ny).T e_u_momentum = e_u_momentum.reshape(Nx, Ny).T e_v_momentum = e_v_momentum.reshape(Nx, Ny).T f_divergence = f_divergence.reshape(Nx, Ny).T plt.figure(figsize=figsize) # plt.title(f'mass conservation residual for {case_name_title}') plt.pcolor(X, Y, e_mass, vmin=-1, vmax=1) plt.colorbar(label='e_mass') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'e_mass_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'u momentum conservation residual for {case_name_title}') plt.pcolor(X, Y, e_u_momentum, vmin=-1, vmax=1) plt.colorbar(label='e_u_momentum') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join( f'{case_name}', 'plots', 'e_u_momentum_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'v momentum conservation residual for {case_name_title}') plt.pcolor(X, Y, e_v_momentum, vmin=-1, vmax=1) plt.colorbar(label='e_v_momentum') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join( f'{case_name}', 'plots', 'e_v_momentum_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'fs divergence residual for {case_name_title}') plt.pcolor(X, Y, f_divergence, vmin=-1, vmax=1) plt.colorbar(label='f_divergence') plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join( f'{case_name}', 'plots', 'f_divergence_plot.png'), dpi=400) plt.close() def curl_f(X,V): dfsx_y = dde.grad.jacobian(V, X, i=3, j=1) dfsy_x = dde.grad.jacobian(V, X, i=4, j=0) return [dfsy_x - dfsx_y] e = model.predict(z, operator=curl_f) f_curl = e[0] data_dict.update({ "curlf": f_curl }) scipy.io.savemat(f"{case_name}/results.mat", data_dict) f_curl[no_data_index] = f_curl[no_data_index] * 0 f_curl = f_curl.reshape(Nx, Ny).T plt.figure(figsize=figsize) # plt.title(f'curl fs for {case_name_title}') plt.pcolor(X, Y, f_curl) plt.colorbar(label=r"$\nabla \times \mathbf{f}$") plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'f_curl_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'curl fs for {case_name_title}') plt.pcolor(X, Y, f_curl, vmin=-2.1125, vmax=2.1125) plt.colorbar(label=r"$\nabla \times \mathbf{f}$") plt.xlabel('x/c') plt.ylabel('y/c') axes=plt.gca() axes.set_aspect(1) plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'f_curl_plot_rescaled.png'), dpi=400) plt.close()
def main(): kf = tf.Variable(0.05) D = tf.Variable(1.0) def pde(x, y): ca, cb = y[:, 0:1], y[:, 1:2] dca_t = dde.grad.jacobian(y, x, i=0, j=1) dca_xx = dde.grad.hessian(y, x, component=0, i=0, j=0) dcb_t = dde.grad.jacobian(y, x, i=1, j=1) dcb_xx = dde.grad.hessian(y, x, component=1, i=0, j=0) eq_a = dca_t - 1e-3 * D * dca_xx + kf * ca * cb**2 eq_b = dcb_t - 1e-3 * D * dcb_xx + 2 * kf * ca * cb**2 return [eq_a, eq_b] def fun_bc(x): return 1 - x[:, 0:1] def fun_init(x): return np.exp(-20 * x[:, 0:1]) geom = dde.geometry.Interval(0, 1) timedomain = dde.geometry.TimeDomain(0, 10) geomtime = dde.geometry.GeometryXTime(geom, timedomain) bc_a = dde.DirichletBC(geomtime, fun_bc, lambda _, on_boundary: on_boundary, component=0) bc_b = dde.DirichletBC(geomtime, fun_bc, lambda _, on_boundary: on_boundary, component=1) ic1 = dde.IC(geomtime, fun_init, lambda _, on_initial: on_initial, component=0) ic2 = dde.IC(geomtime, fun_init, lambda _, on_initial: on_initial, component=1) observe_x, Ca, Cb = gen_traindata() observe_y1 = dde.PointSetBC(observe_x, Ca, component=0) observe_y2 = dde.PointSetBC(observe_x, Cb, component=1) data = dde.data.TimePDE( geomtime, pde, [bc_a, bc_b, ic1, ic2, observe_y1, observe_y2], num_domain=2000, num_boundary=100, num_initial=100, anchors=observe_x, num_test=50000, ) net = dde.maps.FNN([2] + [20] * 3 + [2], "tanh", "Glorot uniform") model = dde.Model(data, net) model.compile("adam", lr=0.001) variable = dde.callbacks.VariableValue([kf, D], period=1000, filename="variables.dat") losshistory, train_state = model.train(epochs=80000, callbacks=[variable]) dde.saveplot(losshistory, train_state, issave=True, isplot=True)
def main(train=True, test=True): # case name case_name = "unNACA0012_Foures_formulation" case_name_title = r'PIV stride $0.02 \times 0.02 fs=0 at airfoil$' set_directory(case_name) x_data, y_data, u_data, v_data, p_data, uu_data, uv_data, vv_data, x_domain, y_domain = read_data( ) airfoil_points = read_airfoil("Data/points_NACA0012.dat") airfoil_array = np.array(airfoil_points) airfoil_array = rotate_points(airfoil_array[:, 0], airfoil_array[:, 1], 0.5, 0, -15 / 180 * math.pi) airfoil_points = airfoil_array.tolist() #domain vertices v_ld = [-0.3, -0.6] v_ru = [2.7, 0.6] Nx = int((v_ru[0] - v_ld[0]) * 500) + 1 Ny = int((v_ru[1] - v_ld[1]) * 500) + 1 print('Nx', Nx, 'Ny', Ny) figsize = (8, 3) # geometry specification geom1 = dde.geometry.Polygon(airfoil_points) geom2 = dde.geometry.Rectangle(v_ld, v_ru) geom = geom2 - geom1 [x_piv, y_piv, u_piv, v_piv, p_piv] = \ generate_PIV_points(x_data, y_data, u_data, v_data, p_data, 10, 10, v_ld, v_ru, geom, True) piv_points = np.hstack((x_piv, y_piv)) # print(piv_points.shape) # print(u_piv.shape) # # exit(0) # BC specification # boundaries functions def boundary_in(x, on_boundary): return on_boundary and np.isclose(x[0], -0.5) def boundary(x, on_boundary): return on_boundary and not (np.isclose(x[0], v_ld[0]) or np.isclose( x[0], v_ru[0]) or np.isclose(x[1], v_ld[1]) or np.isclose(x[1], v_ru[1])) # BC objects u_piv_points = dde.PointSetBC(piv_points, u_piv, component=0) v_piv_points = dde.PointSetBC(piv_points, v_piv, component=1) bc_wall_u = dde.DirichletBC(geom, func_zeros, boundary, component=0) bc_wall_v = dde.DirichletBC(geom, func_zeros, boundary, component=1) bc_wall_fx = dde.DirichletBC(geom, func_zeros, boundary, component=3) bc_wall_fy = dde.DirichletBC(geom, func_zeros, boundary, component=4) # custom domain points domain_points = generate_domain_points(x_domain, y_domain, geometry=geom) # pde and physics compilation pde = RANSf02D(500) if train: data = dde.data.PDE( geom, pde, [ bc_wall_u, bc_wall_v, bc_wall_fx, bc_wall_fy, u_piv_points, v_piv_points ], 100, 1600, solution=None, num_test=100, train_distribution="custom", custom_train_points=domain_points, ) plot_train_points(data, [4, 6], ["airfoil", "piv"], case_name, title=case_name_title, figsize=figsize) else: data = dde.data.PDE(geom, pde, [ bc_wall_u, bc_wall_v, bc_wall_fx, bc_wall_fy, u_piv_points, v_piv_points ], 100, 100, solution=None, num_test=100) # NN model definition layer_size = [2] + [100] * 7 + [5] activation = "tanh" initializer = "Glorot uniform" net = dde.maps.FNN(layer_size, activation, initializer) # PINN definition model = dde.Model(data, net) if train: # Adam optimization loss_weights = [1, 1, 1, 1, 10, 10, 10, 10, 10, 10] model.compile("adam", lr=0.001, loss_weights=loss_weights) checkpointer = dde.callbacks.ModelCheckpoint( f"{case_name}/models/model_{case_name}.ckpt", verbose=1, save_better_only=True, ) loss_update = dde.callbacks.LossUpdateCheckpoint( momentum=0.7, verbose=1, period=1, report_period=100, base_range=[0, 1, 2, 3], update_range=[4, 5, 6, 7, 8, 9]) print('Training for 20000 epochs') losshistory, train_state = model.train( epochs=20000, callbacks=[checkpointer, loss_update], display_every=100) model.save(f"{case_name}/models/model-adam-last") # L-BFGS-B optimization model.compile("L-BFGS-B", loss_weights=loss_weights) losshistory, train_state = model.train() model.save(f"{case_name}/models/model-bfgs-last") if test: model.compile("adam", lr=0.001) model.compile("L-BFGS-B") last_epoch = model.train_state.epoch if not train: last_epoch = 44560 model.restore(f"{case_name}/models/model-bfgs-last-{last_epoch}") x_plot = np.linspace(v_ld[0], v_ru[0], Nx) y_plot = np.linspace(v_ld[1], v_ru[1], Ny) # domain data x_data = x_data.reshape(1501, 601).T y_data = y_data.reshape(1501, 601).T u_data = u_data.reshape(1501, 601).T v_data = v_data.reshape(1501, 601).T p_data = p_data.reshape(1501, 601).T x_dom = np.linspace(-0.3, 2.7, 1501) y_dom = np.linspace(-0.6, 0.6, 601) x_min = np.argmin(np.abs(x_dom - v_ld[0])) x_max = np.argmin(np.abs(x_dom - v_ru[0])) y_min = np.argmin(np.abs(y_dom - v_ld[1])) y_max = np.argmin(np.abs(y_dom - v_ru[1])) print(x_min, x_max, y_min, y_max) x_data = x_data[y_min:y_max + 1, x_min:x_max + 1].T.reshape(-1, 1) y_data = y_data[y_min:y_max + 1, x_min:x_max + 1].T.reshape(-1, 1) u_data = u_data[y_min:y_max + 1, x_min:x_max + 1].T.reshape(-1, 1) v_data = v_data[y_min:y_max + 1, x_min:x_max + 1].T.reshape(-1, 1) p_data = p_data[y_min:y_max + 1, x_min:x_max + 1].T.reshape(-1, 1) z = np.array([np.array([i, j]) for i in x_plot for j in y_plot]) y = model.predict(z) u_star = y[:, 0][:, None] v_star = y[:, 1][:, None] p_star = y[:, 2][:, None] fx_star = y[:, 3][:, None] fy_star = y[:, 4][:, None] data_dict = { "u_star": u_star, "v_star": v_star, "p_star": p_star, "fx_star": fx_star, "fy_star": fy_star } scipy.io.savemat(f"{case_name}/results.mat", data_dict) zero_index = (x_data < 0) & (x_data > 0) zero_index = zero_index | ((u_data == 0) & (v_data == 0)) no_data_index = zero_index u_star_data = deepcopy(u_star) v_star_data = deepcopy(v_star) p_star_data = deepcopy(p_star) u_star_data[no_data_index] = u_star[no_data_index] * 0 v_star_data[no_data_index] = v_star[no_data_index] * 0 p_star_data[no_data_index] = p_star[no_data_index] * 0 u_star_data = u_star_data.reshape(Nx, Ny).T v_star_data = v_star_data.reshape(Nx, Ny).T p_star_data = p_star_data.reshape(Nx, Ny).T X, Y = np.meshgrid(x_plot, y_plot) plt.figure(figsize=figsize) # plt.title(f'regressed u field for {case_name_title}') plt.pcolor(X, Y, u_star_data) plt.colorbar(label='u') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'u_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed v field for {case_name_title}') plt.pcolor(X, Y, v_star_data) plt.colorbar(label='v') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'v_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed p field for {case_name_title}') plt.pcolor(X, Y, p_star_data) plt.colorbar(label='p') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'p_plot.png'), dpi=400) plt.close() # data error u_star_data = deepcopy(u_star) v_star_data = deepcopy(v_star) p_star_data = deepcopy(p_star) u_star_data[no_data_index] = u_star[no_data_index] * 0 v_star_data[no_data_index] = v_star[no_data_index] * 0 p_star_data[no_data_index] = p_star[no_data_index] * 0 u_star_data = u_star_data.reshape(Nx, Ny).T v_star_data = v_star_data.reshape(Nx, Ny).T p_star_data = p_star_data.reshape(Nx, Ny).T u_true = None v_true = None p_true = None u_true = deepcopy(u_data) v_true = deepcopy(v_data) p_true = deepcopy(p_data) u_true = u_true.reshape(Nx, Ny).T v_true = v_true.reshape(Nx, Ny).T p_true = p_true.reshape(Nx, Ny).T u_err = np.abs(u_true - u_star_data) v_err = np.abs(v_true - v_star_data) p_err = np.abs(p_true - p_star_data) plt.figure(figsize=figsize) # plt.title(f'u field abs error for {case_name_title}') plt.pcolor(X, Y, u_err) plt.colorbar(label='u') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'u_err_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'v field abs error for {case_name_title}') plt.pcolor(X, Y, v_err) plt.colorbar(label='v') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'v_err_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'p field abs error for {case_name_title}') plt.pcolor(X, Y, p_err) plt.colorbar(label='p') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'p_err_plot.png'), dpi=400) plt.close() e = model.predict(z, operator=pde) e_mass = e[0] e_u_momentum = e[1] e_v_momentum = e[2] f_divergence = e[3] data_dict.update({ "e_mass": e_mass, "e_u_momentum": e_u_momentum, "e_v_momentum": e_v_momentum, "f_divergence": f_divergence }) scipy.io.savemat(f"{case_name}/results.mat", data_dict) e_mass[no_data_index] = e_mass[no_data_index] * 0 e_u_momentum[no_data_index] = e_u_momentum[no_data_index] * 0 e_v_momentum[no_data_index] = e_v_momentum[no_data_index] * 0 f_divergence[no_data_index] = f_divergence[no_data_index] * 0 e_mass = e_mass.reshape(Nx, Ny).T e_u_momentum = e_u_momentum.reshape(Nx, Ny).T e_v_momentum = e_v_momentum.reshape(Nx, Ny).T f_divergence = f_divergence.reshape(Nx, Ny).T plt.figure(figsize=figsize) # plt.title(f'mass conservation residual for {case_name_title}') plt.pcolor(X, Y, e_mass, vmin=-1, vmax=1) plt.colorbar(label='e_mass') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'e_mass_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'u momentum conservation residual for {case_name_title}') plt.pcolor(X, Y, e_u_momentum, vmin=-1, vmax=1) plt.colorbar(label='e_u_momentum') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'e_u_momentum_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'v momentum conservation residual for {case_name_title}') plt.pcolor(X, Y, e_v_momentum, vmin=-1, vmax=1) plt.colorbar(label='e_v_momentum') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'e_v_momentum_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'fs divergence residual for {case_name_title}') plt.pcolor(X, Y, f_divergence, vmin=-1, vmax=1) plt.colorbar(label='f_divergence') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'f_divergence_plot.png'), dpi=400) plt.close() def curl_f(X, V): dfsx_y = dde.grad.jacobian(V, X, i=3, j=1) dfsy_x = dde.grad.jacobian(V, X, i=4, j=0) return [dfsy_x - dfsx_y] e = model.predict(z, operator=curl_f) f_curl = e[0] data_dict.update({"curlf": f_curl}) scipy.io.savemat(f"{case_name}/results.mat", data_dict) f_curl[no_data_index] = f_curl[no_data_index] * 0 f_curl = f_curl.reshape(Nx, Ny).T plt.figure(figsize=figsize) # plt.title(f'curl fs for {case_name_title}') plt.pcolor(X, Y, f_curl) plt.colorbar(label=r"$\nabla \times \mathbf{f}$") plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'f_curl_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'curl fs for {case_name_title}') plt.pcolor(X, Y, f_curl, vmin=-6.13125, vmax=6.26875) plt.colorbar(label=r"$\nabla \times \mathbf{f}$") plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'f_curl_plot_rescaled.png'), dpi=400) plt.close() def curl_f_alternative(X, V): u = V[:, 0:1] du_xy = dde.grad.hessian(u, X, i=0, j=1) du_yy = dde.grad.hessian(u, X, i=1, j=1) v = V[:, 1:2] dv_xx = dde.grad.hessian(v, X, i=0, j=0) dv_xy = dde.grad.hessian(v, X, i=0, j=1) du_y = dde.grad.jacobian(V, X, i=0, j=1) du_xxy = dde.grad.hessian(du_y, X, i=0, j=0) du_yyy = dde.grad.hessian(du_y, X, i=1, j=1) dv_x = dde.grad.jacobian(V, X, i=1, j=0) dv_xyy = dde.grad.hessian(dv_x, X, i=1, j=1) dv_xxx = dde.grad.hessian(dv_x, X, i=0, j=0) return [ -(u * du_xy + v * du_yy - 1 / 500 * (du_xxy + du_yyy)) + (u * dv_xx + v * dv_xy - 1 / 500 * (dv_xxx + dv_xyy)), -(u * du_xy + v * du_yy) + (u * dv_xx + v * dv_xy), (1 / 500 * (du_xxy + du_yyy)) - (1 / 500 * (dv_xxx + dv_xyy)) ] e = model.predict(z, operator=curl_f_alternative) f_curl_alt = e[0] f_curl_alt_1st = e[1] f_curl_alt_2nd = e[2] data_dict.update({ "curlfalt": f_curl_alt, "curlfalt1st": f_curl_alt_1st, "curlfalt2nd": f_curl_alt_2nd }) scipy.io.savemat(f"{case_name}/results.mat", data_dict) f_curl_alt[no_data_index] = f_curl_alt[no_data_index] * 0 f_curl_alt_1st[no_data_index] = f_curl_alt_1st[no_data_index] * 0 f_curl_alt_2nd[no_data_index] = f_curl_alt_2nd[no_data_index] * 0 f_curl_alt = f_curl_alt.reshape(Nx, Ny).T f_curl_alt_1st = f_curl_alt_1st.reshape(Nx, Ny).T f_curl_alt_2nd = f_curl_alt_2nd.reshape(Nx, Ny).T plt.figure(figsize=figsize) # plt.title(f'curl fs for {case_name_title}') plt.pcolor(X, Y, f_curl_alt) plt.colorbar(label=r"$\nabla \times \mathbf{f}$ alt") plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'f_curl_alternative_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'curl fs for {case_name_title}') plt.pcolor(X, Y, f_curl_alt, vmin=-6.13125, vmax=6.26875) plt.colorbar(label=r"$\nabla \times \mathbf{f}$ alt rescaled") plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'f_curl_alternative_plot_rescaled.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'curl fs for {case_name_title}') plt.pcolor(X, Y, f_curl_alt_1st) plt.colorbar(label=r"$\nabla \times \mathbf{f}$ alt 1st") plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'f_curl_alternative_plot_1st.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'curl fs for {case_name_title}') plt.pcolor(X, Y, f_curl_alt_2nd) plt.colorbar(label=r"$\nabla \times \mathbf{f}$ alt 2nd") plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'f_curl_alternative_plot_2nd.png'), dpi=400) plt.close() def u_derivatives(X, V): u = V[:, 0:1] du_xy = dde.grad.hessian(u, X, i=0, j=1) du_yy = dde.grad.hessian(u, X, i=1, j=1) v = V[:, 1:2] dv_xx = dde.grad.hessian(v, X, i=0, j=0) dv_xy = dde.grad.hessian(v, X, i=0, j=1) du_y = dde.grad.jacobian(V, X, i=0, j=1) du_x = dde.grad.jacobian(V, X, i=0, j=0) # du_xxy = dde.grad.hessian(du_y, X, i=0, j=0) # du_yyy = dde.grad.hessian(du_y, X, i=1, j=1) dv_x = dde.grad.jacobian(V, X, i=1, j=0) dv_y = dde.grad.jacobian(V, X, i=1, j=1) # dv_xyy = dde.grad.hessian(dv_x, X, i=1, j=1) # dv_xxx = dde.grad.hessian(dv_x, X, i=0, j=0) return [u, v, du_x, du_y, dv_x, dv_y, du_xy, du_yy, dv_xx, dv_xy] e = model.predict(z, operator=u_derivatives) u = e[0] v = e[1] du_x = e[2] du_y = e[3] dv_x = e[4] dv_y = e[5] du_xy = e[6] du_yy = e[7] dv_xx = e[8] dv_xy = e[9] data_dict = { "u": u, "v": v, "dux": du_x, "duy": du_y, "dvx": dv_x, "dvy": dv_y, "duxy": du_xy, "duyy": du_yy, "dvxx": dv_xx, "dvxy": dv_xy } scipy.io.savemat(f"{case_name}/velocity_and_derivatives.mat", data_dict)
def main(args): ## Get Dynamics Class dynamics = utils.system_dynamics() ## Parameters to inverse (if needed) params = dynamics.params_to_inverse(args.inverse) ## Generate Data file_name = args.file_name observe_x, V, W = dynamics.generate_data(file_name, args.dim) ## Split data to train and test observe_train, observe_test, v_train, v_test, w_train, w_test = train_test_split( observe_x, V, W, test_size=test_size) ## Add noise to training data if needed if args.noise: v_train = v_train + noise * np.random.randn(v_train.shape[0], v_train.shape[1]) ## Geometry and Time domains geomtime = dynamics.geometry_time(args.dim) ## Define Boundary Conditions bc = dynamics.BC_func(args.dim, geomtime) ## Define Initial Conditions ic = dynamics.IC_func(observe_train, v_train) ## Model observed data observe_v = dde.PointSetBC(observe_train, v_train, component=0) input_data = [bc, ic, observe_v] if args.w_input: ## If W required as an input observe_w = dde.PointSetBC(observe_train, w_train, component=1) input_data = [bc, ic, observe_v, observe_w] ## Select relevant PDE (Dim, Heterogeneity) and define the Network model_pinn = pinn.PINN(dynamics, args.dim, args.heter, args.inverse) model_pinn.define_pinn(geomtime, input_data, observe_train) ## Train Network out_path = dir_path + args.model_folder_name model, losshistory, train_state = model_pinn.train(out_path, params) ## Compute rMSE pred = model.predict(observe_test) v_pred, w_pred = pred[:, 0:1], pred[:, 1:2] rmse_v = np.sqrt(np.square(v_pred - v_test).mean()) print('--------------------------') print("V rMSE for test data:", rmse_v) print('--------------------------') print("Arguments: ", args) ## Save predictions, data np.savetxt("train_data.dat", np.hstack((observe_train, v_train, w_train)), header="observe_train,v_train, w_train") np.savetxt("test_pred_data.dat", np.hstack((observe_test, v_test, v_pred, w_test, w_pred)), header="observe_test,v_test, v_pred, w_test, w_pred") ## Generate Figures data_list = [observe_x, observe_train, v_train, V] if args.plot and args.dim == 1: plot_1D(data_list, dynamics, model, args.model_folder_name) elif args.plot and args.dim == 2: plot_2D(data_list, dynamics, model, args.animation, args.model_folder_name) return model
def main(train=True, test=True): # case name case_name = "steady_NACA_limiting_resolution" case_name_title = r'PIV stride $0.2 \times 0.2$' set_directory(case_name) x_data, y_data, u_data, v_data, p_data, x_domain, y_domain = read_data() airfoil_points = read_airfoil("Data/points_ok.dat") airfoil_array = np.array(airfoil_points) airfoil_array = rotate_points( airfoil_array[:, 0], airfoil_array[:, 1], 0.5, 0, -5 / 180 * math.pi ) airfoil_points = airfoil_array.tolist() #domain vertices v_ld = [-0.3, -0.6] v_ru = [2.7, 0.6] Nx = int((v_ru[0]-v_ld[0])*500)+1 Ny = int((v_ru[1]-v_ld[1])*500)+1 print('Nx', Nx, 'Ny', Ny) figsize = (8,3) # geometry specification geom1 = dde.geometry.Polygon(airfoil_points) geom2 = dde.geometry.Rectangle(v_ld, v_ru) geom = geom2 - geom1 [x_piv, y_piv, u_piv, v_piv, p_piv] = \ generate_PIV_points(x_data, y_data, u_data, v_data, p_data, 100, 100, v_ld, v_ru, geom, True) piv_points = np.hstack((x_piv, y_piv)) # BC specification # boundaries functions def boundary_in(x, on_boundary): return on_boundary and np.isclose(x[0], -0.5) def boundary(x, on_boundary): return on_boundary and not ( np.isclose(x[0], v_ld[0]) or np.isclose(x[0], v_ru[0]) or np.isclose(x[1], v_ld[1]) or np.isclose(x[1], v_ru[1]) ) # BC objects u_piv_points = dde.PointSetBC(piv_points, u_piv, component=0) v_piv_points = dde.PointSetBC(piv_points, v_piv, component=1) bc_wall_u = dde.DirichletBC(geom, func_zeros, boundary, component=0) bc_wall_v = dde.DirichletBC(geom, func_zeros, boundary, component=1) # custom domain points domain_points = generate_domain_points(x_domain, y_domain, geometry=geom) # pde and physics compilation pde = NS2D(500) if train: data = dde.data.PDE( geom, pde, [bc_wall_u, bc_wall_v, u_piv_points, v_piv_points], 100, 1600, solution=None, num_test=100, train_distribution="custom", custom_train_points=domain_points, ) plot_train_points(data, [2, 4], ["airfoil", "piv"], case_name, title=case_name_title, figsize=figsize) else: data = dde.data.PDE( geom, pde, [bc_wall_u, bc_wall_v, u_piv_points, v_piv_points], 100, 100, solution=None, num_test=100 ) dde.backend.tf.logging.set_verbosity(20) print(dde.backend.tf.logging.get_verbosity()) # exit(0) # NN model definition layer_size = [2] + [100] * 7 + [3] activation = "tanh" initializer = "Glorot uniform" net = dde.maps.FNN(layer_size, activation, initializer) # PINN definition model = dde.Model(data, net) if train: # Adam optimization loss_weights = [1, 1, 1, 10, 10, 10, 10] model.compile("adam", lr=0.001, loss_weights=loss_weights) checkpointer = dde.callbacks.ModelCheckpoint( f"{case_name}/models/model_{case_name}.ckpt", verbose=1, save_better_only=True, ) loss_update = dde.callbacks.LossUpdateCheckpoint( momentum=0.7, verbose=1, period=1, report_period=100, base_range=[0, 1, 2], update_range=[3, 4, 5, 6] ) print('Training for 100 epochs') losshistory, train_state = model.train( epochs=20000, callbacks=[checkpointer, loss_update], display_every=100 ) model.save(f"{case_name}/models/model-adam-last") # L-BFGS-B optimization model.compile("L-BFGS-B", loss_weights=loss_weights) losshistory, train_state = model.train() model.save(f"{case_name}/models/model-bfgs-last") if test: model.compile("adam", lr=0.001) model.compile("L-BFGS-B") last_epoch = model.train_state.epoch if not train: last_epoch=50001 model.restore(f"{case_name}/models/model-bfgs-last-{last_epoch}") x_plot = np.linspace(v_ld[0], v_ru[0], Nx) y_plot = np.linspace(v_ld[1], v_ru[1], Ny) # domain data x_data = x_data.reshape(1501, 601).T y_data = y_data.reshape(1501, 601).T u_data = u_data.reshape(1501, 601).T v_data = v_data.reshape(1501, 601).T p_data = p_data.reshape(1501, 601).T x_dom = np.linspace(-0.3, 2.7, 1501) y_dom = np.linspace(-0.6, 0.6, 601) x_min = np.argmin(np.abs(x_dom-v_ld[0])) x_max = np.argmin(np.abs(x_dom-v_ru[0])) y_min = np.argmin(np.abs(y_dom-v_ld[1])) y_max = np.argmin(np.abs(y_dom-v_ru[1])) print(x_min, x_max, y_min, y_max) x_data = x_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) y_data = y_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) u_data = u_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) v_data = v_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) p_data = p_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) z = np.array([np.array([i, j]) for i in x_plot for j in y_plot]) y = model.predict(z) u_star = y[:, 0][:, None] v_star = y[:, 1][:, None] p_star = y[:, 2][:, None] data_dict = { "u_star": u_star, "v_star": v_star, "p_star": p_star, } scipy.io.savemat(f"{case_name}/results.mat", data_dict) zero_index = (x_data < 0) & (x_data > 0) zero_index = zero_index | ((u_data == 0) & (v_data == 0)) no_data_index = zero_index u_star_data = deepcopy(u_star) v_star_data = deepcopy(v_star) p_star_data = deepcopy(p_star) u_star_data[no_data_index] = u_star[no_data_index]*0 v_star_data[no_data_index] = v_star[no_data_index]*0 p_star_data[no_data_index] = p_star[no_data_index]*0 u_star_data = u_star_data.reshape(Nx, Ny).T v_star_data = v_star_data.reshape(Nx, Ny).T p_star_data = p_star_data.reshape(Nx, Ny).T X, Y = np.meshgrid(x_plot, y_plot) plt.figure(figsize=figsize) # plt.title(f'regressed u field for {case_name_title}') plt.pcolor(X, Y, u_star_data) plt.colorbar(label='u') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'u_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed v field for {case_name_title}') plt.pcolor(X, Y, v_star_data) plt.colorbar(label='v') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'v_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed p field for {case_name_title}') plt.pcolor(X, Y, p_star_data) plt.colorbar(label='p') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'p_plot.png'), dpi=400) plt.close() # data error u_star_data = deepcopy(u_star) v_star_data = deepcopy(v_star) p_star_data = deepcopy(p_star) u_star_data[no_data_index] = u_star[no_data_index]*0 v_star_data[no_data_index] = v_star[no_data_index]*0 p_star_data[no_data_index] = p_star[no_data_index]*0 u_star_data = u_star_data.reshape(Nx, Ny).T v_star_data = v_star_data.reshape(Nx, Ny).T p_star_data = p_star_data.reshape(Nx, Ny).T u_true = None v_true = None p_true = None u_true = deepcopy(u_data) v_true = deepcopy(v_data) p_true = deepcopy(p_data) u_true = u_true.reshape(Nx, Ny).T v_true = v_true.reshape(Nx, Ny).T p_true = p_true.reshape(Nx, Ny).T u_err = np.abs(u_true-u_star_data) v_err = np.abs(v_true-v_star_data) p_err = np.abs(p_true-p_star_data) plt.figure(figsize=figsize) # plt.title(f'u field abs error for {case_name_title}') plt.pcolor(X, Y, u_err) plt.colorbar(label='u') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'u_err_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'v field abs error for {case_name_title}') plt.pcolor(X, Y, v_err) plt.colorbar(label='v') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'v_err_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'p field abs error for {case_name_title}') plt.pcolor(X, Y, p_err) plt.colorbar(label='p') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'p_err_plot.png'), dpi=400) plt.close() e = model.predict(z, operator=pde) e_mass = e[0] e_u_momentum = e[1] e_v_momentum = e[2] data_dict.update({ "e_mass": e_mass, "e_u_momentum": e_u_momentum, "e_v_momentum": e_v_momentum }) scipy.io.savemat(f"{case_name}/results.mat", data_dict) e_mass[no_data_index] = e_mass[no_data_index] * 0 e_u_momentum[no_data_index] = e_u_momentum[no_data_index] * 0 e_v_momentum[no_data_index] = e_v_momentum[no_data_index] * 0 e_mass = e_mass.reshape(Nx, Ny).T e_u_momentum = e_u_momentum.reshape(Nx, Ny).T e_v_momentum = e_v_momentum.reshape(Nx, Ny).T plt.figure(figsize=figsize) # plt.title(f'mass conservation residual for {case_name_title}') plt.pcolor(X, Y, e_mass, vmin=-1, vmax=1) plt.colorbar(label='e_mass') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'e_mass_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'u momentum conservation residual for {case_name_title}') plt.pcolor(X, Y, e_u_momentum, vmin=-1, vmax=1) plt.colorbar(label='e_u_momentum') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join( f'{case_name}', 'plots', 'e_u_momentum_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'v momentum conservation residual for {case_name_title}') plt.pcolor(X, Y, e_v_momentum, vmin=-1, vmax=1) plt.colorbar(label='e_v_momentum') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join( f'{case_name}', 'plots', 'e_v_momentum_plot.png'), dpi=400) plt.close()
(tf.sin(np.pi * x[:, 0:1]) - np.pi**2 * tf.sin(np.pi * x[:, 0:1]))) def func(x): return np.sin(np.pi * x[:, 0:1]) * np.exp(-x[:, 1:]) geom = dde.geometry.Interval(-1, 1) timedomain = dde.geometry.TimeDomain(0, 1) geomtime = dde.geometry.GeometryXTime(geom, timedomain) bc = dde.DirichletBC(geomtime, func, lambda _, on_boundary: on_boundary) ic = dde.IC(geomtime, func, lambda _, on_initial: on_initial) observe_x = np.vstack((np.linspace(-1, 1, num=10), np.full((10), 1))).T observe_y = dde.PointSetBC(observe_x, func(observe_x), component=0) data = dde.data.TimePDE( geomtime, pde, [bc, ic, observe_y], num_domain=40, num_boundary=20, num_initial=10, anchors=observe_x, solution=func, num_test=10000, ) layer_size = [2] + [32] * 3 + [1] activation = "tanh"
def pde(x, y): u, q = y[:, 0:1], y[:, 1:2] du_xx = dde.grad.hessian(y, x, component=0, i=0, j=0) return -du_xx + q def sol(x): # solution is u(x) = sin(pi*x), q(x) = -pi^2 * sin(pi*x) return np.sin(np.pi * x ** 2) geom = dde.geometry.Interval(-1, 1) bc = dde.DirichletBC(geom, sol, lambda _, on_boundary: on_boundary, component=0) ob_x, ob_u = gen_traindata(100) observe_u = dde.PointSetBC(ob_x, ob_u, component=0) data = dde.data.PDE( geom, pde, [bc, observe_u], num_domain=200, num_boundary=2, anchors=ob_x, num_test=1000, ) net = dde.maps.PFNN([1, [20, 20], [20, 20], [20, 20], 2], "tanh", "Glorot uniform") model = dde.Model(data, net) model.compile("adam", lr=0.0001, loss_weights=[1, 100, 1000])
def boundary(_, on_initial): return on_initial geom = dde.geometry.TimeDomain(0, 3) # Initial conditions ic1 = dde.IC(geom, lambda X: -8, boundary, component=0) ic2 = dde.IC(geom, lambda X: 7, boundary, component=1) ic3 = dde.IC(geom, lambda X: 27, boundary, component=2) # Get the train data observe_t, ob_y = gen_traindata() observe_y0 = dde.PointSetBC(observe_t, ob_y[:, 0:1], component=0) observe_y1 = dde.PointSetBC(observe_t, ob_y[:, 1:2], component=1) observe_y2 = dde.PointSetBC(observe_t, ob_y[:, 2:3], component=2) data = dde.data.PDE( geom, Lorenz_system, [ic1, ic2, ic3, observe_y0, observe_y1, observe_y2], num_domain=400, num_boundary=2, anchors=observe_t, ) net = dde.maps.FNN([1] + [40] * 3 + [3], "tanh", "Glorot uniform") model = dde.Model(data, net) model.compile("adam", lr=0.001, external_trainable_variables=[C1, C2, C3])
def main(): def pde(x, y): u, q = y[:, 0:1], y[:, 1:2] du_xx = dde.grad.hessian(y, x, component=0, i=0, j=0) # solution is u(x) = sin(pi*x), q(x) = -pi^2 * sin(pi*x) return -du_xx + q def sol(x): return np.sin(np.pi * x**2) geom = dde.geometry.Interval(-1, 1) bc = dde.DirichletBC(geom, sol, lambda _, on_boundary: on_boundary, component=0) ob_x, ob_u = gen_traindata(100) observe_u = dde.PointSetBC(ob_x, ob_u, component=0) data = dde.data.PDE( geom, pde, [bc, observe_u], num_domain=200, num_boundary=2, anchors=ob_x, num_test=1000, ) net = dde.maps.PFNN([1, [20, 20], [20, 20], [20, 20], 2], "tanh", "Glorot uniform") model = dde.Model(data, net) model.compile("adam", lr=0.0001, loss_weights=[1, 100, 1000]) losshistory, train_state = model.train(epochs=20000) dde.saveplot(losshistory, train_state, issave=True, isplot=True) # view results x = geom.uniform_points(500) yhat = model.predict(x) uhat, qhat = yhat[:, 0:1], yhat[:, 1:2] utrue = np.sin(np.pi * x) print("l2 relative error for u: " + str(dde.metrics.l2_relative_error(utrue, uhat))) plt.figure() plt.plot(x, uhat, label="uhat") plt.plot(x, utrue, label="utrue") plt.legend() qtrue = -np.pi**2 * np.sin(np.pi * x) print("l2 relative error for q: " + str(dde.metrics.l2_relative_error(qtrue, qhat))) plt.figure() plt.plot(x, qhat, label="qhat") plt.plot(x, qtrue, label="qtrue") plt.legend() plt.show()
def main(train=True, test=True): # case name case_name = "unNACA0012_f_as_var_with_inlet_bc" case_name_title = r'PIV stride $0.02 \times 0.02$ curlf as var inlet BC' set_directory(case_name) x_data, y_data, u_data, v_data, p_data, uu_data, uv_data, vv_data, x_domain, y_domain = read_data() airfoil_points = read_airfoil("./Data/points_ok.dat") airfoil_array = np.array(airfoil_points) airfoil_array = rotate_points( airfoil_array[:, 0], airfoil_array[:, 1], 0.5, 0, -15 / 180 * math.pi ) airfoil_points = airfoil_array.tolist() #domain vertices v_ld = [-0.3, -0.6] v_ru = [2.7, 0.6] figsize = (10, 10*(v_ru[1]-v_ld[1])/(v_ru[0]-v_ld[0])) figsize = (8,3) Nx = int((v_ru[0]-v_ld[0])*500)+1 Ny = int((v_ru[1]-v_ld[1])*500)+1 print('Nx', Nx, 'Ny', Ny) # geometry specification geom1 = dde.geometry.Polygon(airfoil_points) geom2 = dde.geometry.Rectangle(v_ld, v_ru) geom = geom2 - geom1 [x_piv, y_piv, u_piv, v_piv, p_piv] = \ generate_PIV_points(x_data, y_data, u_data, v_data, p_data, 10, 10, v_ld, v_ru, geom, True) piv_points = np.hstack((x_piv, y_piv)) # BC specification # boundaries functions def boundary(x, on_boundary): return on_boundary and not ( np.isclose(x[0], v_ld[0]) or np.isclose(x[0], v_ru[0]) or np.isclose(x[1], v_ld[1]) or np.isclose(x[1], v_ru[1]) ) def boundary_left_free(x, on_boundary): return on_boundary and (np.isclose(x[0], v_ld[0]) or (np.isclose(x[1], v_ru[1]) and x[0]<=-0.3) or (np.isclose(x[1], v_ld[1]) and x[0]<=-0.3)) def boundary_left_full(x, on_boundary): return on_boundary and not (np.isclose(x[0], v_ru[0]) or (np.isclose(x[1], v_ru[1]) and x[0]>-0.3) or (np.isclose(x[1], v_ld[1]) and x[0]>-0.3)) # BC objects u_piv_points = dde.PointSetBC(piv_points, u_piv, component=0) v_piv_points = dde.PointSetBC(piv_points, v_piv, component=1) bc_wall_u = dde.DirichletBC(geom, func_zeros, boundary, component=0) bc_wall_v = dde.DirichletBC(geom, func_zeros, boundary, component=1) bc_wall_fx = dde.DirichletBC(geom, func_zeros, boundary_left_full, component=3) bc_wall_fy = dde.DirichletBC(geom, func_zeros, boundary_left_full, component=4) bc_wall_curlf = dde.DirichletBC(geom, func_zeros, boundary_left_free, component=5) # custom domain points domain_points = generate_domain_points(x_domain, y_domain, geometry=geom) # pde and physics compilation pde = RANSf0var2D(500) if train: data = dde.data.PDE( geom, pde, [bc_wall_u, bc_wall_v, bc_wall_fx, bc_wall_fy, bc_wall_curlf, u_piv_points, v_piv_points], 100, 1600, solution=None, num_test=100, train_distribution="custom", custom_train_points=domain_points, ) plot_train_points(data, [2,4,5,7], ["airfoil velocities", "forcing", "curl", "piv"], case_name, title=case_name_title, figsize=figsize) else: data = dde.data.PDE( geom, pde, [bc_wall_u, bc_wall_v, bc_wall_fx, bc_wall_fy, bc_wall_curlf, u_piv_points, v_piv_points], 100, 100, solution=None, num_test=100 ) # exit(0) # NN model definition layer_size = [2] + [100] * 7 + [6] activation = "tanh" initializer = "Glorot uniform" net = dde.maps.FNN(layer_size, activation, initializer) # PINN definition model = dde.Model(data, net) if train: # Adam optimization loss_weights = [1, 1, 1, 1, 1, 10, 10, 10, 10, 10, 10, 10] model.compile("adam", lr=0.001, loss_weights=loss_weights) checkpointer = dde.callbacks.ModelCheckpoint( f"{case_name}/models/model_{case_name}.ckpt", verbose=1, save_better_only=True, ) loss_update = dde.callbacks.LossUpdateCheckpoint( momentum=0.7, verbose=1, period=1, report_period=100, base_range=[0, 1, 2, 3 ,4], update_range=[ 5, 6, 7, 8, 9, 10,11] ) print('Training for 10000 epochs') losshistory, train_state = model.train( epochs=20000, callbacks=[checkpointer, loss_update], display_every=100 ) model.save(f"{case_name}/models/model-adam-last") # L-BFGS-B optimization model.compile("L-BFGS-B", loss_weights=loss_weights) losshistory, train_state = model.train() model.save(f"{case_name}/models/model-bfgs-last") if test: model.compile("adam", lr=0.001) model.compile("L-BFGS-B") last_epoch = model.train_state.epoch if not train: last_epoch = 60001 model.restore(f"{case_name}/models/model-bfgs-last-{last_epoch}") x_plot = np.linspace(v_ld[0], v_ru[0], Nx) y_plot = np.linspace(v_ld[1], v_ru[1], Ny) # domain data x_data = x_data.reshape(1501, 601).T y_data = y_data.reshape(1501, 601).T u_data = u_data.reshape(1501, 601).T v_data = v_data.reshape(1501, 601).T p_data = p_data.reshape(1501, 601).T x_dom = np.linspace(-0.3, 2.7, 1501) y_dom = np.linspace(-0.6, 0.6, 601) x_min = np.argmin(np.abs(x_dom-v_ld[0])) x_max = np.argmin(np.abs(x_dom-v_ru[0])) y_min = np.argmin(np.abs(y_dom-v_ld[1])) y_max = np.argmin(np.abs(y_dom-v_ru[1])) print(x_min, x_max, y_min, y_max) x_data = x_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) y_data = y_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) u_data = u_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) v_data = v_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) p_data = p_data[y_min:y_max+1, x_min:x_max+1].T.reshape(-1,1) z = np.array([np.array([i, j]) for i in x_plot for j in y_plot]) y = model.predict(z) u_star = y[:, 0][:, None] v_star = y[:, 1][:, None] p_star = y[:, 2][:, None] fx_star = y[:, 3][:,None] fy_star = y[:, 4][:,None] curl_f = y[:, 5][:,None] data_dict = { "u_star": u_star, "v_star": v_star, "p_star": p_star, "fx_star": fx_star, "fy_star": fy_star, "curlfvar_star": curl_f, } scipy.io.savemat(f"{case_name}/results.mat", data_dict) zero_index = (x_data < 0) & (x_data > 0) zero_index = zero_index | ((u_data == 0) & (v_data == 0)) no_data_index = zero_index u_star_data = deepcopy(u_star) v_star_data = deepcopy(v_star) p_star_data = deepcopy(p_star) fx_star_data = deepcopy(fx_star) fy_star_data = deepcopy(fy_star) curl_f_data = deepcopy(curl_f) u_star_data[no_data_index] = u_star[no_data_index]*0 v_star_data[no_data_index] = v_star[no_data_index]*0 p_star_data[no_data_index] = p_star[no_data_index]*0 fx_star_data[no_data_index] = fx_star[no_data_index]*0 fy_star_data[no_data_index] = fy_star[no_data_index]*0 curl_f_data[no_data_index] = curl_f[no_data_index]*0 u_star_data = u_star_data.reshape(Nx, Ny).T v_star_data = v_star_data.reshape(Nx, Ny).T p_star_data = p_star_data.reshape(Nx, Ny).T fx_star_data = fx_star_data.reshape(Nx, Ny).T fy_star_data = fy_star_data.reshape(Nx, Ny).T curl_f_data = curl_f_data.reshape(Nx, Ny).T X, Y = np.meshgrid(x_plot, y_plot) plt.figure(figsize=figsize) # plt.title(f'regressed u field for {case_name_title}') plt.pcolor(X, Y, u_star_data) plt.colorbar(label='u') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'u_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed v field for {case_name_title}') plt.pcolor(X, Y, v_star_data) plt.colorbar(label='v') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'v_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed p field for {case_name_title}') plt.pcolor(X, Y, p_star_data) plt.colorbar(label='p') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'p_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed fx field for {case_name_title}') plt.pcolor(X, Y, fx_star_data) plt.colorbar(label='fx') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'fx_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed fy field for {case_name_title}') plt.pcolor(X, Y, fy_star_data) plt.colorbar(label='fy') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'fy_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'regressed var curlf field for {case_name_title}') plt.pcolor(X, Y, -curl_f_data, vmin=-6.13125, vmax=6.26875) plt.colorbar(label=r"$\nabla \times \mathbf{f}$") plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'curl_f_var_plot.png'), dpi=400) plt.close() # data error u_star_data = deepcopy(u_star) v_star_data = deepcopy(v_star) p_star_data = deepcopy(p_star) u_star_data[no_data_index] = u_star[no_data_index]*0 v_star_data[no_data_index] = v_star[no_data_index]*0 p_star_data[no_data_index] = p_star[no_data_index]*0 u_star_data = u_star_data.reshape(Nx, Ny).T v_star_data = v_star_data.reshape(Nx, Ny).T p_star_data = p_star_data.reshape(Nx, Ny).T u_true = None v_true = None p_true = None u_true = deepcopy(u_data) v_true = deepcopy(v_data) p_true = deepcopy(p_data) u_true = u_true.reshape(Nx, Ny).T v_true = v_true.reshape(Nx, Ny).T p_true = p_true.reshape(Nx, Ny).T u_err = np.abs(u_true-u_star_data) v_err = np.abs(v_true-v_star_data) p_err = np.abs(p_true-p_star_data) plt.figure(figsize=figsize) # plt.title(f'u field abs error for {case_name_title}') plt.pcolor(X, Y, u_err) plt.colorbar(label='u') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'u_err_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'v field abs error for {case_name_title}') plt.pcolor(X, Y, v_err) plt.colorbar(label='v') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'v_err_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'p field abs error for {case_name_title}') plt.pcolor(X, Y, p_err) plt.colorbar(label='p') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'p_err_plot.png'), dpi=400) plt.close() e = model.predict(z, operator=pde) e_mass = e[0] e_u_momentum = e[1] e_v_momentum = e[2] f_divergence = e[3] f_curl_err = e[4] data_dict.update({ "e_mass": e_mass, "e_u_momentum": e_u_momentum, "e_v_momentum": e_v_momentum, "f_divergence": f_divergence, "fvarerr_residual": f_curl_err }) scipy.io.savemat(f"{case_name}/results.mat", data_dict) e_mass[no_data_index] = e_mass[no_data_index] * 0 e_u_momentum[no_data_index] = e_u_momentum[no_data_index] * 0 e_v_momentum[no_data_index] = e_v_momentum[no_data_index] * 0 f_divergence[no_data_index] = f_divergence[no_data_index] * 0 f_curl_err[no_data_index] = f_curl_err[no_data_index] * 0 e_mass = e_mass.reshape(Nx, Ny).T e_u_momentum = e_u_momentum.reshape(Nx, Ny).T e_v_momentum = e_v_momentum.reshape(Nx, Ny).T f_divergence = f_divergence.reshape(Nx, Ny).T f_curl_err = f_curl_err.reshape(Nx, Ny).T plt.figure(figsize=figsize) # plt.title(f'mass conservation residual for {case_name_title}') plt.pcolor(X, Y, e_mass, vmin=-1, vmax=1) plt.colorbar(label='e_mass') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'e_mass_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'u momentum conservation residual for {case_name_title}') plt.pcolor(X, Y, e_u_momentum, vmin=-1, vmax=1) plt.colorbar(label='e_u_momentum') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join( f'{case_name}', 'plots', 'e_u_momentum_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'v momentum conservation residual for {case_name_title}') plt.pcolor(X, Y, e_v_momentum, vmin=-1, vmax=1) plt.colorbar(label='e_v_momentum') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join( f'{case_name}', 'plots', 'e_v_momentum_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'fs divergence residual for {case_name_title}') plt.pcolor(X, Y, f_divergence, vmin=-1, vmax=1) plt.colorbar(label='f_divergence') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join( f'{case_name}', 'plots', 'f_divergence_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'f_curl equality residual for {case_name_title}') plt.pcolor(X, Y, f_curl_err, vmin=-1, vmax=1) plt.colorbar(label='f_curl err') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join( f'{case_name}', 'plots', 'f_curl_eql_err_plot.png'), dpi=400) plt.close() def curl_f(X,V): dfsx_y = dde.grad.jacobian(V, X, i=3, j=1) dfsy_x = dde.grad.jacobian(V, X, i=4, j=0) return [dfsy_x - dfsx_y] e = model.predict(z, operator=curl_f) f_curl = e[0] data_dict.update({ "f_curl_star": e[0] }) scipy.io.savemat(f"{case_name}/results.mat", data_dict) f_curl[no_data_index] = f_curl[no_data_index] * 0 f_curl = f_curl.reshape(Nx, Ny).T plt.figure(figsize=figsize) # plt.title(f'curl fs for {case_name_title}') plt.pcolor(X, Y, f_curl) plt.colorbar(label='f_curl') plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'f_curl_plot.png'), dpi=400) plt.close() plt.figure(figsize=figsize) # plt.title(f'curl fs for {case_name_title}') plt.pcolor(X, Y, f_curl, vmin=-6.13125, vmax=6.26875) plt.colorbar(label=r"$\nabla \times \mathbf{f}$") plt.xlabel('x/c') plt.ylabel('y/c') plt.tight_layout() plt.savefig(os.path.join(f'{case_name}', 'plots', 'f_curl_plot_rescaled.png'), dpi=400) plt.close()
timedomain = dde.geometry.TimeDomain(0, 10) geomtime = dde.geometry.GeometryXTime(geom, timedomain) bc_a = dde.DirichletBC(geomtime, fun_bc, lambda _, on_boundary: on_boundary, component=0) bc_b = dde.DirichletBC(geomtime, fun_bc, lambda _, on_boundary: on_boundary, component=1) ic1 = dde.IC(geomtime, fun_init, lambda _, on_initial: on_initial, component=0) ic2 = dde.IC(geomtime, fun_init, lambda _, on_initial: on_initial, component=1) observe_x, Ca, Cb = gen_traindata() observe_y1 = dde.PointSetBC(observe_x, Ca, component=0) observe_y2 = dde.PointSetBC(observe_x, Cb, component=1) data = dde.data.TimePDE( geomtime, pde, [bc_a, bc_b, ic1, ic2, observe_y1, observe_y2], num_domain=2000, num_boundary=100, num_initial=100, anchors=observe_x, num_test=50000, ) net = dde.maps.FNN([2] + [20] * 3 + [2], "tanh", "Glorot uniform") model = dde.Model(data, net)