{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PINN Solution of the Nonlinear Shroedinger PDE\n",
    "\n",
    "This PyTorch code demonstrates the application of physically-informed neural networks (PINN) in the solution of a well-known Nonlinear Shroedinger PDE with periodic boundary condition\n",
    "\\begin{aligned}\n",
    "  &\\mathbf{u}_t = i * \\mathbf{u}_{xx} + i * |\\mathbf{u}|^2 * \\mathbf{u} \\in [0, T]\\times[-L, L]\\\\\n",
    "  &\\mathbf{u}(0, x) = \\mathbf{u}_0(x), \\quad \\forall x \\in [-L, L] \\\\\n",
    "  &\\mathbf{u}(t, -L) = \\mathbf{u}(t, L), \\quad \\forall t \\in [0, T]\n",
    "\\end{aligned}\n",
    "where $i^2 = -1$, and $[-L, L]$ covers one full period, i.e. $T = 2L$.  If we let $\\mathbf{u} = u + i * v$, then we obtain two PDEs\n",
    "\\begin{aligned}\n",
    "u_t &= -v_{xx} - (u^2 + v^2) * v \\\\\n",
    "v_t &= u_{xx} + (u^2 + v^2) * u\n",
    "\\end{aligned}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries and Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.optim\n",
    "import torch.optim.lr_scheduler as lr_scheduler\n",
    "from itertools import chain\n",
    "from collections import OrderedDict\n",
    "from pyDOE import lhs\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.io\n",
    "from scipy.interpolate import griddata\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "import matplotlib.gridspec as gridspec\n",
    "import time\n",
    "\n",
    "np.random.seed(1234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Working on mps\n"
     ]
    }
   ],
   "source": [
    "if torch.backends.mps.is_available():\n",
    "    device = torch.device('mps')\n",
    "elif torch.cuda.is_available():\n",
    "    device = torch.device('cuda')\n",
    "else:\n",
    "    device = torch.device('cpu')\n",
    "#\n",
    "print(f\"Working on {device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = np.pi\n",
    "xlo = -L\n",
    "xhi = L\n",
    "period = xhi - xlo\n",
    "tlo = 0.0\n",
    "thi = 2.0\n",
    "sqrt2 = torch.tensor(np.sqrt(2)).float().to(device)\n",
    "# taking A = 1 and B = 1\n",
    "u0 = lambda x: 2.0/(2.0 - np.sqrt(2) * np.cos(x)) - 1.0\n",
    "v0 = lambda x: np.zeros_like(x)\n",
    "u0_ten = lambda x: 2.0/(2.0 - sqrt2 * torch.cos(x)) - 1.0\n",
    "v0_ten = lambda x: torch.zeros_like(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Physics-informed Neural Networks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the deep neural network\n",
    "class DNN(torch.nn.Module):\n",
    "    def __init__(self, layers):\n",
    "        super(DNN, self).__init__()\n",
    "        # parameters\n",
    "        self.depth = len(layers) - 1\n",
    "        # set up layer order dict\n",
    "        self.activation = torch.nn.Tanh\n",
    "        layer_list = list()\n",
    "        for i in range(self.depth - 1): \n",
    "            layer_list.append(\n",
    "                ('layer_%d' % i, torch.nn.Linear(layers[i], layers[i+1]))\n",
    "            )\n",
    "            layer_list.append(('activation_%d' % i, self.activation()))\n",
    "            \n",
    "        layer_list.append(\n",
    "            ('layer_%d' % (self.depth - 1), torch.nn.Linear(layers[-2], layers[-1]))\n",
    "        )\n",
    "        layerDict = OrderedDict(layer_list)\n",
    "        # deploy layers\n",
    "        self.layers = torch.nn.Sequential(layerDict)\n",
    "        self.layers[0].weight = torch.load('initial_weight.pt')\n",
    "    def forward(self, x):\n",
    "        out = self.layers(x)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PhysicsInformedNN():\n",
    "    def __init__(self, period,  X_IC, u_IC, v_IC, X_BC, u_BC, v_BC, X_PDE, layers):\n",
    "        # IC data point\n",
    "        self.t_IC = torch.tensor(X_IC[:, 0:1]).float().to(device)\n",
    "        self.x_IC = torch.tensor(X_IC[:, 1:2]).float().to(device)\n",
    "        self.u_IC = torch.tensor(u_IC).float().to(device)\n",
    "        self.v_IC = torch.tensor(v_IC).float().to(device) \n",
    "        # BC data point\n",
    "        self.t_BC = torch.tensor(X_BC[:, 0:1]).float().to(device)\n",
    "        self.x_BC = torch.tensor(X_BC[:, 1:2]).float().to(device)\n",
    "        self.u_BC = torch.tensor(u_BC).float().to(device)\n",
    "        self.v_BC = torch.tensor(v_BC).float().to(device) \n",
    "        self.period = torch.tensor(period).float().to(device)\n",
    "        # PDE data, gradients will be computed on these points so requires_grad = True\n",
    "        self.t_PDE = torch.tensor(X_PDE[:, 0:1], requires_grad=True).float().to(device)\n",
    "        self.x_PDE = torch.tensor(X_PDE[:, 1:2], requires_grad=True).float().to(device)\n",
    "        # equation related parameters\n",
    "        \n",
    "        # layers to build Neural Net\n",
    "        self.layers = layers\n",
    "        # deep neural networks\n",
    "        self.dnn = DNN(layers).to(device)    \n",
    "        # prepare the optimizer\n",
    "        self.optimizer_Adam = torch.optim.Adam(self.dnn.parameters(), lr = 1e-3)\n",
    "        # add a learning rate scheduler\n",
    "        self.optimizer_LBFGS = torch.optim.LBFGS(\n",
    "            self.dnn.parameters(), \n",
    "            lr=1.0, \n",
    "            max_iter=10000, \n",
    "            max_eval=5000, \n",
    "            history_size=50,\n",
    "            tolerance_grad=1e-7, \n",
    "            tolerance_change=1.0 * np.finfo(float).eps,\n",
    "            line_search_fn=\"strong_wolfe\"       # can be \"strong_wolfe\"\n",
    "        )      \n",
    "        self.scheduler = lr_scheduler.ExponentialLR(self.optimizer_Adam, gamma=0.99)\n",
    "        \n",
    "        \n",
    "        self.iter = 0\n",
    "    # evaluater neural network, no transformation\n",
    "    def NN_eval(self, t, x): \n",
    "        NN = self.dnn(torch.cat([t, x], dim = 1)) \n",
    "        u = NN[:, 0][:, None]\n",
    "        v = NN[:, 1][:, None]\n",
    "        return u, v\n",
    "    # compute the PDE\n",
    "    def pde_eval(self, t, x):\n",
    "        \"\"\" The pytorch autograd version of calculating residual \"\"\"\n",
    "        u, v = self.NN_eval(t, x)\n",
    "        # compute the derivatives for u\n",
    "        u_t    = torch.autograd.grad(u,     t, grad_outputs = torch.ones_like(u), retain_graph = True, create_graph=True)[0]\n",
    "        u_x    = torch.autograd.grad(u,     x, grad_outputs = torch.ones_like(u), retain_graph = True, create_graph=True)[0]\n",
    "        u_xx   = torch.autograd.grad(u_x,   x, grad_outputs = torch.ones_like(u), retain_graph = True, create_graph=True)[0]\n",
    "        v_t    = torch.autograd.grad(v,     t, grad_outputs = torch.ones_like(u), retain_graph = True, create_graph=True)[0]\n",
    "        v_x    = torch.autograd.grad(v,     x, grad_outputs = torch.ones_like(u), retain_graph = True, create_graph=True)[0]\n",
    "        v_xx   = torch.autograd.grad(v_x,   x, grad_outputs = torch.ones_like(u), retain_graph = True, create_graph=True)[0]   \n",
    "        # pre-compute the norm of \\mathbf{u}, so that it can be re-used\n",
    "        U_norm = torch.pow(u, 2.0) + torch.pow(v, 2.0)\n",
    "        Eq1    = u_t + v_xx + U_norm * v\n",
    "        Eq2    = v_t - u_xx - U_norm * u\n",
    "        return Eq1, Eq2\n",
    "    # compute the total loss for the second-order optimizer\n",
    "    def loss_func(self):\n",
    "        # reset the gradient\n",
    "        self.optimizer_LBFGS.zero_grad()\n",
    "        # compute IC loss\n",
    "        uIC_pred, vIC_pred = self.NN_eval(self.t_IC, self.x_IC)\n",
    "        loss_IC = torch.mean((self.u_IC - uIC_pred)**2.0) + torch.mean((self.v_IC - vIC_pred)**2.0)\n",
    "        # compute PBC loss\n",
    "        uBC_pred_left, vBC_pred_left = self.NN_eval(self.t_BC, self.x_BC)\n",
    "        uBC_pred_right, vBC_pred_right = self.NN_eval(self.t_BC, self.x_BC+self.period)\n",
    "        loss_BC = torch.mean(( uBC_pred_left - uBC_pred_right)**2.0) + torch.mean((vBC_pred_left - vBC_pred_right)**2.0)\n",
    "        \n",
    "       \n",
    "        # compute PDE loss\n",
    "        pde1_pred, pde2_pred = self.pde_eval(self.t_PDE, self.x_PDE)\n",
    "        loss_PDE = torch.mean(pde1_pred ** 2) + torch.mean(pde2_pred ** 2)   \n",
    "        # compute the total loss, it can be weighted\n",
    "        loss = loss_IC + loss_BC + loss_PDE\n",
    "        # backward propagation\n",
    "        loss.backward()\n",
    "        # increase the iteration counter\n",
    "        self.iter += 1\n",
    "        # output\n",
    "        # output the progress\n",
    "        if self.iter % 1000 == 0:\n",
    "            end_time = time.time()\n",
    "            print('Iter %5d, Total: %10.4e, Time: %.2f secs' % (self.iter, loss.item(), end_time - self.start_time))\n",
    "            print('IC: %10.4e, PBC: %10.4e, PDE: %10.4e' % (loss_IC.item(), loss_BC.item(), loss_PDE.item()))\n",
    "            self.start_time = end_time\n",
    "        return loss\n",
    "    #\n",
    "    def train(self, nIter):\n",
    "        # start the timer\n",
    "        start_time = time.time()        \n",
    "        # start the training with Adam first\n",
    "        self.dnn.train()\n",
    "        print('Starting with Adam')\n",
    "        for epoch in range(nIter):\n",
    "            # compute IC loss\n",
    "            uIC_pred, vIC_pred = self.NN_eval(self.t_IC, self.x_IC)\n",
    "            loss_IC = torch.mean((self.u_IC - uIC_pred)**2.0) + torch.mean((self.v_IC - vIC_pred)**2.0)\n",
    "        # compute PBC loss\n",
    "            uBC_pred_left, vBC_pred_left = self.NN_eval(self.t_BC, self.x_BC)\n",
    "            uBC_pred_right, vBC_pred_right = self.NN_eval(self.t_BC, self.x_BC+self.period)\n",
    "            loss_BC = torch.mean(( uBC_pred_left - uBC_pred_right)**2.0) + torch.mean((vBC_pred_left - vBC_pred_right)**2.0)\n",
    "        \n",
    "       \n",
    "        # compute PDE loss\n",
    "            pde1_pred, pde2_pred = self.pde_eval(self.t_PDE, self.x_PDE)\n",
    "            loss_PDE = torch.mean(pde1_pred ** 2) + torch.mean(pde2_pred ** 2)   \n",
    "        # compute the total loss, it can be weighted\n",
    "            loss = loss_IC + loss_BC + loss_PDE\n",
    "            # Backward and optimize\n",
    "            self.optimizer_Adam.zero_grad()\n",
    "            loss.backward()\n",
    "            self.optimizer_Adam.step() \n",
    "            # output the progress\n",
    "            if (epoch + 1) % 1000 == 0:\n",
    "                end_time = time.time()\n",
    "                print('Iter %5d, Total: %10.4e, Time: %.2f secs' % (epoch + 1, loss.item(), end_time - start_time))\n",
    "                print('IC: %10.4e, PBC: %10.4e, PDE: %10.4e' % (loss_IC.item(), loss_BC.item(), loss_PDE.item()))\n",
    "                start_time = end_time\n",
    "                # change the learning rate\n",
    "                self.scheduler.step()\n",
    "        # Using the second-order L-BFGS optimizer\n",
    "#         print('Starting with L-BFGS')\n",
    "        self.start_time = time.time()\n",
    "        self.optimizer_LBFGS.step(self.loss_func)                \n",
    "    #        \n",
    "    def predict(self, X):\n",
    "        t = torch.tensor(X[:, 0:1], requires_grad=True).float().to(device)\n",
    "        x = torch.tensor(X[:, 1:2], requires_grad=True).float().to(device)\n",
    "        self.dnn.eval()\n",
    "        u, v = self.NN_eval(t, x)\n",
    "        u = u.detach().cpu().numpy()\n",
    "        v = v.detach().cpu().numpy()\n",
    "        return u,v\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting with Adam\n",
      "Iter  1000, Total: 4.1847e-02, Time: 85.93 secs\n",
      "IC: 1.7506e-02, PBC: 3.7238e-05, PDE: 2.4304e-02\n",
      "Iter  2000, Total: 3.1136e-01, Time: 116.08 secs\n",
      "IC: 2.3158e-01, PBC: 7.3006e-04, PDE: 7.9047e-02\n",
      "Iter  3000, Total: 1.3308e-01, Time: 115.28 secs\n",
      "IC: 6.4332e-02, PBC: 3.4915e-03, PDE: 6.5258e-02\n",
      "Iter  4000, Total: 7.7328e-02, Time: 114.92 secs\n",
      "IC: 3.8169e-02, PBC: 1.0532e-03, PDE: 3.8106e-02\n",
      "Iter  5000, Total: 4.7750e-02, Time: 115.01 secs\n",
      "IC: 2.4613e-02, PBC: 3.5022e-04, PDE: 2.2787e-02\n",
      "Iter  6000, Total: 3.6599e-02, Time: 115.26 secs\n",
      "IC: 1.6948e-02, PBC: 2.6294e-04, PDE: 1.9387e-02\n",
      "Iter  7000, Total: 3.1333e-02, Time: 116.31 secs\n",
      "IC: 1.3040e-02, PBC: 2.2541e-04, PDE: 1.8068e-02\n",
      "Iter  8000, Total: 2.7368e-02, Time: 115.06 secs\n",
      "IC: 1.0781e-02, PBC: 2.0844e-04, PDE: 1.6378e-02\n",
      "Iter  9000, Total: 2.3439e-02, Time: 116.14 secs\n",
      "IC: 9.0100e-03, PBC: 1.9851e-04, PDE: 1.4231e-02\n",
      "Iter 10000, Total: 1.9120e-02, Time: 116.29 secs\n",
      "IC: 7.3416e-03, PBC: 1.7370e-04, PDE: 1.1605e-02\n",
      "Iter 11000, Total: 1.4331e-02, Time: 116.64 secs\n",
      "IC: 5.6761e-03, PBC: 1.2942e-04, PDE: 8.5252e-03\n",
      "Iter 12000, Total: 1.0214e-02, Time: 115.20 secs\n",
      "IC: 4.0711e-03, PBC: 7.8193e-05, PDE: 6.0646e-03\n",
      "Iter 13000, Total: 7.5704e-03, Time: 116.11 secs\n",
      "IC: 2.8381e-03, PBC: 4.7292e-05, PDE: 4.6850e-03\n",
      "Iter 14000, Total: 5.6777e-03, Time: 116.51 secs\n",
      "IC: 2.0366e-03, PBC: 3.7130e-05, PDE: 3.6040e-03\n",
      "Iter 15000, Total: 4.2007e-03, Time: 116.22 secs\n",
      "IC: 1.4612e-03, PBC: 2.5911e-05, PDE: 2.7136e-03\n",
      "Iter 16000, Total: 3.1869e-03, Time: 115.75 secs\n",
      "IC: 1.0629e-03, PBC: 1.6390e-05, PDE: 2.1076e-03\n",
      "Iter 17000, Total: 2.4845e-03, Time: 116.24 secs\n",
      "IC: 7.9414e-04, PBC: 1.1609e-05, PDE: 1.6788e-03\n",
      "Iter 18000, Total: 1.9416e-03, Time: 115.50 secs\n",
      "IC: 5.9745e-04, PBC: 8.6133e-06, PDE: 1.3355e-03\n",
      "Iter 19000, Total: 1.5116e-03, Time: 115.50 secs\n",
      "IC: 4.4860e-04, PBC: 6.5791e-06, PDE: 1.0564e-03\n",
      "Iter 20000, Total: 1.1692e-03, Time: 115.24 secs\n",
      "IC: 3.3625e-04, PBC: 5.0010e-06, PDE: 8.2798e-04\n",
      "Iter 21000, Total: 7.4033e-02, Time: 114.78 secs\n",
      "IC: 4.0507e-02, PBC: 2.2435e-04, PDE: 3.3302e-02\n",
      "Iter 22000, Total: 4.4599e-02, Time: 115.46 secs\n",
      "IC: 2.2245e-02, PBC: 5.4731e-05, PDE: 2.2299e-02\n",
      "Iter 23000, Total: 3.3813e-02, Time: 115.91 secs\n",
      "IC: 1.5414e-02, PBC: 8.7875e-05, PDE: 1.8310e-02\n",
      "Iter 24000, Total: 2.5582e-02, Time: 115.24 secs\n",
      "IC: 1.1108e-02, PBC: 1.1615e-04, PDE: 1.4358e-02\n",
      "Iter 25000, Total: 1.8352e-02, Time: 109.63 secs\n",
      "IC: 7.5599e-03, PBC: 8.1796e-05, PDE: 1.0710e-02\n",
      "Iter 26000, Total: 1.2775e-02, Time: 111.51 secs\n",
      "IC: 4.9147e-03, PBC: 3.6494e-05, PDE: 7.8242e-03\n",
      "Iter 27000, Total: 9.2195e-03, Time: 110.49 secs\n",
      "IC: 3.2718e-03, PBC: 2.1903e-05, PDE: 5.9258e-03\n",
      "Iter 28000, Total: 6.9926e-03, Time: 110.28 secs\n",
      "IC: 2.3374e-03, PBC: 2.1293e-05, PDE: 4.6338e-03\n",
      "Iter 29000, Total: 5.4036e-03, Time: 110.41 secs\n",
      "IC: 1.7875e-03, PBC: 1.7427e-05, PDE: 3.5987e-03\n",
      "Iter 30000, Total: 4.1485e-03, Time: 114.54 secs\n",
      "IC: 1.4096e-03, PBC: 1.0215e-05, PDE: 2.7288e-03\n",
      "Iter 31000, Total: 3.1564e-03, Time: 115.73 secs\n",
      "IC: 1.1096e-03, PBC: 4.6040e-06, PDE: 2.0422e-03\n",
      "Iter 32000, Total: 2.4134e-03, Time: 115.28 secs\n",
      "IC: 8.7003e-04, PBC: 1.9226e-06, PDE: 1.5415e-03\n",
      "Iter 33000, Total: 1.8734e-03, Time: 115.88 secs\n",
      "IC: 6.8516e-04, PBC: 1.4589e-06, PDE: 1.1867e-03\n",
      "Iter 34000, Total: 1.4767e-03, Time: 115.85 secs\n",
      "IC: 5.4189e-04, PBC: 2.0450e-06, PDE: 9.3275e-04\n",
      "Iter 35000, Total: 1.1815e-03, Time: 116.36 secs\n",
      "IC: 4.2791e-04, PBC: 2.5065e-06, PDE: 7.5110e-04\n",
      "Iter 36000, Total: 9.5929e-04, Time: 115.46 secs\n",
      "IC: 3.3649e-04, PBC: 2.4766e-06, PDE: 6.2032e-04\n",
      "Iter 37000, Total: 7.8581e-04, Time: 115.49 secs\n",
      "IC: 2.6391e-04, PBC: 2.1041e-06, PDE: 5.1980e-04\n",
      "Iter 38000, Total: 6.4348e-04, Time: 116.01 secs\n",
      "IC: 2.0666e-04, PBC: 1.6590e-06, PDE: 4.3515e-04\n",
      "Iter 39000, Total: 1.3819e-01, Time: 116.45 secs\n",
      "IC: 9.2589e-02, PBC: 4.7906e-03, PDE: 4.0808e-02\n",
      "Iter 40000, Total: 6.6206e-02, Time: 115.29 secs\n",
      "IC: 4.0512e-02, PBC: 2.5093e-03, PDE: 2.3185e-02\n",
      "Iter 41000, Total: 4.0971e-02, Time: 115.97 secs\n",
      "IC: 2.4673e-02, PBC: 1.4042e-03, PDE: 1.4895e-02\n",
      "Iter 42000, Total: 2.8040e-02, Time: 112.76 secs\n",
      "IC: 1.6803e-02, PBC: 7.4064e-04, PDE: 1.0496e-02\n",
      "Iter 43000, Total: 2.0698e-02, Time: 112.38 secs\n",
      "IC: 1.2125e-02, PBC: 3.8240e-04, PDE: 8.1900e-03\n",
      "Iter 44000, Total: 1.5999e-02, Time: 116.38 secs\n",
      "IC: 9.0020e-03, PBC: 2.1760e-04, PDE: 6.7799e-03\n",
      "Iter 45000, Total: 1.2553e-02, Time: 116.01 secs\n",
      "IC: 6.7379e-03, PBC: 1.3382e-04, PDE: 5.6811e-03\n",
      "Iter 46000, Total: 9.8791e-03, Time: 115.56 secs\n",
      "IC: 5.0402e-03, PBC: 8.6639e-05, PDE: 4.7522e-03\n",
      "Iter 47000, Total: 7.7527e-03, Time: 116.45 secs\n",
      "IC: 3.7598e-03, PBC: 5.8868e-05, PDE: 3.9340e-03\n",
      "Iter 48000, Total: 6.0536e-03, Time: 112.62 secs\n",
      "IC: 2.7974e-03, PBC: 4.1101e-05, PDE: 3.2151e-03\n",
      "Iter 49000, Total: 4.7267e-03, Time: 115.29 secs\n",
      "IC: 2.0822e-03, PBC: 2.8740e-05, PDE: 2.6158e-03\n",
      "Iter 50000, Total: 3.7254e-03, Time: 116.72 secs\n",
      "IC: 1.5615e-03, PBC: 1.9868e-05, PDE: 2.1440e-03\n",
      "Iter  1000, Total: 3.5801e-03, Time: 125.11 secs\n",
      "IC: 1.4437e-03, PBC: 1.8588e-05, PDE: 2.1178e-03\n",
      "Iter  2000, Total: 3.4607e-03, Time: 125.37 secs\n",
      "IC: 1.3639e-03, PBC: 1.7709e-05, PDE: 2.0791e-03\n",
      "Iter  3000, Total: 3.3574e-03, Time: 100.09 secs\n",
      "IC: 1.3014e-03, PBC: 1.6969e-05, PDE: 2.0391e-03\n",
      "Iter  4000, Total: 3.2668e-03, Time: 64.06 secs\n",
      "IC: 1.2502e-03, PBC: 1.6294e-05, PDE: 2.0003e-03\n",
      "Iter  5000, Total: 3.1838e-03, Time: 62.36 secs\n",
      "IC: 1.2057e-03, PBC: 1.5652e-05, PDE: 1.9624e-03\n"
     ]
    }
   ],
   "source": [
    "layers = [2, 32, 32, 32, 32, 32, 32, 32, 2]\n",
    "N_IC = 128\n",
    "ptsIC=np.load('ptsIC.npy')\n",
    "ptsBC=np.load('ptsBC.npy')\n",
    "ptsPDE=np.load('random_data.npy')\n",
    "x_IC = np.expand_dims(np.linspace(xlo, xhi, N_IC), axis = 1)\n",
    "uIC = u0(x_IC)\n",
    "vIC = v0(x_IC)\n",
    "uBC = np.load('uBC.npy')\n",
    "vBC = np.load('vBC.npy')\n",
    "model = PhysicsInformedNN(period, ptsIC, uIC, vIC, ptsBC, uBC, vBC, ptsPDE, layers)\n",
    "model.train(50000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.linspace(tlo, thi, 201)\n",
    "x = np.linspace(xlo, xhi, 501)\n",
    "T, X = np.meshgrid(t, x)\n",
    "pts_flat = np.hstack((T.flatten()[:, None], X.flatten()[:, None]))\n",
    "u_pred, v_pred = model.predict(pts_flat)           \n",
    "u_pred = griddata(pts_flat, u_pred.flatten(), (T, X), method='cubic')\n",
    "v_pred = griddata(pts_flat, v_pred.flatten(), (T, X), method='cubic')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = scipy.io.loadmat('Data/NLS.mat')\n",
    "t = data['t'].flatten()[:,None]\n",
    "x2 = data['x'].flatten()[:,None]\n",
    "u_sol = np.real(data['Exact']).T\n",
    "v_sol = np.imag(data['Exact']).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "[encoded data, 218472 characters]",
      "text/plain": [
       "<Figure size 1100x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(11, 5))\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "#\n",
    "ax.plot(ptsPDE[:, 0], ptsPDE[:, 1], \n",
    "    'rd', label = 'PDE Data (%d points)' % (ptsPDE.shape[0]), \n",
    "    markersize = 4,  # marker size doubled\n",
    "    clip_on = False,\n",
    "    alpha=1.0\n",
    ")\n",
    "\n",
    "ax.plot(ptsIC[:, 0], ptsIC[:, 1], \n",
    "    'bd', label = 'IC Data (%d points)' % (ptsIC.shape[0]), \n",
    "    markersize = 4,  # marker size doubled\n",
    "    clip_on = False,\n",
    "    alpha=1.0\n",
    ")\n",
    "\n",
    "\n",
    "ax.plot(ptsBC[:, 0], ptsBC[:, 1], \n",
    "    'gd', label = 'BC Data (%d points)' % (ptsBC.shape[0]), \n",
    "    markersize = 4,  # marker size doubled\n",
    "    clip_on = False,\n",
    "    alpha=1.0\n",
    ")\n",
    "\n",
    "ax.set_xlabel('$t$', size=15)\n",
    "ax.set_ylabel('$x$', size=15)\n",
    "ax.legend(\n",
    "    loc='upper center', \n",
    "    bbox_to_anchor=(0.9, -0.05), \n",
    "    ncol=5, \n",
    "    frameon=False, \n",
    "    prop={'size': 15}\n",
    ")\n",
    "ax.legend()\n",
    "ax.set_title('Points', fontsize = 15) # font size doubled\n",
    "ax.tick_params(labelsize=12)\n",
    "#\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def relative_error_l2(pred,exact):\n",
    "    error_l2 = np.sqrt(np.sum(np.power(pred - exact,2)))\n",
    "    relative = error_l2/np.sqrt(np.sum(np.power(exact,2)))\n",
    "    return relative\n",
    "def relative_error_l1(pred,exact):\n",
    "    error_l1 = np.sum(np.abs(pred-exact))\n",
    "    relative = error_l1/np.sum(np.abs(exact))\n",
    "    return relative\n",
    "def relative_error_linf(pred,exact):\n",
    "    error_linf = np.max(np.abs(pred-exact))\n",
    "    relative = error_linf/np.max(np.abs(exact))\n",
    "    return relative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l2: 0.36312511561857974\n",
      "l1: 0.28763793416167177\n",
      "linf: 0.30261247148785275\n"
     ]
    }
   ],
   "source": [
    "print(f'l2: {relative_error_l2(u_pred.T,u_sol)}')\n",
    "print(f'l1: {relative_error_l1(u_pred.T,u_sol)}')\n",
    "print(f'linf: {relative_error_linf(u_pred.T,u_sol)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l2: 0.506167587582388\n",
      "l1: 0.5357040906259094\n",
      "linf: 0.4537702336781823\n"
     ]
    }
   ],
   "source": [
    "print(f'l2: {relative_error_l2(-v_pred.T,v_sol)}')\n",
    "print(f'l1: {relative_error_l1(-v_pred.T,v_sol)}')\n",
    "print(f'linf: {relative_error_linf(-v_pred.T,v_sol)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
