2d_shallow_water_invers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solving the Shallow Water Equations (2D + t) as an Inverse Problem\n",
    "\n",
    "## Problem Statement\n",
    "\n",
    "We consider the 2D shallow water equations (SWE) with the following form:\n",
    "\n",
    "### Conservation of Mass:\n",
    "$$\n",
    "\\frac{\\partial h}{\\partial t} + \\frac{\\partial (hV_x)}{\\partial x} + \\frac{\\partial (hV_y)}{\\partial y} = 0,\n",
    "$$\n",
    "\n",
    "### Momentum Equation in the x-direction:\n",
    "$$\n",
    "\\frac{\\partial V_x}{\\partial t} + V_x \\frac{\\partial V_x}{\\partial x} + V_y \\frac{\\partial V_x}{\\partial y} + g \\frac{\\partial h}{\\partial x} = 0,\n",
    "$$\n",
    "\n",
    "### Momentum Equation in the y-direction:\n",
    "$$\n",
    "\\frac{\\partial V_y}{\\partial t} + V_x \\frac{\\partial V_y}{\\partial x} + V_y \\frac{\\partial V_y}{\\partial y} + g \\frac{\\partial h}{\\partial y} = 0\n",
    "$$\n",
    "\n",
    "where:\n",
    "- $h(x, y, t)$ is the water height,\n",
    "- $V_x(x, y, t)$ and $V_y(x, y, t)$ are the velocity components in the x and y directions,\n",
    "- $g$ is the gravitational constant.\n",
    "\n",
    "## Inverse Problem\n",
    "\n",
    "In this notebook, we aim to solve the shallow water equations using a Physics-Informed Neural Network (PINN). Unlike traditional forward problems, where the initial conditions (ICs) and boundary conditions (BCs) are known, we treat this as an inverse problem. Specifically, we assume that we do not have direct information about the ICs and BCs. Instead, we have access to a sparse set of observed data points generated from a numerical solver (RK4).\n",
    "\n",
    "### Key Assumptions:\n",
    "\n",
    "1. **Sparse Data Availability**: We only have observed data for 10% of the points in the domain.\n",
    "2. **No Explicit ICs and BCs**: Instead of explicitly known ICs and BCs, we rely on the observed data to guide the solution.\n",
    "3. **PDE Residuals**: The PINN is trained to minimize the residuals of the PDEs along with the loss from the observed data points.\n",
    "\n",
    "## Methodology\n",
    "\n",
    "### Data Generation\n",
    "- We use the Runge-Kutta 4th Order (RK4) method to generate data points for the water height \\(h\\) and velocity components $V_x$, $V_y$ over time.\n",
    "- A subset (10%) of these data points is used as the observed data.\n",
    "\n",
    "### PINN Setup\n",
    "- A neural network is defined to approximate the solution of the shallow water equations.\n",
    "- The loss function combines the residuals of the PDEs and the difference between the PINN predictions and the observed data.\n",
    "\n",
    "### Training\n",
    "- The network is trained using the Adam optimizer.\n",
    "- The total loss, including the PDE residuals and data loss, is minimized.\n",
    "\n",
    "### Visualization\n",
    "- The trained model's predictions are compared with the observed data and the RK4 solution.\n",
    "\n",
    "By approaching the problem in this way, we leverage the physics-informed framework to enforce the underlying physical laws while fitting the sparse observed data. This allows us to solve the inverse problem and predict the solution accurately even with limited data availability.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Generation via RK4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "from IPython.display import display, clear_output\n",
    "\n",
    "# Define the RK4 solver for the shallow water equations\n",
    "def rk4_step(f, y, t, dt, *args):\n",
    "    k1 = f(y, t, *args)\n",
    "    k2 = f(y + 0.5 * k1 * dt, t + 0.5 * dt, *args)\n",
    "    k3 = f(y + 0.5 * k2 * dt, t + 0.5 * dt, *args)\n",
    "    k4 = f(y + k3 * dt, t + dt, *args)\n",
    "    return y + (dt / 6.0) * (k1 + 2 * k2 + 2 * k3 + k4)\n",
    "\n",
    "def shallow_water_rhs(y, t, g):\n",
    "    h, u, v = y\n",
    "    h_x = np.gradient(h, axis=0)\n",
    "    h_y = np.gradient(h, axis=1)\n",
    "    u_x = np.gradient(u, axis=0)\n",
    "    u_y = np.gradient(u, axis=1)\n",
    "    v_x = np.gradient(v, axis=0)\n",
    "    v_y = np.gradient(v, axis=1)\n",
    "    h_t = - (h * u_x + h * v_y)\n",
    "    u_t = - (u * u_x + v * u_y + g * h_x)\n",
    "    v_t = - (u * v_x + v * v_y + g * h_y)\n",
    "    return np.array([h_t, u_t, v_t])\n",
    "\n",
    "# Initial conditions\n",
    "def initial_conditions(x, y):\n",
    "    h = np.exp(-((x - 0.5)**2 + (y - 0.5)**2) / (2 * 0.1**2))\n",
    "    u = np.zeros_like(x)\n",
    "    v = np.zeros_like(y)\n",
    "    return h, u, v\n",
    "\n",
    "# Generate data using RK4\n",
    "def generate_data():\n",
    "    num_points = 100\n",
    "    x = np.linspace(0, 1, num_points)\n",
    "    y = np.linspace(0, 1, num_points)\n",
    "    X, Y = np.meshgrid(x, y, indexing='ij')\n",
    "    t_max = 0.5\n",
    "    dt = 0.01\n",
    "    g = 9.81\n",
    "\n",
    "    h, u, v = initial_conditions(X, Y)\n",
    "    y = np.array([h, u, v])\n",
    "    t = 0.0\n",
    "    data = []\n",
    "\n",
    "    while t < t_max:\n",
    "        data.append((t, h.copy(), u.copy(), v.copy()))\n",
    "        y = rk4_step(shallow_water_rhs, y, t, dt, g)\n",
    "        h, u, v = y\n",
    "        t += dt\n",
    "\n",
    "    return data\n",
    "\n",
    "# Generate data\n",
    "data = generate_data()\n",
    "\n",
    "# Select 10% of data points as observed data\n",
    "def select_observed_data(data, fraction=0.1):\n",
    "    num_data_points = len(data)\n",
    "    num_observed_points = int(num_data_points * fraction)\n",
    "    indices = np.random.choice(num_data_points, num_observed_points, replace=False)\n",
    "    observed_data = [data[i] for i in indices]\n",
    "    return observed_data\n",
    "\n",
    "observed_data = select_observed_data(data)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PINN structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the PINN model\n",
    "class SWE_PINN(nn.Module):\n",
    "    def __init__(self, num_hidden_layers, num_neurons):\n",
    "        super(SWE_PINN, self).__init__()\n",
    "        self.net = nn.Sequential(\n",
    "            nn.Linear(3, num_neurons),\n",
    "            nn.Tanh(),\n",
    "            *[nn.Sequential(nn.Linear(num_neurons, num_neurons), nn.Tanh()) for _ in range(num_hidden_layers - 1)],\n",
    "            nn.Linear(num_neurons, 3)  # Output: h, u, v\n",
    "        )\n",
    "\n",
    "    def forward(self, x, y, t):\n",
    "        xy_t = torch.cat([x, y, t], dim=1)\n",
    "        return self.net(xy_t)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loss calculation function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the loss function for the inverse problem with PDE residuals\n",
    "def compute_loss(model, x, y, t, h_real, u_real, v_real, g):\n",
    "    # Predictions for all points\n",
    "    x.requires_grad_(True)\n",
    "    y.requires_grad_(True)\n",
    "    t.requires_grad_(True)\n",
    "\n",
    "    h, u, v = model(x, y, t).chunk(3, dim=1)\n",
    "\n",
    "    # Calculate derivatives\n",
    "    h_t = torch.autograd.grad(h, t, torch.ones_like(h), create_graph=True)[0]\n",
    "    u_t = torch.autograd.grad(u, t, torch.ones_like(u), create_graph=True)[0]\n",
    "    v_t = torch.autograd.grad(v, t, torch.ones_like(v), create_graph=True)[0]\n",
    "    h_x = torch.autograd.grad(h, x, torch.ones_like(h), create_graph=True)[0]\n",
    "    h_y = torch.autograd.grad(h, y, torch.ones_like(h), create_graph=True)[0]\n",
    "    u_x = torch.autograd.grad(u, x, torch.ones_like(u), create_graph=True)[0]\n",
    "    u_y = torch.autograd.grad(u, y, torch.ones_like(u), create_graph=True)[0]\n",
    "    v_x = torch.autograd.grad(v, x, torch.ones_like(v), create_graph=True)[0]\n",
    "    v_y = torch.autograd.grad(v, y, torch.ones_like(v), create_graph=True)[0]\n",
    "\n",
    "    # PDE residuals\n",
    "    continuity_residual = h_t + (h * u_x) + (h * v_y)\n",
    "    momentum_x_residual = u_t + u * u_x + v * u_y + g * h_x\n",
    "    momentum_y_residual = v_t + u * v_x + v * v_y + g * h_y\n",
    "\n",
    "    loss_continuity = torch.mean(continuity_residual**2)\n",
    "    loss_momentum_x = torch.mean(momentum_x_residual**2)\n",
    "    loss_momentum_y = torch.mean(momentum_y_residual**2)\n",
    "\n",
    "    # Data loss\n",
    "    loss_h = torch.mean((h - h_real)**2)\n",
    "    loss_u = torch.mean((u - u_real)**2)\n",
    "    loss_v = torch.mean((v - v_real)**2)\n",
    "\n",
    "    # Total loss\n",
    "    total_loss = loss_continuity + loss_momentum_x + loss_momentum_y + loss_h + loss_u + loss_v\n",
    "    return total_loss, loss_continuity, loss_momentum_x, loss_momentum_y, loss_h, loss_u, loss_v\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example usage\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "num_hidden_layers = 10\n",
    "num_neurons = 70\n",
    "model = SWE_PINN(num_hidden_layers, num_neurons).to(device)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# Prepare data for PINN training\n",
    "X, Y = np.meshgrid(np.linspace(0, 1, 100), np.linspace(0, 1, 100), indexing='ij')\n",
    "x = torch.tensor(np.concatenate([X.flatten() for t, h, u, v in data]), dtype=torch.float32).reshape(-1, 1).to(device)\n",
    "y = torch.tensor(np.concatenate([Y.flatten() for t, h, u, v in data]), dtype=torch.float32).reshape(-1, 1).to(device)\n",
    "t = torch.tensor(np.concatenate([np.full_like(X.flatten(), fill_value=t) for t, h, u, v in data]), dtype=torch.float32).reshape(-1, 1).to(device)\n",
    "h_real = torch.tensor(np.concatenate([h.flatten() for t, h, u, v in data]), dtype=torch.float32).reshape(-1, 1).to(device)\n",
    "u_real = torch.tensor(np.concatenate([u.flatten() for t, h, u, v in data]), dtype=torch.float32).reshape(-1, 1).to(device)\n",
    "v_real = torch.tensor(np.concatenate([v.flatten() for t, h, u, v in data]), dtype=torch.float32).reshape(-1, 1).to(device)\n",
    "\n",
    "# Select observed data points\n",
    "obs_x = torch.tensor(np.concatenate([X.flatten() for t, h, u, v in observed_data]), dtype=torch.float32).reshape(-1, 1).to(device)\n",
    "obs_y = torch.tensor(np.concatenate([Y.flatten() for t, h, u, v in observed_data]), dtype=torch.float32).reshape(-1, 1).to(device)\n",
    "obs_t = torch.tensor(np.concatenate([np.full_like(X.flatten(), fill_value=t) for t, h, u, v in observed_data]), dtype=torch.float32).reshape(-1, 1).to(device)\n",
    "obs_h = torch.tensor(np.concatenate([h.flatten() for t, h, u, v in observed_data]), dtype=torch.float32).reshape(-1, 1).to(device)\n",
    "obs_u = torch.tensor(np.concatenate([u.flatten() for t, h, u, v in observed_data]), dtype=torch.float32).reshape(-1, 1).to(device)\n",
    "obs_v = torch.tensor(np.concatenate([v.flatten() for t, h, u, v in observed_data]), dtype=torch.float32).reshape(-1, 1).to(device)\n",
    "\n",
    "# Training loop\n",
    "epochs = 1000\n",
    "g = 9.81\n",
    "losses = {'total_loss': [], 'loss_continuity': [], 'loss_momentum_x': [], 'loss_momentum_y': [],\n",
    "          'loss_h': [], 'loss_u': [], 'loss_v': []}\n",
    "\n",
    "# Create a figure for live plotting\n",
    "fig, ax = plt.subplots()\n",
    "lines = {key: ax.plot([], [], label=key)[0] for key in losses}\n",
    "ax.set_xlim(0, epochs)\n",
    "ax.set_yscale('log')\n",
    "ax.set_ylim(1e-9, 1)\n",
    "ax.legend()\n",
    "ax.set_xlabel('Epoch')\n",
    "ax.set_ylabel('Loss')\n",
    "\n",
    "def update_plot(epoch):\n",
    "    for key, line in lines.items():\n",
    "        line.set_data(range(len(losses[key])), losses[key])\n",
    "    ax.relim()\n",
    "    ax.autoscale_view()\n",
    "    clear_output(wait=True)\n",
    "    display(fig)\n",
    "    plt.pause(0.01)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training Model:  38%|███▊      | 381/1000 [01:35<02:25,  4.25it/s, Total Loss=0.0274, Continuity=0.0000, Momentum X=0.0000, Momentum Y=0.0000, Loss h=0.0272, Loss u=0.0001, Loss v=0.0001]"
     ]
    }
   ],
   "source": [
    "\n",
    "pbar = tqdm(range(epochs), desc=\"Training Model\")\n",
    "for epoch in pbar:\n",
    "    optimizer.zero_grad()\n",
    "    x.requires_grad_(True)\n",
    "    y.requires_grad_(True)\n",
    "    t.requires_grad_(True)\n",
    "    \n",
    "    # Compute loss\n",
    "    total_loss, loss_continuity, loss_momentum_x, loss_momentum_y, loss_h, loss_u, loss_v = compute_loss(model, obs_x, obs_y, obs_t, obs_h, obs_u, obs_v, g)\n",
    "    total_loss.backward()\n",
    "    optimizer.step()\n",
    "\n",
    "    # Update losses\n",
    "    losses['total_loss'].append(total_loss.item())\n",
    "    losses['loss_continuity'].append(loss_continuity.item())\n",
    "    losses['loss_momentum_x'].append(loss_momentum_x.item())\n",
    "    losses['loss_momentum_y'].append(loss_momentum_y.item())\n",
    "    losses['loss_h'].append(loss_h.item())\n",
    "    losses['loss_u'].append(loss_u.item())\n",
    "    losses['loss_v'].append(loss_v.item())\n",
    "\n",
    "    # Update tqdm\n",
    "    pbar.set_postfix({\n",
    "        'Total Loss': f'{total_loss.item():.4f}',\n",
    "        'Continuity': f'{loss_continuity.item():.4f}',\n",
    "        'Momentum X': f'{loss_momentum_x.item():.4f}',\n",
    "        'Momentum Y': f'{loss_momentum_y.item():.4f}',\n",
    "        'Loss h': f'{loss_h.item():.4f}',\n",
    "        'Loss u': f'{loss_u.item():.4f}',\n",
    "        'Loss v': f'{loss_v.item():.4f}'\n",
    "    })\n",
    "\n",
    "    # Update live plot\n",
    "    if epoch % 50 == 0:\n",
    "        update_plot(epoch)\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute PINN predictions for the x-y plane at a specific time t=0.5\n",
    "x_plot = torch.linspace(0, 1, 100).to(device)\n",
    "y_plot = torch.linspace(0, 1, 100).to(device)\n",
    "X_plot, Y_plot = torch.meshgrid(x_plot, y_plot, indexing='ij')\n",
    "t_plot = torch.full_like(X_plot, 0.5).to(device)\n",
    "\n",
    "X_plot_flat = X_plot.flatten().view(-1, 1)\n",
    "Y_plot_flat = Y_plot.flatten().view(-1, 1)\n",
    "t_plot_flat = t_plot.flatten().view(-1, 1)\n",
    "\n",
    "with torch.no_grad():\n",
    "    H_plot = model(X_plot_flat, Y_plot_flat, t_plot_flat)[:, 0].cpu().numpy().reshape(100, 100)\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.contourf(x_plot.cpu().numpy(), y_plot.cpu().numpy(), H_plot, levels=50, cmap='viridis')\n",
    "plt.colorbar()\n",
    "plt.title('PINN Solution for h at t=0.5')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}