Crossing_waves.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6963bf93-a774-4b7f-b0b4-1ee1ca85e16b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from numpy import meshgrid\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import TensorDataset, DataLoader, Dataset\n",
    "from torch.autograd import gradcheck\n",
    "from numpy import exp, mod, meshgrid, cos, sin, exp, pi\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.ndimage import shift\n",
    "from math import sqrt\n",
    "from scipy.sparse import diags\n",
    "from scipy.linalg import cholesky\n",
    "\n",
    "import os\n",
    "impath = \"./data/Crossing_waves/mac/\"\n",
    "immpath = \"./plots/Crossing_waves/mac/\"\n",
    "os.makedirs(impath, exist_ok=True)\n",
    "os.makedirs(immpath, exist_ok=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c06a92b5",
   "metadata": {},
   "source": [
    "# Crossing waves example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad91d999-b9a0-4eb1-87a5-f83d4a535ff3",
   "metadata": {},
   "source": [
    "## Create data for example model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "091a766a-2477-40bd-8256-2becd7e3f685",
   "metadata": {},
   "outputs": [],
   "source": [
    "Nx, Nt, sigma = 400, 200, 4.0\n",
    "coefficients1 = [0.15,0,0.8,1.5]\n",
    "coefficients2 = [-18,2]\n",
    "seed = 27\n",
    "center_matrix3 = 200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "beaa849e-2253-4409-a4a7-74dfd079ff4b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x106ad3450>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "16fa4e08-6af1-4be7-afdf-342abbd873b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_data(Nx, Nt, coeff1, coeff2, center1, center2, sigma_slope=0.1, sigma_base=4.0):\n",
    "    sigma = 5.0\n",
    "    x = np.arange(0, Nx)\n",
    "    t = np.linspace(-10,10, Nt)\n",
    "    t_max = np.max(t)\n",
    "    [X, T] = np.meshgrid(x, t)\n",
    "    X = X.T\n",
    "    T = T.T    \n",
    "\n",
    "    def gaussian(x, mu, sigma=1.0):\n",
    "        return np.exp(-np.power(x - mu, 2.0) / (2 * np.power(sigma, 2.0)))\n",
    "\n",
    "    q1 = np.zeros_like(X, dtype=np.float64)\n",
    "    q2 = np.zeros_like(X, dtype=np.float64)\n",
    "    shift1 = np.polyval(coeff1, t)\n",
    "    shift2 = np.polyval(coeff2, t)\n",
    "    for col in range(Nt):\n",
    "        sigma_t = sigma_base \n",
    "        for row in range(Nx):\n",
    "            q1[row, col] = sin(pi * t[col] / t_max) * gaussian(row, center1 + shift1[col], sigma_t)\n",
    "            q2[row, col] = cos(pi * t[col] / t_max) * gaussian(row, center2 + shift2[col], sigma_t)\n",
    "    \n",
    "    Q = q1 + q2\n",
    "    Q /= Q.max()\n",
    "    \n",
    "    return Q, x, t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d97099bc-9e3e-4705-b76a-83fa0a616335",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q,x,t = generate_data(Nx, Nt, coefficients1, coefficients2, center_matrix3, center_matrix3, sigma_base=sigma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2e01f6fc-d3ea-432f-89df-e93dc70665bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X, T = np.meshgrid(x, t)\n",
    "\n",
    "plt.pcolormesh(X.T, T.T, Q)\n",
    "plt.colorbar()\n",
    "plt.xlabel('Position ($x_i$)')\n",
    "plt.ylabel('Time ($t_j$)')\n",
    "plt.title('Snapshot Matrix Q')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4743ba98",
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_fig(filepath, figure=None, **kwargs):\n",
    "    import tikzplotlib\n",
    "    import os\n",
    "    import matplotlib.pyplot as plt\n",
    "\n",
    "    ## split extension\n",
    "    fpath = os.path.splitext(filepath)[0]\n",
    "    ## get figure handle\n",
    "    if figure is None:\n",
    "        figure = plt.gcf()\n",
    "    figure.savefig(fpath + \".png\", dpi=300, transparent=True)\n",
    "    tikzplotlib.save(\n",
    "        figure=figure,\n",
    "        filepath=fpath + \".tex\",\n",
    "        axis_height='\\\\figureheight',\n",
    "        axis_width='\\\\figurewidth',\n",
    "        override_externals=True,\n",
    "        **kwargs\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa9deb0f-c6ed-4cfc-a618-34dcd83258d6",
   "metadata": {},
   "source": [
    "## Define inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "50e2b140-5375-408f-8558-322cdf889543",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x106ad3450>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f5a7ffe7-d523-4462-aa17-128d9c6d5181",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "inputs = np.stack([x.repeat(Nt), np.tile(t, Nx)], axis=1)\n",
    "inputs_tensor = torch.tensor(inputs, dtype=torch.float32)\n",
    "Q_tensor = torch.tensor(Q)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc760045-a001-4f52-aa11-9ba6604714c6",
   "metadata": {},
   "source": [
    "## Define a model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bf5b954e-d310-4638-a310-0013326f60d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "class NuclearNormAutograd(torch.autograd.Function):\n",
    "    @staticmethod\n",
    "    def forward(ctx, input_matrix):\n",
    "        ctx.save_for_backward(input_matrix)\n",
    "        return torch.linalg.matrix_norm(input_matrix, ord=\"nuc\")\n",
    "\n",
    "    @staticmethod\n",
    "    def backward(ctx, grad_output):\n",
    "        input_matrix, = ctx.saved_tensors\n",
    "        u, s, v = torch.svd(input_matrix, some=False)\n",
    "        rank = torch.sum(s > 0).item()\n",
    "        dtype = input_matrix.dtype\n",
    "        eye_approx = torch.diag((s > 0).to(dtype)[:rank])\n",
    "        grad_input = torch.matmul(torch.matmul(u[:, :rank], eye_approx), v[:, :rank].t())\n",
    "        return grad_input * grad_output.unsqueeze(-1).unsqueeze(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d18bf8b6-4e12-449f-bf1a-eb8fa332dafc",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ShapeShiftNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(ShapeShiftNet, self).__init__()\n",
    "        self.elu = nn.ELU()\n",
    "        \n",
    "        # Subnetwork for f^1 and shift^1\n",
    "        self.f1_fc1 = nn.Linear(2, 5)\n",
    "        self.f1_fc2 = nn.Linear(5, 10)\n",
    "        self.f1_fc3 = nn.Linear(10, 5)\n",
    "        self.f1_fc4 = nn.Linear(5, 1)\n",
    "        \n",
    "        self.shift1_fc1 = nn.Linear(1, 5)\n",
    "        self.shift1_fc2 = nn.Linear(5, 5)\n",
    "        self.shift1_fc3 = nn.Linear(5, 1)\n",
    "\n",
    "\n",
    "        # Subnetwork for f^2 and shift^2\n",
    "        self.f2_fc1 = nn.Linear(2, 5)\n",
    "        self.f2_fc2 = nn.Linear(5, 10)\n",
    "        self.f2_fc3 = nn.Linear(10, 5)\n",
    "        self.f2_fc4 = nn.Linear(5, 1)\n",
    "        \n",
    "        self.shift2_fc1 = nn.Linear(1, 5)\n",
    "        self.shift2_fc2 = nn.Linear(5, 5)\n",
    "        self.shift2_fc3 = nn.Linear(5, 1)\n",
    "\n",
    "        \n",
    "    def forward(self, x, t):\n",
    "        # Pathway for f^1 and shift^1\n",
    "        shift1 = self.elu(self.shift1_fc1(t))\n",
    "        shift1 = self.elu(self.shift1_fc2(shift1))\n",
    "        shift1 = self.shift1_fc3(shift1)\n",
    "\n",
    "        x_shifted1 = x + shift1\n",
    "        f1 = self.elu(self.f1_fc1(torch.cat((x_shifted1, t), dim=1)))\n",
    "        f1 = self.elu(self.f1_fc2(f1))\n",
    "        f1 = self.elu(self.f1_fc3(f1))\n",
    "        f1 = self.f1_fc4(f1)\n",
    "        \n",
    "        f1_without_shift = self.elu(self.f1_fc1(torch.cat((x, t), dim=1)))\n",
    "        f1_without_shift = self.elu(self.f1_fc2(f1_without_shift))\n",
    "        f1_without_shift = self.elu(self.f1_fc3(f1_without_shift))\n",
    "        f1_without_shift = self.f1_fc4(f1_without_shift)\n",
    "        \n",
    "        \n",
    "        # Pathway for f^2 and shift^2\n",
    "        shift2 = self.elu(self.shift2_fc1(t))\n",
    "        shift2 = self.elu(self.shift2_fc2(shift2))\n",
    "        shift2 = self.shift2_fc3(shift2)\n",
    "\n",
    "        x_shifted2 = x + shift2\n",
    "        f2 = self.elu(self.f2_fc1(torch.cat((x_shifted2, t), dim=1)))\n",
    "        f2 = self.elu(self.f2_fc2(f2))\n",
    "        f2 = self.elu(self.f2_fc3(f2))\n",
    "        f2 = self.f2_fc4(f2)\n",
    "        \n",
    "        f2_without_shift = self.elu(self.f2_fc1(torch.cat((x, t), dim=1)))\n",
    "        f2_without_shift = self.elu(self.f2_fc2(f2_without_shift))\n",
    "        f2_without_shift = self.elu(self.f2_fc3(f2_without_shift))\n",
    "        f2_without_shift = self.f2_fc4(f2_without_shift)\n",
    "        \n",
    "        return f1, f2, shift1, shift2, f1_without_shift, f2_without_shift, shift1, shift2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "efb55892-854b-44de-b6fa-0160443e759c",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = ShapeShiftNet()\n",
    "\n",
    "pretrained_load = True\n",
    "if pretrained_load:\n",
    "    state_dict_original = torch.load(\"./data/Crossing_waves/seed=27/Crossing_waves.pth\")\n",
    "    state_dict_new = model.state_dict()\n",
    "    \n",
    "    for name, param in state_dict_original.items():\n",
    "        if name in state_dict_new:\n",
    "            state_dict_new[name].copy_(param)\n",
    "    model.load_state_dict(state_dict_new, strict=False)\n",
    "\n",
    "\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.0001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3011e406-ac3c-475f-b6c9-25295f2c845a",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0/1000, Frob Loss: 1.0196120090166456, Nuclear Loss: 54.04690170288086, Total loss: 55.06651371189751,\n",
      "Epoch 100/1000, Frob Loss: 2.0643849006379535, Nuclear Loss: 52.0303840637207, Total loss: 54.09476896435866,\n",
      "Epoch 200/1000, Frob Loss: 2.102300267254818, Nuclear Loss: 51.972286224365234, Total loss: 54.07458649162005,\n",
      "Epoch 300/1000, Frob Loss: 2.1197128345009513, Nuclear Loss: 51.939964294433594, Total loss: 54.059677128934545,\n",
      "Epoch 400/1000, Frob Loss: 2.1250266251329806, Nuclear Loss: 51.98928451538086, Total loss: 54.11431114051384,\n",
      "Epoch 500/1000, Frob Loss: 2.1664693877973282, Nuclear Loss: 51.9548454284668, Total loss: 54.121314816264125,\n",
      "Epoch 600/1000, Frob Loss: 2.1560914393802073, Nuclear Loss: 51.898651123046875, Total loss: 54.05474256242708,\n",
      "Epoch 700/1000, Frob Loss: 2.159940739738868, Nuclear Loss: 51.877296447753906, Total loss: 54.03723718749278,\n",
      "Epoch 800/1000, Frob Loss: 2.1651873209613335, Nuclear Loss: 51.840782165527344, Total loss: 54.00596948648868,\n",
      "Epoch 900/1000, Frob Loss: 2.1476453797211335, Nuclear Loss: 51.893028259277344, Total loss: 54.04067363899848,\n",
      "Epoch 1000/1000, Frob Loss: 2.1557502997452977, Nuclear Loss: 51.87998580932617, Total loss: 54.03573610907147,\n"
     ]
    }
   ],
   "source": [
    "num_epochs = 1000\n",
    "lambda_k = 0.5\n",
    "\n",
    "for epoch in range(num_epochs + 1):\n",
    "    x_flat, t_flat = inputs_tensor[:, 0:1], inputs_tensor[:, 1:2]\n",
    "    optimizer.zero_grad()\n",
    "    f1_full, f2_full, shift1_pred, shift2_pred, f1_full_nos, f2_full_nos, s1, s2 = model(x_flat, t_flat)\n",
    "    \n",
    "    frobenius_loss = torch.norm(Q_tensor - f1_full.view(Nx, Nt) - f2_full.view(Nx, Nt), 'fro') ** 2\n",
    "    \n",
    "    nuclear_loss_q1 = NuclearNormAutograd.apply(f1_full_nos.view(Nx, Nt))\n",
    "    nuclear_loss_q2 = NuclearNormAutograd.apply(f2_full_nos.view(Nx, Nt))\n",
    "    nuclear_loss = lambda_k*(nuclear_loss_q1 + nuclear_loss_q2)\n",
    "    \n",
    "    total_loss = frobenius_loss + nuclear_loss\n",
    "\n",
    "    total_loss.backward(retain_graph=True)\n",
    "    optimizer.step()\n",
    "\n",
    "    if frobenius_loss < 1:\n",
    "        print(\"Early stopping is triggered\")\n",
    "        break\n",
    "    \n",
    "    if epoch % 100 == 0:\n",
    "        print(\n",
    "            f'Epoch {epoch}/{num_epochs}, Frob Loss: {frobenius_loss.item()}, Nuclear Loss: {nuclear_loss.item()}, Total loss: {total_loss.item()},')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4f62484c-890c-4ca4-9b1b-d99a33eedc44",
   "metadata": {},
   "outputs": [],
   "source": [
    "combined = f1_full + f2_full\n",
    "Q_tilde = combined.view(Nx, Nt).detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c2e24626-8eb2-4aa1-86e6-ece12bf68b3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x16a8d3fa0>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x432 with 7 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1, 6, figsize=(20, 6))\n",
    "vmin = np.min(Q)\n",
    "vmax = np.max(Q)\n",
    "\n",
    "axs[0].pcolormesh(X.T, T.T, Q, vmin=vmin, vmax=vmax)\n",
    "axs[0].set_title(r\"${\\mathbf{Q}}$\")\n",
    "axs[0].set_xlabel(\"x\")\n",
    "axs[0].set_ylabel(\"t\")\n",
    "axs[0].set_xticks([])\n",
    "axs[0].set_yticks([])\n",
    "\n",
    "#Qtilde\n",
    "axs[1].pcolormesh(X.T, T.T, Q_tilde, vmin=vmin, vmax=vmax)\n",
    "axs[1].set_title(r\"$\\tilde{\\mathbf{Q}}$\")\n",
    "axs[1].set_xlabel(\"x\")\n",
    "axs[1].set_ylabel(\"t\")\n",
    "axs[1].set_xticks([])\n",
    "axs[1].set_yticks([])\n",
    "\n",
    "# f^1\n",
    "axs[2].pcolormesh(X.T, T.T, f1_full.view(Nx, Nt).detach().numpy(), vmin=vmin)\n",
    "axs[2].set_title(r\"$\\mathcal{T}^1\\mathbf{Q}^1$\")\n",
    "axs[2].set_xlabel(\"x\")\n",
    "axs[2].set_ylabel(\"t\")\n",
    "axs[2].set_xticks([])\n",
    "axs[2].set_yticks([])\n",
    "\n",
    "# f^2\n",
    "axs[3].pcolormesh(X.T, T.T, f2_full.view(Nx,Nt).detach().numpy(), vmin=vmin, vmax=vmax)\n",
    "axs[3].set_title(r\"$\\mathcal{T}^2\\mathbf{Q}^2$\")\n",
    "axs[3].set_xlabel(\"x\")\n",
    "axs[3].set_ylabel(\"t\")\n",
    "axs[3].set_xticks([])\n",
    "axs[3].set_yticks([])\n",
    "\n",
    "# f^1\n",
    "axs[4].pcolormesh(X.T, T.T, f1_full_nos.view(Nx,Nt).detach().numpy(), vmin=vmin, vmax=vmax)\n",
    "axs[4].set_title(r\"$\\mathbf{Q}^1$\")\n",
    "axs[4].set_xlabel(\"x\")\n",
    "axs[4].set_ylabel(\"t\")\n",
    "axs[4].set_xticks([])\n",
    "axs[4].set_yticks([])\n",
    "\n",
    "# f^2\n",
    "cax4 = axs[5].pcolormesh(X.T, T.T, f2_full_nos.view(Nx,Nt).detach().numpy(), vmin=vmin, vmax=vmax)\n",
    "axs[5].set_title(r\"$\\mathbf{Q}^2$\")\n",
    "axs[5].set_xlabel(\"x\")\n",
    "axs[5].set_ylabel(\"t\")\n",
    "axs[5].set_xticks([])\n",
    "axs[5].set_yticks([])\n",
    "\n",
    "plt.colorbar(cax4, ax=axs.ravel().tolist(), orientation='vertical')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4ce92f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "save_fig(filepath=immpath + \"Crossing_waves_NN\", figure=fig)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cfde215",
   "metadata": {},
   "source": [
    "## Saving the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d9bcdbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(model.state_dict(), impath + 'Crossing_waves.pth')\n",
    "np.save(impath + 'Q.npy', Q)\n",
    "np.save(impath + 'Q_tilde.npy', Q_tilde)\n",
    "np.save(impath + 'T1Q1.npy', f1_full.view(Nx, Nt).detach().numpy())\n",
    "np.save(impath + 'T2Q2.npy', f2_full.view(Nx, Nt).detach().numpy())\n",
    "np.save(impath + 'Q1.npy', f1_full_nos.view(Nx, Nt).detach().numpy())\n",
    "np.save(impath + 'Q2.npy', f2_full_nos.view(Nx, Nt).detach().numpy())\n",
    "np.save(impath + 'shifts1.npy', s1.detach().numpy()[:Nt]) \n",
    "np.save(impath + 'shifts2.npy', s2.detach().numpy()[:Nt]) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "946b34a9",
   "metadata": {},
   "source": [
    "# Apply rsPOD taking the results from the above as initial guesses\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e57180ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "sys.path.append(\"./sPOD/lib/\")\n",
    "\n",
    "import numpy as np\n",
    "from numpy import meshgrid\n",
    "import matplotlib.pyplot as plt\n",
    "from sPOD_algo import (\n",
    "    shifted_POD,\n",
    "    sPOD_Param,\n",
    "    give_interpolation_error,\n",
    ")\n",
    "from transforms import Transform\n",
    "from plot_utils import save_fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4dd80548",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the data\n",
    "Q = np.load(impath + 'Q.npy')\n",
    "Q_tilde = np.load(impath + 'Q_tilde.npy')\n",
    "T1Q1 = np.load(impath + 'T1Q1.npy')\n",
    "T2Q2 = np.load(impath + 'T2Q2.npy')\n",
    "Q1 = np.load(impath + 'Q1.npy')\n",
    "Q2 = np.load(impath + 'Q2.npy')\n",
    "shifts1 = np.load(impath + 'shifts1.npy')\n",
    "shifts2 = np.load(impath + 'shifts2.npy') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98245b13",
   "metadata": {},
   "outputs": [],
   "source": [
    "err = np.linalg.norm(Q - Q_tilde) / np.linalg.norm(Q)\n",
    "print(\"NN prediction error: %1.2e \" % err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62ef435a",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(shifts2 + 400)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15f08396",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prepare the transformations\n",
    "L = x[-1]\n",
    "dx = x[1] - x[0]\n",
    "s1 = np.polyval(shifts1, t)\n",
    "s2 = np.polyval(shifts2 + 400, t)\n",
    "\n",
    "data_shape = [Nx, 1, 1, Nt]\n",
    "transfos = [\n",
    "    Transform(data_shape, [L], shifts=s1, dx=[dx], interp_order=5),\n",
    "    Transform(data_shape, [L], shifts=s2, dx=[dx], interp_order=5),\n",
    "]\n",
    "\n",
    "interp_err = np.max([give_interpolation_error(Q, trafo) for trafo in transfos])\n",
    "print(\"interpolation error: %1.2e \" % interp_err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b986be7",
   "metadata": {},
   "outputs": [],
   "source": [
    "METHOD = \"ALM\"\n",
    "\n",
    "# Parameters\n",
    "mu0 = Nx * Nt / (4 * np.sum(np.abs(Q))) * 0.003\n",
    "lambd0 = 1 / np.sqrt(np.maximum(Nx, Nt))\n",
    "myparams = sPOD_Param()\n",
    "myparams.maxit = 28\n",
    "param_alm = mu0  # adjust for case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6905916",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Call the ALM method\n",
    "ret = shifted_POD(Q, transfos, [1, 1], myparams, METHOD, param_alm, [T1Q1, T2Q2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f902a25",
   "metadata": {},
   "outputs": [],
   "source": [
    "sPOD_frames, qtilde, rel_err = ret.frames, ret.data_approx, ret.rel_err_hist\n",
    "qf = [\n",
    "    np.squeeze(np.reshape(transfo.apply(frame.build_field()), data_shape))\n",
    "    for transfo, frame in zip(transfos, sPOD_frames)\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb4bb7e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# %% 1. visualize your results: sPOD frames\n",
    "############################################\n",
    "\n",
    "fig, axs = plt.subplots(1, 4, figsize=(20, 6))\n",
    "vmin = np.min(Q)\n",
    "vmax = np.max(Q)\n",
    "\n",
    "axs[0].pcolormesh(X.T, T.T, Q, vmin=vmin, vmax=vmax)\n",
    "axs[0].set_title(r\"${\\mathbf{Q}}$\")\n",
    "axs[0].set_xlabel(\"x\")\n",
    "axs[0].set_ylabel(\"t\")\n",
    "axs[0].set_xticks([])\n",
    "axs[0].set_yticks([])\n",
    "\n",
    "#Qtilde\n",
    "axs[1].pcolormesh(X.T, T.T, qtilde, vmin=vmin, vmax=vmax)\n",
    "axs[1].set_title(r\"$\\tilde{\\mathbf{Q}}$\")\n",
    "axs[1].set_xlabel(\"x\")\n",
    "axs[1].set_ylabel(\"t\")\n",
    "axs[1].set_xticks([])\n",
    "axs[1].set_yticks([])\n",
    "\n",
    "# f^1\n",
    "axs[2].pcolormesh(X.T, T.T, qf[0], vmin=vmin)\n",
    "axs[2].set_title(r\"$\\mathcal{T}^1\\mathbf{Q}^1$\")\n",
    "axs[2].set_xlabel(\"x\")\n",
    "axs[2].set_ylabel(\"t\")\n",
    "axs[2].set_xticks([])\n",
    "axs[2].set_yticks([])\n",
    "\n",
    "# f^2\n",
    "cax3 = axs[3].pcolormesh(X.T, T.T, qf[1], vmin=vmin, vmax=vmax)\n",
    "axs[3].set_title(r\"$\\mathcal{T}^2\\mathbf{Q}^2$\")\n",
    "axs[3].set_xlabel(\"x\")\n",
    "axs[3].set_ylabel(\"t\")\n",
    "axs[3].set_xticks([])\n",
    "axs[3].set_yticks([])\n",
    "\n",
    "plt.colorbar(cax3, ax=axs.ravel().tolist(), orientation='vertical')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30b7d1b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "save_fig(filepath=immpath + \"Crossing_waves_sPOD\", figure=fig)"
   ]
  }
 ],
 "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.9.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}