Finite_Volume_Fluid_Simulation_in_JAX.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "**Goal:**\n",
        "\n",
        "In this notebook we will be building a hardware accelerated finite volume  simulation with JAX.\n",
        "\n",
        "**Credits:**\n",
        "\n",
        "The code used if based on this tutorial by Philip Mocz. We will be porting the logic to JAX.\n",
        "\n",
        "https://github.com/pmocz/finitevolume-python/blob/master/finitevolume.py\n",
        "\n"
      ],
      "metadata": {
        "id": "zygLVYS_kyv6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install chex"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cvCzC9EPufUS",
        "outputId": "dffb0def-6d49-4155-d850-d442fbed5ce7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: chex in /usr/local/lib/python3.10/dist-packages (0.1.7)\n",
            "Requirement already satisfied: absl-py>=0.9.0 in /usr/local/lib/python3.10/dist-packages (from chex) (1.4.0)\n",
            "Requirement already satisfied: dm-tree>=0.1.5 in /usr/local/lib/python3.10/dist-packages (from chex) (0.1.8)\n",
            "Requirement already satisfied: jax>=0.4.6 in /usr/local/lib/python3.10/dist-packages (from chex) (0.4.20)\n",
            "Requirement already satisfied: jaxlib>=0.1.37 in /usr/local/lib/python3.10/dist-packages (from chex) (0.4.20+cuda11.cudnn86)\n",
            "Requirement already satisfied: numpy>=1.18.0 in /usr/local/lib/python3.10/dist-packages (from chex) (1.23.5)\n",
            "Requirement already satisfied: toolz>=0.9.0 in /usr/local/lib/python3.10/dist-packages (from chex) (0.12.0)\n",
            "Requirement already satisfied: typing-extensions>=4.2.0 in /usr/local/lib/python3.10/dist-packages (from chex) (4.5.0)\n",
            "Requirement already satisfied: ml-dtypes>=0.2.0 in /usr/local/lib/python3.10/dist-packages (from jax>=0.4.6->chex) (0.2.0)\n",
            "Requirement already satisfied: opt-einsum in /usr/local/lib/python3.10/dist-packages (from jax>=0.4.6->chex) (3.3.0)\n",
            "Requirement already satisfied: scipy>=1.9 in /usr/local/lib/python3.10/dist-packages (from jax>=0.4.6->chex) (1.11.4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zcQON2yZjluX"
      },
      "outputs": [],
      "source": [
        "import jax\n",
        "import chex\n",
        "from jax import jit, lax\n",
        "import jax.numpy as jnp"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "## Modelling in JAX\n",
        "\n",
        "The `jax.numpy` module in JAX is a drop in replacement and has most of the numpy API. The key thing to remember is that JAX requires you to use pure functions: all the input data is passed through the function parameters, all the results are output through the function results. A pure function will always return the same result if invoked with the same inputs.\n",
        "\n",
        "The code from the tutorial already used pure functions, so the only change needed to port from numpy to JAX was to change numpy call from `np` to `jnp`. This example shows how easy it existing python code can be converted into JAX.\n",
        "Keep in mind that numpy is executed on the host machine and JAX functions are compiled and executed on the device (GPU/TPU). We need to be aware about where we transfer data from the host (CPU) to device and vice-versa. Unintentional data transfer from device to host slowing down execution.\n"
      ],
      "metadata": {
        "id": "kbfF57aglLm6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def getConserved( rho, vx, vy, P, gamma, vol ):\n",
        "\t\"\"\"\n",
        "    Calculate the conserved variable from the primitive\n",
        "\trho      is matrix of cell densities\n",
        "\tvx       is matrix of cell x-velocity\n",
        "\tvy       is matrix of cell y-velocity\n",
        "\tP        is matrix of cell pressures\n",
        "\tgamma    is ideal gas gamma\n",
        "\tvol      is cell volume\n",
        "\tMass     is matrix of mass in cells\n",
        "\tMomx     is matrix of x-momentum in cells\n",
        "\tMomy     is matrix of y-momentum in cells\n",
        "\tEnergy   is matrix of energy in cells\n",
        "\t\"\"\"\n",
        "\tMass   = rho * vol\n",
        "\tMomx   = rho * vx * vol\n",
        "\tMomy   = rho * vy * vol\n",
        "\tEnergy = (P/(gamma-1) + 0.5*rho*(vx**2+vy**2))*vol\n",
        "\n",
        "\treturn Mass, Momx, Momy, Energy"
      ],
      "metadata": {
        "id": "sEpUOdDQk_vg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def getPrimitive( Mass, Momx, Momy, Energy, gamma, vol ):\n",
        "\t\"\"\"\n",
        "    Calculate the primitive variable from the conservative\n",
        "\tMass     is matrix of mass in cells\n",
        "\tMomx     is matrix of x-momentum in cells\n",
        "\tMomy     is matrix of y-momentum in cells\n",
        "\tEnergy   is matrix of energy in cells\n",
        "\tgamma    is ideal gas gamma\n",
        "\tvol      is cell volume\n",
        "\trho      is matrix of cell densities\n",
        "\tvx       is matrix of cell x-velocity\n",
        "\tvy       is matrix of cell y-velocity\n",
        "\tP        is matrix of cell pressures\n",
        "\t\"\"\"\n",
        "\trho = Mass / vol\n",
        "\tvx  = Momx / rho / vol\n",
        "\tvy  = Momy / rho / vol\n",
        "\tP   = (Energy/vol - 0.5*rho * (vx**2+vy**2)) * (gamma-1)\n",
        "\n",
        "\treturn rho, vx, vy, P"
      ],
      "metadata": {
        "id": "QNJzLfBOlIsH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def getGradient(f, dx):\n",
        "\t\"\"\"\n",
        "    Calculate the gradients of a field\n",
        "\tf        is a matrix of the field\n",
        "\tdx       is the cell size\n",
        "\tf_dx     is a matrix of derivative of f in the x-direction\n",
        "\tf_dy     is a matrix of derivative of f in the y-direction\n",
        "\t\"\"\"\n",
        "  # directions for jnp.roll()\n",
        "\tR = -1   # right\n",
        "\tL = 1    # left\n",
        "\n",
        "\tf_dx = ( jnp.roll(f,R,axis=0) - jnp.roll(f,L,axis=0) ) / (2*dx)\n",
        "\tf_dy = ( jnp.roll(f,R,axis=1) - jnp.roll(f,L,axis=1) ) / (2*dx)\n",
        "\n",
        "\treturn f_dx, f_dy\n"
      ],
      "metadata": {
        "id": "f0wi2z3FlKZ5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def slopeLimit(f, dx, f_dx, f_dy):\n",
        "\t\"\"\"\n",
        "    Apply slope limiter to slopes\n",
        "\tf        is a matrix of the field\n",
        "\tdx       is the cell size\n",
        "\tf_dx     is a matrix of derivative of f in the x-direction\n",
        "\tf_dy     is a matrix of derivative of f in the y-direction\n",
        "\t\"\"\"\n",
        "\t# directions for jnp.roll()\n",
        "\tR = -1   # right\n",
        "\tL = 1    # left\n",
        "\n",
        "\tf_dx = jnp.maximum(0., jnp.minimum(1., ( (f-jnp.roll(f,L,axis=0))/dx)/(f_dx + 1.0e-8*(f_dx==0)))) * f_dx\n",
        "\tf_dx = jnp.maximum(0., jnp.minimum(1., (-(f-jnp.roll(f,R,axis=0))/dx)/(f_dx + 1.0e-8*(f_dx==0)))) * f_dx\n",
        "\tf_dy = jnp.maximum(0., jnp.minimum(1., ( (f-jnp.roll(f,L,axis=1))/dx)/(f_dy + 1.0e-8*(f_dy==0)))) * f_dy\n",
        "\tf_dy = jnp.maximum(0., jnp.minimum(1., (-(f-jnp.roll(f,R,axis=1))/dx)/(f_dy + 1.0e-8*(f_dy==0)))) * f_dy\n",
        "\n",
        "\treturn f_dx, f_dy\n"
      ],
      "metadata": {
        "id": "sB1YDKx2m3ET"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def extrapolateInSpaceToFace(f, f_dx, f_dy, dx):\n",
        "\t\"\"\"\n",
        "    Calculate the gradients of a field\n",
        "\tf        is a matrix of the field\n",
        "\tf_dx     is a matrix of the field x-derivatives\n",
        "\tf_dy     is a matrix of the field y-derivatives\n",
        "\tdx       is the cell size\n",
        "\tf_XL     is a matrix of spatial-extrapolated values on `left' face along x-axis\n",
        "\tf_XR     is a matrix of spatial-extrapolated values on `right' face along x-axis\n",
        "\tf_YL     is a matrix of spatial-extrapolated values on `left' face along y-axis\n",
        "\tf_YR     is a matrix of spatial-extrapolated values on `right' face along y-axis\n",
        "\t\"\"\"\n",
        "\t# directions for np.roll()\n",
        "\tR = -1   # right\n",
        "\tL = 1    # left\n",
        "\n",
        "\tf_XL = f - f_dx * dx/2\n",
        "\tf_XL = jnp.roll(f_XL,R,axis=0)\n",
        "\tf_XR = f + f_dx * dx/2\n",
        "\n",
        "\tf_YL = f - f_dy * dx/2\n",
        "\tf_YL = jnp.roll(f_YL,R,axis=1)\n",
        "\tf_YR = f + f_dy * dx/2\n",
        "\n",
        "\treturn f_XL, f_XR, f_YL, f_YR\n"
      ],
      "metadata": {
        "id": "sbPQQnklnCn9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def applyFluxes(F, flux_F_X, flux_F_Y, dx, dt):\n",
        "\t\"\"\"\n",
        "    Apply fluxes to conserved variables\n",
        "\tF        is a matrix of the conserved variable field\n",
        "\tflux_F_X is a matrix of the x-dir fluxes\n",
        "\tflux_F_Y is a matrix of the y-dir fluxes\n",
        "\tdx       is the cell size\n",
        "\tdt       is the timestep\n",
        "\t\"\"\"\n",
        "\t# directions for np.roll()\n",
        "\tR = -1   # right\n",
        "\tL = 1    # left\n",
        "\n",
        "\t# update solution\n",
        "\tF += - dt * dx * flux_F_X\n",
        "\tF +=   dt * dx * jnp.roll(flux_F_X,L,axis=0)\n",
        "\tF += - dt * dx * flux_F_Y\n",
        "\tF +=   dt * dx * jnp.roll(flux_F_Y,L,axis=1)\n",
        "\n",
        "\treturn F\n"
      ],
      "metadata": {
        "id": "9D9xOliNnGMO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def getFlux(rho_L, rho_R, vx_L, vx_R, vy_L, vy_R, P_L, P_R, gamma):\n",
        "\t\"\"\"\n",
        "    Calculate fluxed between 2 states with local Lax-Friedrichs/Rusanov rule\n",
        "\trho_L        is a matrix of left-state  density\n",
        "\trho_R        is a matrix of right-state density\n",
        "\tvx_L         is a matrix of left-state  x-velocity\n",
        "\tvx_R         is a matrix of right-state x-velocity\n",
        "\tvy_L         is a matrix of left-state  y-velocity\n",
        "\tvy_R         is a matrix of right-state y-velocity\n",
        "\tP_L          is a matrix of left-state  pressure\n",
        "\tP_R          is a matrix of right-state pressure\n",
        "\tgamma        is the ideal gas gamma\n",
        "\tflux_Mass    is the matrix of mass fluxes\n",
        "\tflux_Momx    is the matrix of x-momentum fluxes\n",
        "\tflux_Momy    is the matrix of y-momentum fluxes\n",
        "\tflux_Energy  is the matrix of energy fluxes\n",
        "\t\"\"\"\n",
        "\n",
        "\t# left and right energies\n",
        "\ten_L = P_L/(gamma-1)+0.5*rho_L * (vx_L**2+vy_L**2)\n",
        "\ten_R = P_R/(gamma-1)+0.5*rho_R * (vx_R**2+vy_R**2)\n",
        "\n",
        "\t# compute star (averaged) states\n",
        "\trho_star  = 0.5*(rho_L + rho_R)\n",
        "\tmomx_star = 0.5*(rho_L * vx_L + rho_R * vx_R)\n",
        "\tmomy_star = 0.5*(rho_L * vy_L + rho_R * vy_R)\n",
        "\ten_star   = 0.5*(en_L + en_R)\n",
        "\n",
        "\tP_star = (gamma-1)*(en_star-0.5*(momx_star**2+momy_star**2)/rho_star)\n",
        "\n",
        "\t# compute fluxes (local Lax-Friedrichs/Rusanov)\n",
        "\tflux_Mass   = momx_star\n",
        "\tflux_Momx   = momx_star**2/rho_star + P_star\n",
        "\tflux_Momy   = momx_star * momy_star/rho_star\n",
        "\tflux_Energy = (en_star+P_star) * momx_star/rho_star\n",
        "\n",
        "\t# find wavespeeds\n",
        "\tC_L = jnp.sqrt(gamma*P_L/rho_L) + jnp.abs(vx_L)\n",
        "\tC_R = jnp.sqrt(gamma*P_R/rho_R) + jnp.abs(vx_R)\n",
        "\tC = jnp.maximum( C_L, C_R )\n",
        "\n",
        "\t# add stabilizing diffusive term\n",
        "\tflux_Mass   -= C * 0.5 * (rho_L - rho_R)\n",
        "\tflux_Momx   -= C * 0.5 * (rho_L * vx_L - rho_R * vx_R)\n",
        "\tflux_Momy   -= C * 0.5 * (rho_L * vy_L - rho_R * vy_R)\n",
        "\tflux_Energy -= C * 0.5 * ( en_L - en_R )\n",
        "\n",
        "\treturn flux_Mass, flux_Momx, flux_Momy, flux_Energy\n"
      ],
      "metadata": {
        "id": "Ltf4fz_HnHuR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Simulation Loop\n",
        "\n",
        "This is where things start to differ. JAX operates on pure functions however a simulation is an iterative stateful process.\n",
        "\n",
        "The State Monad in functional programming can be used to our create simulation. Each iteration of the simulation can be seen to take in a state, perform computation and return a new state.\n",
        "\n",
        "```\n",
        "iteration : s -> (s, a)\n",
        "```\n",
        "\n",
        "Another advantage that we get from this pattern is that we can save the state of simulation at a particular iteration and replay from that point.\n",
        "\n",
        "For a physics simulation such as this, there are a lot of variables in the state. To encapsulate them we create immutable dataclasses. Typically for working with classes in JAX we need to define how the class has to be flattened and unflattened. chex is a library in the JAX ecosystem with a convenient utilities."
      ],
      "metadata": {
        "id": "4YrhzqZlo80G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "@chex.dataclass\n",
        "class State:\n",
        "  Mass: jax.Array\n",
        "  Momx: jax.Array\n",
        "  Momy: jax.Array\n",
        "  Energy: jax.Array\n",
        "\n",
        "@chex.dataclass\n",
        "class Environment:\n",
        "  courant_fac: jnp.float32\n",
        "  dx: jnp.float32\n",
        "  gamma: jnp.float32\n",
        "  vol: jnp.float32"
      ],
      "metadata": {
        "id": "NZ9OdL8JvE19"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "@jit\n",
        "def iteration(environment: Environment, state: State) -> State:\n",
        "  dx = environment.dx\n",
        "  gamma = environment.gamma\n",
        "  vol = environment.vol\n",
        "\n",
        "  Mass = state.Mass\n",
        "  Momx = state.Momx\n",
        "  Momy = state.Momy\n",
        "  Energy = state.Energy\n",
        "\n",
        "  rho, vx, vy, P = getPrimitive( Mass, Momx, Momy, Energy, gamma, vol )\n",
        "  dt = environment.courant_fac * jnp.min( dx / (jnp.sqrt( gamma*P/rho ) + jnp.sqrt(vx**2+vy**2)) )\n",
        "\n",
        "  # calculate gradients\n",
        "  rho_dx, rho_dy = getGradient(rho, dx)\n",
        "  vx_dx,  vx_dy  = getGradient(vx,  dx)\n",
        "  vy_dx,  vy_dy  = getGradient(vy,  dx)\n",
        "  P_dx,   P_dy   = getGradient(P,   dx)\n",
        "\n",
        "  # extrapolate half-step in time\n",
        "  rho_prime = rho - 0.5*dt * ( vx * rho_dx + rho * vx_dx + vy * rho_dy + rho * vy_dy)\n",
        "  vx_prime  = vx  - 0.5*dt * ( vx * vx_dx + vy * vx_dy + (1/rho) * P_dx )\n",
        "  vy_prime  = vy  - 0.5*dt * ( vx * vy_dx + vy * vy_dy + (1/rho) * P_dy )\n",
        "  P_prime   = P   - 0.5*dt * ( gamma*P * (vx_dx + vy_dy)  + vx * P_dx + vy * P_dy )\n",
        "\n",
        "  # extrapolate in space to face centers\n",
        "  rho_XL, rho_XR, rho_YL, rho_YR = extrapolateInSpaceToFace(rho_prime, rho_dx, rho_dy, dx)\n",
        "  vx_XL,  vx_XR,  vx_YL,  vx_YR  = extrapolateInSpaceToFace(vx_prime,  vx_dx,  vx_dy,  dx)\n",
        "  vy_XL,  vy_XR,  vy_YL,  vy_YR  = extrapolateInSpaceToFace(vy_prime,  vy_dx,  vy_dy,  dx)\n",
        "  P_XL,   P_XR,   P_YL,   P_YR   = extrapolateInSpaceToFace(P_prime,   P_dx,   P_dy,   dx)\n",
        "\n",
        "  # compute fluxes (local Lax-Friedrichs/Rusanov)\n",
        "  flux_Mass_X, flux_Momx_X, flux_Momy_X, flux_Energy_X = getFlux(rho_XL, rho_XR, vx_XL, vx_XR, vy_XL, vy_XR, P_XL, P_XR, gamma)\n",
        "  flux_Mass_Y, flux_Momy_Y, flux_Momx_Y, flux_Energy_Y = getFlux(rho_YL, rho_YR, vy_YL, vy_YR, vx_YL, vx_YR, P_YL, P_YR, gamma)\n",
        "\n",
        "  # update solution\n",
        "  Mass   = applyFluxes(Mass, flux_Mass_X, flux_Mass_Y, dx, dt)\n",
        "  Momx   = applyFluxes(Momx, flux_Momx_X, flux_Momx_Y, dx, dt)\n",
        "  Momy   = applyFluxes(Momy, flux_Momy_X, flux_Momy_Y, dx, dt)\n",
        "  Energy = applyFluxes(Energy, flux_Energy_X, flux_Energy_Y, dx, dt)\n",
        "\n",
        "  # update time\n",
        "  # t += dt\n",
        "\n",
        "  return state.replace(\n",
        "      Mass = Mass,\n",
        "      Momx = Momx,\n",
        "      Momy = Momy,\n",
        "      Energy = Energy\n",
        "  )"
      ],
      "metadata": {
        "id": "kZx7RRZao7sJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "@jit\n",
        "def multi_step(environment: Environment, state: State, count: int):\n",
        "  return lax.fori_loop(0, count, lambda i, s: iteration(environment, s), state)"
      ],
      "metadata": {
        "id": "Mo905xU_xRml"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from jax import tree_util\n",
        "import numpy as np\n",
        "\n",
        "def run_simulation(\n",
        "    environment: Environment,\n",
        "    state: State,\n",
        "    count: int,\n",
        "    nr_snapshots: int = 10\n",
        "):\n",
        "  nr_iter_per_snapshot = count // nr_snapshots\n",
        "\n",
        "  results = [state]\n",
        "  for i in range(nr_snapshots):\n",
        "    state = multi_step(environment, state, nr_iter_per_snapshot)\n",
        "    results.append(state)\n",
        "\n",
        "  # Get data from device\n",
        "  results = jax.device_get(results)\n",
        "\n",
        "  return tree_util.tree_map(lambda *xs: np.stack([np.array(x) for x in xs]), *results)\n"
      ],
      "metadata": {
        "id": "KURpCYwXzZ37"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Initial Conditions\n",
        "\n",
        "### Environment"
      ],
      "metadata": {
        "id": "s2vKOPoVyIs4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Simulation parameters\n",
        "N                      = 128 # resolution\n",
        "boxsize                = 1.\n",
        "gamma                  = 5/3 # ideal gas gamma\n",
        "courant_fac            = 0.4\n",
        "t                      = 0\n",
        "tEnd                   = 2\n",
        "tOut                   = 0.02 # draw frequency\n",
        "\n",
        "# Mesh\n",
        "dx = boxsize / N\n",
        "vol = dx**2\n",
        "\n",
        "environment = Environment(\n",
        "  courant_fac=courant_fac,\n",
        "  dx=dx,\n",
        "  gamma=gamma,\n",
        "  vol=vol\n",
        ")"
      ],
      "metadata": {
        "id": "PlxD_tohyGcc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "xlin = jnp.linspace(0.5*dx, boxsize-0.5*dx, N)\n",
        "Y, X = jnp.meshgrid( xlin, xlin )\n",
        "\n",
        "# Generate Initial Conditions - opposite moving streams with perturbation\n",
        "w0 = 0.1\n",
        "sigma = 0.05/jnp.sqrt(2.)\n",
        "rho = 1. + (jnp.abs(Y-0.5) < 0.25)\n",
        "vx = -0.5 + (jnp.abs(Y-0.5)<0.25)\n",
        "vy = w0*jnp.sin(4*jnp.pi*X) * ( jnp.exp(-(Y-0.25)**2/(2 * sigma**2)) + jnp.exp(-(Y-0.75)**2/(2*sigma**2)) )\n",
        "P = 2.5 * jnp.ones(X.shape)\n",
        "\n",
        "\n",
        "# Get conserved variables\n",
        "Mass, Momx, Momy, Energy = getConserved( rho, vx, vy, P, gamma, vol )\n",
        "\n",
        "initial_state = State(\n",
        "    Mass=Mass,\n",
        "    Momx=Momx,\n",
        "    Momy=Momy,\n",
        "    Energy=Energy\n",
        ")\n"
      ],
      "metadata": {
        "id": "7Zi5r4L9zExZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Running the simulation"
      ],
      "metadata": {
        "id": "0fa2_0THzRzK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nr_iterations = 1000\n",
        "nr_snapshots = 100\n",
        "results = run_simulation(environment, initial_state, nr_iterations, nr_snapshots)"
      ],
      "metadata": {
        "id": "QAlkEQ5LzPOL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "%timeit -n 1 run_simulation(environment, initial_state, nr_iterations, nr_snapshots)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hBMk5_lK7A6s",
        "outputId": "12677bd7-2a93-4d17-a1bf-3eb68052679d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "335 ms ± 66 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Visualization"
      ],
      "metadata": {
        "id": "H30KFdurzVsN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import skimage.filters\n",
        "import proglog\n",
        "from moviepy.editor import ImageSequenceClip"
      ],
      "metadata": {
        "id": "DUqxilcvzXr7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.imshow(results.Mass[-1].T / vol, cmap='jet')\n",
        "plt.clim(0.8, 2.2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 434
        },
        "id": "B9Pk47Qd5QeN",
        "outputId": "6d1aa066-ff65-4d44-ff10-ad1259d2a7a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.cm\n",
        "import matplotlib.colors\n",
        "from PIL import Image\n",
        "\n",
        "def make_images(data, cmap='jet', vmax=None, vmin=None):\n",
        "  images = []\n",
        "  for frame in data:\n",
        "    if vmax is None:\n",
        "      this_vmax = np.max(abs(frame))\n",
        "    else:\n",
        "      this_vmax = vmax\n",
        "    if vmin is None:\n",
        "      this_vmin = np.min(abs(frame))\n",
        "    else:\n",
        "      this_vmin = vmin\n",
        "    norm = matplotlib.colors.Normalize(vmin=-this_vmin, vmax=this_vmax)\n",
        "    mappable = matplotlib.cm.ScalarMappable(norm=norm, cmap=cmap)\n",
        "    rgba = mappable.to_rgba(frame, bytes=True)\n",
        "    image = Image.fromarray(rgba, mode='RGBA')\n",
        "    images.append(image)\n",
        "  return images\n",
        "\n",
        "def save_movie(images, path, duration=100, loop=0, **kwargs):\n",
        "  images[0].save(path, save_all=True, append_images=images[1:],\n",
        "                 duration=duration, loop=loop, **kwargs)\n",
        "\n",
        "images = make_images((results.Mass / vol).transpose(0, 2, 1), vmax=2.2, vmin=0.8)"
      ],
      "metadata": {
        "id": "eUPznnRX5VcM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from functools import partial\n",
        "\n",
        "proglog.default_bar_logger = partial(proglog.default_bar_logger, None)\n",
        "ImageSequenceClip([np.array(im) for im in images], fps=25).ipython_display()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DuNO8kET5XuT",
        "outputId": "c688aed6-aa99-4353-cd77-cb4ea8e60a8c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<moviepy.video.io.html_tools.HTML2 object>"
            ],
            "text/html": [
              "<div align=middle><video src='data:video/mp4;base64,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' controls>Sorry, seems like your browser doesn't support HTML5 audio/video</video></div>"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Save GIF.\n",
        "save_movie(images,'finite_volume_sim.gif', duration=[2000]+[200]*(len(images)-2)+[2000])\n",
        "# The movie sometimes takes a second before showing up in the file system.\n",
        "import time; time.sleep(1)"
      ],
      "metadata": {
        "id": "vjMy6NGNMy2Q"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Download animation.\n",
        "try:\n",
        "    from google.colab import files\n",
        "except ImportError:\n",
        "    pass\n",
        "else:\n",
        "    files.download('finite_volume_sim.gif')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "CUIgohg-M62I",
        "outputId": "26aacdcd-726e-446d-b0f6-b5ee2891b04d"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_d842a6ce-72f3-485e-83d7-12d7aedb2705\", \"finite_volume_sim.gif\", 168782)"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Reference\n",
        "\n",
        "1. https://github.com/pmocz/finitevolume-python/blob/master/finitevolume.py\n",
        "2. https://github.com/google/jax/blob/main/cloud_tpu_colabs/Wave_Equation.ipynb\n"
      ],
      "metadata": {
        "id": "I9LKyArD_qV-"
      }
    }
  ]
}