step flow over a cylinder

[Elyasin97]

Hi!!
Firstly I have to appreciate the developer of this library and after that I have a question.
I'm new with PINNs and I'm trying to simulate the step fluid flow field around a cylinder and here is the code:
`def wall_top_boundary(x, on_boundary):
"""Checks for points on top wall boundary"""
return on_boundary and np.isclose(x[1], 2.0)

def wall_bottom_boundary(x, on_boundary):
"""Checks for points on bottom wall boundary"""
return on_boundary and np.isclose(x[1], 0.0)

def wall_mid_horizontal_boundary(x, on_boundary):
"""Check for points on step horizontal boundary"""
return on_boundary and (np.isclose(x[1], 1.0) and x[0] < 2.0)

def wall_mid_vertical_boundary(x, on_boundary):
"""Check for points on step horizontal boundary"""
return on_boundary and (x[1] < 1.0 and np.isclose(x[0], 2.0))

def outlet_boundary(x, on_boundary):
"""Implements the outlet boundary with zero y-velocity component"""
return on_boundary and np.isclose(x[0], 12.0)

def inlet_boundary(x, on_boundary):
"""Implements the inlet boundary with parabolic x-velocity component"""
return on_boundary and np.isclose(x[0], 0.0)

def boundary_circle(x, on_boundary):
#centre (4, 1), radius 0.3
return on_boundary and disk_domain.on_boundary(x)

def parabolic_velocity(x):
"""Parabolic velocity"""
return (6 * (x[:, 1] - 1) * (2 - x[:, 1])).reshape(-1, 1)

def zero_velocity(x):
"""Zero velocity"""
return np.zeros((x.shape[0], 1))

def output_transformer(inputs, outputs):
"""Apply output transforms to strictly enforce boundary conditions"""

top_line = inputs[:, 1] - 2.0
bottom_line = inputs[:, 1]
mid_hor_line = inputs[:, 1] - 1.0
mid_ver_line = inputs[:, 0] - 2.0
outlet_line = inputs[:, 0] - 12.0
inlet_line = inputs[:, 0]
# velocity_profile = 6.0 * (inputs[:, 1] - 1.0) * (2.0 - inputs[:, 1])
velocity_profile = 1.0

u_multiplier = (top_line * bottom_line * mid_hor_line * mid_ver_line *
                velocity_profile)
v_multiplier = (top_line * bottom_line * mid_hor_line * mid_ver_line *
                outlet_line * inlet_line)
p_multiplier = 1.0

return tf.transpose(
    tf.stack((
        u_multiplier * outputs[:, 0],
        v_multiplier * outputs[:, 1],
        p_multiplier * outputs[:, 2]
    ))
)

def navier_stokes(x, y):
"""Navier-Stokes equation"""
rho = 1.0
nu = 0.01
eps = 1e-8

u, v, p = y[:, 0:1], y[:, 1:2], y[:, 2:3]

du = tf.gradients(u, x)[0]
dv = tf.gradients(v, x)[0]
dp = tf.gradients(p, x)[0]

p_x, p_y = dp[:, 0:1], dp[:, 1:2]
u_x, u_y = du[:, 0:1], du[:, 1:2]
v_x, v_y = dv[:, 0:1], dv[:, 1:2]

u_xx = tf.gradients(u_x, x)[0][:, 0:1]
u_yy = tf.gradients(u_y, x)[0][:, 1:2]

v_xx = tf.gradients(v_x, x)[0][:, 0:1]
v_yy = tf.gradients(v_y, x)[0][:, 1:2]

continuity = u_x + v_y + eps * p
x_momentum = u * u_x + v * u_y + 1 / rho * p_x - nu * (u_xx + u_yy)
y_momentum = u * v_x + v * v_y + 1 / rho * p_y - nu * (v_xx + v_yy)

return [continuity, x_momentum, y_momentum]

if name == 'main':
geom1 = dde.geometry.geometry_2d.Polygon([
[0.0, 2.0], [12.0, 2.0], [12.0, 0.0], [2.0, 0.0], [2.0, 1.0],
[0.0, 1.0]
])
disk_domain = dde.geometry.Disk([4,1],0.3)
geom = geom1-disk_domain

inlet_x = dde.icbc.DirichletBC(geom, parabolic_velocity, inlet_boundary,
                      component=0)
inlet_y = dde.icbc.DirichletBC(geom, zero_velocity, inlet_boundary, component=1)
outlet = dde.icbc.DirichletBC(geom, zero_velocity, outlet_boundary, component=1)
wallt_x = dde.icbc.DirichletBC(geom, zero_velocity, wall_top_boundary, component=0)
wallt_y = dde.icbc.DirichletBC(geom, zero_velocity, wall_top_boundary, component=1)
wallb_x = dde.icbc.DirichletBC(geom, zero_velocity, wall_bottom_boundary,
                      component=0)
wallb_y = dde.icbc.DirichletBC(geom, zero_velocity, wall_bottom_boundary,
                      component=1)
wallsh_x = dde.icbc.DirichletBC(geom, zero_velocity, wall_mid_horizontal_boundary,
                       component=0)
wallsh_y = dde.icbc.DirichletBC(geom, zero_velocity, wall_mid_horizontal_boundary,
                       component=1)
wallsv_x = dde.icbc.DirichletBC(geom, zero_velocity, wall_mid_vertical_boundary,
                       component=0)
wallsv_y = dde.icbc.DirichletBC(geom, zero_velocity, wall_mid_vertical_boundary,
                       component=1)
circle_u = dde.icbc.boundary_conditions.DirichletBC(geom, zero_velocity, boundary_circle, component=0)
circle_v = dde.icbc.boundary_conditions.DirichletBC(geom, zero_velocity, boundary_circle, component=1)
data = dde.data.PDE(
    geom, navier_stokes,
    [inlet_x, inlet_y, outlet, wallb_x, wallb_y, wallsh_x, wallsh_y,
     wallsv_x, wallsv_y, wallt_x, wallt_y, circle_u, circle_v],
    num_domain=1000, num_boundary=3000,
    num_test=5000
)

layer_size = [2] + [30] * 3 + [3]
net = dde.maps.FNN(layer_size, "tanh", "Glorot uniform")

model = dde.Model(data, net)
model.compile("adam", lr=0.001)

early_stopping = dde.callbacks.EarlyStopping(min_delta=1e-8, patience=10000)
model.train(epochs=25000, display_every=1000,
            disregard_previous_best=True, callbacks=[early_stopping])`

and this is the result:

while it should be like this:

I do not know how to fix the issue, any help would be appreciated

[Elyasin97]

I understood what my mistake was.

[lemon123428]

Hi，I am learning to simulate the flow around a cylinder , but there is no example for my reference.So ,if possible，can you show me your code ?Thank you!!

[davidgomes343]

Hello,
I am also trying to use the same methodology for flow reconstruction; however, I am not getting good results.
Any one of you could provide the code for the right reconstruction? @Elyasin97 @lemon123428
Thank you in advance!