No penetration Boundary condition

[jmtucny]

Hello @lululxvi,

Thank you and your collaborators again for your work on this library.

I have an inverse problem where I'd like to predict the flow field of a rarefied gas around a cylinder, and I have training data. I'd like to implement a no-penetration boundary condition $n \cdot v = 0 $ in the PINN at the surface of the cylinder. I've tried imposing the non-penetration BC as hard penalty function. To compute the normal to my cylinder, I have to use a numpy array instead of keeping the backend tensors. So I've tried imposing a hard BC the following way:

"Data"
ob_xy = training_data[:,0:2]
ob_var = training_data[:,3:]
ob_var = ob_var/dimless_const[3:]
minimum_ob = np.min(ob_var, axis=0)
maximum_ob = np.max(ob_var, axis=0)
ob_vx = dde.icbc.PointSetBC(ob_xy, ob_var, component = 0, shuffle=True)
ob_vy = dde.icbc.PointSetBC(ob_xy, ob_var, component = 1, shuffle=True)
ob_momxy = dde.icbc.PointSetBC(ob_xy, ob_var, component = 2, shuffle=True)
ob_momxx = dde.icbc.PointSetBC(ob_xy, ob_var, component = 3, shuffle=True)
ob_momyy = dde.icbc.PointSetBC(ob_xy, ob_var, component = 4, shuffle=True)

"Set the domain"
cylinder = dde.geometry.Disk([0, 0], 0.25)
rectangle = dde.geometry.Rectangle([-1,-1], [1,1])
geom = rectangle - cylinder

"Cylinder boundary condition"
def boundary_cylinder(x, on_boundary):
    return on_boundary and cylinder.on_boundary(x)

def no_penetration(x, y):
    xc = x[:, 0:1].detach().numpy()
    yc = x[:, 1:2].detach().numpy()
    vxcyl = y[:,0:1].detach().numpy()
    vycyl = y[:,1:2].detach().numpy()
    pos = np.hstack((xc,yc))
    vv = np.hstack((vxcyl,vycyl))
    normal = -cylinder.boundary_normal(pos) 
    result = np.sum(normal*vv,axis=1)[:,None]
    return result

data = dde.data.PDE(
    geom,
    PDEs,
    bcs=[ob_vx, ob_vy, ob_momxy, ob_momxx, ob_momyy],
    num_boundary=0,
    anchors=ob_xy
)

#%% Create the model
neuronsperlayer = [20, 20, 20, 20, 20]
net = dde.nn.PFNN([2] + neuronsperlayer*6 + [5], "tanh", "Glorot normal")

#net.regularizer=("l2", 0.00001)
net.apply_output_transform(no_penetration)
model = dde.Model(data, net)

model.compile("adam", lr=1e-4, loss_weights=[0.1, 0.1, 0.1, 1, 1, 1, 1, 1], loss="mse")
losshistory, train_state = model.train(iterations=1, display_every=1)

dde.saveplot(losshistory, train_state, issave=True, isplot=True)
vxhat, vyhat, momxyhat, momxxhat, momyyhat = record_results(ob_xy)

The function no_penetration computes the normal component of the flow correctly. However, it returns the following error: "unhashable type: 'numpy.ndarray'". Perhaps I should not try to convert to np.array. Also, I'm not sure this is the right approach even without the np.array conversion problem. Would you have suggestions on how to implement a no-penetration BC ?

[lululxvi]

You need to implement using pure TensorFlow or PyTorch code.