dataExample.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ed81f8ac",
   "metadata": {},
   "source": [
    "# Load modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8aebcdad",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import operator\n",
    "from functools import reduce\n",
    "from functools import partial\n",
    "\n",
    "from timeit import default_timer\n",
    "import scipy.io\n",
    "import math\n",
    "import gc\n",
    "import glob\n",
    "\n",
    "import h5py"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cde0102",
   "metadata": {},
   "source": [
    "# Load data (will take a while) and process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8ccb9106",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Checkpoint 1\n"
     ]
    }
   ],
   "source": [
    "hf_r = h5py.File(f'/oak/stanford/schools/ees/smbenson/andchu/shale_clean.hdf5', 'r')\n",
    "data_x_shale = np.array(hf_r.get('x'))\n",
    "data_SG_shale = np.array(hf_r.get('SG'))\n",
    "data_P_shale = np.array(hf_r.get('P'))\n",
    "data_P_init_shale = np.array(hf_r.get('P_init'))\n",
    "hf_r.close()\n",
    "print('Checkpoint 1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4bbec22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.019367479650039064\n",
      "0.10341674964334545\n"
     ]
    }
   ],
   "source": [
    "# GAS SATURATION DATA -------------------------------------------------\n",
    "# Z SCORE NORMALIZATION\n",
    "SG_mean = np.mean(data_SG_shale)\n",
    "SG_std = np.std(data_SG_shale)\n",
    "print(SG_mean)\n",
    "print(SG_std)\n",
    "    \n",
    "data_SG_shale = (data_SG_shale - SG_mean)/(SG_std)\n",
    "\n",
    "data_x = np.concatenate([data_x_shale], axis=0)\n",
    "data_sg = np.concatenate([data_SG_shale], axis=0)\n",
    "\n",
    "data_nr = data_x.shape[0]\n",
    "test_nr = 600\n",
    "train_nr = data_nr - test_nr\n",
    "\n",
    "np.random.seed(0)\n",
    "shuffle_index = np.random.choice(data_nr, data_nr, replace=False)\n",
    "\n",
    "data_x = data_x[shuffle_index, ...]\n",
    "data_sg = data_sg[shuffle_index, ...]\n",
    "\n",
    "print('Checkpoint 2')\n",
    "\n",
    "idx = [0,6,12,18,19,20,21,22,23]\n",
    "data_x_fit = np.zeros((data_x.shape[0], len(idx)+3, 96, 200))\n",
    "for j, index in enumerate(idx):\n",
    "    data_x_fit[:,j,:,:] = data_x[:,index,:,:]\n",
    "    \n",
    "print('Checkpoint 3')\n",
    "    \n",
    "dz = 2.083330\n",
    "dx = [0.1]\n",
    "\n",
    "with open('DRV.txt') as f:\n",
    "    for line in f:\n",
    "        line = line.strip().split('*')\n",
    "        dx.append(float(line[-1]))\n",
    "dx = np.cumsum(dx)\n",
    "grid_x = dx/np.max(dx)\n",
    "grid_x = grid_x[1:]\n",
    "grid_y = np.linspace(0, 200, 96)/np.max(dx)\n",
    "\n",
    "data_x_fit[:,-3,:,:] = grid_x[np.newaxis, np.newaxis, :]\n",
    "data_x_fit[:,-2,:,:] = grid_y[np.newaxis, :, np.newaxis]\n",
    "data_x_fit[:,-1,:,:] = np.ones(data_x_fit[:,-1,:,:].shape)\n",
    "\n",
    "data_x_fit[:,-3,:,:] = data_x_fit[:,-3,:,:]/np.max(data_x_fit[:,-3,:,:])\n",
    "data_x_fit[:,-2,:,:] = data_x_fit[:,-2,:,:]/np.max(data_x_fit[:,-2,:,:])\n",
    "\n",
    "x_in = data_x_fit.transpose((0,2,3,1))\n",
    "SG = data_sg.transpose((0,2,3,1))\n",
    "\n",
    "x_in = x_in.astype(np.float32)\n",
    "SG = SG.astype(np.float32)\n",
    "\n",
    "x_in = torch.from_numpy(x_in)\n",
    "SG = torch.from_numpy(SG)\n",
    "\n",
    "print('Checkpoint 4')\n",
    "\n",
    "# a input u output\n",
    "train_a = x_in[:train_nr,:,:,:]\n",
    "train_u = SG[:train_nr,:,:,:]\n",
    "\n",
    "test_a = x_in[train_nr:train_nr+ test_nr,:,:,:]\n",
    "test_u = SG[train_nr:train_nr+ test_nr,:,:,:]\n",
    "\n",
    "T = 24\n",
    "\n",
    "train_a = train_a[:,:,:,np.newaxis,:]\n",
    "test_a = test_a[:,:,:,np.newaxis,:]\n",
    "\n",
    "train_a = train_a.repeat([1,1,1,T,1])\n",
    "test_a = test_a.repeat([1,1,1,T,1])\n",
    "\n",
    "print('Checkpoint 5')\n",
    "\n",
    "t = np.cumsum(np.power(1.421245, range(24)))\n",
    "t /= np.max(t)\n",
    "for i in range(24):\n",
    "    train_a[:,:,:,i,-1] = t[i]\n",
    "    test_a[:,:,:,i,-1] = t[i]\n",
    "    \n",
    "train_a_SG = train_a\n",
    "test_a_SG = test_a\n",
    "train_u_SG = train_u\n",
    "test_u_SG = test_u\n",
    "    \n",
    "print('Checkpoint 6')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7c0ba1df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.1323901246254815\n",
      "9.17773280445466\n",
      "Checkpoint 2\n",
      "Checkpoint 3\n",
      "Checkpoint 4\n",
      "Checkpoint 5\n",
      "Checkpoint 6\n"
     ]
    }
   ],
   "source": [
    "# PRESSURE BUILDUP ---------------------------------------------------\n",
    "data_dP_shale = data_P_shale - data_P_init_shale\n",
    "\n",
    "# Z-Score Normalization\n",
    "dP_mean = np.mean(data_dP_shale)\n",
    "dP_std = np.std(data_dP_shale)\n",
    "print(dP_mean)\n",
    "print(dP_std)\n",
    "\n",
    "data_dP_shale = (data_dP_shale - dP_mean)/(dP_std)\n",
    "\n",
    "data_x = np.concatenate([data_x_shale], axis=0)\n",
    "data_dP = np.concatenate([data_dP_shale], axis=0)\n",
    "\n",
    "data_nr = data_x.shape[0]\n",
    "test_nr = 100\n",
    "train_nr = data_nr - test_nr\n",
    "\n",
    "np.random.seed(0)\n",
    "shuffle_index = np.random.choice(data_nr, data_nr, replace=False)\n",
    "\n",
    "data_x = data_x[shuffle_index, ...]\n",
    "data_dP = data_dP[shuffle_index, ...]\n",
    "\n",
    "print('Checkpoint 2')\n",
    "\n",
    "idx = [0,6,12,18,19,20,21,22,23]\n",
    "data_x_fit = np.zeros((data_x.shape[0], len(idx)+3, 96, 200))\n",
    "for j, index in enumerate(idx):\n",
    "    data_x_fit[:,j,:,:] = data_x[:,index,:,:]\n",
    "\n",
    "print('Checkpoint 3')\n",
    "    \n",
    "dz = 2.083330\n",
    "dx = [0.1]\n",
    "\n",
    "with open('DRV.txt') as f:\n",
    "    for line in f:\n",
    "        line = line.strip().split('*')\n",
    "        dx.append(float(line[-1]))\n",
    "dx = np.cumsum(dx)\n",
    "grid_x = dx/np.max(dx)\n",
    "grid_x = grid_x[1:]\n",
    "grid_y = np.linspace(0, 200, 96)/np.max(dx)\n",
    "\n",
    "data_x_fit[:,-3,:,:] = grid_x[np.newaxis, np.newaxis, :]\n",
    "data_x_fit[:,-2,:,:] = grid_y[np.newaxis, :, np.newaxis]\n",
    "data_x_fit[:,-1,:,:] = np.ones(data_x_fit[:,-1,:,:].shape)\n",
    "\n",
    "data_x_fit[:,-3,:,:] = data_x_fit[:,-3,:,:]/np.max(data_x_fit[:,-3,:,:])\n",
    "data_x_fit[:,-2,:,:] = data_x_fit[:,-2,:,:]/np.max(data_x_fit[:,-2,:,:])\n",
    "\n",
    "x_in = data_x_fit.transpose((0,2,3,1))\n",
    "dP = data_dP.transpose((0,2,3,1))\n",
    "\n",
    "x_in = x_in.astype(np.float32)\n",
    "dP = dP.astype(np.float32)\n",
    "\n",
    "x_in = torch.from_numpy(x_in)\n",
    "dP = torch.from_numpy(dP)\n",
    "\n",
    "print('Checkpoint 4')\n",
    "\n",
    "# [3616, 96, 200, 12] = [num reservoirs, vertical length, lateral length, 12 parameters]\n",
    "# [3616, 96, 200, 12] = [..., ..., ..., 24 time steps for prediction]\n",
    "\n",
    "# a input u output\n",
    "train_a = x_in[:train_nr,:,:,:]\n",
    "train_u = dP[:train_nr,:,:,:]\n",
    "\n",
    "test_a = x_in[train_nr:train_nr+ test_nr,:,:,:]\n",
    "test_u = dP[train_nr:train_nr+ test_nr,:,:,:]\n",
    "\n",
    "T = 24\n",
    "\n",
    "train_a = train_a[:,:,:,np.newaxis,:]\n",
    "test_a = test_a[:,:,:,np.newaxis,:]\n",
    "\n",
    "train_a = train_a.repeat([1,1,1,T,1])\n",
    "test_a = test_a.repeat([1,1,1,T,1])\n",
    "\n",
    "print('Checkpoint 5')\n",
    "\n",
    "t = np.cumsum(np.power(1.421245, range(24)))\n",
    "t /= np.max(t)\n",
    "for i in range(24):\n",
    "    train_a[:,:,:,i,-1] = t[i]\n",
    "    test_a[:,:,:,i,-1] = t[i]\n",
    "    \n",
    "train_a_dP = train_a\n",
    "test_a_dP = test_a\n",
    "train_u_dP = train_u\n",
    "test_u_dP = test_u\n",
    "\n",
    "print('Checkpoint 6')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2010c8e",
   "metadata": {},
   "source": [
    "# Initialize helper function for plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "57c9e917",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plotMasked(position, x_in, X, Y, data, cbarlim):\n",
    "    mask = x_in != 0\n",
    "    thickness = sum(mask[:,0])\n",
    "    axsObj = fig.add_axes(position)\n",
    "    myplot = axsObj.pcolor(X[:thickness, :200], Y[:thickness, :200], \n",
    "                           np.flipud(data[mask].reshape((thickness, -1))), \n",
    "                           shading='auto')\n",
    "    axsObj.set_xlim(0, 5000)\n",
    "    #axsObj.set_aspect(10)\n",
    "    \n",
    "    axsObj.set_position(position)\n",
    "    \n",
    "    if position[1] > 0.5: # top row\n",
    "        position[0] = position[0] + 0.05\n",
    "    else: # bottom row\n",
    "        position[0] = position[0] + 0.08\n",
    "        \n",
    "    cbaraxes = fig.add_axes(position)\n",
    "    cbaraxes.set_axis_off()\n",
    "    cbar = fig.colorbar(myplot, ax=cbaraxes)\n",
    "    if cbarlim != None:\n",
    "        myplot.set_clim(cbarlim)\n",
    "    \n",
    "    return axsObj"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03192011",
   "metadata": {},
   "source": [
    "# Plot figure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9b4d92f8",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 15 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 475\n",
    "    \n",
    "fig = plt.figure(figsize=(12, 4))\n",
    "plt.rcParams.update({'font.size':13})\n",
    "\n",
    "plt.jet()\n",
    "x = train_a_SG[n, :, :, 0, 0]\n",
    "dx = np.cumsum(3.5938*np.power(1.035012, range(200))) + 0.1\n",
    "X, Y = np.meshgrid(dx, np.linspace(0,200,num = 96))\n",
    "\n",
    "# POSITIONING\n",
    "# x_start, y_start, x_length, y_length. relative to bottom left corner. units are size of entire figure\n",
    "wspace_top = 0.32\n",
    "wspace_bot = 0.47\n",
    "figlen_top = 0.22\n",
    "figlen_bot = 0.39\n",
    "fighei_top = 0.20\n",
    "fighei_bot = 0.28\n",
    "pos0 = [None] * 3 # initialize array containing None x3\n",
    "pos1 = [None] * 2\n",
    "pos0[0] = [0.07, 0.7, figlen_top, fighei_top]\n",
    "pos0[1] = [0.07 + wspace_top, 0.7, figlen_top, fighei_top]\n",
    "pos0[2] = [0.07 + 2*wspace_top, 0.7, figlen_top, fighei_top]\n",
    "pos1[0] = [0.07, 0.15, figlen_bot, fighei_bot]\n",
    "pos1[1] = [0.07 + wspace_bot, 0.15, figlen_bot, fighei_bot]\n",
    "\n",
    "# TOP ROW OF PLOTS\n",
    "\n",
    "axs00 = plotMasked(pos0[0], x, X, Y, np.log(np.exp(train_a_SG[n, :, :, 0, 0]*15)), None)\n",
    "axs00.set_title(\"ln($k_r$) (log mD)\")\n",
    "axs00.set_xlabel(\"$r$ (m)\")\n",
    "axs00.set_ylabel(\"$z$ (m)\")\n",
    "\n",
    "axs01 = plotMasked(pos0[1], x, X, Y, np.log(np.exp(train_a_SG[n, :, :, 0, 1]*15)), None)\n",
    "axs01.set_title(\"ln($k_z$) (log mD)\")\n",
    "axs01.set_xlabel(\"$r$ (m)\")\n",
    "axs01.set_yticks([])\n",
    "\n",
    "axs02 = plotMasked(pos0[2], x, X, Y, train_a_SG[n, :, :, 0, 2], None)\n",
    "axs02.set_title(\"$\\phi$ (-)\")\n",
    "axs02.set_xlabel(\"$r$ (m)\")\n",
    "axs02.set_yticks([])\n",
    "\n",
    "# BOTTOM ROW OF PLOTS\n",
    "\n",
    "axs10 = plotMasked(pos1[0], x, X, Y, train_u_SG[n, :, :, -1] * SG_std + SG_mean, [0, 1])\n",
    "axs10.set_title(\"$SG$ (-), $t = 30y$\")\n",
    "axs10.set_xlabel(\"$r$ (m)\")\n",
    "axs10.set_ylabel(\"$z$ (m)\")\n",
    "\n",
    "cmax = torch.max(train_u_dP[n, :, :, -1] * dP_std + dP_mean).item()\n",
    "axs11 = plotMasked(pos1[1], x, X, Y, train_u_dP[n, :, :, -1] * dP_std + dP_mean, [0, cmax])\n",
    "axs11.set_title(\"$dP$ (bar), $t = 30y$\")\n",
    "axs11.set_xlabel(\"$r$ (m)\")\n",
    "axs11.set_yticks([])\n",
    "\n",
    "# fig.savefig('_paper_datasetExample.png', dpi=300)\n",
    "fig.show()"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}