{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numba import jit\n",
    "\n",
    "import scipy.stats as sts\n",
    "from scipy.ndimage import generic_filter\n",
    "import pandas as pd\n",
    "\n",
    "\n",
    "import geotiff\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import cm\n",
    "import matplotlib.animation as animation\n",
    "from PIL import Image \n",
    "from skimage import draw\n",
    "\n",
    "\n",
    "import tqdm \n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image, ImageDraw, ImageFont"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_water(layer, fill = 1, kind = 'border'):\n",
    "    # later is slice of CA with water heights\n",
    "\n",
    "    water_layer = layer.copy()\n",
    "\n",
    "    if kind == 'border':\n",
    "    \n",
    "        water_layer[0,:], water_layer[-1,:] = fill, fill\n",
    "        water_layer[:,0], water_layer[:, -1] = fill, fill\n",
    "\n",
    "    elif kind == 'everywhere':\n",
    "        water_layer[:] = fill\n",
    "\n",
    "    elif kind == 'circle':\n",
    "        # generate a circle of rainfall in center\n",
    "        pass\n",
    "        \n",
    "\n",
    "    return water_layer\n",
    "\n",
    "directions = {\n",
    "    0: 1,\n",
    "    1: 2,\n",
    "    2: 4,\n",
    "    3: 8,\n",
    "    5: 16,\n",
    "    6: 32, \n",
    "    7: 64, \n",
    "    8: 128}\n",
    "\n",
    "def find_direction(window, method  = 'Dinf'):\n",
    "    # alias: Dinf in literature. Direct flow to lowest neighbor(s)\n",
    "\n",
    "    # Keys for neighbor positions relative to kernel\n",
    "    # 0 1 2\n",
    "    # 3 4 5\n",
    "    # 6 7 8 \n",
    "    \n",
    "    # window has flat array positions\n",
    "    center = window[4]\n",
    "    lower_cells = np.where(window < center, window, float('inf'))\n",
    "    \n",
    "    # Get indices of downstream cells\n",
    "    idxs = np.where(lower_cells < float('inf'))\n",
    "    idxs = list(*idxs)\n",
    "    \n",
    "    return np.sum([directions[i] for i in idxs]) if len(idxs) > 0 else 0\n",
    "\n",
    "def init_directions(layer, method = 'Dinf'):\n",
    "    # idx for elevation values\n",
    "    moore_kernel = np.ones((3,3)) \n",
    "    \n",
    "    # TODO: better cval for constant mode\n",
    "    # maybe repeat? \n",
    "    directions = generic_filter(\n",
    "                    layer,\n",
    "                    find_direction,\n",
    "                    footprint = moore_kernel,  \n",
    "                    mode = 'constant',\n",
    "                    cval = np.nan)\n",
    "\n",
    "    # Set border of directions to 0\n",
    "    directions[0,:] = 0\n",
    "    directions[:,0] = 0\n",
    "    directions[-1,:] = 0\n",
    "    directions[:,-1] = 0\n",
    "    \n",
    "    return directions\n",
    "\n",
    "def calculate_slope(window, d = 1, degrees = True):\n",
    "    # d is width of a cell\n",
    "\n",
    "    # 0 1 2 3 [4] 5 6 7 8\n",
    "    # 0 1 2 3     4 5 6 7\n",
    "\n",
    "    # if central cell is no_data, return itself\n",
    "    if window[4] == np.nan or window[4] < 0:\n",
    "        return window[4]\n",
    "    \n",
    "    df_dx = (np.sum(window[[2, 5, 5, 8]])  - np.sum(window[[0, 3, 3, 6]]))/8*d\n",
    "    df_dy = (np.sum(window[[6, 7, 7, 8]])  - np.sum(window[[0, 1, 1, 2]]))/8*d\n",
    "\n",
    "    rise_run = np.sqrt(df_dx**2 + df_dy**2)\n",
    "\n",
    "    if degrees:\n",
    "        # rise/run -> value in degrees \n",
    "        # 57.29578 ~ 180/pi (acceptable precision)\n",
    "        return np.arctan(rise_run) * 57.29578\n",
    "\n",
    "    else:\n",
    "        #return absolute value of rise/run\n",
    "        return rise_run\n",
    "\n",
    "def init_slope(dem_layer):\n",
    "    # Fill out gradients (degrees) for each cell in grid\n",
    "    # idx for elevation values\n",
    "\n",
    "    moore_kernel = np.ones((3,3))    \n",
    "    slopes = generic_filter(\n",
    "                dem_layer,\n",
    "                calculate_slope,\n",
    "                footprint = moore_kernel,  \n",
    "                mode = 'nearest',\n",
    "                cval = 0)\n",
    "\n",
    "    return slopes\n",
    "    \n",
    "def resample_array(a, new_rows, new_cols): \n",
    "    '''\n",
    "    This function takes an 2D numpy array a and produces a smaller array \n",
    "    of size new_rows, new_cols. new_rows and new_cols must be less than \n",
    "    or equal to the number of rows and columns in a.\n",
    "\n",
    "    From https://stackoverflow.com/questions/8090229/resize-with-averaging-or-rebin-a-numpy-2d-array\n",
    "\n",
    "    '''\n",
    "    rows = len(a)\n",
    "    cols = len(a[0])\n",
    "    yscale = float(rows) / new_rows \n",
    "    xscale = float(cols) / new_cols\n",
    "\n",
    "    # first average across the cols to shorten rows    \n",
    "    new_a = np.zeros((rows, new_cols)) \n",
    "    for j in range(new_cols):\n",
    "        # get the indices of the original array we are going to average across\n",
    "        the_x_range = (j*xscale, (j+1)*xscale)\n",
    "        firstx = int(the_x_range[0])\n",
    "        lastx = int(the_x_range[1])\n",
    "        # figure out the portion of the first and last index that overlap\n",
    "        # with the new index, and thus the portion of those cells that \n",
    "        # we need to include in our average\n",
    "        x0_scale = 1 - (the_x_range[0]-int(the_x_range[0]))\n",
    "        xEnd_scale =  (the_x_range[1]-int(the_x_range[1]))\n",
    "        # scale_line is a 1d array that corresponds to the portion of each old\n",
    "        # index in the_x_range that should be included in the new average\n",
    "        scale_line = np.ones((lastx-firstx+1))\n",
    "        scale_line[0] = x0_scale\n",
    "        scale_line[-1] = xEnd_scale\n",
    "        # Make sure you don't screw up and include an index that is too large\n",
    "        # for the array. This isn't great, as there could be some floating\n",
    "        # point errors that mess up this comparison.\n",
    "        if scale_line[-1] == 0:\n",
    "            scale_line = scale_line[:-1]\n",
    "            lastx = lastx - 1\n",
    "        # Now it's linear algebra time. Take the dot product of a slice of\n",
    "        # the original array and the scale_line\n",
    "        new_a[:,j] = np.dot(a[:,firstx:lastx+1], scale_line)/scale_line.sum()\n",
    "\n",
    "    # Then average across the rows to shorten the cols. Same method as above.\n",
    "    # It is probably possible to simplify this code, as this is more or less\n",
    "    # the same procedure as the block of code above, but transposed.\n",
    "    # Here I'm reusing the variable a. Sorry if that's confusing.\n",
    "    a = np.zeros((new_rows, new_cols))\n",
    "    for i in range(new_rows):\n",
    "        the_y_range = (i*yscale, (i+1)*yscale)\n",
    "        firsty = int(the_y_range[0])\n",
    "        lasty = int(the_y_range[1])\n",
    "        y0_scale = 1 - (the_y_range[0]-int(the_y_range[0]))\n",
    "        yEnd_scale =  (the_y_range[1]-int(the_y_range[1]))\n",
    "        scale_line = np.ones((lasty-firsty+1))\n",
    "        scale_line[0] = y0_scale\n",
    "        scale_line[-1] = yEnd_scale\n",
    "        if scale_line[-1] == 0:\n",
    "            scale_line = scale_line[:-1]\n",
    "            lasty = lasty - 1\n",
    "        a[i:,] = np.dot(scale_line, new_a[firsty:lasty+1,])/scale_line.sum() \n",
    "\n",
    "    return a \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_basin(N = 5, layers = 5, seed = 1):\n",
    "    # Return a toy elevation model\n",
    "    # layers can be :[DEM, WaterLevels, Slope, Direction, ICVols]\n",
    "    \n",
    "    #set seed for reproducibility\n",
    "    np.random.seed(seed)\n",
    "\n",
    "    grid = np.zeros((N,N,layers))\n",
    "\n",
    "    for i in range(N):\n",
    "        for j in range(N):\n",
    "            # Use small scale as tally is easier for testing\n",
    "            grid[i,j,0] -= 50**2*sts.norm.pdf(i*2, loc = N/2, scale = N) + \\\n",
    "                        50**2*sts.norm.pdf(j*2, loc = N/2, scale = N) - 500\n",
    "\n",
    "    '''\n",
    "    dem = np.array(\n",
    "    [\n",
    "        [10,10,10,10,10],\n",
    "        [10,8 ,8 ,8 ,10],\n",
    "        [10,8 ,5,8 ,10],\n",
    "        [10,8 ,8 ,8 ,10],\n",
    "        [10,10,10,10,10],\n",
    "    ]\n",
    "    )\n",
    "\n",
    "    grid[...,0] = dem'''\n",
    "\n",
    "    return init_grid(grid)\n",
    "\n",
    "def init_grid(grid, **kwargs):\n",
    "    # Initialise each layer of the grid\n",
    "    # Check number of features in last column \n",
    "    # if 1, then it is a DEM\n",
    "\n",
    "    if len(grid.shape) == 2:\n",
    "        # Add additional columns for water column, direction, and slope\n",
    "        dem  = grid\n",
    "        grid = np.zeros((grid.shape[0], grid.shape[1], 5))\n",
    "        grid[...,0] = dem    \n",
    "\n",
    "    grid = grid.copy()\n",
    "\n",
    "    fill = kwargs.get('fill', 1)\n",
    "    kind = kwargs.get('kind', 'border')\n",
    "\n",
    "    grid[...,1] = init_water(grid[...,1], fill = fill, kind = kind)\n",
    "    grid[...,2] = init_slope(grid[...,0])\n",
    "    grid[...,3] = init_directions(grid[...,0])\n",
    "    \n",
    "    return grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dist(\n",
    "    layer,\n",
    "    benchmark = None,\n",
    "\n",
    "    ax = None,\n",
    "    title = \"\",\n",
    "    bins=20, \n",
    "    color='w', \n",
    "    edgecolor='k', \n",
    "    figsize=(5,3), \n",
    "    ):\n",
    "\n",
    "    if ax == None:\n",
    "        fig = plt.figure(figsize=figsize)\n",
    "        ax = fig.add_subplot(1,1,1)\n",
    "\n",
    "    ax.hist(\n",
    "        layer.flatten(),\n",
    "        bins = bins,\n",
    "        color = color, \n",
    "        hatch = '///',\n",
    "        edgecolor = edgecolor)\n",
    "\n",
    "    ax.set_title(\n",
    "        title)\n",
    "\n",
    "    if benchmark:\n",
    "        ax.axvline(\n",
    "            benchmark,\n",
    "            color = 'red',\n",
    "            label = f''\n",
    "        )\n",
    "\n",
    "        ax.plot(\n",
    "            0,0,',',\n",
    "            label = f'')\n",
    "        ax.legend(loc = \"upper left\")\n",
    "\n",
    "    adjust_spines(ax, ['bottom'])\n",
    "    ax.set_xlabel(f'')\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    return ax\n",
    "        \n",
    "def adjust_spines(ax, spines, offset = 0):\n",
    "        for loc, spine in ax.spines.items():\n",
    "            if loc in spines:\n",
    "                spine.set_position(('outward', offset))  # outward by offset points\n",
    "                #spine.set_smart_bounds(True)\n",
    "            else:\n",
    "                spine.set_color('none')\n",
    "        # turn off ticks where there is no spine\n",
    "        if 'left' in spines:\n",
    "            ax.yaxis.set_ticks_position('left')\n",
    "        else:\n",
    "            # no yaxis ticks\n",
    "            ax.yaxis.set_ticks([])\n",
    "\n",
    "        if 'bottom' in spines:\n",
    "            ax.xaxis.set_ticks_position('bottom')\n",
    "        else:\n",
    "            # no xaxis ticks\n",
    "            ax.xaxis.set_ticks([])\n",
    "\n",
    "\n",
    "def plot_dem(dem, rotation = 30,  cmap = 'binary', ax = None):\n",
    "    # A function that plots a DEM (or any 2d array) in 3d\n",
    "\n",
    "    bins = dem.shape[0]\n",
    "    dem = dem.flatten()\n",
    "\n",
    "    if not ax:\n",
    "        fig = plt.figure()\n",
    "        ax = fig.add_subplot(projection='3d')\n",
    "\n",
    "    hist, xedges, yedges = np.histogram2d(dem, dem, bins=bins, range=[[0, bins], [0, bins]])\n",
    "\n",
    "    # Figure out anchors for each bar\n",
    "    xpos, ypos = np.meshgrid(xedges[:-1] + 0.1, yedges[:-1] + 0.1, indexing=\"ij\")\n",
    "    xpos = xpos.ravel()\n",
    "    ypos = ypos.ravel()\n",
    "    zpos = 0\n",
    "\n",
    "    # Construct arrays with the dimensions for each bar\n",
    "    dx = dy = 1 * np.ones_like(zpos)\n",
    "    dz = dem\n",
    "\n",
    "    cmap = cm.get_cmap(cmap) # discrete colormap\n",
    "    max_height = np.max(dz)   # max height\n",
    "    min_height = np.min(dz)    \n",
    "    # normalize each z to [0,1], and get their rgb values\n",
    "    rgba = [cmap((k-min_height)/max_height) for k in dz] \n",
    "\n",
    "    lc = ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color = rgba, zsort='average')\n",
    "\n",
    "    # show from side\n",
    "    ax.view_init(elev=rotation, azim= -90 + rotation)\n",
    "    # remove axes and ticks\n",
    "    ax.set_xticks([])\n",
    "    ax.set_yticks([])\n",
    "    ax.set_zticks([])\n",
    "\n",
    "    return lc\n",
    "\n",
    "# A function that plots a DEM heightmap in 4 angles\n",
    "def orbit_dem(dem, n = 4, cmap = 'Greys_r'):\n",
    "    # Plot a DEM from different n angles\n",
    "    # init 3d subplots\n",
    "    # A figure with a grid of subplots, no margin\n",
    "    fig = plt.figure(figsize=(15,15))\n",
    "    for i in range(n):\n",
    "        ax = fig.add_subplot(n, 4, i+1, projection='3d')\n",
    "        rot = 90 * i/n\n",
    "        lc = plot_dem(dem, rot, cmap, ax)\n",
    "\n",
    "    # Make layout compact\n",
    "    fig.tight_layout()\n",
    "\n",
    "    return fig\n",
    "\n",
    "\n",
    "def plot_water(dem, water, rotation = 45, ax = None):\n",
    "    # A function that plots a DEM (or any 2d array) in 3d\n",
    "\n",
    "    bins = dem.shape[0]\n",
    "    dem = dem.flatten()\n",
    "\n",
    "    if not ax:\n",
    "        fig = plt.figure()\n",
    "        ax = fig.add_subplot(projection='3d')\n",
    "\n",
    "    hist, xedges, yedges = np.histogram2d(dem, dem, bins=bins, range=[[0, bins], [0, bins]])\n",
    "\n",
    "    # Figure out anchors for each bar\n",
    "    xpos, ypos = np.meshgrid(xedges[:-1] + 0.1, yedges[:-1] + 0.1, indexing=\"ij\")\n",
    "    xpos = xpos.ravel()\n",
    "    ypos = ypos.ravel()\n",
    "    zpos = 0\n",
    "\n",
    "    # Construct arrays with the dimensions for each bar\n",
    "    dx = dy = 1 * np.ones_like(zpos)\n",
    "    dz = dem\n",
    "    # so we can see the water better\n",
    "    dz = dem - dem.min()\n",
    "\n",
    "    cmap = cm.get_cmap(\"Greys_r\") # discrete colormap\n",
    "    max_height = np.max(dz)   # max height\n",
    "    min_height = np.min(dz)    \n",
    "    # normalize each z to [0,1], and get their rgb values\n",
    "    rgba = [cmap((k-min_height)/max_height) for k in dz] \n",
    "\n",
    "    lc1 = ax.bar3d(xpos, ypos, zpos, dx, dy, dz, color = rgba, alpha = 0.01, zsort='average')\n",
    "\n",
    "    # Now stack the water map\n",
    "    bins = water.shape[0]\n",
    "    water = water.flatten()\n",
    "\n",
    "    dz1 = water\n",
    "\n",
    "    cmap = cm.get_cmap(\"Greys\") # discrete colormap\n",
    "    max_height = np.max(dz1)   # max height\n",
    "    min_height = np.min(dz1)   \n",
    "    #normalize each z to [0,1], and get their rgb values\n",
    "    rgba = [\"blue\" if k >= 1e-6 else cmap((k-min_height)/max_height) for k in dz1] \n",
    "\n",
    "    # stack over previous 3d barplot\n",
    "    lc2 = ax.bar3d(xpos, ypos, dz, dx, dy, dz1, color = rgba, alpha = 0.5, zsort='average')\n",
    "\n",
    "    # show from side\n",
    "    ax.view_init(elev=rotation, azim= -90 + rotation)\n",
    "    # remove axes and ticks\n",
    "    ax.set_xticks([])\n",
    "    ax.set_yticks([])\n",
    "    ax.set_zticks([])\n",
    "\n",
    "    return lc2\n",
    "\n",
    "\n",
    "def diagnostic_plot(results):\n",
    "    # plot mean flow late and totmass (should be conserved)\n",
    "    # results is dict of sim variables\n",
    "    fig, ax = plt.subplots(1,1, figsize = (5,5), dpi = 100)\n",
    "    p1 = ax.plot(\n",
    "        results['tot_mass'],\n",
    "        '-',\n",
    "        linewidth = 0.5,\n",
    "        label = 'Total Water Volume $(m^3)$')\n",
    "    # on different y axis plot flow_rate\n",
    "    twin = ax.twinx()\n",
    "\n",
    "    p2 = twin.plot(\n",
    "        results['flow_rate'], \n",
    "        '-g',\n",
    "        linewidth = 0.8,\n",
    "        label = 'Mean Flow Rate $(m^3/t)$',\n",
    "    )\n",
    "    # make left yaxis labels red\n",
    "    ax.yaxis.label.set_color('red')\n",
    "    ax.legend(handles = [p1[0], p2[0]])\n",
    "\n",
    "\n",
    "    # set twin ylabel\n",
    "    ax.set_ylabel('Total Water Volume $(m^3)$', color = 'black')\n",
    "    twin.set_ylabel('Mean Flow Rate $(m^3/t)$', color = 'green')\n",
    "\n",
    "    t = results['t']\n",
    "    # set xlabel\n",
    "    ax.set_xlabel(f'Iterations $({ t } s)$')\n",
    "\n",
    "    cells = results[\"N\"] * results[\"N\"]\n",
    "    area = results[\"area\"] * cells / 1e6\n",
    "    # add commas to area\n",
    "    area = f'{area:,}'\n",
    "    cells = f'{cells:,}'\n",
    "    sim_params = f' Total Water & Mean Flow Rate vs Time \\n  Cells = { cells  } Area = {area} km^2 '\n",
    "\n",
    "    # pad title\n",
    "    ax.set_title(f'{sim_params}', pad = 15)\n",
    "    ax.set_xticks(np.arange(0, results['frac_flooded'].shape[0], results['frac_flooded'].shape[0]/12))\n",
    "\n",
    "    # do not show figure\n",
    "    plt.close(fig)\n",
    "\n",
    "    return fig\n",
    "\n",
    "# plot each column in res['frac_flooded']\n",
    "def flood_plot(results):\n",
    "    # init figure\n",
    "    fig, ax = plt.subplots(1,1, figsize = (6,4), dpi = 100)\n",
    "    # for each column in frac flooded, plot\n",
    "    for i in range(results['frac_flooded'].shape[1]):\n",
    "        ax.plot(\n",
    "            results['frac_flooded'][:,i], \n",
    "            '-',\n",
    "            linewidth = 1,\n",
    "            label = f'{results[\"thresholds\"][i]} m')\n",
    "\n",
    "    ax.legend()\n",
    "    # add labels\n",
    "    t = results['t']\n",
    "    ax.set_xlabel(f'Iterations ({t*60} s)')\n",
    "    ax.set_ylabel('Fraction of Cells Flooded')\n",
    "    \n",
    "    cells = results[\"N\"] * results[\"N\"]\n",
    "    area = results[\"area\"] * cells / 1e6\n",
    "    # add commas to area\n",
    "    area = f'{area:,}'\n",
    "    cells = f'{cells:,}'\n",
    "    sim_params = f' Fraction Flooded vs Time \\n  Cells = { cells  } Area = {area} km^2 '\n",
    "\n",
    "    # set x axis ticks to hours \n",
    "    ax.set_xticks(np.arange(0, results['frac_flooded'].shape[0], results['frac_flooded'].shape[0]/12))\n",
    "    \n",
    "\n",
    "\n",
    "    ax.set_title(f'{sim_params}')\n",
    "    plt.close()\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_direction_keys(num):\n",
    "    # get direction key(s) of lowest neighbor(s)\n",
    "    binary = np.binary_repr(num, width=8)\n",
    "    # invert binary convert to list\n",
    "    binary = list(map(int, binary[::-1]))\n",
    "    # find all 1s\n",
    "    indices = np.where(np.array(binary) == 1)\n",
    "\n",
    "    return list(indices[0]) if len(indices[0]) > 0 else None\n",
    "\n",
    "def get_direction_idxs(key):\n",
    "    # unpack ij_dict to displacement indices\n",
    "    return ij_dict[key][0], ij_dict[key][1]\n",
    "\n",
    "def make_direction_dict():\n",
    "        # 3x3 array 0 to 8\n",
    "    i = np.array([-1,-1,-1, 0, 0, 0, 1, 1, 1])\n",
    "    j = np.array([-1, 0, 1,-1, 0, 1,-1, 0, 1])\n",
    "\n",
    "    # stack i and j\n",
    "    ij = np.stack((i,j), axis = 1)\n",
    "\n",
    "    # save each row as value in dict\n",
    "    ij_dict = {k:list(v) for k,v in enumerate(ij)}\n",
    "\n",
    "    return ij_dict\n",
    "\n",
    "def generate_flow_acc(dir_grid, n_iters = 10000, max_visits = 5, rainfall = None ):\n",
    "\n",
    "    # Take a direction grid and generate flow accumulation grid\n",
    "    N = dir_grid.shape[0]\n",
    "    # Init flow accumulation matrix\n",
    "    flow_acc = np.zeros((N,N))\n",
    "\n",
    "    global ij_dict\n",
    "\n",
    "    ij_dict = make_direction_dict()\n",
    "\n",
    "\n",
    "    for i in range(n_iters):\n",
    "\n",
    "        # pick a random cell OR pick cells in rainfall grid\n",
    "        if not rainfall:\n",
    "            x = np.random.randint(0, N)\n",
    "            y = np.random.randint(0, N)\n",
    "\n",
    "        else: \n",
    "            # sample from rainfall grid\n",
    "            pass\n",
    "\n",
    "\n",
    "        curr_cell = [x,y]\n",
    "    \n",
    "        lim = 0\n",
    "        while lim < max_visits:\n",
    "            i,j  = curr_cell[0], curr_cell[1]\n",
    "            direction = int(dir_grid[i,j])\n",
    "            # Get directions of flow\n",
    "            dir_keys = get_direction_keys(direction)\n",
    "\n",
    "            if dir_keys:\n",
    "                # performance: choose a neighbor to flow to first\n",
    "                key_idx = np.random.choice(len(dir_keys))\n",
    "                key = dir_keys[key_idx]\n",
    "                dx, dy = get_direction_idxs(key)\n",
    "\n",
    "                downstream_neighbor = [i+dx, j+dy]\n",
    "\n",
    "                curr_cell = downstream_neighbor\n",
    "                flow_acc[curr_cell[0], curr_cell[1]] += 1\n",
    "                lim += 1\n",
    "            else:\n",
    "                # reached boundary/outlet, break\n",
    "                break \n",
    "\n",
    "    return flow_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_rain(iter, avg = 700):\n",
    "\n",
    "    iter = int(iter % 60)\n",
    "    # poisson distribution for days in a month\n",
    "    monthly_rainfall = np.random.poisson(lam=avg/30, size=30)\n",
    "\n",
    "    # sample a day from monthly_rainfall\n",
    "    day = np.random.choice(range(len(monthly_rainfall)), size=1)\n",
    "\n",
    "    # poisson distribution for rainfall each hour\n",
    "    daily_rainfall = np.random.poisson(lam=monthly_rainfall[day]/12, size=12)\n",
    "\n",
    "    # sample an hour from daily_rainfall\n",
    "    hour = np.random.choice(range(len(daily_rainfall)), size=1)\n",
    "    # poisson distribution for rainfall each minute\n",
    "    hourly_rainfall = np.random.poisson(lam=daily_rainfall[hour]/60, size=60)\n",
    "\n",
    "    rain_m = hourly_rainfall[iter]\n",
    "    \n",
    "    return  rain_m / 1000\n",
    "\n",
    "# Optimization\n",
    "@jit(nopython=True)\n",
    "def calc_diffs(i,j, water_heights, central_height, tau, area, N):\n",
    "    # store downstream neighbors (position, height diff)\n",
    "    v = []\n",
    "\n",
    "    # calculate height difference between central cell and neighbors\n",
    "    for dx in range(-1,2):\n",
    "        for dy in range(-1,2):\n",
    "            # if neighbor is in bounds\n",
    "            if 0 <= i+dx < N and 0 <= j+dy < N:\n",
    "                neighbor_height = water_heights[i+dx,j+dy]\n",
    "                # exclude no_data cells\n",
    "                if neighbor_height > 0:\n",
    "                    # calculate difference\n",
    "                    diff = central_height - neighbor_height\n",
    "                    # exclude self and higher neighbors\n",
    "                    if diff - tau > 0:\n",
    "                        v.append(((i + dx, j + dy), diff * area))\n",
    "\n",
    "    return v\n",
    "\n",
    "def run_sim(basin, **kwargs):\n",
    "\n",
    "    #### Parameters #########\n",
    "    # average rainfall (mm) over a month\n",
    "    avg = kwargs.get('avg', 700)\n",
    "    # difference threshold to limit oscillations\n",
    "    tau = kwargs.get('tau', 0.1)\n",
    "    t = kwargs.get('t', 60)\n",
    "\n",
    "    edgel = kwargs.get('edgel', 10)\n",
    "    area = edgel*edgel\n",
    "    dist = edgel\n",
    "\n",
    "    g = 10\n",
    "    # Manning's roughness coefficient\n",
    "    n = kwargs.get('n', 0.02)\n",
    "    iter  = kwargs.get('iter', 60)\n",
    "    thresholds = kwargs.get('thresh', [0.1, 0.5, 1., 5.])\n",
    "\n",
    "    #### Variables ##########\n",
    "    tot_mass = np.zeros(iter)\n",
    "    target_cell = kwargs.get('target_cell', [0,0])\n",
    "    cell_water = np.zeros(iter)\n",
    "    flow_rate = np.zeros(iter)\n",
    "    frac_flooded = np.zeros((iter, len(thresholds)))\n",
    "    tally = 0\n",
    "    its = 0\n",
    "\n",
    "    plot = kwargs.get('plot', False)\n",
    "\n",
    "    if plot:\n",
    "        interval = kwargs.get('interval', 10)\n",
    "        frames = []\n",
    "        fig = plt.figure()\n",
    "        ax = fig.add_subplot(111, projection='3d')\n",
    "        frames.append([plot_water(basin[...,0],basin[...,1], ax = ax)])\n",
    "\n",
    "    else:\n",
    "        frames  = None\n",
    "        fig = None\n",
    "\n",
    "    start = time.time()\n",
    "    \n",
    "\n",
    "    N = basin[...,0].shape[0]\n",
    "    for it in tqdm.tqdm(range(iter)):\n",
    "\n",
    "        rain = get_rain(iter, avg)\n",
    "        basin[...,1] += rain\n",
    "        \n",
    "        water_heights = basin[...,0] + basin[...,1]\n",
    "        # make a copy of water levels layer\n",
    "        water_levels = basin[...,1].copy()\n",
    "        # alias for previous intercellular transfers\n",
    "        intercellular_transfers = basin[...,4]\n",
    "\n",
    "        it_flows = []\n",
    "\n",
    "        for i in range(N):\n",
    "            for j in range(N):\n",
    "\n",
    "                central_height = water_heights[i,j]\n",
    "                \n",
    "                # store downstream neighbors (position, height-diff*area)\n",
    "                v = calc_diffs(i,j, water_heights, central_height, tau, area, N)\n",
    "\n",
    "                # sum up differences to find total available volume\n",
    "                vols = [x[1] for x in v]\n",
    "                v_tot_avail = np.sum(vols)\n",
    "\n",
    "                \n",
    "                # To reduce oscillations, we sit minium and maximum volums\n",
    "                try: \n",
    "                    v_min = min(vols)\n",
    "                except: \n",
    "                    v_min = 1e-6\n",
    "                try:\n",
    "                    v_max = max(vols)\n",
    "                except:\n",
    "                    # possibly np.inf\n",
    "                    v_max = 1e6\n",
    "                \n",
    "                # calculate weight for each downstream neighbor\n",
    "                v_tot_avail += v_min\n",
    "                weights = [(x[0], x[1]/(v_tot_avail)) for x in v]\n",
    "                w_min = v_min/(v_tot_avail)\n",
    "                weights.append(((i,j),  w_min))\n",
    "                w_max = max([x[1] for x in weights])\n",
    "\n",
    "                # do weights sum to 1\n",
    "                #assert 1 - np.array([x[1] for x in weights]).sum()) <=  0.01\n",
    "\n",
    "                central_depth = basin[i,j,1]\n",
    "                manning = 1/n * central_depth**(2/3) * np.sqrt(v_max / dist)\n",
    "                # maximum permissible velocity\n",
    "                vm = min(np.sqrt(central_depth*g), manning)\n",
    "                inter_cell_max = vm * central_depth * t * edgel\n",
    "\n",
    "                v_incell = central_depth * area\n",
    "                ic_prev = intercellular_transfers[i,j]\n",
    "\n",
    "                # total amount flowing out of central cell (m^3/t)\n",
    "                ic_vol = min(v_incell, inter_cell_max/w_max, v_min + ic_prev)\n",
    "\n",
    "                if ic_vol == v_min + ic_prev:\n",
    "                    tally += 1\n",
    "                its += 1\n",
    "                # update intercellular transfer\n",
    "                intercellular_transfers[i,j] = ic_vol\n",
    "                it_flows.append(ic_vol)\n",
    "\n",
    "                # update water column in neighbors\n",
    "                for x in weights:\n",
    "                    ii,jj = x[0]\n",
    "                    if i == ii and j == jj:\n",
    "                        # update water column in central cell\n",
    "                        water_levels[ii,jj] -= ic_vol/area\n",
    "                    # update water column in neighbors\n",
    "                    water_levels[ii,jj] += ic_vol * x[1] / area\n",
    "\n",
    "        # merge copy into basin\n",
    "        basin[...,1] = water_levels\n",
    "        # clear water levels from memory\n",
    "        water_levels = None\n",
    "        \n",
    "        \n",
    "        ##### For Analysis #####\n",
    "        if plot:\n",
    "            if it % interval == 0:\n",
    "                frames.append([plot_water(basin[...,0],basin[...,1], ax = ax)])\n",
    "                plt.close()\n",
    "        \n",
    "        tot_mass[it]  = basin[...,1].sum() * area\n",
    "        cell_water[it] = basin[target_cell[0], target_cell[1], 1]\n",
    "        flow_rate[it] = np.mean(it_flows)\n",
    "        frac_flooded[it, :] = np.transpose([np.sum(basin[...,1] > thresh)/basin[...,1].size for thresh in thresholds])\n",
    "\n",
    "        # if last iteration, store water levels\n",
    "        if it == iter-1:\n",
    "            final_levels = basin[...,1].copy()\n",
    "\n",
    "\n",
    "    stop = time.time()\n",
    "    duration = stop - start\n",
    "\n",
    "\n",
    "    # write results to new line in results.txt\n",
    "    with open('perf_results.txt', 'a') as f:\n",
    "        f.write((f'{duration},{N},{iter},{tot_mass[0]},{tau},{t},{area} \\n'))\n",
    "\n",
    "    return {\n",
    "        'tot_mass': tot_mass,\n",
    "        'cell_water': cell_water,\n",
    "        'flow_rate': flow_rate,\n",
    "        'duration': duration,\n",
    "        'N': N,\n",
    "        'iter': iter,\n",
    "        'tau': tau,\n",
    "        't': t,\n",
    "        'area': area,\n",
    "        'frames': frames,\n",
    "        'fig': fig,\n",
    "        'frac_flooded': frac_flooded,\n",
    "        'thresholds': thresholds,\n",
    "        'tally': tally,\n",
    "        'its': its,\n",
    "        'final_levels': final_levels\n",
    "    }\n",
    "\n",
    "def run_batch(basin, **kwargs):\n",
    "    # a batch runner that run_sim for a range of parameters\n",
    "    #### Parameters ####\n",
    "    trials = kwargs.get('trial', 20)\n",
    "    tau_range = kwargs.get('tau_range', [0.001])\n",
    "    t_range = kwargs.get('t_range', [60])\n",
    "    n_range = kwargs.get('n_range', [0.02])\n",
    "    iter_range = kwargs.get('iter_range', [60*12])\n",
    "    # Threshold for \"flooded\" in (m)\n",
    "    thresh_range = kwargs.get('thresh_range', [[0.1, 0.5, 1, 2]])\n",
    "    avg = kwargs.get('avg', 1500)\n",
    "    edgel = kwargs.get('edgel', 30)\n",
    "\n",
    "    # create a list of dictionaries to store results\n",
    "    results = []\n",
    "    \n",
    "    # run simulations for each parameter combination\n",
    "    for t in range(trials):\n",
    "        for tau in tau_range:\n",
    "            for t in t_range:\n",
    "                for n in n_range:\n",
    "                    for iter in iter_range:\n",
    "                        for thresh in thresh_range:\n",
    "                            curr_basin = basin.copy()\n",
    "                            kwargs = {\n",
    "                                'tau': tau,\n",
    "                                't': t,\n",
    "                                'n': n,\n",
    "                                'iter': iter,\n",
    "                                'thresh': thresh,\n",
    "                                'target_cell': (1,1),\n",
    "                                'avg': avg,\n",
    "                                'edgel': edgel,\n",
    "                            }\n",
    "                            \n",
    "                            results.append(run_sim(curr_basin, **kwargs))\n",
    "                        \n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_bitmap(text, size):\n",
    "    \"\"\" Return a numpified image of text, with values in [-1,1]\"\"\"\n",
    "    pil_font = ImageFont.truetype(\n",
    "        \"/Library/Fonts/Arial.ttf\",\n",
    "         size = int(2*size//len(text)))\n",
    "\n",
    "    text_width, text_height = pil_font.getsize(text)\n",
    "    \n",
    "    canvas = Image.new('RGB', [size, size], (255, 255, 255))\n",
    "    # draw the text onto the canvas\n",
    "    draw = ImageDraw.Draw(canvas)\n",
    "    offset = ((size - text_width)//2,\n",
    "              (size - text_height)//2)\n",
    "    white = \"#000000\"\n",
    "    draw.text(offset, text, font=pil_font, fill=white)\n",
    "\n",
    "    # Clip Values\n",
    "    img = (255 - np.asarray(canvas)) / 255.0\n",
    "\n",
    "    # Constrain values to {-1, 1} selon McKay\n",
    "    #img = np.where(img > 0, -1, 1)\n",
    "    \n",
    "    # Return just 1 color channel\n",
    "    return img[..., 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:01<00:00, 53.74it/s]\n"
     ]
    }
   ],
   "source": [
    "hello = init_grid(generate_bitmap('Pablo', 30) + 10, kind =  'everywhere', fill = 0.01)\n",
    "res = run_sim(hello, iter = 100,avg =1e4 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7f9c5fa923d0>"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_water(hello[...,0], hello[...,1], rotation = 80,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Poly3DCollection' object has no attribute 'savefig'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/6v/v3k0ftn92ld7ss4w20w4t8480000gn/T/ipykernel_23020/1944340149.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# save high res fig\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msavefig\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'figures/dem_high.png'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdpi\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m300\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Poly3DCollection' object has no attribute 'savefig'"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_dem(hello[...,1], rotation = 80)\n",
    "\n",
    "# save high res fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#basin = create_basin(N = 10)\n",
    "#results = run_sim(basin)\n",
    "\n",
    "cell = results['cell_water']\n",
    "\n",
    "# calc differences beteen iterations in cell\n",
    "diff = np.diff(cell)*-1\n",
    "\n",
    "plt.plot(diff, label = 'Empirical Velocity')\n",
    "# overlay maximum theoretical velocity as a function of height (root(gh))\n",
    "# make sure that the difference between iterations is less than the maximum theoretical velocity\n",
    "g = 10\n",
    "plt.semilogy(np.sqrt(cell*g), label = \"Theoretical Max Velocity\")\n",
    "# add labels\n",
    "plt.xlabel('Time (s)')\n",
    "plt.ylabel('Velocity (m/s)')\n",
    "plt.title('Basin Model: Empirical vs. Theoretical Velocity')\n",
    "plt.legend()\n",
    "\n",
    "# save fig\n",
    "plt.savefig('velocity_comparison.png', dpi = 200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cell[:-1] - cell[1:] == diff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fec0ff15b20>]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(cell[:-1] - cell[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1201, 1201)\n",
      "(801, 601)\n"
     ]
    }
   ],
   "source": [
    "kerala = geotiff.GeoTiff(r'./media/kerala.tif')\n",
    "\n",
    "dem = np.array(kerala.read())\n",
    "print(dem.shape)\n",
    "# fit to mountains\n",
    "dem = dem[400: , 600:]\n",
    "# if negative set to 0\n",
    "dem[dem < 0] = 0\n",
    "print(dem.shape)\n",
    "\n",
    "small_dem = resample_array(dem, 100, 100)\n",
    "\n",
    "# set fill to 0 as we start dry\n",
    "#kerala = init_grid(small_dem, fill = 0, edgel = 240)\n",
    "\n",
    "#test = run_sim(kerala, iter = 60*12, avg = 1500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 720/720 [02:30<00:00,  4.80it/s]\n",
      "100%|██████████| 720/720 [02:17<00:00,  5.25it/s]\n",
      "100%|██████████| 720/720 [02:18<00:00,  5.21it/s]\n",
      "100%|██████████| 720/720 [02:22<00:00,  5.04it/s]\n",
      "100%|██████████| 720/720 [02:22<00:00,  5.05it/s]\n",
      "100%|██████████| 720/720 [02:31<00:00,  4.74it/s]\n",
      "100%|██████████| 720/720 [02:24<00:00,  4.98it/s]\n",
      "100%|██████████| 720/720 [02:20<00:00,  5.13it/s]\n",
      "100%|██████████| 720/720 [02:18<00:00,  5.18it/s]\n",
      "100%|██████████| 720/720 [02:21<00:00,  5.08it/s]\n",
      "100%|██████████| 720/720 [02:33<00:00,  4.69it/s]\n",
      "100%|██████████| 720/720 [02:21<00:00,  5.09it/s]\n",
      "100%|██████████| 720/720 [02:19<00:00,  5.15it/s]\n",
      "100%|██████████| 720/720 [02:19<00:00,  5.15it/s]\n",
      "100%|██████████| 720/720 [02:18<00:00,  5.19it/s]\n",
      "100%|██████████| 720/720 [02:18<00:00,  5.21it/s]\n",
      "100%|██████████| 720/720 [02:20<00:00,  5.11it/s]\n",
      "100%|██████████| 720/720 [02:27<00:00,  4.90it/s]\n",
      "100%|██████████| 720/720 [02:28<00:00,  4.86it/s]\n",
      "100%|██████████| 720/720 [02:27<00:00,  4.88it/s]\n",
      "100%|██████████| 720/720 [02:27<00:00,  4.87it/s]\n",
      "100%|██████████| 720/720 [02:26<00:00,  4.91it/s]\n",
      "100%|██████████| 720/720 [02:26<00:00,  4.91it/s]\n",
      "100%|██████████| 720/720 [02:23<00:00,  5.03it/s]\n",
      "100%|██████████| 720/720 [02:19<00:00,  5.15it/s]\n",
      "100%|██████████| 720/720 [02:20<00:00,  5.12it/s]\n",
      "100%|██████████| 720/720 [02:20<00:00,  5.14it/s]\n",
      "100%|██████████| 720/720 [02:19<00:00,  5.15it/s]\n",
      "100%|██████████| 720/720 [02:22<00:00,  5.05it/s]\n",
      "100%|██████████| 720/720 [02:17<00:00,  5.22it/s]\n",
      "100%|██████████| 720/720 [02:15<00:00,  5.32it/s]\n",
      "100%|██████████| 720/720 [02:04<00:00,  5.80it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.84it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.83it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.84it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.85it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.85it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.84it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.84it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.85it/s]\n",
      "100%|██████████| 720/720 [02:04<00:00,  5.80it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.84it/s]\n",
      "100%|██████████| 720/720 [02:02<00:00,  5.86it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.84it/s]\n",
      "100%|██████████| 720/720 [02:02<00:00,  5.86it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.84it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.84it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.83it/s]\n",
      "100%|██████████| 720/720 [02:03<00:00,  5.85it/s]\n",
      "100%|██████████| 720/720 [02:02<00:00,  5.86it/s]\n"
     ]
    }
   ],
   "source": [
    "large_dam = init_grid(small_dem, fill = 0, edgel = 720)\n",
    "\n",
    "# create a very large dam\n",
    "large_dam[55:75,45,0] = 500\n",
    "\n",
    "large_dam_batch = run_batch(large_dam, iter_range = [12*60], avg = 1500, trial = 50)\n",
    "ld_df = pd.DataFrame(large_dam_batch)\n",
    "# clear small_dam_batch from memory\n",
    "del large_dam_batch\n",
    "del large_dam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 720/720 [02:04<00:00,  5.77it/s]\n",
      "100%|██████████| 720/720 [02:04<00:00,  5.77it/s]\n",
      "100%|██████████| 720/720 [02:04<00:00,  5.76it/s]\n",
      "100%|██████████| 720/720 [02:04<00:00,  5.77it/s]\n",
      "100%|██████████| 720/720 [02:05<00:00,  5.75it/s]\n",
      "100%|██████████| 720/720 [02:05<00:00,  5.74it/s]\n",
      "100%|██████████| 720/720 [02:05<00:00,  5.75it/s]\n",
      "100%|██████████| 720/720 [02:06<00:00,  5.70it/s]\n",
      "100%|██████████| 720/720 [02:05<00:00,  5.73it/s]\n",
      "100%|██████████| 720/720 [02:05<00:00,  5.73it/s]\n",
      "100%|██████████| 720/720 [02:06<00:00,  5.71it/s]\n",
      "100%|██████████| 720/720 [02:05<00:00,  5.72it/s]\n",
      "100%|██████████| 720/720 [02:06<00:00,  5.70it/s]\n",
      "100%|██████████| 720/720 [02:05<00:00,  5.72it/s]\n",
      "100%|██████████| 720/720 [02:06<00:00,  5.69it/s]\n",
      "100%|██████████| 720/720 [02:06<00:00,  5.69it/s]\n",
      "100%|██████████| 720/720 [02:07<00:00,  5.66it/s]\n",
      "100%|██████████| 720/720 [02:07<00:00,  5.63it/s]\n",
      "100%|██████████| 720/720 [02:07<00:00,  5.66it/s]\n",
      "100%|██████████| 720/720 [02:07<00:00,  5.63it/s]\n",
      "100%|██████████| 720/720 [02:07<00:00,  5.64it/s]\n",
      "100%|██████████| 720/720 [02:07<00:00,  5.63it/s]\n",
      "100%|██████████| 720/720 [02:07<00:00,  5.64it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.62it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.60it/s]\n",
      "100%|██████████| 720/720 [02:09<00:00,  5.58it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.59it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.60it/s]\n",
      "100%|██████████| 720/720 [02:09<00:00,  5.58it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.59it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.60it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.60it/s]\n",
      "100%|██████████| 720/720 [02:09<00:00,  5.56it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.60it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.61it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.58it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.60it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.60it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.61it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.60it/s]\n",
      "100%|██████████| 720/720 [02:09<00:00,  5.58it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.61it/s]\n",
      "100%|██████████| 720/720 [02:09<00:00,  5.58it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.62it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.60it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.59it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.61it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.60it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.59it/s]\n",
      "100%|██████████| 720/720 [02:08<00:00,  5.59it/s]\n"
     ]
    }
   ],
   "source": [
    "small_dams = init_grid(small_dem, fill = 0, edgel = 720)\n",
    "\n",
    "# create lots of small dams\n",
    "x = [55, 75, 65, 45,55,45]\n",
    "y = [45,45, 45, 35, 35, 55]\n",
    "\n",
    "# set each to 500\n",
    "small_dams[x,y,0] = 500\n",
    "\n",
    "small_dam_batch = run_batch(small_dams, iter_range = [12*60], avg = 1500, trial = 50)\n",
    "sds_df = pd.DataFrame(small_dam_batch)\n",
    "# clear small_dam_batch from memory\n",
    "del small_dam_batch\n",
    "del small_dams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_fracs(df, df2):\n",
    "    thresholds = df[\"thresholds\"][0]\n",
    "\n",
    "    # 4 subplots sharey\n",
    "    fig, axs = plt.subplots(1,4, figsize = (9,3), sharey=True)\n",
    "\n",
    "    for thresh in range(len(thresholds)):\n",
    "        for i in range(len(df.index)):\n",
    "            axs[thresh].plot(df['frac_flooded'].to_numpy()[i][:,thresh], alpha = 0.1, linewidth = 0.5, color = 'red')\n",
    "            axs[thresh].set_title(f\"{  thresholds[thresh] } m\")\n",
    "\n",
    "\n",
    "    for thresh in range(len(thresholds)):\n",
    "        for i in range(len(df.index)):\n",
    "            axs[thresh].plot(df2['frac_flooded'].to_numpy()[i][:,thresh], alpha = 0.1, linewidth = 0.5, color = 'blue')\n",
    "            axs[thresh].set_xlabel(\"Iterations (60s)\")\n",
    "            #set xticks every 120\n",
    "            axs[thresh].set_xticks(np.arange(0, df.iter[0], 120))\n",
    "\n",
    "    # create legend\n",
    "    axs[3].legend([\"Large Dam\", \"Small Dams\"])\n",
    "    # set first color in legend to red\n",
    "    leg = axs[3].get_legend()\n",
    "    leg.legendHandles[0].set_color('red')\n",
    "    leg.legendHandles[1].set_color('blue')\n",
    "    for i in leg.legendHandles:\n",
    "        i.set_linewidth(2)\n",
    "\n",
    "\n",
    "\n",
    "    # label axes\n",
    "    axs[0].set_ylabel(\"Fraction Flooded\")\n",
    "\n",
    "    # overall title\n",
    "    fig.suptitle('Fraction of Cells Flooded (Both Strategies, 50 Trials)')\n",
    "    # pad title\n",
    "    fig.tight_layout()\n",
    "\n",
    "    # save figure\n",
    "    fig.savefig(r'./media/all_dams_frac.png', dpi = 300)\n",
    "\n",
    "all_fracs(sds_df, ld_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "sds_finals = []\n",
    "for trial in sds_df['frac_flooded']:\n",
    "    # get last row\n",
    "    final = trial[-1]\n",
    "    sds_finals.append(final)\n",
    "\n",
    "sds_finals = np.array(sds_finals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "sd_finals = []\n",
    "for trial in sd_df['frac_flooded']:\n",
    "    # get last row\n",
    "    final = trial[-1]\n",
    "    sd_finals.append(final)\n",
    "\n",
    "sd_finals = np.array(sd_finals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = diagnostic_plot(sds_df.iloc[1,:])\n",
    "\n",
    "# get ax of f\n",
    "ax = f.axes[0]\n",
    "ax.set_title(\"Study Area: 12 Hours with Heavy Rain\")\n",
    "\n",
    "# save f\n",
    "f.savefig(r'./media/diag_study.png', dpi = 300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAEdCAYAAAARlcZeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABNzElEQVR4nO3debwcVZn/8c+TfQUCCZCQjT0BEpZE2QTDjkggoIIQR+IyYUbBDUcBEaPojOKIDqO/0agISKIgBpFNFiEEMIBcQgiQsIiBhJsdEkjInuf3R9VNOk133eqleqn6vl+vft2+fU5XP1V9nqo6VdV1zN0RERERERGRynWodwAiIiIiIiJpoQ6WiIiIiIhIlaiDJSIiIiIiUiXqYImIiIiIiFSJOlgiIiIiIiJVog6WiIiIiIhIlaiDJSJ1Z2bHmNmLdfjc/c1slpm9Y2ZfSGD6bmb7hM+vN7PvVnHaY8xsYbWmlzPdoWHcnWr53lozswlm9miZ7y273STZ1s1skpndVMH7nzezMdWLaLtpX2hmP0li2iXEMN7M7otZN9ayNLNpZnZq5dGJSJqogyUi2zGz+Wa21sxW5zwGVPkztnY8ANz9EXffv5qfEdPXgOnu3tvdry1UwcxOMbMZ4c70MjN72MzOqFWA4bJak/NdrKzVZ9dSnA6PmU03s3V5bfOOWsWYI7LdmNmBZnafmb1lZivNrMXMToO6tvX8GN/T4Xf3A919egKf1QW4Avhhzmv57fpXee/5spktNrNVZnadmXUtMN3BeW0hf5rH5M3fFHc/ucqz933ge1Wepog0OXWwRKSQse7eK+fRmlvYDGcoYhoCPF+s0Mw+CvwBuBEYCOwGXAmMrUl02xyc813sVOPPbjQX5bXNWn8X0E67Ae4A7idoL7sCXwDerkFcjepMYJ67v5H3em67/mzbi2Z2CnApcAIwFNgL+Hb+RN399dy2UGCaj+RMM5F1lrs/CexgZqOTmL6INCd1sEQklvDo8OfN7GXg5fC1/zGzBWb2dniU/pic+h3N7HIz+0d49qfFzAaZ2YywyuzwKPO5+Ze7mdnw8GzFyvCypTNyyq43s5+Z2V3hdJ8ws70j4j4jnMbKcJrDw9cfBI4DfhrGsV/e+wy4BrjK3X/l7qvcfYu7P+zu/5pT79NmNjc8W3GvmQ2JsSz7mtmdYUxvmtkjZlbR+ridZbajmd0YnoF7zcyuaPu88Hv6bzNbbmavAh/Om+6OZvZrM1tkZm+Y2XfNrGOc9xaI8dKc9vCCmZ3VFjvwc+BIK/MsXVsbMrNLzGxpGO+ncsp3MbM/h231SaBomwnrl9tu+gJ7Ar909w3h4zF3fzQ3zpz6883sP8zs2fDsy6/NbDczuydcTg+YWZ9C7815/4lF5uEPtu0s0AwzOzB8fSIwHvia5ZwFzJ2WmXU1s5+YWWv4+ImFZ5HaW9YFfAh4OGp557kA+LW7P+/ubwFXARNKeH/bGdHHzOzHZvYmMMnyzpJaxPorb1rdzOwmM1sRtoe/m9luOVWm007bF5FsUQdLREoxDjgcOCD8/+/AIcDOwFTgD2bWLSz7CnAecBqwA/Bp4F13PzYsbzvSfHPuB5hZZ4IzAPcRHP2/GJhiZrmXVZ1HcES7D/AKRS7RCXd+fwd8CegH3A3cYWZd3P144BG2nRF5Ke/t+wODgFuLLQwzGwdcDpwdTv+R8PPacwmwMHzPbuE0PMb7isXR3jL7X2BHgjMBHwQ+CbTtEP8rcDpwKDAa+Gje5G8ANgH7hHVOBj4b8735/gEcE8bybeAmM+vv7nOBfwNmVniWbvdw2nsAnwF+1tY5AX4GrAP6E7TFTxebSIXtZgVBm7zJzMbl7YgX8xHgJGA/grOj9xC0ib4E2+lyfx94D7AvQZt4GpgC4O6Tw+dXR5wF/AZwBEF+Hwy8n+AyvzZRyzrfCKDQ785mhB3AaWY2NOf1A4HZOf/PBnYzs12Kz2pBhwOvEsx/oXVE1Por1wUE8zoI2IWgra7NKZ9LsIxERAB1sESksD+FR2pXmtmfcl7/L3d/093XArj7Te6+wt03ufuPgK4EHRMIdsKvcPcXPTDb3VfE+OwjgF7A98Oj/w8CdxJ0qtpMc/cn3X0TwY7iIUWmdS5wl7vf7+4bgf8GugNHxYijbWduUUSdCwmWydwwlv8EDrH2z2JtJNjRH+LuG8Pf5UR1sJ7O+T4K/Vas6DILzzadC1zm7u+4+3zgR8C/hO89B/iJuy9w9zeB/2qbaNg5+BDwJXdf4+5LgR8DH2/vvYW4+x/cvTU8E3gzwZnQ90e9p4Brc5bFSjO7KqdsI/CdcJneDawG9g+XwUeAK8P5eI6g41hM2e0m/B6PA+YTLOdF4dmjfSPe9r/uviS8hO4R4Al3n+Xu64HbCDqwJXP368LvfD0wCTjYzHaM+fbxBMtyqbsvI+gQ/0tOecFlXWRaOwHv5L32QYLL/4YBrcCdtu0yvl7Aqpy6bc97x4y9Tau7/2+4flqbX9jO+ivXRoL1wT7uvtndW9w995LPdwjmUUQEUAdLRAob5+47hY9xOa8vyK0UXiI0N7wEaSXBUd6+YfEggjMWpRoALHD3LTmvvUZwpLzN4pzn7xLskBWb1mtt/4TTXJA3rWLaOoP9I+oMAf6nbWcfeBOwGNP/IcFZjvvM7FUzu7Sd+oflfB+FzmZELbO+QBdylgPbL88BbP+95tYbAnQm6CS0zeMvCM4ItPfe9zCzT5rZMznTOoht7SWuL+Qsi53c/Zs5ZSvCjm6btrbRD+hUQqyVtBvcfaG7X+TuexMswzUEv+MrZknO87UF/i/Wvouy4PLN71twSebbBB0+iL+8t1sG4fPcm90UW9aFvEVe58jdZ4QHA1YCXyS4rHJ4WLya4Kx3m7bn+Z209iyIKmxn/ZXrt8C9wO/DyyWvDs8at+kNrCwxNhFJMXWwRKQUW8+yhL9X+DrBWYw+4WVdqwg6GBDs3ET+zqWIVmCQbf+bpMFA/g/k405r69kkMzOCjl+cab1IMA8fiaizALgwb4e/u7v/LWrC4VmFS9x9L4JLwr5iZifEiKmYqGW2nOAI/JACZRCcoRuUV9ZmAbAe6Jszfzu4+4Ex3rud8KzeL4GLgF3C9vIc29pL2ZdIxrCM4DLHWLFSWbvZjrsvILg88aBS31vAGqBHTlwdCTqPhZxPcHOJEwk6DkPb3tYWWjuftd0yIFherUXqtudZgssfozjbYnue7S+5OxhYEvMMeP40C4qx/to2keAs3bfd/QCCs5inE1xm22Y421/SKCIZpw6WiJSrN8FO6zKgk5ldyfZHnX8FXGVm+1pgZM5vKJYQ/B6okCcIdiS/ZmadLRiXZyzw+zJivAX4sJmdEB5xvoSgwxDZAYKtl3p9BfimmX3KzHYwsw5m9gEzmxxW+zlwmW27ecCOZvax9qZtZqeb2T7hjvvbwObwUa6iy8zdNxMsh++ZWe+wo/MVoG2Mn1uAL5jZwPA3NFvPprn7IoLfdf0oZ/73NrMPtvfeAnoS7PAuC5fBp9i+07EEGGjBLb2rKlwG0whudNDDzA4g+F1NMWW3GzPrY2bfDr/fDhbc9OLTwOOVzwkvAd3M7MNhXFcQXNZWSO8w5hUEnbL/zCuPykEIfoN2hZn1C+fhSra1mVLdTXBJILD1NvaHhGfZehFcSvkGwW+ZIDjb9xkzOyBsV1cA15f52cW0t/7aysyOM7MRYYf2bYIDFrn5+kGC37uJiADqYIlI+e4l2Kl4ieDyoXVsf0nONQQ7qvcR7JT8muB3LBD8HuSG8FKxc3In6u4bgDMIfvuzHPh/wCfdfV6pAbr7i8AnCG7ysJyg0zE2/Iw477+V4Pc4nyY4er8E+C5we1h+G/ADgkuH3iY4I/OhGJPeF3iA4FKomcD/8wrGH4qxzC4m6IC9CjxK8IP+68KyXxJ8l7MJboQwLW/ynyS4xPAFgku9bmXbZZPtvTc3xhcIdqRnEizHEcBjOVUeJDhzsdjMlkfMbtvd+9oeLRF1c11EcAnbYoKd9d9ExFpJu9lAcLboAYJ2/xxBR2dCzDiLcvdVwOcIDl68QfCdFhts+kaCvHyD4LvL7+D9GjjA3vs7yzbfBZ4iOPs0h+D7LXeg7DuAYbZtPL3dgJsJls+rBMvr9PD3brj7X4CrgYfCeXgN+FaZn11Me+uvXLsTtPu3CTqBDxN2Ns3sfcAaD27XLiICgEX/rlpERESkMhbcGv4Ad/9SvWOpJjP7I8Et5e+udywi0jjUwRIREREREakSXSIoIiIiIiJSJepgiYiIiIiIVIk6WCIiIiIiIlWiDpaIiIiIiEiVqIMlIiIiIiJSJepgiYiIiIiIVIk6WCIiIiIiIlWiDpaIiIiIiEiVqIMlIiIiIiJSJepgiYiIiIiIVIk6WCIiIiIiIlWiDpaIiIiIiEiVqIMlIiIiIiJSJepgiYiIiIiIVIk6WCIiIiIiIlWiDpaIiIiIiEiVqIMlIiIiIiJSJepgScnMbIKZPVrvOESagfJFpDgzm25mn613HCLNQjnTHNTBKoOZ7Wxmt5nZGjN7zczOj6h7kJnda2bLzcxrGWezMbMTzGyemb1rZg+Z2ZCIuheZ2VNmtt7Mrs8r62Jmt5rZfDNzMxuTcOgSocR8mWBmm81sdc5jTO2ibR5x88XMuprZr8Nl/46ZzTKzDxWp+60wZ05MNnopR9R6T7axwA/MbEX4uNrMrEjdA8Jl+lb4eMDMDsgp/w8zey7MnX+a2X/Ubk6kEqWs+7KuxJw5wszuN7M3zWyZmf3BzPrnlCtnUAerXD8DNgC7AeOB/zOzA4vU3QjcAnymRrE1JTPrC0wDvgnsDDwF3Bzxllbgu8B1RcofBT4BLK5imFKeUvIFYKa798p5TK9FkM2kxHzpBCwAPgjsGL7nFjMbmjfNvYGPAouSiVqqoL31ngQmAuOAg4GRwOnAhUXqthK0+52BvsCfgd/nlBvwSaAPcCpwkZl9PJGopdpirfsEKC1n+gCTgaHAEOAd4Dc55coZ1MEqmZn1BD4CfNPdV7v7owQr5H8pVN/dX3T3XwPPx5y+m9nnzOzlsPd/lZntbWYzzextM7vFzLrEnNb1Zvbz8EjDO2b2cNtR7vD1/86rf7uZfSV8fqmZ/SN83wtmdlacz6zA2cDz7v4Hd18HTAIONrNhhSq7+zR3/xOwokDZBnf/SfjdbE4wZmlHqflSxvSVL+3ki7uvcfdJ7j7f3be4+53AP4FReVV/CnydoDMsDShqvZfPgrPBj5nZj81spZm9amZHha8vMLOlZnZB3M8Oc+0L4XSWm9kPzaxDeJZgpZkdlFO3n5mtNbNdzayPmd0ZHul+K3w+sLwlENsFwI/cfaG7vwH8CJhQqKK7rwxzwwl2DDcD++SUX+3uT7v7Jnd/EbgdODrh+KUKSlj3AcoZ4ufMPeG25213f5dg23F0TrlyBnWwyrEfsNndX8p5bTYQdUS+VKcSrACOAL5GcKRgPDAIOAg4r4RpjQeuIjgy9wwwJXx9KnCuWXAK2Mz6ACez7cjdP4BjCI76fBu4yXJOAUcJVxzFHpcWeduBBMsRCFaMYQzVXK5Se+Xky6HhxuglM/ummXVq5zOULyXki5ntRvC9PJ/z2seADe5+d5yYpWkcDjwL7ELQhn8PvI+gA/EJ4Kdm1quE6Z0FjAYOA84EPu3u6wnOpubm2TnAw+6+lGA/4zcER7oHA2sJdsjaZWbnt5Mfg4u8dbv8IMY22sxWAuuA/wX+s0gdI8jzWAdMpbEUWvcVoJwJlLJfeyxFlmmWc0YdrNL1AlblvbYK6F3Fz/hBeGTgeeA54D53f9XdVwH3AIeWMK273H1GmNDfAI40s0HAI4ATNHwILpGY6e6tAOHRidbwqM/NwMvA++N8oLvvFPH4fpG31WK5Su2V+r3OIOgU7Upw5us8oL3rt5UvgXbzxcw6E3Qab3D3eeFrvQh2KL8UJ15pKv9099+4+2aCS0gHAd9x9/Xufh/B2cp9IqewvR+4+5vu/jrwE7btIE5l+53F88PXcPcV7v5Hd3/X3d8BvkdwyVa73H1qO/nxepG35ufHKqBX2wGSIp+1E8EBkouAWUWqTWLbzq80kULrviKUM4F2cwbAzEYCV1J8Oz2JjOaMOlilWw3skPfaDgTXoFbLkpznawv8X8rRkwVtT9x9NfAmMCC8HOL3bEvw89l2tB4z+6SZPdN21INgp7dvKTNRolosV6m9kr7XsGP0z7CjMgf4DkFnJoryJRCZL2bWAfgtwQ7CRTlF3wZ+6+7/rHaQUnf5uYC7VyU/gNeAAeHzB4HuZna4BZfVHgLcBmBmPczsFxbcaOBtgoMoO5lZx5LmpDT5+bEDsDrM46LCM8E/B240s11zy8zsIoLflXw4PAAjTSJi3VeIcibQbs6Y2T4EBzG/6O6PFCjPdM6og1W6l4BOZrZvzmsH07inPwe1PQmPVO9M8KNegN8BHw2T+3Dgj2G9IcAvCVZEu4RH9p4juD69Xbb9HeDyH5cXedvzBMuxbRo9gb1p3OUq8VSaL22/i6iVVOZLeBTy1wQ3GvmIu2/MKT4B+IKZLTazxeEyuMXMvh4nfsmUQTnPBxPmhrtvIbiZ03kEBx/uDI+8A1wC7A8c7u47EFxOBDHyw8zGt5MfxS532i4/KG2d0wHoAeyRE8engUuBE9x9YczpSANoZ91XC6nMmXC79wBwlbv/tkB55nNGHawShUe4pgHfMbOeZnY0wXW172lgsPXWl92ALuH/3cysa7XisfZvQ36amX3Agh/6XwU84e4LwnmZBSwDfgXc6+4rw/f0JNixXRZ+xqcIjsjH4tvfAS7/UfDadoIjNweZ2UfC5XUl8GyxU/lm1ims1xHoGC7XTjnlXcNygC5heS131IWy8uVDFlwnjwU3bPgmwQ9kqyKr+QL8HzAcGOvua/PKTgjjPSR8tBLcPepncedBaqO99V6F055gZvPbqfYfFvwAfxDwRba/c+VU4FyC3zFOzXm9N8FR/5VmtjPwrbgxufuUdvKj2OVONwJfMbM9zGwAwQ7r9YUqmtlJZnaomXU0sx2Aa4C3gLlh+XiCS2hPcvdX48YuDSNq3VeRDOfMHgRn4H7m7j8vUK6cQR2scn0O6A4sJTiq/e8e/P4DMxucd5RgCEGitB0JWAu8WI0gLLirzGpgTkS1qQTJ+SbBjQDG55X/DjiRnOR29xcI7iAzk+B0+QjgsWrEXIy7LyP4zc33CDZuhwNbb+tpZpeb2T05b7mCYFleSvDD07Xha21eDF/bA7g3fF50XC1JVCn5cgLwrJmtAe4m6JwV62SUJKv5Eh5pvJCg87Q450jm+HBaK9x9cduD4C5qb4WXSEpjaW+9V4lBtN9ubwdaCG4AcxfBmQEA3P0JYA3BJVC56+qfEOT/cuBx4C9VijfKL4A7CHL9uTDWX7QVmtnzbe0f2Ikgr1cR3ChmH+BUD+7OCcFt8XcB/p6TO+/ZqZTG0966rwqymjOfBfYCvpV7dixnWsoZwNq5JFkamJl9AjjQ3S8rUn49sNDdq7UBFmlayheR4szsPoLfUswtUu7Avu7+Sm0jE2lMyhmJUpVLC6Q+3P2mescg0iyULyLFufvJ9Y5BpJkoZySKLhEUERERERGpEl0iKCIiIiIiUiU6gyUiIiIiIlIlTfEbrL59+/rQoUPrHYZIVbW0tCx3935JTFs5I2mTZL6AckbSRzkjUppq5kxTdLCGDh3KU089Ve8wsuUXv4ALL6xWNSnAzF5LatrKmSYQkTzKq/dKMl9AOVNTavs1oZxpMNqvanjVzBldIiiFLVpUzWoiki8ieZRXkmpq+5JF2q/KFHWwpLCJE6tZTUTyRSSP8kpSTW1fskj7VZmiDpYUNnlyNauJSL6I5FFeSaqp7UsWab8qU5riN1hSB/vtV81qIpIvInmUV5JqavuSRXmNe+PGjSxcuJB169Zt9/rpp8PcubUMLHu6devGwIED6dy5c2KfoQ6WFDZgQDWriUi+iORRXkmqqe1LFuU17oULF9K7d2+GDh2KmW19/Z13oHfvWgeXHe7OihUrWLhwIXvuuWdin6NLBKWw6dOrWU1E8kUkj/JKUk1tX7Ior3GvW7eOXXbZZbvOFQQdLEmOmbHLLru858xhtamDJYV95CPVrCYi+SKSR3klqaa2L1lUoHHnd64AdtqpBrFkXKHlXm3qYElhOoMlkiwdxZesUtuXLIrZuHUGKx30GywpbMWKalYTaUitrZVPo+zfjEQkj/JKUk1tX7IoZuPevDnhOHJ873vfY+rUqXTs2JEOHTrwi1/8gsMPP7zi6fbq1YvVq1czf/58Tj/9dJ577rntyufPn8/w4cMZNmwY69ato3fv3nz+85/nggsuqPizG4U6WFKYxmsQSZbGApKsUtuXLIrZuPv2TTiO0MyZM7nzzjt5+umn6dq1K8uXL2fDhg21+XBg7733ZtasWQC8+uqrnH322WzZsoVPfepTNYshSbpEUArTeA0iydJYQJJVavuSRTEb9/LlCccRWrRoEX379qVr164A9O3blwHhJRlDhw7l8ssv58gjj2T06NE8/fTTnHLKKey99978/Oc/B2D16tWccMIJHHbYYYwYMYLbb7+97Fj22msvrrnmGq699loAnnzySY466igOPfRQjjrqKF588UUArr/+esaNG8fYsWPZc889+elPf8o111zDoYceyhFHHMGbb74JwLXXXssBBxzAyJEj+fjHP152XJVQB0sKGzGimtVEJF9E8iivJNXU9iWLYjbu7t0TjiN08skns2DBAvbbbz8+97nP8fDDD29XPmjQIGbOnMkxxxzDhAkTuPXWW3n88ce58sorgWAsqdtuu42nn36ahx56iEsuuQR3Lzueww47jHnz5gEwbNgwZsyYwaxZs/jOd77D5ZdfvrXec889x9SpU3nyySf5xje+QY8ePZg1axZHHnkkN954IwDf//73mTVrFs8+++zWDmGt6RJBKaxXr2pWE5F8EcmjvJJUU9uXLGqvcU+fDtOn0+nkj0DL9OA3WxMnBme+RowI3j9zJpx3Htx5J6xfD+efD9dfD6NGBdNoaYEJE2DqVDjqKBgzJiKcXrS0tPDII4/w0EMPce655/L973+fCRMmAHDGGWcAMGLECFavXk3v3r3p3bs33bp1Y+XKlfTs2ZPLL7+cGTNm0KFDB9544w2WLFnC7rvvXtbiye2crVq1igsuuICXX34ZM2Pjxo1by4477ritsey4446MHTt2a5zPPvssACNHjmT8+PGMGzeOcePGlRVPpdTBksJmzoRTTqlWNRHJF5E8yitJNbV9yaL2GveYMTBmDO+0Qu+jcs52TZq07Xnb+/ffv3B52Nkg54xPlI4dOzJmzBjGjBnDiBEjuOGGG7Z2sNouHezQocPW523/b9q0iSlTprBs2TJaWlro3LkzQ4cOrWhsqVmzZjF8+HAAvvnNb3Lcccdx2223MX/+fMbkdBTzY8mNc9OmTQDcddddzJgxgz//+c9cddVVPP/883TqVNsujy4RlMLOO6+a1UQkX0TyKK8k1dT2JYtiNu6dd044jtCLL77Iyy+/vPX/Z555hiFDhsR+/6pVq9h1113p3LkzDz30EK+99lrZscyfP5+vfvWrXHzxxVunvcceewDB765KsWXLFhYsWMBxxx3H1VdfzcqVK1m9enXZsZVLHSwp7M47q1lNRPJFJI/ySlJNbV+yKGbjXrky2TDarF69mgsuuGDrzSBeeOEFJuWeDWvH+PHjeeqppxg9ejRTpkxh2LBhJX3+P/7xDw499FCGDx/OOeecw8UXX7z1DoJf+9rXuOyyyzj66KPZXOJ96zdv3swnPvEJRowYwaGHHsqXv/xldqrD6M26RFAKW7++mtVEJF9E8iivJNXU9iWLYjbuCu4TUZJRo0bxt7/9rWDZ/Pnztz6fMGHC1ssG88tmzpxZ8P1tZ4yGDh36njGw2l5fu3Zt0diOPPJIXnrppa3/X3XVVe3Gklv26KOPFp12regMlhR2/vnVrCYi+SKSR3klqaa2L1kUs3HX6hJBSZY6WFJYzGteS7w0VkTaRCSP8kpSTW1fsihm416xItkwpDbUwZLC2m75WZ1qIpIvInmUV5JqavuSRTEbd48eCcchNaEOloiIiIiISJUk1sEys+vMbKmZPZfz2s5mdr+ZvRz+7ZPU50uFWlqqWU1E8kUkj/JKUk1tX7IoZuN+992E45CaSPIM1vXAqXmvXQr81d33Bf4a/i+NKOcuLVWoJiL5IpJHeSWpprYvWRSzce+yS7JhSG0k1sFy9xnAm3kvnwncED6/ARiX1OdLhaZOrWY1EckXkTzKK0k1tX3JopiN+838PecE9erVq3YflmfMmDHsv//+jBw5kmHDhnHRRRexslaDgNVArcfB2s3dFwG4+yIz27VYRTObCEwEGDx4cI3Ck9bW4G/PZRtY8/TiduuvW9aD1tYdtv4/YED1YihXNWJoRsqZGlqcmxtbousWa5BduxZ9S0RRIirNOWjOvFPO1EChxrVuXdFG17Vr8g0pq+29GpQzFYi5YjdLOI4q2LRpE506Vd6FmDJlCqNHj2bDhg1cdtllnHnmmTz88MNViLD+GvYmF+4+2d1Hu/vofv361TuczFl3zImx6p14jEaFbBTKmSZz+unlFEkVKWfq5MTi2xe1/camnKlAzMa9007JhtGeO+64g8MPP5xDDz2UE088kSVLlgAwadIkJk6cyMknn8wnP/lJli1bxkknncRhhx3GhRdeyJAhQ1i+fDkAN910E+9///s55JBDuPDCC9m8eXPkZ3bp0oWrr76a119/ndmzZwMwbtw4Ro0axYEHHsjkyZO31u3Vqxdf//rXGTVqFCeeeCJPPvkkY8aMYa+99uLPf/5zQkuldLXuYC0xs/4A4d+lNf58ianHvX+KVe/2e7snG4hIWv3ud+UUiTS/228vWqS2L6kVs3HX8hLBQj7wgQ/w+OOPM2vWLD7+8Y9z9dVXby1raWnh9ttvZ+rUqXz729/m+OOP5+mnn+ass87i9ddfB2Du3LncfPPNPPbYYzzzzDN07NiRKVOmtPu5HTt25OCDD2bevHkAXHfddbS0tPDUU09x7bXXsiIcIGzNmjWMGTOGlpYWevfuzRVXXMH999/PbbfdxpVXXpnAEilPrS8R/DNwAfD98G/xtazU1YYRMcfBGrEh4UhEUurII8spEml+EeMBqe1LarXTuKdPDx4nnwx//GMw4PDEiTB5MowYAb16wcyZcN55cOedsH49nH9+MH5xW0q1tAT30pg6FY46CsaMKT3MhQsXcu6557Jo0SI2bNjAnnvuubXsjDPOoHv34MD6o48+ym233QbAqaeeSp8+wY3B//rXv9LS0sL73vc+ANauXcuuuxb9RdB23H3r82uvvXbr9BcsWMDLL7/MLrvsQpcuXTj11OAeeiNGjKBr16507tyZESNGMH/+/NJnOCGJdbDM7HfAGKCvmS0EvkXQsbrFzD4DvA58LKnPl8rY2jWx6q1Z2wQXC4s0otWryykSaX5rim9f1PYltdpp3GPGBI+33go6R20mTdr2/JRTgr/771+4fOzY4O/ll5cf5sUXX8xXvvIVzjjjDKZPn86knA/o2bPn1ue5naFc7s4FF1zAf/3Xf5X0uZs3b2bOnDkMHz6c6dOn88ADDzBz5kx69OjBmDFjWLduHQCdO3fGwh+qdejQga7hb9s6dOjApk2bSvrMJCV5F8Hz3L2/u3d294Hu/mt3X+HuJ7j7vuHfOp8IlWI6vzIvVr15r3ROOBKRlJozp5wikeY3r/j2RW1fUitm4167NuE42rFq1Sr22GMPAG644Yai9T7wgQ9wyy23AHDffffx1ltvAXDCCSdw6623snRp8CugN998k9deey3yMzdu3Mhll13GoEGDGDlyJKtWraJPnz706NGDefPm8fjjj1dj1mqqYW9yIfW15uxPxKo3/myNiCdSlokTyykSaX7jxxctUtuX1IrZuPv2TTiOHO+++y4DBw7c+rjmmmuYNGkSH/vYxzjmmGPoGxHMt771Le677z4OO+ww7rnnHvr370/v3r054IAD+O53v8vJJ5/MyJEjOemkk1i0aFHBaYwfP56RI0dy0EEHsWbNGm4Pf5956qmnsmnTJkaOHMk3v/lNjjjiiETmP0m1/g2WNIme027inQu/2m69KdN6cMmIGgQkkjaTJ29/bUe8IpHmN2UKXHJJwSK1fUmtmI17+fLaDQOwZUvhYUbOPPPM97w2KS/2HXfckXvvvZdOnToxc+ZMHnrooa2X65177rmce+65kZ89ffr0omVdu3blnnvuKVi2OudSy/yYVjfQNcbqYElBW3bsE6tenx3bGQNIRArbZZdyikSaX5/i2xe1fUmtmI27Y8eE46iS119/nXPOOYctW7bQpUsXfvnLX9Y7pIaiDpYUtH7UUe1XAo4cpbsIipQl4vZO5dz5SaRpRNxNTW1fUitm4+7dO9kwqmXfffdl1qxZ9Q6jYek3WFJQ9wfvilXv7ge7JRyJSEr98Y/lFIk0v7vvLlqkti+pVaBxF7oT38qVNYgl44rdAbGa1MGSgnQGSyRhOoMlWaUzWJJFeY27W7durFix4j07+81yBqtZuTsrVqygW7dkTxDoEkEpqOOyxbHqLVmmPrpIWVpbyykSaX5LlhQtUtuX1Mpr3AMHDmThwoUsW7Zsu9fXrIGc4aYkAd26dWPgwIGJfoY6WFJQp9dfjVXv1dfVhETK8tJL5RSJNL9Xi29f1PYltfIad+fOndlzzz3fU23SJN1JMw10+kEK0jhYIgnTOFiSVRoHS7IoZuNWDqSDOlhSUM9pN8WqN2Vaj4QjEUmpyZPLKRJpflOmFC1S25fUitm4lQPpoA6WFLS5766x6u3ad3PCkYikVP/+5RSJNL9di29f1PYltWI2buVAOugHNFLQxgMOjlXv4AM2JhyJSJMr9qv9IUOgtZXWxTnHuXbfPbco2uJ4N6LJna5kWzVuIDFgQIUxLO5A54GHsHFx4eO7cdp+pTFIc2iE9lpVo0eXVa0RbvzSUMuxSegMlhTUbcb9serdP0PjYImU5f7iORZRJNL0orYvavuSWnfcUc1q0uDUwZKC1h3xwVj1jj1ifcKRiKTUsceWUyTS9KK2L2r7klonn1zNatLg1MGSgjq9FvM27a/pKlORskTcqjqiSKTpRW1f1PYltWKOQaChCtJBHSwpqNOiBbHqLVzUMeFIRFJq4cJyikSaXtT2RW1fUmv+/GpWkwanDpYUpHGwRBIWMRZQRJFI04vavqjtS2ppHKxMUQdLCtI4WCIJixgLKKJIpOlFbV/U9iW1NA5WpqiDJQVt6j8oVr2B/TUOlkhZBg4sp0ik6UVtX9T2JbWGDq1mNWlw6mBJQZuG7BWr3l5DNiUciUhK7VU8xyKKRJpe1PZFbV9Sa7/9qllNGpw6WFJQt8cfjlVvxuNdE45EJKVmzCinSKTpRW1f1PYlte67r5rVpMGpgyUFrTv2pFj1Tjp2XcKRiKTUScVzLKJIpOlFbV/U9iW1xo6tZjVpcOpgSUGdX5gdq97sFzonHIlISs0unmMRRSJNL2r7orYvqfXUU9WsJg1OHSwpqOPypbHqLV2ucbBEyrK0eI5FFIk0vajti9q+pNaiRdWsJg1OHSwpSONgiSRM42BJRmkcLMkkjYOVKXXpYJnZl83seTN7zsx+Z2bd6hGHFKdxsEQSpnGwJKM0DpZkksbBypSad7DMbA/gC8Bodz8I6Ah8vNZxSLRNg2Pepn2wbtMuUhbdpl0yKmr7orYvqaXbtGdKvS4R7AR0N7NOQA+gtU5xSBGb++0eq95u/bYkHIlISu22WzlFIk0vavuiti+pNWBANatJg+tU6w909zfM7L+B14G1wH3u/p67/pvZRGAiwODBg2sbZJNqrWI3tWvL39gw+qh2681s6cJRp1fvc6V8ypkmM3MmHFU4xyKKpIqUM6HFi+PXHRDv4FuUqO2L2n5ja6qcWbwYqNFB4Di9ounTYcyYbf8X2Wmbfkdvxuz3zrYXFuecC9m98vyT2qjHJYJ9gDOBPYEBQE8ze88vXt19sruPdvfR/fr1q3WYmbf2+A/Hqnfa8RoHq1EoZ5rMaaeVUyRVpJypj6jti9p+Y1POVOAjH4lX7bS1CQcitVCPSwRPBP7p7svcfSMwDdDxqgbTteVvserNbOmScCQiKTVzZjlFIk0vavuiti+pNX16vGozuyYbh9REPTpYrwNHmFkPMzPgBGBuHeKQCB1WvRWr3lurdKd/kbK8VTzHIopEml7U9kVtX1JrxYp41d7SflUa1PxbdPcngFuBp4E5YQy6KWWD0ThYIgnTOFiSURoHSzIp7jhY49ckHIjUQl26ye7+LXcf5u4Hufu/uPv6esQhxWkcLJGEaRwsySiNgyWZFHccrCk9Ew5EakHnIaWgjfsMi1Vv2D4bE45EJKWGFc+xiCKRphe1fVHbl9QaMSJetWHar0oDdbCkIO8e7whKz+6ecCQiKdWzeI5FFIk0vajti9q+pFavXvGq9dR+VRqogyUFdZnTEqteyxzdRVCkLC3FcyyiSKTpRW1f1PYltWLeIlN3Z04HdbCkoHdPGRer3pmnaLwGkbKceWY5RSJNL2r7orYvqXXeefGqnambh6WBOlhSULdHHohV74FHNF6DSFkeKJ5jEUUiTS9q+6K2L6l1553xqj3QLeFApBbUwZKCbGO8Gztu2GgJRyKSUhs2lFMk0vSiti9q+5Ja6+PtV63foP2qNFAHSwpae+rZseqddeq6hCMRSamzziqnSKTpRW1f1PYltc4/P161s/TTizRQB0sK6nHHzbHq3XJH94QjEUmpW24pp0ik6UVtX9T2JbWuvz5etVs0vmgaqIMlBW0YPjJWvRHDNV6DSFkixkSJOVyKSFOK2r6o7UtqjRoVr9oIXSebBrE6WGZ2UNKBiIiIiIiINLu4Z7B+bmZPmtnnzGynJAOSxtBl7rOx6s2Z2znhSERSas6ccopEml7U9kVtX1Ir5iBvGl80HTrFqeTuHzCzfYFPA0+Z2ZPAb9z9/kSjk+pZvLik6u+OPTdWvXPGrgW2jU7e2lrSx4hk1znnlFMk0vSiti/nHLcMFm+OfH9r7uZs992rFJVIwiZMiFftHI2DlQaxf4Pl7i8DVwBfBz4IXGtm88ws3u3mpKl0/8u0WPVu+4vGaxApy223lVMk0vSiti/apkhqTZ0ar9ptunlYGsT9DdZIM/sxMBc4Hhjr7sPD5z9OMD6pE+8cbwDhLp094UhEUqpL8ctAIopEml7U9kXbFEmtrvH2q7p2UQ6kQaxLBIGfAr8ELnf3rTfod/dWM7sikcikrtYdc2KseiceE2/gPBHJc2LxHIsoEml6UdsXbVMktU4/PV61EzW+aBrEvUTwNGBqW+fKzDqYWQ8Ad/9tUsFJ/fS490+x6t1+r05li5Tl9tvLKRJpelHbF21TJLV+97t41W7XOFhpELeD9QCQu9brEb4mKbVhhMZrEElUxJgoMYdLEWlKUdsXbVMktY48Ml61UcqBNIjbwerm7qvb/gmfq4udYrZ2Tax6a9ZawpGIpNSa4jkWUSTS9KK2L9qmSGqtXt1+HWD1GuVAGsTtYK0xs8Pa/jGzUcDaiPrS5Dq/Mi9WvXmvaBwskbLMK55jEUUiTS9q+6JtiqRWzEHe5sxTDqRB3JtcfAn4g5m1jXLUH4g3UJI0pTVnfyJWvfFnv0vuOFgiEtP48eUUiTS9qO1LsE0RSaGJE+NVG69LGNIg1hksd/87MAz4d+BzwHB3jzcktTSlntNuilVvyjRdKSpSlilTyikSaXpR2xdtUyS1Jk+OV21Kz4QDkVqIewYL4H3A0PA9h5oZ7n5jIlFJ3W3ZsU+sen123JJwJCIp1ad4jkUUiTS9qO2LtimSWrvsEq9aH+VAGsTqYJnZb4G9gWeAzeHLDqiDlVLrRx0Vq57udiNSpog7SsW82ZRIU4ravmibIqk1Zky8akdqLLg0iHuTi9HA0e7+OXe/OHx8IcnApL66P3hXrHp3P9gt4UhEUuruu8spEml6UdsXbVMktf74x3jV7tZYcGkQt4P1HLB7koFIY9EZLJGE6QyWZJTOYEkm6QxWpsT9DVZf4AUzexLY+s27+xnlfKiZ7QT8CjiI4FLDT7v7zHKmJcnouGxxrHpLlsXto4vIdpYsKadIpOlFbV+0TZHUam1tvw7QuqRjwoFILcTtYE2q8uf+D/AXd/+omXVBgxY3nE6vvxqr3quvl3KfFBHZ6tXiORZRJNL0orYv2qZIar30UrxqryoH0iDWt+juD5vZEGBfd3/AzHoAZXWxzWwH4FhgQjjtDYCuCWgwGgdLJGEaB0sySuNgSSZpHKxMiXsXwX8FJgI7E9xNcA/g58AJZXzmXsAy4DdmdjDQAnzR3bdrUWY2MfxMBg8eXMbHZED+6ebF1bu0oue0m3jnwq+2W2/KtB5c0i/e5YRl2V0//YtLOdNkpkyBSy4ptUiqSDlTH1HblynTenDJhatrHJHEpZypwOTJMGlS+9Wm9GTSJe9U97MXl7Gfpv2visTdI/88cDTwNoC7vwzsWuZndgIOA/7P3Q8F1gCX5ldy98nuPtrdR/fr16/Mj5Jybe4b7+vdte/m9itJTShnmsyuxXMsokiqSDlTH1HbF21TGptypgL9+8ertqtyIA3idrDWh5fyAWBmnQhuTlGOhcBCd38i/P9Wgg6XNJCNBxwcq97BB2xMOBKRlDq4eI5FFIk0vajti7YpklqjR8erdrByIA3idrAeNrPLge5mdhLwB+COcj7Q3RcDC8xs//ClE4AXypmWJKfbjPtj1bt/hsYsESnL/cVzLKJIpOlFbV+0TZHUuiPebvMd9ysH0iDurUouBT4DzAEuBO4muM16uS4GpoR3EHwV+FQF05IErDvig7HqHXuExmsQKcuxx5ZTJNL0orYv2qZIap18crxqx65LOBCphVhnsNx9i7v/0t0/5u4fDZ+Xe4kg7v5MeA3vSHcf5+5vlTstSUan12Lepv013U5UpCy6TbtkVNT2RdsUSS3dpj1T4t5F8J8U+M2Vu+9V9YikIXRatCBWvYWLNCCeSFkWLiynSKTpRW1ftE2R1Jo/P161hepgpUHcbzH3l3ndgI8R3LJdUqq0cbBEpGQaB0sySuNgSSZpHKxMiXuJ4Iqcxxvu/hPg+GRDk3rqOe2mWPWmTOuRcCQiKTVlSjlFIk0vavuibYqk1uTJ8apN6ZlwIFILcS8RzL2NegeCM1q9E4lIGsKm/oNi1RvYX+M1iJRl4MByikSaXtT2RdsUSa2hQ+NVG7gp2TikJuJeIvijnOebgPnAOVWPRhrGpiHxfl631xCtCETKslfxHIsoEml6UdsXbVMktfbbL161vZQDaRD3EsHjch4nufu/uvuLSQcn9dPt8Ydj1ZvxeNeEIxFJqRkzyikSaXpR2xdtUyS17rsvXjWNBZcKcS8R/EpUubtfU51wpFGsO/akWPVO0ngNIuU5qXiORRSJNL2o7Yu2KZJaY8fGq3aSciANYp3BIvjN1b8De4SPfwMOIPgdln6LlUKdX5gdq97sFzonHIlISs0unmMRRSJNL2r7om2KpNZTT8WrNls5kAZxf4PVFzjM3d8BMLNJwB/c/bNJBSb11XH50lj1li7XmCUiZVlaPMciikSaXtT2RdsUSa1Fi+JVW6ocSIO4Z7AGAxty/t8ADK16NNIwNA6WSMI0DpZklMbBkkzSOFiZEreD9VvgSTObZGbfAp4AbkwuLKk3jYMlkjCNgyUZpXGwJJM0DlamxLpE0N2/Z2b3AMeEL33K3WclF1Y2tT69uMR3xO0fl27T4Ji3aR+s24mKlKVRb9O+uIT10O67JxeHNKbW1oonEbV9SXybUkr7BrXxJMRtQ4tz9nHK/B5aF1e2nzRg9y0VvR+2zW73fvuxNnfWi8TWb+fNFcddN+WsHwYMqH4cDaCUb7AH8La7/w+w0Mz2TCgmaQCb+8Vbme3Wr/KVj0gm7bZbOUUiTS9q+6JtiqTV5t3idSSUA+kQq4MVXhb4deCy8KXOQLxryKQpdW35W6x6M1u6JByJSErNnFlOkUjTi9q+aJsiadV15vRY9ZQD6RD3DNZZwBnAGgB3b0W3Z0+1tcd/OFa9047XeA0iZTnttHKKRJpe1PZF2xRJq7WnfSRWPeVAOsTtYG1wdwccwMz0C7yU0xkskYTpDJZklM5gSRbpDFa2xO1g3WJmvwB2MrN/BR4AfplcWFJvHVa9FaveW6ua9IeYIvX2VvEciygSaXpR2xdtUyStOry1IlY95UA6tHsXQTMz4GZgGPA2sD9wpbvfn3BsUkcaB0skYRoHSzJK42BJFq0ZH28cLOVAOrTbTQ4vDfyTu9/v7v/h7l9V5yr9NA6WSMI0DpZklMbBkizqOSXeOFjKgXSIex7ycTN7X6KRSEPZuM+wWPWG7bMx4UhEUmpY8RyLKBJpelHbF21TJK02DhsRq55yIB1iDTQMHAf8m5nNJ7iToBGc3BqZVGBSX9493n1Menb3hCMRSamexXMsokik6UVtX7RNkbTynr1i1VMOpEPkGSwzGxw+/RCwF3A8MBY4PfwrKdVlTkusei1zdLcbkbK0FM+xiCKRphe1fdE2RdKqS0u828MqB9KhvTNYfwIOc/fXzOyP7h7vJv7S9N49ZVysemeesjbZQETS6swzyykSaXpR2xdtUySt3j3zvFj1lAPp0N5vsCzn+V5JBiKNpdsjD8Sq98AjXROORCSlHiieYxFFIk0vavuibYqkVbcH7oxVTzmQDu11sLzIc0k527g+Vr0NG639SiLyXhs2lFMk0vSiti/apkha2QbtV2VJe5cIHmxmbxOcyeoePodtN7nYodwPNrOOwFPAG+5+ernTkWSsPfXsWPXOOnVdwpGIpNRZZ5VTJNL0orYv2qZIWq096/xY9ZQD6RB5BsvdO7r7Du7e2907hc/b/i+7cxX6IjC3wmlIQnrccXOserfc0T3hSERS6pZbyikSaXpR2xdtUyStetxyfax6yoF0iDsOVlWZ2UDgw8Cv6vH50r4Nw+PdgX/EcI3XIFKWEcXHRIkoEml6UdsXbVMkrTaMGBWrnnIgHeKOg1VtPwG+BvQuVsHMJgITAQYPHlysWu21tpZWf8CAZOKQokr9igppxq+tYXOmWSxeXNbbWheXd5yq68oOrM9/b1sMK7vC4njX60v56pYzZW5HqrFuq1S57T0xZeZt5dPfUvjlZtx4lEDbmSKikrMtZ1a+lXx7TUjsdU/E+mHA7kVyJqVqvqY0s9OBpe4eOdKLu09299HuPrpfv341ik7adJn7bKx6c+Z2TjgSiUs501yickx5VRvKmfpQ229eypnyab8qW+pxKOpo4Awzmw/8HjjezG6qQxwS4d2x58aqd85YjdcgUo6oHFNeSZqp7UsWab8qW2rewXL3y9x9oLsPBT4OPOjun6h1HBKt+1+mxap321+6JRyJSDpF5ZjyStJMbV+ySPtV2dJgF1NLo/DO8Qa669JZw6OJlCMqx5RXkmZq+5JF2q/Klnrd5AIAd58OTK9nDFLYumNOjFXvxGP0Q3yRckTlmPJK0kxtX7JI+1XZojNYUlCPe/8Uq97t92q8BpFyROWY8krSTG1fskj7VdmiDpYUFHe8hlEjNiQciUg6ReWY8krSTG1fskj7VdmiDpYUZGvXxKq3Zq0lHIlIOkXlmPJK0kxtX7JI+1XZog6WFNT5lXmx6s17ReM1iJQjKseUV5JmavuSRdqvyhZ1sKSgNWfHu3P++LPfTTgSkXSKyjHllaSZ2r5kkfarskUdLCmo57R4Yz9PmdYj4UhE0ikqx5RXkmZq+5JF2q/KFnWwpKAtO/aJVa/PjlsSjkQknaJyTHklaaa2L1mk/apsUQdLClo/6qhY9Y4cpbvdiJQjKseUV5JmavuSRdqvyhZ1sKSg7g/eFave3Q92SzgSkXSKyjHllaSZ2r5kkfarskUdLClIR1pEkqWj+JJVavuSRdqvyhZ1sKSgjssWx6q3ZJmakEg5onJMeSVpprYvWaT9qmzpVO8A0qJ1cboSotPrr8aq9+rrCTehxfFWSFvtvnsycUiyWlvj1x0wILk4aigqxxLPK5E6SkPbr3Sbn5LVWOpVc9+uKvtVpe4TpUgpuwnF1DLv0tUrkKrReA0iydJYQJJVavuSRdqvyhZ1sKQgjdcgkiyNBSRZpbYvWaT9qmxRB0sK2tx311j1du27OeFIRNIpKseUV5JmavuSRdqvyhZ1sKSgjQccHKvewQdsTDgSkXSKyjHllaSZ2r5kkfarskUdLCmo24z7Y9W7f4bGaxApR1SOKa8kzdT2JYu0X5Ut6mBJQeuO+GCsescesT7hSETSKSrHlFeSZmr7kkXar8oWdbCkoE6vxbyd6GvNcUtdkUYTlWPKK0kztX3JIu1XZYs6WFJQp0ULYtVbuKhjwpGIpFNUjimvJM3U9iWLtF+VLepgSUEar0EkWRoLSLJKbV+ySPtV2aIOlhSk8RpEkqWxgCSr1PYli7RflS3qYElBm/oPilVvYH+N1yBSjqgcU15JmqntSxZpvypb1MGSgjYN2StWvb2GbEo4EpF0isox5ZWkmdq+ZJH2q7JFHSwpqNvjD8eqN+PxrglHIpJOUTmmvJI0U9uXLNJ+VbbUvINlZoPM7CEzm2tmz5vZF2sdg7Rv3bEnxap30rHrEo5EJJ2ickx5JWmmti9ZpP2qbKnHGaxNwCXuPhw4Avi8mR1QhzgkQucXZseqN/uFzglHIpJOUTmmvJI0U9uXLNJ+VbbUvIPl7ovc/enw+TvAXGCPWsch0TouXxqr3tLlGq9BpBxROaa8kjRT25cs0n5VttR1uGgzGwocCjxRoGwiMBFg8ODBtQ1Mmne8hsWLS6u/++4FX25trSyMAQMqe385mi1ntlvGi0s41lPqd9ygajoWUA2WmXKmgTR4jmgcrMrzBRo/Z4rOYynr+63vaew2HUfT7ldJWep2kwsz6wX8EfiSu7+dX+7uk919tLuP7tevX+0DzDiN19B8lDPNRWMB1Z9ypj7U9puXcqZ82q/Klrp0sMysM0Hnaoq7T6tHDBJt0+CYtxMdrNuJipQjKseUV5JmavuSRdqvypZ63EXQgF8Dc939mlp/vsSzuV/hS+fy7dZvS8KRiKRTVI4pryTN1PYli7RflS31OIN1NPAvwPFm9kz4OK0OcUiEri1/i1VvZkuXhCMRSaeoHFNeSZqp7UsWab8qW2p+kwt3fxSwWn+ulGbt8R+OVe+04zVeg0g5onJMeSVpprYvWaT9qmyp200upLHpSItIsnQUX7JKbV+ySPtV2aIOlhTUYdVbseq9tUpNSKQcUTmmvJI0U9uXLNJ+VbboW5SCNF6DSLI0FpBkldq+ZJH2q7JFHSwpSOM1iCRLYwFJVqntSxZpvypb1MGSgjbuMyxWvWH7bEw4EpF0isox5ZWkmdq+ZJH2q7JFHSwpyLv3jFWvZ3dPOBKRdIrKMeWVpJnavmSR9quyRR0sKajLnJZY9Vrm6G43IuWIyjHllaSZ2r5kkfarskUdLCno3VPGxap35ilrkw1EJKWickx5JWmmti9ZpP2qbFEHSwrq9sgDseo98EjXhCMRSaeoHFNeSZqp7UsWab8qW9TBkoJs4/pY9TZstIQjEUmnqBxTXkmaqe1LFmm/KlvUwZKC1p56dqx6Z526LuFIRNIpKseUV5JmavuSRdqvypZO9Q6gGlpbK5/GgAGVT6OgxYsTmnCyetxxM+9c+NV2691yR3cuuXB1DSKSamronMmIqBxTXjWeauTMVotLPLbZpNuRYtT2JYuabr+qyuud1lLXe00uW3MrsW0YPjJWvRHDNV6DSDmickx5JWmmti9ZpP2qbFEHS0REREREpErUwZKCusx9Nla9OXM7JxyJSDpF5ZjyStJMbV+ySPtV2aIOlhT07thzY9U7Z6zGaxApR1SOKa8kzdT2JYu0X5Ut6mBJQd3/Mi1Wvdv+0i3hSETSKSrHlFeSZmr7kkXar8oWdbCkIO8cb6C7Lp094UhE0ikqx5RXkmZq+5JF2q/KFnWwpKB1x5wYq96Jx8QbOE9EtheVY8orSTO1fcki7VdlizpYUlCPe/8Uq97t93ZPNhCRlIrKMeWVpJnavmSR9quyRR0sKWjDiFGx6o0asSHhSETSKSrHlFeSZmr7kkXar8oWdbCkIFu7Jla9NWst4UhE0ikqx5RXkmZq+5JF2q/KFnWwpKDOr8yLVW/eKxqvQaQcUTmmvJI0U9uXLNJ+VbaogyUFrTn7E7HqjT/73YQjEUmnqBxTXkmaqe1LFmm/KlvUwZKCek67KVa9KdN6JByJSDpF5ZjyStJMbV+ySPtV2VKXDpaZnWpmL5rZK2Z2aT1ikGhbduwTq16fHbckHIlIOkXlmPJK0kxtX7JI+1XZUvMOlpl1BH4GfAg4ADjPzA6odRwSbf2oo2LVO3KU7nYjUo6oHFNeSZqp7UsWab8qW+pxBuv9wCvu/qq7bwB+D5xZhzgkQvcH74pV7+4HuyUciUg6ReWY8krSTG1fskj7Vdli7l7bDzT7KHCqu382/P9fgMPd/aK8ehOBieG/+wMvAn2B5TUMN2lpmp80zQvUZn6GuHu/ak2sSM6kWdraXBTNa5XzBSrKmUb9PhRXadIeV61yplGXYxI0r+nUNq9Vy5l6dLA+BpyS18F6v7tfHOO9T7n76KRjrJU0zU+a5gXSNz9plKXvSPPaWBo1RsVVGsVVHc0WbyU0r+mUxLzW4xLBhcCgnP8HAq11iENERERERKSq6tHB+juwr5ntaWZdgI8Df65DHCIiIiIiIlXVqdYf6O6bzOwi4F6gI3Cduz8f8+2Tk4usLtI0P2maF0jf/KRRlr4jzWtjadQYFVdpFFd1NFu8ldC8plPV57Xmv8ESERERERFJq7oMNCwiIiIiIpJG6mCJiIiIiIhUSd06WGZ2qpm9aGavmNmlBcrNzK4Ny581s8NyynYys1vNbJ6ZzTWzI8PXdzaz+83s5fBvnyafn0lm9oaZPRM+TmvkeTGz/XNifcbM3jazL4VlTffdtDM/dflusqKC76ybmT1pZrPN7Hkz+3btoy9NJeuOsLyjmc0ysztrF3XpKlxHzjezOWGuPdVAcRV8bzXWDxXGdZ2ZLTWz5/LeU/F6OKG46ra8zGyQmT1kwbb3eTP7Ys576ra82okrse1PQvlQt+1/lITm9YcW7Ms9a2a3mdlONZqdSEnMa075V83Mzaxv0vMRR1LzamYXh2XPm9nV7Qbi7jV/ENzc4h/AXkAXYDZwQF6d04B7AAOOAJ7IKbsB+Gz4vAuwU/j8auDS8PmlwA+afH4mAV9tpu8mbzqLCQZta9rvJmJ+av7dZOVRyXcW/t8rfN4ZeAI4ot7zlMS85pR/BZgK3Fnv+UlqPoH5QN9GiivqvZWuH6qwvI4FDgOey3tPRevhBOOq2/IC+gOHhc97Ay/lfI91W17txFXR8qpDPtRl+1+neT0Z6BQ+/0Ga5zUsH0Rw07rXSGAd3SjzChwHPAB0Df/ftb1Y6nUG6/3AK+7+qrtvAH4PnJlX50zgRg88DuxkZv3NbAeClfSvAdx9g7uvzHnPDeHzG4Bxyc7GVknNTz2UPS95dU4A/uHur+W8p6m+m7w6+fMjySn7Owv/Xx3W6Rw+GvlOPhW1TzMbCHwY+FUtgy5DtfKwkeKK8956xIW7zwDeLDDdStfDScVVqUrWGYvc/ekwvneAucAeOe+py/JqJ66kJJUP9dr+R0lkXt39PnffFL7/cYKxXustyfXcj4Gv0Tjb2aTm9d+B77v7egB3X9peIPXqYO0BLMj5fyHvXXEUq7MXsAz4jQWXxfzKzHqGdXZz90UA4d9dkwi+gKTmB+Ci8BTmdTU6rV7JvOT6OPC7nP+b8bvJlT8/UPvvJisq+s4suGTuGWApcL+7P5FcqBWrtH3+hGDjtiWh+Kql0vl04D4zazGziQ0SV3vvrWT9UK31Vr5K18NJxQUNsLzMbChwKMGZb2iQ5VUgLkhm+5NUPtRr+x8lydxv82mCMyX1lsi8mtkZwBvuPrvaAVcgqe91P+AYM3vCzB42s/e1F0i9OlhW4LX83m+xOp0ILjH4P3c/FFhDcMq5npKan/8D9gYOARYBP6pGsO2oZF6CwmAA6TOAP1QxrnIlNT/1+G6yoqLvzN03u/shBEcO329mB1U3vKoqe17N7HRgqbu3VD+sqqs0D49298OADwGfN7NjGyCuqPdWun6oeL2VkKTiqvvyMrNewB+BL7n72yV+fq3jSmr7k1Q+NKJE59XMvgFsAqaUFV11VX1ezawH8A3gygpjq7akvtdOQB+CSwr/A7jFzArV36peHayFBNdtthkItMassxBYmHNU+laCDgrAkpxLZ/oTHMGuhUTmx92XhDuLW4BfEpy+TFol89LmQ8DT7r4k57Vm/G7avGd+6vTdZEU1vjM8uNR2OnBq1SOsnkrm9WjgDDObT3Apw/FmdlNyoVakou/U3dv+LgVuo3r5Vum6u1i8la4fqpIDBVS6Hk4krnovLzPrTNCJmeLu03Lq1HV5FYsrwe1PIvlA/bb/UZKaV8zsAuB0YLy7N0InM4l53RvYE5gdboMGAk+b2e5Vjbx0SX2vC4Fp4WWFTxJcNRJ9Uw+vz4/QOgGvEnw5bT8kOzCvzofZ/kdoT+aUPQLsHz6fBPwwfP5Dtv8h5dVNPj/9c+p8Gfh9o89LWP574FN5rzXldxMxPzX/brLyqOQ7A/qx7SYx3cPcOr3e85TEvObVGUNj3+Siku+0J9A75/nfgFMbIK6i7610/VCl9dZQ3nsziYrWwwnGVbflFf5/I/CTAtOt2/JqJ65Etj8J5kNdtv91mtdTgReAfvWex6TnNe/982mMm1wk9b3+G/Cd8Pl+BJcSWmQsdVwIpxHcFecfwDdyZuDfwucG/CwsnwOMznnvIcBTwLPAn4A+4eu7AH8FXg7/7tzk8/PbsO6zwJ/JWak28Lz0AFYAO+ZNs1m/m2LzU5fvJiuPcr8zYCQwK/xengOurPe8JDWvedMYQwN3sCr8Tvci2NDNBp5ve2+94yr23vD1itcPFcb1O4JLxzYSHHn9TPh6xevhhOKq2/ICPkBwGdCzwDPh47R6L6924kps+1Ph91ssH+q2/a/DvL5CsPPd9p39vN7zmdS85k1/Pg3QwUrwe+0C3ESwX/E0cHx7cVj4RhEREREREalQ3QYaFhERERERSRt1sERERERERKpEHSwREREREZEqUQdLRERERESkStTBEhERERERqRJ1sGrMzH5sZl/K+f9eM/tVzv8/MrOvRLx/gpkNqDCGCWb200qm0c7055vZewZgs8CDZrZDCdM63cy+Xd0IpZkoZ5QzUhrljHJGSqOcUc5UmzpYtfc34CgAM+tAMBL0gTnlRwGPRbx/AlBSEptZp9JCTMxpwGx3f7uE99wFnGFmPRKKSRqfckY5I6VRzihnpDTKGeVMVamDVXuPESYxQfI+B7xjZn3MrCswHJhlZlea2d/N7DkzmxweYfgoMBqYYmbPmFl3MxtlZg+bWUt4xKU/gJlNN7P/NLOHgS/GCczMPmFmT4bT/oWZdTSzfzezq3PqTDCz/y1Wv52PGA/cHr53qJnNM7NfhfM4xcxONLPHzOxlM3s/gAcDtU0HTo8zD5JKyhmUM1IS5QzKGSmJcgblTDWpg1Vj7t4KbDKzwQTJPBN4AjiSIEGfdfcNwE/d/X3ufhDQHTjd3W8FngLGu/shwCbgf4GPuvso4Drgezkft5O7f9Ddf9ReXGY2HDgXODqc9maCpLsVODun6rnAzRH1oxwNtOT8vw/wP8BIYBhwPsHo9V8FLs+p9xRwTHvzIOmknFHOSGmUM8oZKY1yRjlTbY1yejJr2o6UHAVcA+wRPl9FcJoa4Dgz+xrQA9gZeB64I286+wMHAfebGUBHYFFO+c0lxHQCMAr4ezit7sBSd19mZq+a2RHAy+FnPgZ8vlD9dj5jZ3d/J+f/f7r7HAAzex74q7u7mc0BhubUW0qJp94ldZQzAeWMxKWcCShnJC7lTEA5UwXqYNVH27W+IwhOQy8ALgHeBq4zs27A/wNGu/sCM5sEdCswHQOed/cji3zOmhJiMuAGd7+sQNnNwDnAPOC2MNGi6hezycw6uPuW8P/1OWVbcv7fwvZtsxuwtoTPkfRRzgSUMxKXciagnJG4lDMB5UwV6BLB+niM4LrVN919s7u/CexEcCp6JtsSdrmZ9QI+mvPed4De4fMXgX5mdiSAmXU2s9wfZZbir8BHzWzXcFo7m9mQsGwaMA44j21HXqLqF/MisFcZse1HsLKT7FLOlEY5I8qZ0ihnRDlTGuVMBHWw6mMOwR1qHs97bZW7L3f3lcAvw9f+BPw9p971wM/N7BmC084fBX5gZrOBZ9j2I832TDCzhW0PgiM0VwD3mdmzwP1AfwB3fwt4ARji7k+Gr71QrH6Eu4AxMePLdVz4Xsku5UxplDOinCmNckaUM6VRzkQwd693DJIRFtxF50Z3P6mE9+wGTHX3E5KLTKQxKWdESqOcESmNciYZ6mBJTZnZOcBfPOZ4C2b2PmCjuz+TaGAiDUo5I1Ia5YxIaZQz1acOloiIiIiISJXoN1giIiIiIiJVog6WiIiIiIhIlaiDJSIiIiIiUiXqYImIiIiIiFSJOlgiIiIiIiJV8v8BVSFIDsLjF8sAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 864x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1, sds_finals.shape[1] , figsize = (12,4), sharey = True)\n",
    "threshs = [0.1, 0.5, 1, 2]\n",
    "pvals = ttest_ind(sd_finals, sds_finals, axis = 0)[1]\n",
    "for i in range(sds_finals.shape[1]):\n",
    "    axs[i].hist(sds_finals[:,i], alpha = 0.1, linewidth = 1, color = 'red', )\n",
    "    axs[i].hist(sd_finals[:,i], alpha = 0.1, linewidth = 1, color = 'blue')\n",
    "    # set title\n",
    "    axs[i].set_title(f\"{ threshs[i] } m, pval = { round(pvals[i],2) }\")\n",
    "    # add mean line\n",
    "    axs[i].axvline(np.mean(sds_finals[:,i]), color = 'red', linewidth = 0.5, linestyle = '--', label = 'Small Dams')\n",
    "    axs[i].axvline(np.mean(sd_finals[:,i]), color = 'blue', linewidth = 0.5, linestyle = '--', label = 'Large Dam')\n",
    "    # label axes\n",
    "    axs[i].set_xlabel(\"Water Level (m)\")\n",
    "    axs[0].set_ylabel(\"Frequency\")\n",
    "    \n",
    "plt.legend()\n",
    "# add title \n",
    "fig.suptitle('Fraction of Cells Flooded at End of Simulation (50 Trials)')\n",
    "plt.tight_layout()\n",
    "\n",
    "# save figure\n",
    "fig.savefig(r'./media/all_dams_hist.png', dpi = 300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "# difference of means test\n",
    "a = sds_df['final_levels'].to_numpy()\n",
    "b = sd_df['final_levels'].to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x216 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# take mean of each array in a,b\n",
    "exp_b = np.mean(b, axis = 0)\n",
    "exp_a = np.mean(a, axis = 0)\n",
    "\n",
    "# 2 column subplots\n",
    "fig, axs = plt.subplots(1,2, figsize = (6,3), sharey = True)\n",
    "\n",
    "fl = axs[0].imshow(exp_a[20:40, 60:80] , cmap = 'Greys')\n",
    "# add title \n",
    "axs[0].set_title(\"Large Dam\")\n",
    "axs[1].imshow(exp_b[20:40, 60:80], cmap = 'Greys')\n",
    "axs[1].set_title(\"Small Dams\")\n",
    "\n",
    "#add colorbar\n",
    "fig.subplots_adjust(right=0.8)\n",
    "cbar_ax = fig.add_axes([0.85, 0.25, 0.02, 0.5])\n",
    "fig.colorbar(fl, cax=cbar_ax)\n",
    "# add label to colorbar\n",
    "cbar_ax.set_ylabel(\"Water Level (m)\")\n",
    "\n",
    "# add overall title\n",
    "fig.suptitle('Expected Final Levels in Kottayam (50 Trials)')\n",
    "\n",
    "#save fig\n",
    "fig.savefig(r'./media/all_dams_exp_final.png', dpi = 300)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# input: curr_time(s) returns: rain (in m)\n",
    "def s_to_h(s, step = 60):\n",
    "    second_of_day = s*60 % (3600*24)\n",
    "    \n",
    "    return second_of_day/3600\n",
    "\n",
    "\n",
    "def plot_floods_kerala():\n",
    "\n",
    "    water = kerala[...,1]\n",
    "    water  = np.where(water > 0.1, 1, 0)\n",
    "\n",
    "    # 2 subplots\n",
    "    fig, axs = plt.subplots(1,2, figsize = (8,4), sharey=True)\n",
    "\n",
    "\n",
    "    img = Image.open(r'./media/map.png')\n",
    "    img_size = img.size \n",
    "    print(img_size)\n",
    "    # crop img\n",
    "    img = img.crop((1042/2.5,0,1042,1042/2))\n",
    "    img = img.resize((100, 100), Image.ANTIALIAS)\n",
    "\n",
    "    axs[0].imshow(water, cmap = 'Greys', alpha=1)\n",
    "    axs[0].imshow(img, alpha = 0.3)\n",
    "    axs[0].set_title('WeightedCA Flood Map')\n",
    "\n",
    "    fa_kerala = generate_flow_acc(kerala[...,3])\n",
    "\n",
    "    axs[1].imshow(fa_kerala, cmap = 'Greys')\n",
    "    axs[1].imshow(img, alpha=0.2)\n",
    "    axs[1].set_title('Flow Accumulation Map')\n",
    "\n",
    "    # SET OVERALL title\n",
    "    fig.suptitle(f'Flood Map for a Heavy Monsoon Day ({1440/30} mm)')\n",
    "\n",
    "    # save fig\n",
    "    fig.savefig(r'./media/flood_map.png', dpi = 200)\n",
    "\n",
    "def proposals():\n",
    "    # protext kottayam !\n",
    "    # draw rectanfle on img\n",
    "    from matplotlib import patches \n",
    "\n",
    "    img = Image.open(r'./media/map.png')\n",
    "    img_size = img.size \n",
    "    print(img_size)\n",
    "    # crop img\n",
    "    img = img.crop((1042/2.5,0,1042,1042/2))\n",
    "    img = img.resize((100, 100), Image.ANTIALIAS)\n",
    "\n",
    "    rect = patches.Rectangle((20,60), 20, 20, fill = False, edgecolor = 'black')\n",
    "    # add label for rect\n",
    "\n",
    "    fig, axs = plt.subplots(1,2, figsize = (8,4))\n",
    "\n",
    "    axs[0].imshow(img)\n",
    "    # add rect\n",
    "    axs[0].add_patch(rect)\n",
    "    axs[0].text(20, 85, 'Kottayam', fontsize = 10)\n",
    "\n",
    "    # add line\n",
    "    x = [45,45]\n",
    "    y = [55, 75]\n",
    "    axs[0].plot(x, y, color = 'indianred', linewidth = 4)\n",
    "    axs[0].text(50, 65, 'Proposed Dam', fontsize = 10, color = \"red\")\n",
    "    # get length of line\n",
    "    line_length = np.sqrt((45-45)**2 + (75-55)**2)\n",
    "    # Add title \n",
    "    axs[0].set_title(f'Large Dam Proposal ({line_length:.2f} km)')\n",
    "\n",
    "\n",
    "    axs[1].imshow(img)\n",
    "    # add rect\n",
    "    rect = patches.Rectangle((20,60), 20, 20, fill = False, edgecolor = 'black')\n",
    "    axs[1].add_patch(rect)\n",
    "    axs[1].text(20, 85, 'Kottayam', fontsize = 10)\n",
    "\n",
    "    # add line\n",
    "    x = [45,45, 45, 35, 35, 55]\n",
    "    y = [55, 75, 65, 45,55,45]\n",
    "    axs[1].scatter(x, y, color = 'indianred', linewidth = 2, marker = 's')\n",
    "    axs[1].text(50, 65, 'Proposed Dams', fontsize = 10, color = \"red\")\n",
    "    # get length of line\n",
    "    line_length = 6*0.72\n",
    "    # Add title \n",
    "    axs[1].set_title(f'Small Dams Proposal ({line_length:.2f} km)')\n",
    "\n",
    "\n",
    "    # save fig\n",
    "    fig.savefig(r'./media/dam_proposal.png', dpi = 200)\n",
    "\n",
    "\n",
    "def plot_rainfall():\n",
    "    # A Poisson-Cascade Model\n",
    "    # init 3 column subplots\n",
    "    fig, axs = plt.subplots(1,3, figsize = (15,5))\n",
    "\n",
    "    avg = 700\n",
    "\n",
    "    # poisson distribution for days in a month\n",
    "    monthly_rainfall = np.random.poisson(lam=avg/30, size=30)\n",
    "\n",
    "    # sample a day from monthly_rainfall\n",
    "    day = np.random.choice(range(len(monthly_rainfall)), size=1)\n",
    "\n",
    "    # poisson distribution for rainfall each hour\n",
    "    daily_rainfall = np.random.poisson(lam=monthly_rainfall[day]/12, size=12)\n",
    "\n",
    "    # sample an hour from daily_rainfall\n",
    "    hour = np.random.choice(range(len(daily_rainfall)), size=1)\n",
    "    # poisson distribution for rainfall each minute\n",
    "    hourly_rainfall = np.random.poisson(lam=daily_rainfall[hour]/60, size=60)\n",
    "\n",
    "    # bar plot of monthly rainfall\n",
    "    axs[0].bar(np.arange(30), monthly_rainfall, alpha = 0.5)\n",
    "    # get color of bar\n",
    "    bar_color = axs[0].patches[3].get_facecolor()\n",
    "    axs[0].bar(day, monthly_rainfall[day], color = bar_color, alpha = 0.6)\n",
    "    axs[0].set_xlabel('Day of Month')\n",
    "\n",
    "    print(np.sum(monthly_rainfall))\n",
    "\n",
    "    # clear plot\n",
    "    axs[1].bar(np.arange(12), daily_rainfall, alpha = 0.6)\n",
    "    bar_color = axs[1].patches[0].get_facecolor()\n",
    "    axs[1].bar(hour, daily_rainfall[hour], color = bar_color, alpha = 1)\n",
    "    # add x label\n",
    "    axs[1].set_xlabel('Hour of Day')\n",
    "    print(np.sum(daily_rainfall))\n",
    "\n",
    "    axs[2].bar(np.arange(1,61), hourly_rainfall)\n",
    "    axs[2].set_xlabel('Minute of Hour')\n",
    "    print(np.sum(hourly_rainfall))\n",
    "\n",
    "    # set y label for all\n",
    "    for ax in axs:\n",
    "        ax.set_ylabel('Rainfall (mm)')\n",
    "\n",
    "    # Set overall tite\n",
    "    fig.suptitle(f'Poisson-Cascade Model for Precipitation, {avg}mm/month average')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def kerala_resample():\n",
    "    # Test: Decrease Resolution by resamp\n",
    "    kerala = geotiff.GeoTiff(r'./media/kerala.tif')\n",
    "\n",
    "    # 2 subplots\n",
    "    fig, axs = plt.subplots(1,3, figsize = (12,4), sharey=False)\n",
    "\n",
    "    dem = np.array(kerala.read())\n",
    "    print(dem.shape)\n",
    "    # fit to mountains\n",
    "    dem = dem[400: , 600:]\n",
    "    # if negative set to 0\n",
    "    dem[dem < 0] = 0\n",
    "    print(dem.shape)\n",
    "\n",
    "    # hist of dem\n",
    "    axs[0].hist(dem.flatten(), bins = 100, color = 'grey')\n",
    "    # title\n",
    "    axs[0].set_title('Elevation')\n",
    "    axs[0].set_xlabel('Elevation (m)')\n",
    "\n",
    "    small_dem = resample_array(dem, 100, 100)\n",
    "    axs[1].hist(small_dem.flatten(), bins = 100, color = 'grey')\n",
    "    axs[1].set_title('Elevation (Resampled)')\n",
    "    axs[1].set_xlabel('Elevation (m)')\n",
    "\n",
    "    img = Image.open(r'./media/Figures_2/map.png')\n",
    "    img_size = img.size \n",
    "    print(img_size)\n",
    "    # crop img\n",
    "    img = img.crop((1042/2.5,0,1042,1042/2))\n",
    "    img = img.resize((100, 100), Image.ANTIALIAS)\n",
    "\n",
    "    axs[2].imshow(img, alpha = 1)\n",
    "\n",
    "    axs[2].imshow(small_dem, cmap = 'gray_r', alpha = 0.65)\n",
    "    # x label\n",
    "    axs[2].set_xlabel('Position Index')\n",
    "    axs[2].set_ylabel('Position Index')\n",
    "    # add colorbar\n",
    "    cbar = fig.colorbar(axs[2].get_images()[1], ax = axs[2])\n",
    "    # add title \n",
    "    axs[2].set_title('Elevation over Study Area')\n",
    "\n",
    "    # save figure\n",
    "    fig.savefig(r'./media/dem_map.png', dpi = 300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Checklist\n",
    "\n",
    "+ Pseudocode, well-written\n",
    "    + [+] Synthesize paper \n",
    "    + [+] Demo flow\n",
    "    + [+] Test on larger raster\n",
    "\n",
    "[+] Get Rainfall Distributions\n",
    "    + Local areas (circles)\n",
    "    + Amounts over time \n",
    "\n",
    "+ Runoff\n",
    "[+] Precipitation \n",
    "    [+] Uniform\n",
    "    [+] Circular (API in progress)\n",
    "    [+] Border\n",
    "    [+] Time-varying\n",
    "    \n",
    "+ Infiltration (much smaller scale), so ruled out. \n",
    "\n",
    "### Testing\n",
    "[+] a funcanim of pouring over time, and if things balance out. \n",
    "[+] Is mass conserved? \n",
    "[+] Water level on cell/1D slice over time\n",
    "[+] Write results to disk (params, time)\n",
    "[+] Quiver plot\n",
    "\n",
    "### Strategies \n",
    "[+] Metrics\n",
    "    + Water height/cell\n",
    "    + mean flow rate (m^3/s)\n",
    "[+] % chance of inundation\n",
    "    \n",
    "[+] Sites. \n",
    "    Sites of interest (e.g. population centers, rivers, etc)\n",
    "[+] Damages caused by flood vs water level\n",
    "    + Blocking Flow (high Walls : what gets flooded in turn?)\n",
    "    + block based on the water levels we observe\n",
    "\n",
    "### Plotting\n",
    "[+] Set rcParams\n",
    "[+] 3D viz of a DEM\n",
    "[+] Flowline of a point using D8, perhaps alternatives\n",
    "    (then do salmon algo)\n",
    "[+] test to see if a flood barrier works\n",
    "\n",
    "### Theoretical Baselines\n",
    "[+] Flow accumulation matrices\n",
    "    [+] \"Swimming Upstream\" over gradient/slope fields\n",
    "[+] Maximum flow velocity (mgh -> 1/2 m v^2)\n",
    "\n",
    "### Upkeep\n",
    "[+] Save figures\n",
    "[+] Save data\n",
    "[+] Refactor code"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "40d3a090f54c6569ab1632332b64b2c03c39dcf918b08424e98f38b5ae0af88f"
  },
  "kernelspec": {
   "display_name": "Python 3.8.5 64-bit ('base': conda)",
   "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.7"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}