inertial_FTLE_gravity.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "This notebook will output a dataset .npy of Lagrangian particle flow map\n",
    "Total particle number : Nx x Ny\n",
    "Finite Time interval : t0 --> t0 + T (trajectory data during this T will not be saved)\n",
    "Output variable : 2D numpy array of tuples;\n",
    "                  Each tuple (x0, y0, x1, y1) stores initial and final positions of a Lagrangian particle,\n",
    "                  i.e. r(t0) = (x0, y0) and r(t0+T) = (x1, y1)\n",
    "''' \n",
    "\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from math import sin, cos, pi\n",
    "\n",
    "from scipy import integrate\n",
    "import scipy as sp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "### create flow domain \n",
    "# there are same number of Lagrangian and Eulerian grid points (Nx, Ny)\n",
    "Lx, Ly = (2, 1)\n",
    "Nx, Ny = (141, 71)\n",
    "x = np.linspace(0,Lx,Nx)\n",
    "y = np.linspace(0,Ly,Ny)\n",
    "X, Y = np.meshgrid(x,y)\n",
    "dx = Lx/(Nx-1)\n",
    "dy = dx\n",
    "\n",
    "t0 = 0\n",
    "tf = 0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "### compute a double gyro flow field\n",
    "\n",
    "# flow parameters\n",
    "A = 0.1\n",
    "eps = 0.25\n",
    "omega = pi\n",
    "\n",
    "# flow streamline\n",
    "a = lambda t: eps * np.sin(omega * t)\n",
    "b = lambda t: 1 - 2 * a(t)\n",
    "fxt = lambda x, t: a(t) * (x**2) + b(t) * x\n",
    "psi = lambda x,y,t: A * np.sin(np.pi*fxt(x,t)) * np.sin(np.pi*y)\n",
    "\n",
    "# flow velocity field (need to sort out the signs!!)\n",
    "U = lambda x,y,t: -A*np.pi * np.sin(np.pi*fxt(x,t)) * np.cos(np.pi*y)\n",
    "V = lambda x,y,t: A*np.pi * np.cos(np.pi*fxt(x,t)) * np.sin(np.pi*y) * (2*a(t)*x + b(t))\n",
    "\n",
    "# # visualise flow field at t0\n",
    "# t0 = 0\n",
    "# fig, ax = plt.subplots(layout='constrained')\n",
    "# CS = ax.contourf(X, Y, V(X,Y,3), 50)\n",
    "# ax.set_aspect('equal')\n",
    "# fig.colorbar(CS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### compute particle trajectories\n",
    "\n",
    "# inertial particle parameters in the MR equation\n",
    "St = 1\n",
    "R = 0\n",
    "W = 5\n",
    "\n",
    "\n",
    "# Solve the IVP RK4 -- for inertial particles\n",
    "def solve_ivp_active(Lag_point, t0 = t0, tf = tf):\n",
    "  '''\n",
    "  Assuming that the inertial particles follow flow field before integrating path, i.e. only released at t0\n",
    "  '''\n",
    "  \n",
    "  # define the IVP to solve -- for INERTIAL particles\n",
    "\n",
    "  t_span = np.linspace(t0,tf,500)\n",
    "\n",
    "  def active_tracer_traj(t, Z) :\n",
    "    # state-space vector Z[2] is vx, Z[3] is vy\n",
    "      # compute flow field at particle position (xp, yp)\n",
    "      xp = Z[0]\n",
    "      yp = Z[1]\n",
    "      a = eps * np.sin(omega * t)\n",
    "      b = 1 - 2 * eps * np.sin(omega * t)\n",
    "      fxt = a*(xp**2) + b*xp\n",
    "      dfdt = (xp**2) * eps * omega * np.cos(omega * t) -2* xp *  eps * omega * np.cos(omega * t)\n",
    "      dfdx = 2*a*xp + b\n",
    "      Uf = -A*np.pi * np.sin(np.pi*fxt) * np.cos(np.pi*yp)\n",
    "      Vf = A*np.pi * np.cos(np.pi*fxt) * np.sin(np.pi*yp) * dfdx\n",
    "      dUdt = -A*(np.pi**2) * np.cos(np.pi*fxt) * np.cos(np.pi*yp) * dfdt\n",
    "      dVdt = A*np.pi * np.sin(np.pi*yp) * ( -np.pi*np.sin(np.pi*fxt)*dfdt*dfdx + np.cos(np.pi*fxt) * (2*xp*eps*omega*np.cos(omega * t) - 2*eps*omega*np.cos(omega * t)) )\n",
    "      dUdx = -A*(np.pi**2) * np.cos(np.pi*fxt) * np.cos(np.pi*yp) * dfdx\n",
    "      dUdy = A*(np.pi**2) * np.sin(np.pi*fxt) * np.sin(np.pi*yp)\n",
    "      dVdx = A*np.pi * np.sin(np.pi*yp) * ( -np.pi*np.sin(np.pi*fxt)*(dfdx**2) + np.cos(np.pi*fxt) * (2*a) )\n",
    "      dVdy = A*(np.pi**2) * np.cos(np.pi*fxt) * np.cos(np.pi*yp) * dfdx\n",
    "\n",
    "\n",
    "\n",
    "      # define derivatives\n",
    "      dxpdt = Z[2]  # vx\n",
    "      dypdt = Z[3]  # vy\n",
    "      ddxpdtt = (Uf - dxpdt)/St + (3*R/2) * (dUdt + Uf*dUdx + Vf*dUdy)\n",
    "      ddypdtt = (Vf - dypdt)/St + (3*R/2) * (dVdt + Uf*dVdx + Vf*dVdy) - W\n",
    "      return [dxpdt, dypdt, ddxpdtt, ddypdtt]\n",
    "\n",
    "\n",
    "  x0, y0 = Lag_point\n",
    "  sol = sp.integrate.solve_ivp(active_tracer_traj, [t0, tf], [x0, y0, U(x0,y0,t=t0), V(x0,y0,t=t0)], t_eval=t_span, vectorized=True)\n",
    "  xpt, ypt = sol.y[0], sol.y[1]\n",
    "  return xpt, ypt\n",
    "\n",
    "  \n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# t = 3\n",
    "# import sympy as sp\n",
    "\n",
    "# # Define symbols\n",
    "# x, y, t, A, eps, omega = sp.symbols('x y t A eps omega')\n",
    "\n",
    "# # Define a(t) and b(t)\n",
    "# a_t = eps * sp.sin(omega * t)\n",
    "# b_t = 1 - 2 * eps * sp.sin(omega * t)\n",
    "\n",
    "# # Define f(x, t)\n",
    "# f_x_t = a_t * x**2 + b_t * x\n",
    "\n",
    "# # Define psi(x, y, t)\n",
    "# psi_sym = A * sp.sin(sp.pi * f_x_t) * sp.sin(sp.pi * y)\n",
    "\n",
    "# # flow velocity field Uf(x,y,t) and Vf(x,y,t)\n",
    "# Uf_sym = -sp.diff(psi_sym, y)\n",
    "# Vf_sym = sp.diff(psi_sym, x)\n",
    "\n",
    "# psi = psi_sym.subs({A: A, eps: eps, omega: omega, x: sp.Matrix(X), y:sp.Matrix(Y), t: 3})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "### compute the INTERTIAL particle flow map in the whole domain\n",
    "\n",
    "# create a flattened array of grid points, first index is x\n",
    "grid_coords = np.column_stack((X.ravel(), Y.ravel()))\n",
    "final_coords = np.empty_like(grid_coords, dtype=object)\n",
    "\n",
    "\n",
    "# ## the slow version\n",
    "# for i, point in enumerate(grid_coords):\n",
    "#     x0, y0 = grid_coords[i, 0], grid_coords[i, 1]\n",
    "#     rt = solve_ivp_active((x0, y0), 0, 15)\n",
    "#     final_coords[i,:] = rt[0][-1], rt[1][-1]\n",
    "\n",
    "\n",
    "## using multiprocessing\n",
    "'''\n",
    "output [res], a list with len = Nx*Ny, \n",
    "each list element is an array of t_span for one particle\n",
    "'''\n",
    "from multiprocessing import Pool\n",
    "\n",
    "n_proc = 12\n",
    "with Pool(n_proc) as pool:\n",
    "    args = list( grid_coords )\n",
    "    res = pool.map( solve_ivp_active, args )\n",
    "\n",
    "final_coords = np.array([(point[0][-1], point[1][-1]) for point in res], dtype=float)\n",
    "\n",
    "\n",
    "\n",
    "## construct flow map of positions at t0 and tf\n",
    "flow_map = np.column_stack((grid_coords, final_coords))\n",
    "# np.save('inertial_flow_map.npy', flow_map)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save(f'inertialGravW{W}_flow_map_w{omega/np.pi}_{tf}_St{St}_R{R}.npy', flow_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# grid_coords = np.column_stack((X.ravel(), Y.ravel()))\n",
    "# final_coords = np.empty_like(grid_coords, dtype=object)\n",
    "# from multiprocessing import Pool\n",
    "# with Pool( 12 ) as pool:\n",
    "#     args = list( grid_coords )\n",
    "#     res = pool.map( solve_ivp_active, args )\n",
    "# res = np.array( res )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# res.shape\n",
    "# # final_coords = res[:,:,-1]\n",
    "# final_coords = res.copy()\n",
    "# flow_map = np.column_stack((grid_coords, final_coords))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# flow_map = np.column_stack((grid_coords, final_coords))\n",
    "# final_coords[i,:] = rt[0][-1], rt[1][-1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is a 3D array and the first two indicies are the particle \"Name\" (defined by its initial position)\n",
    "flow_map_arr = np.array([tuple(row) for row in flow_map]).reshape((Ny, Nx, 4))\n",
    "X0 = flow_map_arr[:,:,0]\n",
    "Y0 = flow_map_arr[:,:,1]\n",
    "Xf = flow_map_arr[:,:,2]\n",
    "Yf = flow_map_arr[:,:,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_ftle(xi, yj, t0, tf):\n",
    "\n",
    "    \"\"\"\n",
    "    the arguments xi, yj are indices, not coordinates\n",
    "    \"\"\"\n",
    "\n",
    "    D = np.zeros((2,2))   # 2D deformation gradient matrix\n",
    "    D[0,0] = (Xf[yj, xi+1] - Xf[yj, xi-1]) / (X0[yj, xi+1] - X0[yj, xi-1])\n",
    "    D[0,1] = (Xf[yj+1, xi] - Xf[yj-1, xi]) / (Y0[yj+1, xi] - Y0[yj-1, xi])\n",
    "    D[1,0] = (Yf[yj, xi+1] - Yf[yj, xi-1]) / (X0[yj, xi+1] - X0[yj, xi-1])\n",
    "    D[1,1] = (Yf[yj+1, xi] - Yf[yj-1, xi]) / (Y0[yj+1, xi] - Y0[yj-1, xi])\n",
    "\n",
    "    CGDtensor = D.T @ D # symmetric square real matrix must have orthogonal eigenvectors,  the SV's are the absolute values of the eigenvalues\n",
    "    # _, SV, _ = np.linalg.svd(CGDtensor, hermitian=True)\n",
    "\n",
    "    _, SV, _ = np.linalg.svd(D)\n",
    "\n",
    "    if SV[0] < 1:\n",
    "        SV = np.ones_like(SV)\n",
    "    else:\n",
    "        SV[1] = 1/SV[0]\n",
    "\n",
    "    ftle = np.log(SV[0]) / np.abs(tf-t0) # use the largest singular value of D\n",
    "    \n",
    "    return ftle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# D = np.zeros((2,2))   # 2D deformation gradient matrix\n",
    "# D[0,0] = (Xf[yj, xi+1] - Xf[yj, xi-1]) / (X0[yj, xi+1] - X0[yj, xi-1])\n",
    "# D[0,1] = (Xf[yj+1, xi] - Xf[yj-1, xi]) / (Y0[yj+1, xi] - Y0[yj-1, xi])\n",
    "# D[1,0] = (Yf[yj, xi+1] - Yf[yj, xi-1]) / (X0[yj, xi+1] - X0[yj, xi-1])\n",
    "# D[1,1] = (Yf[yj+1, xi] - Yf[yj-1, xi]) / (Y0[yj+1, xi] - Y0[yj-1, xi])\n",
    "\n",
    "# CGDtensor = D.T @ D # symmetric square real matrix must have orthogonal eigenvectors,  the SV's are the absolute values of the eigenvalues\n",
    "# _, SV, _ = np.linalg.svd(CGDtensor, hermitian=True)\n",
    "\n",
    "# # ftle = np.log(SV[0]) / np.abs(tf-t0)\n",
    "# CGDtensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# incompressibility = True\n",
    "# np.linalg.det(CGDtensor)\n",
    "# eigenvalues, _ = np.linalg.eig(CGDtensor)\n",
    "# # if incompressibility:\n",
    "\n",
    "# np.linalg.det(CGDtensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "FTLE_field = np.empty((Ny-2, Nx-2))\n",
    "# FTLE_field = np.empty((Ny, Nx))\n",
    "\n",
    "\n",
    "for xi in range(Nx-2) :\n",
    "    for yj in range(Ny-2) :\n",
    "        FTLE_field[yj, xi] = compute_ftle((xi+1), (yj+1), t0, tf)\n",
    "\n",
    "# for xi in range(1, Nx-1) :\n",
    "#     for yj in range(1, Ny-1) :\n",
    "#         FTLE_field[yj, xi] = compute_ftle(xi, yj, t0, tf)\n",
    "\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(layout='constrained')\n",
    "CS = ax.contourf(X[1:-1, 1:-1], Y[1:-1, 1:-1], FTLE_field, 50)\n",
    "ax.set_aspect('equal')\n",
    "cbar = fig.colorbar(CS)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.12"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}