Solving Non-Linear Schrodinger Equation in fibre optics with deepxde

[Gocoderunav]

Dear professor,
I'm trying to solve the Non-Linear Schrodinger Equation in fibre optics with deepxde I have attached the image also. I'm reading your code on solving Schrodinger equation with deepxde. In my case the derivatives wrt to x and t are swapped you can understand by looking at image also .

I'm seeking your assistance in understanding and correcting this issue. I've been studying your code for solving the Schrödinger equation with deepxde, but I'm unsure how to address this particular problem.

Thank you for taking the time to read my message. Your guidance on this matter would be greatly appreciated.

Image:-

@source:-[https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=9489953]

--> My Questions is:-
Q-1 I'm using a Gaussian-like initial pulse, shaped as sech(t), applied at z=0. While it's periodic in time, existing classes like PeriodicBC are designed for spatial periodicity. Can I still use PeriodicBC to enforce boundary conditions effectively?"

Q-2 The real and imaginary parts of the Schrödinger equation seem inconsistent when solving it using either h=u+iv or h=u-iv. Can you please review this?

Here's the code I'm using to solve the NLSE in fiber optics

Code `:-import numpy as np

import deepxde as dde

For plotting

import matplotlib.pyplot as plt
from scipy.interpolate import griddata x_lower = 0
x_upper = 4
t_lower= -24
t_upper = 24

x =np.linspace(x_lower ,x_upper , 256)
t =np.linspace(t_lower ,t_upper , 201)

X,T =np.meshgrid(x,t)
X_star = np.hstack((X.flatten()[:, None], T.flatten()[:, None]))

space_domain = dde.geometry.Interval(x_lower,x_upper)
time_domain = dde.geometry.TimeDomain(t_lower,t_upper)
geomtime = dde.geometry.GeometryXTime(space_domain ,time_domain) def pde(x,y):
"""
INPUTS:
x: x[:,0] is x-coordinate
x[:,1] is t-coordinate
y: Network output, in this case:
y[:,0] is u(x,t) the real part
y[:,1] is v(x,t) the imaginary part
OUTPUT:
The pde in standard form i.e. something that must be zero
"""
u = y[:, 0:1] # real part
v = y[:,1:2] #imag part
u_z = dde.grad.jacobian( y, x, i=0 , j=0)
v_z = dde.grad.jacobian( y, x, i=1 , j=0)

In 'hessian', i and j are both input components. (The Hessian could be in principle something like d^2y/dxdt, d^2y/d^2x etc)

# The output component is selected by "component"
v_tt =dde.grad.hessian(y ,x ,component = 1, i=1 , j=1 )
u_tt =dde.grad.hessian(y ,x ,component = 0, i=1 , j=1 )

f_u = u_z -0.5*15*v_tt + 1.3*(u**2 + v**2)*v
f_v = v_z +0.5*15*u_tt -1.3* (u**2 +v**2)*u

return [f_u ,f_v]`

bc_u_0 = dde.icbc.PeriodicBC( geomtime, 0, lambda _, on_boundary: on_boundary, derivative_order=0, component=0 ) bc_u_1 = dde.icbc.PeriodicBC( geomtime, 0, lambda _, on_boundary: on_boundary, derivative_order=1, component=0 ) bc_v_0 = dde.icbc.PeriodicBC( geomtime, 0, lambda _, on_boundary: on_boundary, derivative_order=0, component=1 ) bc_v_1 = dde.icbc.PeriodicBC( geomtime, 0, lambda _, on_boundary: on_boundary, derivative_order=1, component=1 )
`# Initial condition
def init_cond_u(x):

return 2 / np.cosh(x[:, 1:2])

def init_cond_v(x):
return 0

ic_u = dde.icbc.IC(geomtime, init_cond_u, lambda _, on_initial: on_initial, component=0)
ic_v = dde.icbc.IC(geomtime, init_cond_v, lambda _, on_initial: on_initial, component=1)
data = dde.data.TimePDE(
geomtime,
pde,
[bc_u_0, bc_u_1, bc_v_0, bc_v_1, ic_u, ic_v],
num_domain=10000,
num_boundary=20,
num_initial=200,
train_distribution="pseudo",
)

Network architecture

net = dde.nn.FNN([2] + [100] * 4 + [2], "tanh", "Glorot normal")

model = dde.Model(data, net) model.compile("adam", lr=1e-3, loss="MSE")
model.train(iterations=10000, display_every=1000)`

[Gocoderunav]

@lululxvi

Dear Prof,
Sorry to bother you I'm still rectifying this.

[aamirf316]

