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(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(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()
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()
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()
