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)
