{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interactive Multiple Point Simulation\n",
    "\n",
    "Michael J. Pyrcz, Professor, The University of Texas at Austin \n",
    "\n",
    "[Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [Applied Geostats in Python e-book](https://geostatsguy.github.io/GeostatsPyDemos_Book/intro.html) | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)\n",
    "\n",
    "This interactive Python dashboard is part of my interactive dashboard collection, as GitHub repo DataScienceInteractivePython. \n",
    "\n",
    "```{admonition} Cite the DataScienceInteractivePython GitHub Repository as:\n",
    ":class: remove-from-content-only\n",
    "\n",
    "Pyrcz, Michael J. (2021). DataScienceInteractivePython: Educational Data Science Interactive Python Dashboards Repository (0.0.1). Zenodo. https://doi.org/10.5281/zenodo.5564966\n",
    "\n",
    "```\n",
    "\n",
    "By Michael J. Pyrcz <br />\n",
    "&copy; Copyright 2024."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This chapter is a tutorial for / demonstration of  **Multiple Point Simulation** for simulating spatial categorical features, e.g., like facies. \n",
    "\n",
    "* specifically we use multiple point simulation to simulate categorical features and to produce models with heterogeneities more complicated than variogram-based methods.\n",
    "\n",
    "**YouTube Lecture**: check out my lectures on:\n",
    "\n",
    "* TBD\n",
    "\n",
    "For your convenience here's a summary of salient points.\n",
    "\n",
    "\n",
    "\n",
    "#### Load the Required libraries\n",
    "\n",
    "The following code loads the required libraries. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GeostatsPy version: 0.0.79\n"
     ]
    }
   ],
   "source": [
    "import geostatspy.GSLIB as GSLIB                              # GSLIB utilities, visualization and wrapper\n",
    "import geostatspy.geostats as geostats                        # GSLIB methods convert to Python      \n",
    "import geostatspy\n",
    "print('GeostatsPy version: ' + str(geostatspy.__version__))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will also need some standard packages. These should have been installed with Anaconda 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os                                                     # set working directory, run executables\n",
    "\n",
    "from tqdm import tqdm                                         # suppress the status bar\n",
    "from functools import partialmethod\n",
    "tqdm.__init__ = partialmethod(tqdm.__init__, disable=True)\n",
    "\n",
    "ignore_warnings = True                                        # ignore warnings?\n",
    "import numpy as np                                            # ndarrays for gridded data\n",
    "import pandas as pd                                           # DataFrames for tabular data\n",
    "import matplotlib.pyplot as plt                               # for plotting\n",
    "import matplotlib.patches as patches\n",
    "import matplotlib as mpl                                      # custom colorbar\n",
    "import matplotlib.patches as mpatches                         # categorical legend\n",
    "\n",
    "from ipywidgets import interactive                            # widgets and interactivity\n",
    "from ipywidgets import widgets                            \n",
    "from ipywidgets import Layout\n",
    "from ipywidgets import Label\n",
    "from ipywidgets import VBox, HBox\n",
    "\n",
    "from matplotlib.colors import LinearSegmentedColormap         \n",
    "from matplotlib.ticker import (MultipleLocator, AutoMinorLocator) # control of axes ticks\n",
    "plt.rc('axes', axisbelow=True)                                # plot all grids below the plot elements\n",
    "if ignore_warnings == True:                                   \n",
    "    import warnings\n",
    "    warnings.filterwarnings('ignore')\n",
    "cmap = plt.cm.inferno                                         # color map\n",
    "seed = 42"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you get a package import error, you may have to first install some of these packages. This can usually be accomplished by opening up a command window on Windows and then typing 'python -m pip install [package-name]'. More assistance is available with the respective package docs. \n",
    "\n",
    "#### Define Functions\n",
    "\n",
    "This is a convenience function to add major and minor gridlines and a combine location map and pixelplot that has color maps and color bars to improve plot interpretability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_grid():\n",
    "    plt.gca().grid(True, which='major',linewidth = 1.0); plt.gca().grid(True, which='minor',linewidth = 0.2) # add y grids\n",
    "    plt.gca().tick_params(which='major',length=7); plt.gca().tick_params(which='minor', length=4)\n",
    "    plt.gca().xaxis.set_minor_locator(AutoMinorLocator()); plt.gca().yaxis.set_minor_locator(AutoMinorLocator()) # turn on minor ticks  \n",
    "    \n",
    "def locpix_colormaps_st(array,xmin,xmax,ymin,ymax,step,vmin,vmax,df,xcol,ycol,vcol,title,xlabel,ylabel,vlabel_loc,vlabel,cmap_loc,cmap):\n",
    "    xx, yy = np.meshgrid(\n",
    "        np.arange(xmin, xmax, step), np.arange(ymax, ymin, -1 * step)\n",
    "    )\n",
    "    cs = plt.imshow(array,interpolation = None,extent = [xmin,xmax,ymin,ymax], vmin = vmin, vmax = vmax,cmap = cmap)\n",
    "    plt.scatter(df[xcol],df[ycol],s=None,c=df[vcol],marker=None,cmap=cmap_loc,vmin=vmin,vmax=vmax,alpha=0.8,linewidths=0.8,\n",
    "        edgecolors=\"black\",)\n",
    "    plt.title(title); plt.xlabel(xlabel); plt.ylabel(ylabel); plt.xlim(xmin, xmax); plt.ylim(ymin, ymax)\n",
    "    cbar_loc = plt.colorbar(orientation=\"vertical\",pad=0.08,ticks=[0, 1],\n",
    "            format=mticker.FixedFormatter(['Shale','Sand'])); cbar_loc.set_label(vlabel_loc, rotation=270,labelpad=20)\n",
    "    cbar = plt.colorbar(cs,orientation=\"vertical\",pad=0.05); cbar.set_label(vlabel, rotation=270,labelpad=20)\n",
    "    return cs\n",
    "\n",
    "def remove_unsimulated_cells_fixed(mini_model, df,nx, ny,xmin, xmax, ymin, ymax,n_unsim,seed=42):\n",
    "    rng = np.random.default_rng(seed); dx = (xmax - xmin) / nx; dy = (ymax - ymin) / ny # convert coordinates → grid indices\n",
    "    ix = ((df[\"X\"].to_numpy() - xmin) / dx).astype(int); iy = ((df[\"Y\"].to_numpy() - ymin) / dy).astype(int) \n",
    "    \n",
    "    ix = np.clip(ix, 0, nx - 1); iy = np.clip(iy, 0, ny - 1)\n",
    "    iy_np = (ny - 1) - iy                                     # flip y-axis for numpy indexing\n",
    "\n",
    "    occupied = np.zeros((ny, nx), dtype=bool)                 # check for occupied grid node (with data)\n",
    "    occupied[iy_np, ix] = True\n",
    "    empty_cells = np.argwhere(~occupied)\n",
    "\n",
    "    if len(empty_cells) == 0:\n",
    "        raise ValueError(\"No empty cells available.\")\n",
    "\n",
    "    perm = rng.permutation(len(empty_cells))                  # fix random path ordering\n",
    "\n",
    "    if n_unsim > len(empty_cells):\n",
    "        raise ValueError(\"n_unsim exceeds number of empty cells\")\n",
    "\n",
    "    remove_cells = empty_cells[perm[:n_unsim]]                # apply removal\n",
    "    out = mini_model.copy()       \n",
    "    for j, i in remove_cells:\n",
    "        out[j, i] = np.nan\n",
    "\n",
    "    return out, remove_cells, empty_cells[perm]\n",
    "\n",
    "def plot_mps_template(grid,template,ix, iy,xmin, xmax, ymin, ymax,title, plot_template, cmap, ax): # visualize template, return effective template\n",
    "    ny, nx = grid.shape                                       # define grid \n",
    "    dx = (xmax - xmin) / nx; dy = (ymax - ymin) / ny\n",
    "    if plot_template:\n",
    "        im = ax.imshow(grid,extent=[xmin, xmax, ymin, ymax],cmap=cmap,alpha=0.85) # plot grid \n",
    "    effective_template = []                                   # build effective template (drop NaNs in grid)\n",
    "\n",
    "    for k, (dix, diy) in enumerate(template):\n",
    "        j = iy + diy; i = ix + dix\n",
    "        if i < 0 or i >= nx or j < 0 or j >= ny:              # skip out-of-bounds\n",
    "            continue\n",
    "        if np.isnan(grid[j, i]):                              # skip unsimulated (NaN) nodes in grid\n",
    "            continue\n",
    "        effective_template.append((dix, diy))                 # draw only valid nodes\n",
    "        x0 = xmin + i * dx; y0 = ymin + ((ny - j) - 1) * dy\n",
    "\n",
    "        if plot_template:\n",
    "            rect = patches.Rectangle((x0, y0),dx, dy,linewidth=2,edgecolor=\"black\",facecolor=\"none\")\n",
    "            ax.add_patch(rect)\n",
    "            if k > 0:\n",
    "                ax.text(x0 + dx / 2,y0 + dy / 2,str(k),ha=\"center\",va=\"center\",fontsize=10,color=\"white\",\n",
    "                    fontweight=\"bold\",zorder=100)\n",
    "                \n",
    "    if plot_template:\n",
    "        cx = xmin + ix * dx; cy = ymin + ((ny - iy) - 1) * dy     # center node\n",
    "        rect = patches.Rectangle((cx, cy),dx, dy,linewidth=2,edgecolor=\"red\",facecolor=\"none\")\n",
    "        ax.add_patch(rect)\n",
    "        ax.set_title(title); ax.set_xlabel(\"X\"); ax.set_ylabel(\"Y\")\n",
    "        cbar = plt.colorbar(im, ticks=[0, 1]); cbar.ax.set_yticklabels([\"Shale\", \"Sand\"]); cbar.set_label(\"Facies\")\n",
    "    return effective_template\n",
    "    \n",
    "def find_template_matches_TI(sim,TI,template,ix,iy,plot,title,cmap,ax): # find TI locations matching SIM-based conditioning pattern.\n",
    "    ny, nx = TI.shape\n",
    "    ref_pattern = []                                          # extract conditioning pattern from SIM\n",
    "    for dix, diy in template:\n",
    "        i_sim = ix + dix\n",
    "        j_sim = iy + diy\n",
    "        if i_sim < 0 or i_sim >= nx or j_sim < 0 or j_sim >= ny:\n",
    "            return None, None\n",
    "        ref_pattern.append(sim[j_sim, i_sim])\n",
    "    ref_pattern = np.array(ref_pattern)\n",
    "\n",
    "    matches = []                                              # scan for data event matches in TI\n",
    "    for j in range(ny):\n",
    "        for i in range(nx):\n",
    "            ok = True\n",
    "            for k, (dix, diy) in enumerate(template):\n",
    "                if dix == 0 and diy == 0:\n",
    "                    continue                   \n",
    "                jj = j + diy\n",
    "                ii = i + dix\n",
    "                if ii < 0 or ii >= nx or jj < 0 or jj >= ny:\n",
    "                    ok = False\n",
    "                    break\n",
    "                if TI[jj, ii] != ref_pattern[k]:\n",
    "                    ok = False\n",
    "                    break\n",
    "            if ok:\n",
    "                matches.append((j, i))\n",
    "    matches = np.array(matches)\n",
    "\n",
    "    if len(matches) > 0:                                      # compute proportions\n",
    "        values = TI[matches[:, 0], matches[:, 1]]\n",
    "        p0 = np.mean(values == 0); p1 = np.mean(values == 1)\n",
    "    else:\n",
    "        p0, p1 = np.nan, np.nan\n",
    "\n",
    "    if plot:                                                  # plot\n",
    "        im = ax.imshow(TI, cmap=cmap,extent=[xmin, xmax, ymin, ymax],alpha=0.85)\n",
    "        x0_matches = xmin + matches[:,1] * cell_size + cell_size*0.5\n",
    "        y0_matches = ymin + ((ny - matches[:,0]) - 1) * cell_size + cell_size*0.5    \n",
    "        if len(matches) > 0:\n",
    "            ax.scatter(x0_matches, y0_matches,c=\"red\", s=20, label=\"matches\")         \n",
    "        ax.set_title(title); ax.set_xlabel(\"X\"); ax.set_ylabel(\"Y\")\n",
    "        cbar = plt.colorbar(im, ticks=[0, 1]); cbar.ax.set_yticklabels([\"Shale\", \"Sand\"])\n",
    "        cbar.set_label(\"Facies\")\n",
    "        \n",
    "    return matches, {\"facies_0\": p0, \"facies_1\": p1}\n",
    "\n",
    "def template_match_probs_drop(sim, TI, template, ix, iy):\n",
    "\n",
    "    ny, nx = TI.shape\n",
    "    template = list(template)\n",
    "    if len(template) == 0:                                    # no conditioning data → global TI prior\n",
    "        vals = TI.ravel()\n",
    "        return np.mean(vals == 0), np.mean(vals == 1), vals.size, []\n",
    "\n",
    "    def compute_probs(current_template):\n",
    "        ref = []                                              # build data event from SIM (conditioning)\n",
    "        for dix, diy in current_template:\n",
    "            ii = ix + dix\n",
    "            jj = iy + diy\n",
    "            if ii < 0 or ii >= nx or jj < 0 or jj >= ny:\n",
    "                return np.nan, np.nan, 0\n",
    "            ref.append(sim[jj, ii])\n",
    "        ref = np.array(ref)\n",
    "        mask = np.ones((ny, nx), dtype=bool)                  # scan TI for matching patterns\n",
    "\n",
    "        for k, (dix, diy) in enumerate(current_template):\n",
    "            j0_src = max(0, -diy)\n",
    "            j1_src = min(ny, ny - diy)\n",
    "            i0_src = max(0, -dix)\n",
    "            i1_src = min(nx, nx - dix)\n",
    "\n",
    "            j0_dst = j0_src + diy\n",
    "            j1_dst = j1_src + diy\n",
    "            i0_dst = i0_src + dix\n",
    "            i1_dst = i1_src + dix\n",
    "\n",
    "            comp = np.zeros((ny, nx), dtype=bool)\n",
    "            comp[j0_src:j1_src, i0_src:i1_src] = (TI[j0_dst:j1_dst, i0_dst:i1_dst] == ref[k])\n",
    "            mask &= comp\n",
    "            if not mask.any():\n",
    "                return np.nan, np.nan, 0\n",
    "        vals = TI[mask]\n",
    "\n",
    "        if vals.size == 0:\n",
    "            return np.nan, np.nan, 0\n",
    "        return np.mean(vals == 0), np.mean(vals == 1), vals.size\n",
    "        \n",
    "    current_template = template.copy()                         # progressive template reduction\n",
    "\n",
    "    while len(current_template) > 0:\n",
    "        p0, p1, nmatch = compute_probs(current_template)\n",
    "        if nmatch > 0:\n",
    "            return p0, p1, nmatch, current_template\n",
    "        current_template = current_template[:-1]\n",
    "    vals = TI.ravel()                                          # fallback: global TI statistics\n",
    "    return np.mean(vals == 0), np.mean(vals == 1), vals.size, []\n",
    "\n",
    "def plot_mps_pie(n_matches, proportions, ax,labels=(\"shale\", \"sand\"),colors=(\"lightgrey\", \"gold\"),\n",
    "    title=\"TI Match Proportions\"):\n",
    "    if n_matches == 0 or np.isnan(proportions[\"facies_0\"]):    # handle empty case\n",
    "        ax.text(0.5, 0.5, \"No Matches\",\n",
    "                ha=\"center\", va=\"center\",\n",
    "                fontsize=12)\n",
    "        ax.set_axis_off()\n",
    "        return\n",
    "\n",
    "    p0 = proportions[\"facies_0\"]; p1 = proportions[\"facies_1\"] # calculate probabilities\n",
    "    sizes = [p0, p1]\n",
    "    counts = [int(round(p0 * n_matches)),int(round(p1 * n_matches))] # convert to counts\n",
    "\n",
    "    def make_autopct(counts):                                  # autopct formatter (percent + count)\n",
    "        def autopct(pct):\n",
    "            idx = autopct.idx\n",
    "            text = f\"{pct:.1f}%\\n(n={counts[idx]})\"\n",
    "            autopct.idx += 1\n",
    "            return text\n",
    "        autopct.idx = 0\n",
    "        return autopct\n",
    "\n",
    "    radius = 0.3 + 0.7 * min(n_matches / 50.0, 1.0)            # scale pie size by support\n",
    "\n",
    "    ax.pie(sizes,labels=labels,colors=colors,startangle=90,autopct=make_autopct(counts), # plot\n",
    "           radius=radius,wedgeprops={\"edgecolor\": \"black\"})\n",
    "    ax.set_title(f\"{title}\\nN={n_matches}\", fontsize=10)\n",
    "\n",
    "def plot_simulated(grid,ix,iy,proportions,xmin,xmax,ymin,ymax,title,cmap,ax):\n",
    "    ny, nx = grid.shape\n",
    "    dx = (xmax - xmin) / nx\n",
    "    dy = (ymax - ymin) / ny\n",
    "\n",
    "    p1 = proportions[\"facies_1\"]\n",
    "    realization = int(np.random.random() < p1)\n",
    "\n",
    "    new_grid = np.copy(grid)\n",
    "    new_grid[iy,ix] = realization  \n",
    "    \n",
    "    im = ax.imshow(new_grid,extent=[xmin, xmax, ymin, ymax],cmap=cmap,alpha=0.85) # plot updated realization\n",
    "\n",
    "    x0 = xmin + ix * dx; y0 = ymin + ((ny - iy) - 1) * dy\n",
    "    rect = patches.Rectangle((x0, y0),dx, dy,linewidth=2,edgecolor=\"red\",facecolor=\"none\") # outline new realization\n",
    "    ax.add_patch(rect)\n",
    "    ax.set_title(title); ax.set_xlabel(\"X (m)\"); ax.set_ylabel(\"Y (m)\")\n",
    "    cbar = plt.colorbar(im, ticks=[0, 1]); cbar.ax.set_yticklabels([\"Shale\", \"Sand\"])\n",
    "    cbar.set_label(\"Facies\")\n",
    "\n",
    "def copy_truth_values(cur_sim,truth,unsim,iunsim):            # copy truth values as \"previously simulated nodes\", mimic partially simulated\n",
    "    n = min(iunsim, len(unsim))                               # safety check\n",
    "    for k in range(n-1):\n",
    "        iy, ix = unsim[k]\n",
    "        cur_sim[iy, ix] = truth[iy, ix]\n",
    "    return cur_sim\n",
    "\n",
    "def copy_truth_values(cur_sim,truth,unsim,iunsim):            # copy truth values as \"previously simulated nodes\", mimic partially simulated\n",
    "    n = min(iunsim, len(unsim))                               # safety check\n",
    "    for k in range(n-1):\n",
    "        iy, ix = unsim[k]\n",
    "        cur_sim[iy, ix] = truth[iy, ix]\n",
    "    return cur_sim\n",
    "\n",
    "def sample_facies(matches_dict):                              # draws a random 0 or 1 based on the facies probabilities in the dictionary.\n",
    "    outcomes = [0, 1]                                         # define the output choices corresponding to facies_0 and facies_1\n",
    "    probabilities = [matches_dict['facies_0'], matches_dict['facies_1']] # extract probabilities from the specific keys\n",
    "    return np.random.choice(outcomes, p=probabilities)        # return a single random selection\n",
    "\n",
    "\n",
    "def sample_facies_fast(p0,p1):                                # draws a random 0 or 1 based on the facies probabilities in the dictionary.\n",
    "    outcomes = [0, 1]                                         # define the output choices corresponding to facies_0 and facies_1\n",
    "    probabilities = [p0,p1] # extract probabilities from the specific keys\n",
    "    return np.random.choice(outcomes, p=probabilities)        # return a single random selection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Make Custom Colorbar\n",
    "\n",
    "We make this colorbar to display our categorical, sand and shale facies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "cmap_facies = mpl.colors.ListedColormap(['grey','gold'])      # sand and shale binary color map\n",
    "cmap_facies.set_over('white'); cmap_facies.set_under('white')\n",
    "cmap_facies_cont = LinearSegmentedColormap.from_list(\"cmap_facies_cont\",[\"grey\", \"gold\"],) # continuous color map variant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set the Working Directory\n",
    "\n",
    "I always like to do this so I don't lose files and to simplify subsequent read and writes (avoid including the full address each time). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#os.chdir(\"c:/PGE383\")                                        # set the working directory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loading Mini-model Setting\n",
    "\n",
    "Since I have not developed an efficient MPS simulation routine, I'm using the brute force method based on a complete scan of the training image for every local simulation, we work with a,\n",
    "\n",
    "* small model, $n_x = 30$, $n_y = 20$\n",
    "\n",
    "* training image, $n_x = 30$, $n_y = 20$\n",
    "\n",
    "* data set, $n_{data} = 20$\n",
    "\n",
    "Here's the,\n",
    "\n",
    "* **truth model** (truth) - an exhaustive model that we extracted the data from that has similar spatial continuity as the training image (they are both extracted from different locations of the same larger model). I used this exhaustive truth model to ensure data and training image consistency (avoiding spatial contradictions). If your computer is slow, you can set, $n_unsim$ below to a number less than 580 ($n_x \\times n_y - n_{data}$) and truth model values will be assigned as previously simulated nodes along the random path. \n",
    "\n",
    "* **training image** (TI) - once again, extracted from the same larger model as the truth model, it has consistent patterns with the simulation (from truth model) and the data (also from the truth model). Remember the training image has no data conditioning nor local information, i.e., it is an exhaustive model with the correct spatial correlation structures.\n",
    "\n",
    "* **data set** (df) - extracted from the truth model, and below it is initialized to the simulation model (as is the first step with geostatistical sequential simulation).\n",
    "\n",
    "Warning, for this demonstration we are assuming the simulation grid, truth grid and training image grid are all the same (same $n_x$ and $n_y$ and extents). \n",
    "\n",
    "* in practice the training image and simuulate grid must have the same cell sizes, but may have different number of cells ($n_x$ and $n_y$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.read_csv(\"https://raw.githubusercontent.com/GeostatsGuy/GeoDataSets/master/2D_facies_minimodel_wells.csv\") # load all from Dr. Pyrcz's GitHub \n",
    "truth = np.loadtxt(fname=\"https://raw.githubusercontent.com/GeostatsGuy/GeoDataSets/master/2D_facies_minimodel_array.csv\", delimiter=\",\")  \n",
    "TI = np.loadtxt(fname=\"https://raw.githubusercontent.com/GeostatsGuy/GeoDataSets/master/2D_facies_minimodel_array_v2.csv\", delimiter=\",\")  \n",
    "import geostatspy.GSLIB as GSLIB                              # GSLIB utilities, visualization and wrapper\n",
    "ny, nx = truth.shape                                          # get the mini-model grid parameters\n",
    "cell_size = 10.0; xmin = 0.0; ymin = 0.0\n",
    "xmax = xmin + nx*cell_size; ymax = ymin + ny*cell_size; \n",
    "\n",
    "plt.subplot(121)                                               # visualize the truth model with data, and the training image\n",
    "cs = plt.imshow(truth,interpolation = None,extent = [xmin,xmax,ymin,ymax], vmin = 0.0, vmax = 1.0,alpha = 0.3,cmap = cmap_facies)      \n",
    "x_edges = np.linspace(xmin, xmax, nx+1); y_edges = np.linspace(ymin, ymax, ny+1)\n",
    "plt.vlines(x_edges, ymin, ymax, colors=\"k\", linewidth=0.2, alpha=0.5) # horizontal andd vertical grid lines\n",
    "plt.hlines(y_edges, xmin, xmax, colors=\"k\", linewidth=0.2, alpha=0.5)\n",
    "\n",
    "plt.scatter(df['X'],df['Y'],s=None,c=df['Facies'],marker=None,cmap=cmap_facies,vmin=0.0,vmax=1.0,\n",
    "    alpha=0.8,linewidths=0.8,edgecolors=\"black\",)\n",
    "\n",
    "cbar = plt.colorbar(cs, ticks=[0, 1])\n",
    "cbar.ax.set_yticklabels([\"Shale\", \"Sand\"])\n",
    "cbar.set_label(\"Facies\")\n",
    "\n",
    "plt.title('Inaccessible Truth Model and Data'); plt.xlabel('X (m)'); plt.ylabel('Y (m)'); plt.tight_layout()\n",
    "\n",
    "plt.subplot(122)\n",
    "cs = plt.imshow(TI,interpolation = None,extent = [xmin,xmax,ymin,ymax], vmin = 0.0, vmax = 1.0,cmap = cmap_facies)\n",
    "plt.vlines(x_edges, ymin, ymax, colors=\"k\", linewidth=0.2, alpha=0.5) # horizontal andd vertical grid lines\n",
    "plt.hlines(y_edges, xmin, xmax, colors=\"k\", linewidth=0.2, alpha=0.5)\n",
    "\n",
    "cbar = plt.colorbar(cs, ticks=[0, 1])\n",
    "cbar.ax.set_yticklabels([\"Shale\", \"Sand\"])\n",
    "cbar.set_label(\"Facies\")\n",
    "\n",
    "plt.title('Training Image'); plt.xlabel('X (m)'); plt.ylabel('Y (m)'); plt.tight_layout()\n",
    "\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=2.2, top=0.7, wspace=0.00, hspace=0.1); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set Up the Circumstances for a Step in Multiple Point Simulation\n",
    "\n",
    "Now to illustrate multiple point simulation, let's,\n",
    "\n",
    "1. make a copy of the truth model\n",
    "\n",
    "2. remove a random set of values from the truth model (not at data locations)\n",
    "\n",
    "Now we have the circumstances in the middle of the calculation of a multiple point simulation,\n",
    "\n",
    "* data are assigned to nearest grid nodes and are immutable\n",
    "\n",
    "* previously simulated values are assigned to grid and treated as data\n",
    "\n",
    "* unsimulated values (future steps on the random path) are unsimulated (unassigned at this step)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_unsim = 580                                             # number of unsimulated nodes in model (580 for only data in grid)\n",
    "total_step = nx*ny - len(df)\n",
    "step = total_step - n_unsim\n",
    "\n",
    "sim, unsim, cells_empty  = remove_unsimulated_cells_fixed(truth,df,nx,ny,xmin,xmax,ymin,ymax,n_unsim,seed=seed) # assign unsimulated\n",
    "\n",
    "plt.subplot(111)                                               # visualize current step in MPS sequential path\n",
    "cs = plt.imshow(sim,interpolation = None,extent = [xmin,xmax,ymin,ymax], vmin = 0.0, vmax = 1.0,cmap = cmap_facies)\n",
    "plt.vlines(x_edges, ymin, ymax, colors=\"k\", linewidth=0.2, alpha=0.5) # horizontal andd vertical grid lines\n",
    "plt.hlines(y_edges, xmin, xmax, colors=\"k\", linewidth=0.2, alpha=0.5)\n",
    "\n",
    "plt.scatter(df['X'],df['Y'],s=None,c=df['Facies'],marker=None,cmap=cmap_facies,vmin=0.0,vmax=1.0,\n",
    "    alpha=0.8,linewidths=0.8,edgecolors=\"black\",)\n",
    "\n",
    "cbar = plt.colorbar(cs, ticks=[0, 1]); cbar.ax.set_yticklabels([\"Shale\", \"Sand\"])\n",
    "cbar.set_label(\"Facies\")\n",
    "\n",
    "for i, (iy, ix) in enumerate(unsim):                       # label random path in node centers\n",
    "    k = nx*ny - (n_unsim - i) - 1\n",
    "    x0 = xmin + ix * cell_size\n",
    "    y0 = ymin + ((ny - iy) - 1) * cell_size\n",
    "    plt.text(x0 + cell_size / 2,y0 + cell_size / 2,str(i+1),ha=\"center\",va=\"center\",fontsize=8,color=\"black\",)\n",
    "\n",
    "plt.title('Data Assigned to Model and Random Path'); plt.xlabel('X (m)'); plt.ylabel('Y (m)'); plt.tight_layout()\n",
    "plt.subplots_adjust(left=0.0, bottom=0.0, right=1.8, top=1.2, wspace=0.2, hspace=0.2); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Interactive Multiple Point Simulation\n",
    "\n",
    "The following dashboard steps through the random path of a single realization of multiple point simulation.\n",
    "\n",
    "* set the current_node from 1 to 580\n",
    "\n",
    "The end members include,\n",
    "\n",
    "* **current_node** = 1 - simulate the first node along the random path, there are no previously simulated nodes and only the data are assigned to the simulation grid\n",
    "\n",
    "* **current_node** = 580 - simulate the last node along the random path, all other nodes are simulated "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = widgets.Text(value='                                                Multiple Point Simulation, Prof. Michael Pyrcz, The University of Texas at Austin',\n",
    "        layout=Layout(width='900px', height='30px'))\n",
    "\n",
    "current_node = widgets.IntSlider(min=1, max = 580, value=2, step = 1, description = r'Current Node:',orientation='horizontal', \n",
    "        style = {'description_width': 'initial'},layout=Layout(width='900px', height='30px'),continuous_update=False)\n",
    "\n",
    "ui_summary = widgets.HBox([current_node,],)\n",
    "ui2_summary = widgets.VBox([l,ui_summary],)\n",
    "\n",
    "def run_plot_summary(current_node):\n",
    "    np.random.seed(seed=seed)\n",
    "\n",
    "    np.random.seed(seed=seed)\n",
    "    \n",
    "    mps_template = [\n",
    "        (0, 0),   # current node\n",
    "        (-1, 0),  # left\n",
    "        (1, 0),   # right\n",
    "        (0, 1),   # up\n",
    "        (0, -1),  # down\n",
    "        (-1, -1),  # lower left\n",
    "        (-1, 1),  # upper left\n",
    "        (1, 1),  # upper right\n",
    "        (1, -1)  # lower right\n",
    "    ]\n",
    "    \n",
    "    cur_sim = np.copy(sim)\n",
    "    \n",
    "    for inode in range(0,current_node):                          # fast method for MPS over all previous nodes\n",
    "        current_loc = unsim[inode-1]\n",
    "        current_mps_template = plot_mps_template(cur_sim,mps_template,ix=current_loc[1], iy=current_loc[0],xmin=0, xmax=300,\n",
    "            ymin=0, ymax=200,title='MPS Simulation with Current Node, MPS template and Random Path',plot_template=False,cmap=cmap_facies,ax=None)\n",
    "        p0, p1, nmatch, current_template = template_match_probs_drop(cur_sim, TI, current_mps_template,ix=current_loc[1],iy=current_loc[0])\n",
    "        np.random.seed(seed=seed+inode)\n",
    "        facies = sample_facies_fast(p0,p1)\n",
    "        cur_sim[current_loc[0],current_loc[1]] = facies\n",
    "    \n",
    "    inode = current_node-1                                       # now simulate the last node with all visualizations\n",
    "    current_loc = unsim[inode]\n",
    "        \n",
    "    fig = plt.figure(figsize=(10,6))\n",
    "    \n",
    "    ax1 = plt.subplot(2, 2, 1)                                   # plot the current simulation with data event for next node\n",
    "    current_mps_template = plot_mps_template(cur_sim,mps_template,ix=current_loc[1], iy=current_loc[0],xmin=0, xmax=300,\n",
    "        ymin=0, ymax=200,title='MPS Simulation with Current Node, MPS template and Random Path',plot_template=True,cmap=cmap_facies,ax=ax1)\n",
    "    \n",
    "    for i, (iy, ix) in enumerate(unsim):                         # label the random path\n",
    "        k = nx*ny - (n_unsim - i) - 1\n",
    "        x0 = xmin + ix * cell_size; y0 = ymin + ((ny - iy) - 1) * cell_size\n",
    "        plt.text(x0 + cell_size / 2,y0 + cell_size / 2,str(i+1),ha=\"center\",va=\"center\",fontsize=6,color=\"black\",)\n",
    "    \n",
    "    x_edges = np.linspace(xmin, xmax, nx+1); y_edges = np.linspace(ymin, ymax, ny+1)\n",
    "    plt.vlines(x_edges, ymin, ymax, colors=\"k\", linewidth=0.2, alpha=0.5) # grid lines\n",
    "    plt.hlines(y_edges, xmin, xmax, colors=\"k\",linewidth=0.2, alpha=0.5) \n",
    "    plt.scatter(df['X'],df['Y'],s=None,c=df['Facies'],marker=None,cmap=cmap_facies,vmin=-0.4,vmax=1.0,alpha=0.8,\n",
    "        linewidths=0.8,edgecolors=\"black\",)\n",
    "    \n",
    "    ax2 = plt.subplot(2, 2, 2)                                   # plot the training image with all the data event matches\n",
    "    matches = find_template_matches_TI(cur_sim,TI,current_mps_template,ix=current_loc[1], iy=current_loc[0],plot=True,\n",
    "        title=\"Training Image with Data Event Matches\",ax=ax2,cmap = cmap_facies)\n",
    "    plt.vlines(x_edges, ymin, ymax, colors=\"k\", linewidth=0.2, alpha=0.5) # grid lines\n",
    "    plt.hlines(y_edges, xmin, xmax, colors=\"k\",linewidth=0.2, alpha=0.5) \n",
    "    \n",
    "    ax3 = plt.subplot(2, 2, 3)                                   # plot the observed fequencies at the matches\n",
    "    proportions = matches[1]; n_matches = len(matches[0])\n",
    "    plot_mps_pie(n_matches, proportions, ax3,labels=(\"Shale\", \"Sand\"),colors=(\"lightgrey\", \"gold\"),title=\"Training Image Data Event Proportions\")\n",
    "    \n",
    "    ax4 = plt.subplot(2, 2, 4)                                   # plot the updates simulated realization\n",
    "    plot_simulated(cur_sim,ix=current_loc[1], iy=current_loc[0],proportions=proportions,xmin=xmin,xmax=xmax,ymin=ymin,ymax=ymax,\n",
    "        title=\"MPS Simulation with Next Sequential Realization\",cmap=cmap_facies,ax=ax4)\n",
    "    \n",
    "    plt.vlines(x_edges, ymin, ymax, colors=\"k\", linewidth=0.2, alpha=0.5) # grid lines\n",
    "    plt.hlines(y_edges, xmin, xmax, colors=\"k\",linewidth=0.2, alpha=0.5) \n",
    "    \n",
    "    plt.subplots_adjust(left=0.0, bottom=0.0, right=1.5, top=1.5, wspace=0.1, hspace=0.3); plt.show()\n",
    "\n",
    "# connect the function to make the samples and plot to the widgets    \n",
    "interactive_plot_summary = widgets.interactive_output(run_plot_summary, {'current_node':current_node,})\n",
    "interactive_plot_summary.clear_output(wait = True)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0aa8175f82e642608803ea4171c4fc45",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Text(value='                                                Multiple Point Simulation, Prof. Mi…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3aa4e7abc73c4f5eaa8de94a0396c2f1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(ui2_summary, interactive_plot_summary)                           # display the interactive plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comments\n",
    "\n",
    "This was a basic demonstration of multiple point simulation with an interactive dashboard. We visualize the,\n",
    "\n",
    "* data event\n",
    "\n",
    "* matches in the training image\n",
    "\n",
    "* frequentist probabilities from the training image\n",
    "\n",
    "* updated simulation model\n",
    "\n",
    "I have many interactive dashboards to support students and working professionals, all available in my repository, [DataScienceInteractivePython](https://github.com/GeostatsGuy/DataScienceInteractivePython/tree/main).\n",
    "\n",
    "I hope this is helpful,\n",
    "\n",
    "*Michael*\n",
    "\n",
    "#### About the Author\n",
    "\n",
    "<figure style=\"text-align: center;\">\n",
    "  <img src=\"_static/intro/michael_pyrcz_officeshot_jacket.jpg\" style=\"display: block; margin: 0 auto; width: 70%;\">\n",
    "  <figcaption style=\"text-align: center;\"> Professor Michael Pyrcz in his office on the 40 acres, campus of The University of Texas at Austin.\n",
    "</figcaption>\n",
    "</figure>\n",
    "\n",
    "Michael Pyrcz is a professor in the [Cockrell School of Engineering](https://cockrell.utexas.edu/faculty-directory/alphabetical/p), and the [Jackson School of Geosciences](https://www.jsg.utexas.edu/researcher/michael_pyrcz/), at [The University of Texas at Austin](https://www.utexas.edu/), where he researches and teaches subsurface, spatial data analytics, geostatistics, and machine learning. Michael is also,\n",
    "\n",
    "* the principal investigator of the [Energy Analytics](https://fri.cns.utexas.edu/energy-analytics) freshmen research initiative and a core faculty in the Machine Learn Laboratory in the College of Natural Sciences, The University of Texas at Austin\n",
    "\n",
    "* an associate editor for [Computers and Geosciences](https://www.sciencedirect.com/journal/computers-and-geosciences/about/editorial-board), and a board member for [Mathematical Geosciences](https://link.springer.com/journal/11004/editorial-board), the International Association for Mathematical Geosciences. \n",
    "\n",
    "Michael has written over 70 [peer-reviewed publications](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en), a [Python package](https://pypi.org/project/geostatspy/) for spatial data analytics, co-authored a textbook on spatial data analytics, [Geostatistical Reservoir Modeling](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) and author of two recently released e-books, [Applied Geostatistics in Python: a Hands-on Guide with GeostatsPy](https://geostatsguy.github.io/GeostatsPyDemos_Book/intro.html) and [Applied Machine Learning in Python: a Hands-on Guide with Code](https://geostatsguy.github.io/MachineLearningDemos_Book/intro.html).\n",
    "\n",
    "All of Michael’s university lectures are available on his [YouTube Channel](https://www.youtube.com/@GeostatsGuyLectures) with links to 100s of Python interactive dashboards and well-documented workflows in over 40 repositories on his [GitHub account](https://github.com/GeostatsGuy), to support any interested students and working professionals with evergreen content. To find out more about Michael’s work and shared educational resources visit his [Website](www.michaelpyrcz.com).\n",
    "\n",
    "#### Want to Work Together?\n",
    "\n",
    "I hope this content is helpful to those that want to learn more about subsurface modeling, data analytics and machine learning. Students and working professionals are welcome to participate.\n",
    "\n",
    "* Want to invite me to visit your company for training, mentoring, project review, workflow design and / or consulting? I'd be happy to drop by and work with you! \n",
    "\n",
    "* Interested in partnering, supporting my graduate student research or my Subsurface Data Analytics and Machine Learning consortium (co-PI is Professor John Foster)? My research combines data analytics, stochastic modeling and machine learning theory with practice to develop novel methods and workflows to add value. We are solving challenging subsurface problems!\n",
    "\n",
    "* I can be reached at mpyrcz@austin.utexas.edu.\n",
    "\n",
    "I'm always happy to discuss,\n",
    "\n",
    "*Michael*\n",
    "\n",
    "Michael Pyrcz, Ph.D., P.Eng. Professor, Cockrell School of Engineering and The Jackson School of Geosciences, The University of Texas at Austin\n",
    "\n",
    "More Resources Available at: [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Geostatistics Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig)  | [Applied Geostats in Python e-book](https://geostatsguy.github.io/GeostatsPyDemos_Book/intro.html) | [Applied Machine Learning in Python e-book](https://geostatsguy.github.io/MachineLearningDemos_Book/) | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.13.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}