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