@Gocoderunav
Hello Gocoderunav! Are we still solving this problem? I need some help with my code. Can you check my code? Because my predicted solution does not coincide with my exact solution? Why? See my code:
`import numpy as np
import deepxde as dde
from deepxde.backend import tf
import matplotlib.pyplot as plt

def complex_pde(x, y):
u, v = y[:, 0:1], y[:, 1:2]
du_dt = dde.grad.jacobian(y, x, i=0, j=0)
dv_dt = dde.grad.jacobian(y, x, i=1, j=0)
du_dx2 = dde.grad.hessian(y, x, component=0, i=1, j=1)
dv_dx2 = dde.grad.hessian(y, x, component=1, i=1, j=1)
return [
du_dt - dv_dx2 - 2 * (u2 + v2) * v,
dv_dt + du_dx2 + 2 * (u2 + v2) * u,
]

def boundary(_, on_initial):
return on_initial

def main():
geom = dde.geometry.Interval(-5, 5)
timedomain = dde.geometry.TimeDomain(0, 1)
geomtime = dde.geometry.GeometryXTime(geom, timedomain)

# Initial conditions
ic_r = dde.icbc.IC(geomtime, lambda x: np.cos(x[:, 1:2]), boundary, component=0)
ic_i = dde.icbc.IC(geomtime, lambda x: np.sin(x[:, 1:2]), boundary, component=1)

def boundary_real(x):
    return np.exp(-0.5 * x[:, 1]) * np.cos(x[:, 0])

def boundary_imag(x):
    return np.exp(-0.5 * x[:, 1]) * np.sin(x[:, 0])

bc_r_left = dde.icbc.DirichletBC(geomtime, boundary_real, lambda _, on_boundary: on_boundary and np.isclose(_[0], -5), component=0)
bc_r_right = dde.icbc.DirichletBC(geomtime, boundary_real, lambda _, on_boundary: on_boundary and np.isclose(_[0], 5), component=0)
bc_i_left = dde.icbc.DirichletBC(geomtime, boundary_imag, lambda _, on_boundary: on_boundary and np.isclose(_[0], -5), component=1)
bc_i_right = dde.icbc.DirichletBC(geomtime, boundary_imag, lambda _, on_boundary: on_boundary and np.isclose(_[0], 5), component=1)


# Enhancing the data resolution
data = dde.data.TimePDE(geomtime, complex_pde, [ic_r, ic_i, bc_r_left, bc_r_right, bc_i_left, bc_i_right], num_domain=4000, num_boundary=400, num_initial=400)

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


model = dde.Model(data, net)
# Using a simple constant learning rate
model.compile("adam", lr=1e-4)
losshistory, train_state = model.train(epochs=30000)

# Exact solution
N = 1000
t = np.linspace(0, 1, N)
x = np.linspace(-5, 5, N)
t, x = np.meshgrid(t, x)
u_real_exact = np.exp(-0.5 * t) * np.cos(x)
u_imag_exact = np.exp(-0.5 * t) * np.sin(x)

# Predicted solution
X = np.vstack((t.flatten(), x.flatten())).T
u_pred = model.predict(X)
u_real_pred, u_imag_pred = u_pred[:, 0], u_pred[:, 1]

# Reshape for plotting
u_real_pred = u_real_pred.reshape(t.shape)
u_imag_pred = u_imag_pred.reshape(t.shape)

# Select a fixed time
fixed_time = 0.5
time_index = np.argmin(np.abs(t[0, :] - fixed_time))

# Extract the solution at the fixed time
u_real_exact_fixed_time = u_real_exact[:, time_index]
u_imag_exact_fixed_time = u_imag_exact[:, time_index]
u_real_pred_fixed_time = u_real_pred[:, time_index]
u_imag_pred_fixed_time = u_imag_pred[:, time_index]

# Plot real part comparison at fixed time
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.plot(x[:, 0], u_real_exact_fixed_time, label='Exact')
plt.plot(x[:, 0], u_real_pred_fixed_time, label='Predicted', linestyle='--')
plt.xlabel('x')
plt.ylabel('Real part')
plt.title(f'Real Part at t = {fixed_time}')
plt.legend()

# Plot imaginary part comparison at fixed time
plt.subplot(1, 2, 2)
plt.plot(x[:, 0], u_imag_exact_fixed_time, label='Exact')
plt.plot(x[:, 0], u_imag_pred_fixed_time, label='Predicted', linestyle='--')
plt.xlabel('x')
plt.ylabel('Imaginary part')
plt.title(f'Imaginary Part at t = {fixed_time}')
plt.legend()

plt.show()

if name == 'main':
main()
`

[Gocoderunav]

check this out https://github.com/lululxvi/deepxde/blob/master/examples/pinn_forward/Schrodinger.ipynb

[Gocoderunav]

@Handi-Zhang Hello sir , https://github.com/lululxvi/deepxde/blob/master/examples/pinn_forward/Schrodinger.ipynb in this schrodinger equation using pinns. You haven't told why you have picked the 2 sech as initial wave. Also you haven't specify what is the order of the soliton also in your result we can see the soliton and it should appear periodically .But I have ran the code for the distance up to 4 I'm still getting the only one soliton why so?
Can you please help?