def pde(x, y): dy_x = tf.gradients(y, x)[0] dy_x, dy_t = dy_x[:, 0:1], dy_x[:, 1:] dy_xx = tf.gradients(dy_x, x)[0][:, 0:1] return ( dy_t - dy_xx + tf.exp(-x[:, 1:]) * (tf.sin(np.pi * x[:, 0:1]) - np.pi**2 * tf.sin(np.pi * x[:, 0:1])))
def pde(x, y): dy_x = tf.gradients(y, x)[0] dy_x, dy_t = dy_x[:, 0:1], dy_x[:, 1:2] dy_xx = tf.gradients(dy_x, x)[0][:, 0:1] return dy_t + y * dy_x - nu * dy_xx def left_boundary(x, on_boundary): return on_boundary and np.isclose(x[0], a) def right_boundary(x, on_boundary): return on_boundary and np.isclose(x[0], b) def on_initial(_, on_initial): return on_initial def g_left(x): return np.zeros((len(x), 1)) def g_right(x): return np.zeros((len(x), 1)) def u_init(x): return np.sin(np.pi*x[:, 0:1])
def pde(x, y): ca, cb = y[:, 0:1], y[:, 1:2] ca_x = tf.gradients(ca, x)[0] dca_x, dca_t = ca_x[:, 0:1], ca_x[:, 1:2] dca_xx = tf.gradients(dca_x, x)[0][:, 0:1] cb_x = tf.gradients(cb, x)[0] dcb_x, dcb_t = cb_x[:, 0:1], cb_x[:, 1:2] dcb_xx = tf.gradients(dcb_x, x)[0][:, 0:1] 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 pde(x, y): f = 1.0 # Definition of the spatial derivatives dy_x = tf.gradients(y, x)[0] dy_x, dy_y = dy_x[:, 0:1], dy_x[:, 1:] dy_xx = tf.gradients(dy_x, x)[0][:, 0:1] dy_yy = tf.gradients(dy_y, x)[0][:, 1:] # Definition of the Poisson equation return dy_xx + dy_yy + f
def pde(x, y): f = 2 * (np.pi**2) * tf.sin(np.pi * x[:, 0:1]) \ * tf.sin(np.pi * x[:, 1:2]) # Definition of the spatial derivatives dy_x = tf.gradients(y, x)[0] dy_x, dy_y = dy_x[:, 0:1], dy_x[:, 1:] dy_xx = tf.gradients(dy_x, x)[0][:, 0:1] dy_yy = tf.gradients(dy_y, x)[0][:, 1:] # Definition of the Poisson equation return dy_xx + dy_yy + f
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 = tf.gradients(y1, x)[0] dy2_x = tf.gradients(y2, x)[0] dy3_x = tf.gradients(y3, x)[0] return [ dy1_x - C1 * (y2 - y1), dy2_x - y1 * (C2 - y3) + y2, dy3_x - y1 * y2 + C3 * y3, ]
def ide(x, y, int_mat): """int_0^x y(t)dt """ lhs1 = tf.matmul(int_mat, y) lhs2 = tf.gradients(y, x)[0] rhs = 2 * np.pi * tf.cos(2 * np.pi * x) + tf.sin(np.pi * x) ** 2 / np.pi return lhs1 + (lhs2 - rhs)[: tf.size(lhs1)]
def SLE_DL(t, y): """ For the deep learning method """ DyFun = SLEfun(y,C) Dygrand = tf.gradients(y, t)[0] return Dygrand - DyFun
def pde(x, y): # Definition of the unknown functions u, v, p = y[:, 0:1], y[:, 1:2], y[:, 2:3] # Definition of the derivatives du = tf.gradients(u, x)[0] dv = tf.gradients(v, x)[0] dp = tf.gradients(p, x)[0] dp_x, dp_y = dp[:, 0:1], dp[:, 1:2] du_x, du_y, du_t = du[:, 0:1], du[:, 1:2], du[:, 1:2] dv_x, dv_y, dv_t = dv[:, 0:1], dv[:, 1:2], dv[:, 2:3] du_xx = tf.gradients(du_x, x)[0][:, 0:1] du_yy = tf.gradients(du_y, x)[0][:, 1:2] dv_xx = tf.gradients(dv_x, x)[0][:, 0:1] dv_yy = tf.gradients(dv_y, x)[0][:, 1:2] # Definition of the equations continuity = du_x + dv_y x_momentum = du_t + u * du_x + v * du_y + \ dp_x - nu * (du_xx + du_yy) y_momentum = dv_t + u * dv_x + v * dv_y + \ dp_y - nu * (dv_xx + dv_yy) return [continuity, x_momentum, y_momentum]
def pde(x, y): f = 4*(1 - (x[:,0:1]**2 + x[:, 1:2]**2))\ *tf.exp(-(x[:, 0:1]**2 + x[:,1:2]**2)) # Definition of the forcing term for the # re-scaled star-shaped domain # f = 2 * (np.pi**2) * tf.sin(np.pi * x[:, 0:1]) \ # * tf.sin(np.pi * x[:, 1:2]) # Definition of the spatial derivatives dy_x = tf.gradients(y, x)[0] dy_x, dy_y = dy_x[:, 0:1], dy_x[:, 1:] dy_xx = tf.gradients(dy_x, x)[0][:, 0:1] dy_yy = tf.gradients(dy_y, x)[0][:, 1:] # Definition of the Poisson equation return dy_xx + dy_yy + f
def ODE(t, y): Ip = y[:, 0:1] Ii = y[:, 1:2] G = y[:, 2:3] h1 = y[:, 3:4] h2 = y[:, 4:5] h3 = y[:, 5:6] f1 = Rm * tf.math.sigmoid(G / (Vg * C1) - a1) f2 = Ub * (1 - tf.math.exp(-G / (Vg * C2))) kappa = (1 / Vi + 1 / (E * ti)) / C4 f3 = (U0 + Um / (1 + tf.pow(tf.maximum(kappa * Ii, 1e-3), -beta))) / (Vg * C3) f4 = Rg * tf.sigmoid(alpha * (1 - h3 / (Vp * C5))) dt = t - meal_t IG = tf.math.reduce_sum( 0.5 * meal_q * k * tf.math.exp(-k * dt) * (tf.math.sign(dt) + 1), axis=1, keepdims=True, ) tmp = E * (Ip / Vp - Ii / Vi) return [ tf.gradients(Ip, t)[0] - (f1 - tmp - Ip / tp), tf.gradients(Ii, t)[0] - (tmp - Ii / ti), tf.gradients(G, t)[0] - (f4 + IG - f2 - f3 * G), tf.gradients(h1, t)[0] - (Ip - h1) / td, tf.gradients(h2, t)[0] - (h1 - h2) / td, tf.gradients(h3, t)[0] - (h2 - h3) / td, ]
def fpde(x, y, int_mat): """du/dt + (D_{0+}^alpha + D_{1-}^alpha) u(x) = f(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) dy_t = tf.gradients(y, x)[0][:, 1:2] x, t = x[:, :-1], x[:, -1:] rhs = -dy_t - tf.exp(-t) * ( x ** 3 * (1 - x) ** 3 + gamma(4) / gamma(4 - alpha) * (x ** (3 - alpha) + (1 - x) ** (3 - alpha)) - 3 * gamma(5) / gamma(5 - alpha) * (x ** (4 - alpha) + (1 - x) ** (4 - alpha)) + 3 * gamma(6) / gamma(6 - alpha) * (x ** (5 - alpha) + (1 - x) ** (5 - alpha)) - gamma(7) / gamma(7 - alpha) * (x ** (6 - alpha) + (1 - x) ** (6 - alpha)) ) return lhs - rhs[: tf.size(lhs)]
def ODE(t, y): v4_1 = kd1 * y[:, 4:5] v4_2 = kd2 * y[:, 4:5] v5_3 = kd3 * y[:, 5:6] v5_4 = kd4 * y[:, 5:6] v7_5 = kd5 * y[:, 7:8] v7_6 = kd6 * y[:, 7:8] v03 = k1 * y[:, 3:4] * y[:, 0:1] v12 = k3 * y[:, 1:2] * y[:, 2:3] v36 = k5 * y[:, 6:7] * y[:, 3:4] return [ tf.gradients(y[:, 0:1], t)[0] - (-v03 + v4_1), tf.gradients(y[:, 1:2], t)[0] - (v4_2 - v12 + v5_3 + v5_4), tf.gradients(y[:, 2:3], t)[0] - (-v12 + v5_3), tf.gradients(y[:, 3:4], t)[0] - (v5_4 - v03 + v4_1 - v36 + v7_5 + v4_2), tf.gradients(y[:, 4:5], t)[0] - (-v4_2 + v03 - v4_1), tf.gradients(y[:, 5:6], t)[0] - (-v5_4 + v12 - v5_3), tf.gradients(y[:, 6:7], t)[0] - (-v36 + v7_5 + v7_6), tf.gradients(y[:, 7:8], t)[0] - (v36 - v7_5 - v7_6), ]
def ODE(t, y): v1 = k1 * y[:, 0:1] * y[:, 5:6] / (1 + tf.maximum(y[:, 5:6] / K1, 1e-3)**q) v2 = k2 * y[:, 1:2] * (N - y[:, 4:5]) v3 = k3 * y[:, 2:3] * (A - y[:, 5:6]) v4 = k4 * y[:, 3:4] * y[:, 4:5] v5 = k5 * y[:, 5:6] v6 = k6 * y[:, 1:2] * y[:, 4:5] v7 = k * y[:, 6:7] J = kappa * (y[:, 3:4] - y[:, 6:7]) return [ tf.gradients(y[:, 0:1], t)[0] - (J0 - v1), tf.gradients(y[:, 1:2], t)[0] - (2 * v1 - v2 - v6), tf.gradients(y[:, 2:3], t)[0] - (v2 - v3), tf.gradients(y[:, 3:4], t)[0] - (v3 - v4 - J), tf.gradients(y[:, 4:5], t)[0] - (v2 - v4 - v6), tf.gradients(y[:, 5:6], t)[0] - (-2 * v1 + 2 * v3 - v5), tf.gradients(y[:, 6:7], t)[0] - (psi * J - v7), ]
def pde(x, y): # u, v, p = y[:, 0:1], y[:, 1:2], y[:, 2:3] du = tf.gradients(u, x)[0] dv = tf.gradients(v, x)[0] dp = tf.gradients(p, x)[0] p_x, p_y = dp[:, 0:1], dp[:, 1:2] u_x, u_y = du[:, 0:1], du[:, 1:2] v_x, v_y = dv[:, 0:1], dv[:, 1:2] u_xx = tf.gradients(u_x, x)[0][:, 0:1] u_yy = tf.gradients(u_y, x)[0][:, 1:2] v_xx = tf.gradients(v_x, x)[0][:, 0:1] v_yy = tf.gradients(v_y, x)[0][:, 1:2] continuity = u_x + v_y x_momentum = u * u_x + v * u_y + p_x - nu * (u_xx + u_yy) y_momentum = u * v_x + v * v_y + p_y - nu * (v_xx + v_yy) return [continuity, x_momentum, y_momentum]
def pde(x, y): dy_x = tf.gradients(y, x)[0] dy_x, dy_y = dy_x[:, 0:1], dy_x[:, 1:] dy_xx = tf.gradients(dy_x, x)[0][:, 0:1] dy_yy = tf.gradients(dy_y, x)[0][:, 1:] return -dy_xx - dy_yy - 1
def dddy(x, y): return tf.gradients(ddy(x, y), x)[0]
def pde(x, y): dy_x = tf.gradients(y, x)[0] dy_x, dy_t = dy_x[:, 0:1], dy_x[:, 1:2] dy_xx = tf.gradients(dy_x, x)[0][:, 0:1] return dy_t + y * dy_x - 0.01 / np.pi * dy_xx
def pde(x, y): dy_x = tf.gradients(y, x)[0] dy_r, dy_theta = dy_x[:, 0:1], dy_x[:, 1:2] dy_rr = tf.gradients(dy_r, x)[0][:, 0:1] dy_thetatheta = tf.gradients(dy_theta, x)[0][:, 1:2] return x[:, 0:1] * dy_r + x[:, 0:1]**2 * dy_rr + dy_thetatheta
def pde(x, y): dy_x = tf.gradients(y, x)[0] dy_xx = tf.gradients(dy_x, x)[0] return dy_xx - 2
def pde(x, y): dy_xxxx = tf.gradients(dddy(x, y), x)[0] return dy_xxxx + 1
def ddy(x, y): dy_x = tf.gradients(y, x)[0] return tf.gradients(dy_x, x)[0]
def pde(x, y): dy_x = tf.gradients(y, x)[0] dy_xx = tf.gradients(dy_x, x)[0] return -dy_xx - np.pi**2 * tf.sin(np.pi * x)
def ide(x, y, int_mat): rhs = tf.matmul(int_mat, y) lhs1 = tf.gradients(y, x)[0] return (lhs1 + y)[:tf.size(rhs)] - rhs