CN_hydrology.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "34a9cfba",
   "metadata": {
    "hide_input": true
   },
   "source": [
    "## Curve Number Hydrology\n",
    "Demonstration use case of ipython notebook in exploring relationships of rainfall and watershed characteristics to runoff.\n",
    "Modify input values in the appropriate boxes then press the run button above.\n",
    "\n",
    "#### Enter base watershed characteristics below. \n",
    "######      Required\n",
    "    pr = precip depth for storm in inches (req'd)\n",
    "    cnum = curve number for soil and landcover type (req'd) \n",
    "    area = watershed area in acres (req'd)  \n",
    "    slp = watershed slope (x/y) (req'd)\n",
    "    pf = hydrograph peak factor (req'd)\n",
    "######      Optional\n",
    "    iabs = intial abstraction value, 0.05 or 0.2 most common, 0.2 is default (opt) \n",
    "    flen = flow path length, in feet, set to 0 if unknown will calculate using eq 630 15-5 (opt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "d16deee8",
   "metadata": {
    "hide_input": false,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       "    if (code_show){\n",
       "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "    } else {\n",
       "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "    }\n",
       "    code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "from IPython.display import HTML\n",
    "from IPython.display import display\n",
    "\n",
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "\n",
    "############### Write code below ##################\n",
    "\n",
    "def resample(delta, xvals, yvals):\n",
    "    \"\"\"\n",
    "    resamples a function of x and y values at a new delta x via linear\n",
    "    interpolation\n",
    "    \"\"\"\n",
    "    nu_x = np.zeros(1)\n",
    "    nu_y = np.zeros(1)\n",
    "    x = 0\n",
    "    # interpolate out just a bit longer than the original distribution\n",
    "    while x < xvals[-1]:\n",
    "        x+=delta\n",
    "        nu_x = np.append(nu_x, x)\n",
    "        y = linterp(x, xvals, yvals)\n",
    "        nu_y = np.append(nu_y, y)\n",
    "    return nu_x, nu_y\n",
    "\n",
    "def linterp(x, xvals, yvals):\n",
    "    \"\"\"\n",
    "    Linearly interpotates the y value given a value x and \n",
    "    vectors of x and y for the function range.  xvals and yvals must be same \n",
    "    dimensions\n",
    "    \n",
    "    Inputs:\n",
    "        x, (float) - known value of x for which corresponding unknown value\n",
    "                    of y is needed\n",
    "        xvals, (vector, floats) - vector of x-values for which corresponding \n",
    "                    y-values are known.\n",
    "        yvals, (vector, floats) - vector of y-values for which corresponding\n",
    "                    x- values are given.\n",
    "    Outputs:\n",
    "        y (float) - determined value of y corresponding to x\n",
    "    \"\"\"\n",
    "    # test for dimensional consistency\n",
    "    if xvals.shape == yvals.shape: \n",
    "        # make sure x is in the range of the function\n",
    "        # check to see if this x value is explicit\n",
    "        if x in xvals:\n",
    "            i = np.where(xvals==x)[0][0]\n",
    "            y = yvals[i]\n",
    "        elif x >= xvals[-1]:\n",
    "            y = yvals[-1] +\\\n",
    "                (yvals[-1]-yvals[-2])/(xvals[-1]-xvals[-2])*(x - xvals[-1])\n",
    "        elif x <= xvals[0]:\n",
    "            y = yvals[0]\n",
    "        else:\n",
    "            i = 0\n",
    "            # get last xval just smaller than desired location    \n",
    "            while x >= xvals[i] and i < xvals.shape[0]-1:\n",
    "                i+=1\n",
    "            emm = (yvals[i] - yvals[i-1])/(xvals[i] - xvals[i-1])\n",
    "            y = yvals[i-1] + (x - xvals[i-1])*emm\n",
    "    else:\n",
    "        print(\"x and y ranges do not agree\")\n",
    "        y = 0\n",
    "    return y\n",
    "\n",
    "\n",
    "def calc_cn_runoff(cn, p, ini_rat=0.05):\n",
    "    \"\"\"\n",
    "    Calculates total and incremental runoff for a given storm \n",
    "    \"\"\"\n",
    "    s = max(1000./cn - 10.,0)\n",
    "    ia = s*ini_rat\n",
    "    inc_ro = np.zeros(p.shape[0])\n",
    "    tot_ro = np.zeros(p.shape[0])\n",
    "    for i in range(p.shape[0]):\n",
    "        if p[i] > ia:\n",
    "            tot_ro[i] = ((p[i]-ia)**2/(p[i]+s-ia)) \n",
    "            inc_ro[i] = tot_ro[i] - tot_ro[i-1]\n",
    "    return tot_ro, inc_ro\n",
    "\n",
    "\n",
    "def calc_gamma(pf, inc,  tol=1e-7, min_pts=100):\n",
    "    \"\"\"\n",
    "    calculates runoff hydrograph at an interval \n",
    "    m-vals across the range of 100-600 can be approximated\n",
    "    using prf and the equation below. Relationship was constructed using\n",
    "    table 630-16.5 from NEH\n",
    "    \n",
    "    Inputs:\n",
    "\n",
    "    Outputs:\n",
    "\n",
    "    \"\"\"\n",
    "    ## calculate m factor for this runoff peaking factor (ropf)\n",
    "    m = round(1.46216e-5*pf**2+4.36124e-4*pf+6.7188e-2,2)\n",
    "    \n",
    "    i = 1\n",
    "    q = tol+1\n",
    "    t_rat = np.zeros(1)\n",
    "    q_rat = np.zeros(1)\n",
    "    \n",
    "    while ((q_rat[i-1] > tol) or (i < min_pts)):\n",
    "        t_rat =np.append(t_rat, t_rat[i-1]+inc)\n",
    "        q = np.exp(m)*t_rat[i]**m*np.exp((-m*t_rat[i]))\n",
    "        if q > tol:\n",
    "            q_rat = np.append(q_rat, q)\n",
    "        else:\n",
    "            q_rat = np.append(q_rat, 0)\n",
    "        i+=1\n",
    "    return t_rat, q_rat\n",
    "\n",
    "\n",
    "def make_hydro(inc_ro, uh_q):\n",
    "    \"\"\"\n",
    "    creates a runoff hydrograph given a incremental runoff and \n",
    "    a unit hydrograph. Time intervals for both inputs must agree.\n",
    "    \n",
    "    \"\"\"\n",
    "    ## now need to \n",
    "    # reverse sort incremental runoff\n",
    "    \n",
    "    ## x is the runoff excess from the design storm hyetograph and \n",
    "    ## curve number \n",
    "    \n",
    "    ## y is unit runoff hydrograph using the design hydrograph and watershed\n",
    "    ## attributes\n",
    "    \n",
    "    ## reversed incremental runoff matrix has m rows, 2 times the length\n",
    "    ## of the incremental runoff vector\n",
    "    \n",
    "    \n",
    "    ## reversed incremental runoff matrix has n rows, the max of the length\n",
    "    ## of the incremental runoff or the hydrograph vectors\n",
    "    ## take longest vector and make the other one same length padding\n",
    "    ## 0's on the end\n",
    "    if inc_ro.shape[0] > uh_q.shape[0]:\n",
    "        n = inc_ro.shape[0]\n",
    "        q = np.zeros(n)\n",
    "        q[0:uh_q.shape[0]] = uh_q\n",
    "        ro = inc_ro\n",
    "    else:\n",
    "        n = uh_q.shape[0]\n",
    "        ro = np.zeros(n)\n",
    "        ro[0:inc_ro.shape[0]] = inc_ro\n",
    "        q = uh_q\n",
    "    m= 2*ro.shape[0]-1    \n",
    "    ro_mat = np.zeros((m,n))\n",
    "    ro = ro[::-1]\n",
    "\n",
    "    for i in range(m):\n",
    "        if i < n:\n",
    "            ro_mat[i,0:i+1] = ro[n-i-1:n]\n",
    "        else:\n",
    "            ro_mat[i, i-n+1:] = ro[0:m-i]\n",
    "\n",
    "    \n",
    "    q = np.matmul(ro_mat,q)    \n",
    "    return q\n",
    "\n",
    "\n",
    "def calc_tc(a, y, cn, l):\n",
    "    \"\"\"\n",
    "    calculates tc, tl based on MN guidance\n",
    "    https://www.nrcs.usda.gov/Internet/FSE_DOCUMENTS/stelprdb1270339.pdf\n",
    "    Inputs:\n",
    "        a , float- area of watershed in acres\n",
    "        y , float- slope of watershed in ft/ft\n",
    "        cn - curve number for watershe\n",
    "        l - flowpath length in feet\n",
    "    \n",
    "    Outputs:\n",
    "        tc, float- time of concentration in hrs\n",
    "    \n",
    "    \"\"\"\n",
    "    # find storage of watershed (in) \n",
    "    # NEH630 Ch10 Eqn 10-12\n",
    "    s = 1000.0/cn-10.0  \n",
    "    \n",
    "    # convert slope to pct\n",
    "    y=y * 100.0\n",
    "  \n",
    "    # NEH630 Ch15 Eqn 15-4b\n",
    "    tc = (l**0.8*(s+1.)**0.7)/(1140.*y**0.5) \n",
    "\n",
    "    tc = round(tc, 1)            \n",
    "    return tc\n",
    "\n",
    "def main(p, cn, a, s, pf, ia=0.2, fl=0):\n",
    "    # conversion factor ac to sqmi\n",
    "    ac2mi = 1.0/640\n",
    "\n",
    "    #MSE3 24hr dist\n",
    "    p_dist = np.array([0.0, 0.0, 0.001, 0.001, 0.001, 0.002, 0.002, 0.002, 0.003, 0.003, 0.004, 0.004, 0.005, 0.005, 0.006, 0.006, \n",
    "              0.007, 0.007, 0.008, 0.009, 0.009, 0.01, 0.01, 0.011, 0.012, 0.013, 0.013, 0.014, 0.015, 0.016, 0.017, 0.018, \n",
    "              0.018, 0.019, 0.02, 0.021, 0.022, 0.023, 0.024, 0.025, 0.026, 0.027, 0.028, 0.029, 0.03, 0.032, 0.033, 0.034, \n",
    "              0.035, 0.036, 0.038, 0.039, 0.04, 0.041, 0.043, 0.044, 0.045, 0.047, 0.048, 0.05, 0.051, 0.052, 0.054, 0.055, \n",
    "              0.057, 0.058, 0.06, 0.062, 0.063, 0.065, 0.066, 0.068, 0.07, 0.071, 0.073, 0.075, 0.077, 0.078, 0.08, 0.082, \n",
    "              0.084, 0.086, 0.087, 0.089, 0.091, 0.093, 0.095, 0.097, 0.099, 0.101, 0.103, 0.106, 0.11, 0.113, 0.116, 0.12, \n",
    "              0.123, 0.127, 0.13, 0.134, 0.138, 0.141, 0.145, 0.149, 0.153, 0.156, 0.162, 0.169, 0.176, 0.184, 0.192, 0.202, \n",
    "              0.212, 0.223, 0.235, 0.248, 0.266, 0.291, 0.325, 0.373, 0.463, 0.628, 0.676, 0.709, 0.734, 0.752, 0.765, 0.777, \n",
    "              0.788, 0.798, 0.808, 0.816, 0.824, 0.831, 0.838, 0.844, 0.847, 0.851, 0.855, 0.859, 0.862, 0.866, 0.87, 0.873, \n",
    "              0.877, 0.88, 0.884, 0.887, 0.89, 0.894, 0.897, 0.899, 0.901, 0.903, 0.905, 0.907, 0.909, 0.911, 0.913, 0.914, \n",
    "              0.916, 0.918, 0.92, 0.922, 0.923, 0.925, 0.927, 0.929, 0.93, 0.932, 0.934, 0.935, 0.937, 0.938, 0.94, 0.942, \n",
    "              0.943, 0.945, 0.946, 0.948, 0.949, 0.95, 0.952, 0.953, 0.955, 0.956, 0.957, 0.959, 0.96, 0.961, 0.962, 0.964, \n",
    "              0.965, 0.966, 0.967, 0.968, 0.97, 0.971, 0.972, 0.973, 0.974, 0.975, 0.976, 0.977, 0.978, 0.979, 0.98, 0.981, \n",
    "              0.982, 0.982, 0.983, 0.984, 0.985, 0.986, 0.987, 0.987, 0.988, 0.989, 0.99, 0.99, 0.991, 0.991, 0.992, 0.993, \n",
    "              0.993, 0.994, 0.994, 0.995, 0.995, 0.996, 0.996, 0.997, 0.997, 0.998, 0.998, 0.998, 0.999, 0.999, 0.999, 1.0, 1.0])\n",
    "    \n",
    "    # default dt for MSE distro\n",
    "    dt = 0.1\n",
    "    \n",
    "    # make vector of corresponding times for 24 hour distro\n",
    "    t_dist = []\n",
    "    for i in range(0,p_dist.shape[0]):\n",
    "        t_dist.append(dt*i)\n",
    "    t_dist = np.array(t_dist)\n",
    "\n",
    "    # if flowlength not specified compute it based on area\n",
    "    if fl <= 0.1:\n",
    "        # eq 630 15-5\n",
    "        fl = round(209*a**0.6,0)\n",
    "\n",
    "    # calculate time of concentration\n",
    "    Tc = calc_tc(a, s, cn, fl)\n",
    "\n",
    "    # calculate delta D for further computations.\n",
    "    #16A–13\n",
    "    delD = 0.133*Tc \n",
    "    \n",
    "    if delD > 0.1:\n",
    "        delD = round(delD, 1)\n",
    "    else:\n",
    "        delD = round(delD, 1)\n",
    "    \n",
    "    ## NEED TO VERIFY THIS!!!!\n",
    "    delT = 0.1\n",
    "    if delT == \"\":\n",
    "        delT = delD\n",
    "    \n",
    "    ## resample precip distro to delD interval\n",
    "    px, py = resample(delT, t_dist, p_dist)\n",
    "    \n",
    "    prec = py*p\n",
    "    time = px\n",
    "    ## calculate incremental runoff for the storm at delD intervals\n",
    "    tot_ro, inc_ro = calc_cn_runoff(cn, prec, ini_rat=ia)\n",
    "    \n",
    "    ## house cleaning\n",
    "    del p_dist, px, py\n",
    "    \n",
    "    ## determine hydrograph that is being used and resample\n",
    "    ## compute with gamma f(x)\n",
    "    # calculate the duh for the number of points and time increment \n",
    "    duh_t, duh_q = calc_gamma(pf, 0.1)\n",
    "\n",
    "    ## calculation unit hydrograph parameters\n",
    "    #Eq 630-16A7\n",
    "    Tp = round(delD/2 + 0.6*Tc,1) \n",
    "    #Eq 630-16A6\n",
    "    Qp = round(pf*(a*ac2mi)*1.0/Tp,1) \n",
    "\n",
    "    uh_q = duh_q*Qp\n",
    "    uh_t = duh_t*Tp\n",
    "    ## resample the unit hydrographs to delD time step\n",
    "    uh_t, uh_q = resample(delT, uh_t, uh_q)\n",
    "\n",
    "    # check the volume under the unit hydro to make sure it agrees with geometry\n",
    "    u_ro = 645.33*a*ac2mi*1.0\n",
    "    if abs(uh_q.sum()*delT - u_ro)/u_ro < 0.02:\n",
    "        q_in = make_hydro(inc_ro, uh_q)\n",
    "        ## should check in_hydro volume\n",
    "    else:\n",
    "        print('unit hydrograph volume descrepancy too large to continue')\n",
    "        q_in = uh_q * 0.0 \n",
    "    \n",
    "    return Tp, Qp, time, prec, tot_ro, inc_ro, q_in "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "559df83b",
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "## required parameters\n",
    "pr = 4.3\n",
    "cnum = 78\n",
    "area = 50\n",
    "slp = 0.002\n",
    "pf = 400\n",
    "\n",
    "## optional parameters\n",
    "iabs = 0.2\n",
    "flen = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "9509ee66",
   "metadata": {
    "hide_input": false,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       "    if (code_show){\n",
       "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "    } else {\n",
       "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "    }\n",
       "    code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "\n",
    "############### Write code below ##################\n",
    "t_peak, q_peak, time, prec, tot_roff, inc_roff, q_in = main(pr, cnum, area, slp, pf, ia=iabs, fl=flen )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "175c0c7a",
   "metadata": {
    "hide_input": false
   },
   "source": [
    "#### This is the rainfall distribution for the specified storm depth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "177f0792",
   "metadata": {
    "hide_input": true,
    "scrolled": true,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       "    if (code_show){\n",
       "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "    } else {\n",
       "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "    }\n",
       "    code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total precipitation: 4.3 in, max precip intensity 53.7 in/hr\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "\n",
    "############### Write code below ##################\n",
    "dt = 0.8* time[1]-time[0]\n",
    "al = 0.4\n",
    "p_bar = \"g\"\n",
    "r_bar = \"b\"\n",
    "## make a container for incremental precip vector\n",
    "inc_prec = [prec[0]-prec[1]]\n",
    "for i in range(1, prec.shape[0]):\n",
    "    inc_prec.append(prec[i]-prec[i-1])\n",
    "inc_prec=np.array(inc_prec)\n",
    "\n",
    "## plot rainfall\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(time, prec, \"--\")\n",
    "ax2 = ax.twinx()\n",
    "ax2.bar(time, inc_prec, color=p_bar, alpha=al, width=dt)\n",
    "ax2.set_ylim([0,inc_prec.max()+0.1*inc_prec.max()])\n",
    "ax2.set_ylabel(\"incremental precip (in)\")\n",
    "\n",
    "ax.legend([\"cumulative\", \"incremental\"])\n",
    "ax.set_title(\"Rainfall distribution\")\n",
    "ax.set_xlabel(\"time (hrs)\")\n",
    "ax.set_ylabel(\"total precip (in)\")\n",
    "ax.set_ylim([0,prec.max()+0.1*prec.max()])\n",
    "ax.set_xlim([0, time[-1]])\n",
    "max_i = prec.max()/dt\n",
    "\n",
    "print(\"total precipitation: {0} in, max precip intensity {1:0.1f} in/hr\".format(prec[-1], max_i))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8438d9b",
   "metadata": {
    "hide_input": true
   },
   "source": [
    "#### This is the runoff distribution of the storm event"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "f4038e42",
   "metadata": {
    "hide_input": false,
    "scrolled": true,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       "    if (code_show){\n",
       "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "    } else {\n",
       "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "    }\n",
       "    code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Runoff 7.3 in, max incremental runoff 1.4 in\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "\n",
    "############### Write code below ##################\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(time, tot_roff, \"--\")\n",
    "ax2 = ax.twinx()\n",
    "ax2.bar(time, inc_roff, color=r_bar, alpha=al, width=dt)\n",
    "ax2.set_ylim([0,inc_roff.max()+0.1*inc_roff.max()])\n",
    "ax2.set_ylim([0,inc_roff.max()+0.1*inc_roff.max()])\n",
    "\n",
    "ax.legend([\"cumulative\", \"incremental\"])\n",
    "ax.set_title(\"Runoff distribution\")\n",
    "ax.set_xlabel(\"time (hrs)\")\n",
    "ax.set_ylabel(\"runoff (in)\")\n",
    "ax.set_ylim([0,tot_roff.max()+0.1*tot_roff.max()])\n",
    "ax.set_xlim([0,time[-1]])\n",
    "print(\"Total Runoff {0:0.1f} in, max incremental runoff {1:0.1f} in\".format(tot_roff.max(),inc_roff.max()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9edab768",
   "metadata": {
    "hide_input": true
   },
   "source": [
    "#### Plot the Runoff Hydrograph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "2ddba037",
   "metadata": {
    "hide_input": false,
    "scrolled": false,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       "    if (code_show){\n",
       "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "    } else {\n",
       "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "    }\n",
       "    code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAasAAAEkCAYAAACR9x5gAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA1iklEQVR4nO3deXycdbn//9eVTPame7q30EIplKVAS9kqFAEtIBQ8iqgoAp4eUI54EAX0K+5HVOTo78hiRBDBAyIgrYhsBSmLSFuk0IVC6UJbaNN9yT6Z6/fHfaedpllmkpnMJPN+Ph7zyNz3/Zn7vm5I58rnc38Wc3dERESyWV6mAxAREemIkpWIiGQ9JSsREcl6SlYiIpL1IpkOQEREusfChQuHRCKRO4EjyN7KSgxYHI1Gvzh58uSq5p1KViIiOSISidw5bNiwwyoqKrbl5eVlZVfwWCxmmzZtmrhhw4Y7gfOa92drZhURkdQ7oqKiYme2JiqAvLw8r6io2EFQ+9u7P0PxiIhI98vL5kTVLIxxn/ykZCUiIllPz6xERHLUzS/fPDiV57v2pGs3J1M+Fovh7uTn53dYVjUrERHpNsuXLy8cN27c4RdffPGYww8/fOK7775bmMjnlKxERKRbrV69uvjSSy/dsmzZsqWHHHJIQyKfUbISEZFuNXz48IbTTz+9OpnPKFmJiEi3Ki0tjSX7GSUrERHJekpWIiKS9dR1XUQkRyXb1TwVJkyY0PDOO+8sSfZzqlmJiEjWU7ISEZGsp2QlIiJZT8lKRESynpKViIhkPSUrERHJekpWIiKS9TTOSkQkR918M6ldIuRa0jZuSzUrERHpNsuXLy8cP3784c3bN95449BrrrlmREefU7ISEZGsp2QlIiJZT8lKRES6TSQS8Vhs7wohdXV1CeUhJSsREek2o0aNim7dujWyYcOG/NraWnvyySf7JfI59QYUEZFuU1RU5F/72tc+mDp16mGjR4+uP/jgg+sS+Zy5e7pjExGRLLBo0aLVkyZN6vZlQTpj0aJFgydNmnRg87aaAUVEJOspWYmISNZTshIRkazXoztY5OXleUlJSabDyBnRaH8ike2ZDkNEOumhhx4iGo0e4O5MmTJlYabjaUssFjMgFr+vRyerkpISqqurMx1GzqishFmzMh2FiHTWqlWrKC8vZ82aNbGOS2dGLBazTZs29QMWx+/v0clKREQSN2rUKNatW0dVVZUtWrQopZPYplAMWByNRr8Yv1PJSkQkRxQUFDB27FjGjRtX6+4HZjqeZKiDhYiIZD0lKxERyXpKViIikvWUrEREJOspWYmISNZTshIRkayXtmRlZneZWZWZLY7bN9DMnjazd8KfA+KO3WBmK8xsuZl9NF1xiYhIz5POmtXvgBkt9l0PzHX38cDccBszmwhcBBwefuY2M8tPY2wiItKDpC1Zufs8YGuL3TOBe8L39wDnx+1/wN3r3X0VsAKYmq7YRESkZ+nuZ1ZD3f2D8P0GYGj4fiSwNq7cunCfiIhI5jpYeLBEcdLLFJvZLDNbYGYLotFoGiITEZFs093JaqOZDQcIf1aF+9cDo+PKjQr37cfdK919irtPiUQ0taGISC7o7mQ1B7gkfH8JMDtu/0VmVmRmY4HxwKvdHJuIiGSptFVNzOx+YDow2MzWAd8BbgIeNLPLgTXAhQDuvsTMHgSWAlHgy+7elK7YRESkZ0lbsnL3T7dx6PQ2yv8I+FG64hERkZ5LM1hIyr25bge3PLWc7TUNmQ5FRDrJzGaEkzSsMLPrWzn+dTN7PXwtNrMmMxuYrniUrCRh89bM67CMu3Pdw2/w/z27gm89urjD8iKSfcJJGW4FzgImAp8OJ2/Yw91/5u5Hu/vRwA3A8+7ecmxtyihZSUqZGb+77DhOGDeQp5dsZFu1alciPdBUYIW7r3T3BuABgskb2vJp4P50BqRkJSk3pLyY6886jIamGC+9uznT4YhI8hKeqMHMSgmmyXs4nQFpoJKk1C1PLWf0wFLOP2YkxQV5rKjanemQRGR/ETNbELdd6e6VnTzXucBL6WwCBCUrSbE/LljLtIMr+OSU0bz6rTPoW1yQ6ZBEZH9Rd5/SzvGEJ2ogmIQ8rU2AoGZASaHq+igbd9YzrqIMQIlKpOeaD4w3s7FmVkiQkOa0LGRm/YBT2TvBQ9ooWUnKrN5SDcCBg4JktXj9Dq64dyHrt9dmMiwRSZK7R4GrgCeBZcCD4eQNV5jZFXFFLwCecvfqdMekZkBJmdWbawA4cHApAPXRGE8s2cAnp4xiZP+STIYmIkly98eBx1vsu6PF9u8I1i5MO9WsJGV21TXSpyjCmIFBsjp4SB8A3t6oThYi0jWqWUnKXDR1DBdNHbNnu19JAYPKCnlva00GoxKR3kA1K0mrUQNKWLdNyUpEukbJSlLm248u5tbnVuyzb+KIvpQVqgIvIl2jbxFJmWffquL4sfvOY/njjx+VoWhEpDdRzUpSIhZzNu6sY2i/4kyHIiK9kJKVpMT22kaiMaeiT9E++5e8v4OZt77EorXbMxOYiPQKSlaSEs1rVw0sK9xnf1Ekj0Vrt7Nqc9rHDIpIL6ZkJSkRjTnjh/RhSN99a1ajBgRjrtQjUES6Qh0sJCUOGVrO09ecut/+4oJ8BvcpYt02TbkkIp2nmpWk3agBJaxVzUpEukDJSlLikdfW8YnbX6amIbrfsRMPGsS4wX0yEJWI9BZqBpSUWL25moXvbaM4kr/fsetmHJqBiESkN1HNSlJie20j/UoKyMuzTIciIr2QkpWkxPaaRvqXtL7Y4nPLqzj+v5/h3U2afV1EOkfJSlJiW00D/UoLWz1WHMln4856Nuyo6+aoRKS30DMrSYmxg8vIs9abAIeGY6827lSyEpHOUbKSlPj+zCPaPDYsnC9wg5KViHSSmgEl7UoLI5QXR6jaWZ/pUESkh1Kyki6LNsU45afP8Yd/rmmzzAXHjGTCsPJujEpEusLMZpjZcjNbYWbXt1Fmupm9bmZLzOz5dMajZkDpsp11Ud7bWkNjNNZmmfaaCUUku5hZPnArcCawDphvZnPcfWlcmf7AbcAMd3/PzIakMybVrKTLtoUzrvdvozdgs6aYd0c4ItJ1U4EV7r7S3RuAB4CZLcp8BnjE3d8DcPeqdAakZCVdtr2mEYD+pa2PswL41bPvcNiNTxBTwhLpCUYCa+O214X74h0CDDCzv5vZQjP7fDoDykiyMrP/Cts4F5vZ/WZWbGYDzexpM3sn/DkgE7FJ8nbUdlyzKi8uoCEaY2tYCxORjIqY2YK416zOnAOYDJwDfBT4tpkdktIo43R7sjKzkcBXgCnufgSQD1wEXA/MdffxwNxwW3qAvsUFnHHYECrKi9os03xMPQJFskLU3afEvSpbHF8PjI7bHhXui7cOeNLdq919MzAPmJSugDPVDBgBSswsApQC7xO0h94THr8HOD8zoUmyphw4kDsvOY6R/UvaLDOkOVnt0lgrkR5gPjDezMaaWSFBhWJOizKzgWlmFjGzUuB4YFm6Aur23oDuvt7MbgbeA2qBp9z9KTMb6u4fhMU2AEO7OzZJnyHlwcDgql2qWYlkO3ePmtlVwJMErV93ufsSM7siPH6Huy8zsyeAN4AYcKe7L05XTN2erMJnUTOBscB24E9mdnF8GXd3M2v1SXzYtjoLoLCw/d5n0j1+9ew73PvKGl654XSsjSmXhvQt4pITD+CgirJujk5EOsPdHwceb7HvjhbbPwN+1h3xZGKc1RnAKnffBGBmjwAnARvNbLi7f2Bmw4FWu0GGbauVAGVlZepalgW2VDdQXd/UZqKCYHn772mslYh0UiaeWb0HnGBmpRZ8u51O0M45B7gkLHMJQXuo9ADV9VHKivZfdLGlhmiM7eoNKCKdkIlnVv80s4eA14Ao8C+CmlIf4EEzuxxYA1zY3bFJ51TXN1FW1PGv0iV3vUpjU4yHrjypG6ISkd4kI9Mtuft3gO+02F1PUMuSHmZXfZTyBJJVRXkRr6/dnv6ARKTX0dyA0mUnjhtEY1Pb8wI2G1JeRNWuOty93edbIiItKVlJl105/aCEyg3pW0RdY4xd9VH6Frc9NZOISEuaG1C6zD2xTpmaxUJEOkvJSrrsuB89ww8eW9phuUmj+nPdjEPpW6IKvYgkR98a0mU7a6MU5Hf8d8+4ij5cOb1PN0QkIr2NalbSJQ3RGA1NMfokMM7K3Vm7tYaqnZofUESSo2QlXVJdHwVIaJwVwOm3PM+dL65KZ0gi0gspWUmX7E4iWZkZQ8qL2KTJbEUkSUpW0iXFBfl84aQDOXRYeULlm8daiYgkQx0spEsqyov47nmHJ1x+SHkx727ancaIRKQ3Us1KuqSxKUZdY1NSY620ppWIJEvJSrrkqSUbOfTbT/D2xsRqSxccO5LvnXd4wslNRATUDChdtLu+ESChJUIAjh0zgGPHDEhnSCLSC6lmJV2yu74JgD4Jdl2vro/y6qqtbK3WulYikjglK+mSZMdZrdpczYW//gevrtqazrBEpJdRspIuqa6PUhjJS2i6JQi6rgNsUvd1kaxmZjPMbLmZrTCz61s5Pt3MdpjZ6+HrxnTG0+Gfw2aWB0wCRgC1wGJ3r0pnUNJznHjQoIRrVQCD+hSRZ2hgsEgWM7N84FbgTGAdMN/M5rh7yxmrX3D3j3VHTG1+y5jZQcB1wBnAO8AmoBg4xMxqgF8D97h7x6vuSa81fcIQpk8YknD5/DxjUB91XxfJclOBFe6+EsDMHgBmAh0vr5Am7f1J/EPgduA/vEU/YzMbAnwG+BxwT/rCk2y3tbqBfDP6lSa+mOIQjbUSybSImS2I265098q47ZHA2rjtdcDxrZznRDNbBLwPXOvuS1IfaqDNZOXun27nWBXwi3QEJD3Lf/3xdbbXNDD7qmkJf+bbH5tIWaFGTYhkUNTdp3TxHK8BB7j7bjM7G3gUGN/lyNqQ0DeGmZ0EHBhf3t1/n6aYpAepbWiipDCxMVbNThg3KE3RiEiKrAdGx22PCvft4e47494/bma3mdlgd9+cjoA67MJlZvcCNwPTgOPCV1czsvQStY1NlBQkl6zWbq1hzqL3aYppFguRLDUfGG9mY82sELgImBNfwMyGmZmF76cS5JMt6QookZrVFGBiy+dWIgA1DVFKC0uT+szfl1fx7dlLOGHcQIaUF6cpMhHpLHePmtlVwJNAPnCXuy8xsyvC43cAnwCuNLMoQU/xi9KZJxJJVouBYcAH6QpCeq66xljSzYAV4Virqp31SlYiWcrdHwceb7Hvjrj3vwJ+1V3xJJKsBgNLzexVYE8XLnc/L21RSY/x5dMOZkT/5BJORZigNNZKRBKVSLL6brqDkJ7rM8ePSfoze2exULISyRVmNoC9k0usTnaMbofJyt2f72Rs0su5O+9u2k1FeTH9ShIfZ7WnGVBTLon0ambWD/gy8GmgkL2TSww1s1eA29z9uUTO1WZvQDN7Mfy5y8x2xr12mdnOtj4nuaOmoYkzbpnHA6++l9TnigvyefjKk7hoavK1MhHpUR4iGFz8IXef4O7T3H2Ku48GbgJmmtnliZyovUHB08Kf5amIWHqf2sZgeZBkO1gATD5Aa1qJ9HbufmY7xxYCCxM9V3tzA/Zx93aXf02kjPRetQ1hskpynBXASys2s2lXPecfMzLVYYlIFjKzkcAB7Du5xLxEP9/eM6vZZvY6MBtY6O7V4QXHAacBFwK/IajmSQ5qrlmVdmLqpD8tWMvC97YpWYnkADP7CfApgolwm8LdDnQ9Wbn76eF8T/8BnBz25IgCy4G/Ape4+4ZOxi69QE1zzaow+WXRhvQtpmpnPe5OOAheRHqv84EJ7t7pLsDt/knc2qCwVDCz/sCdwBEE2fUygiT4R4I5CFcDF7r7tlRfW1JnZP8S/vuCIzl0WN+kP1vRp4j6aIydddGkehKKSI+0EiggbqxusjI19fUvgSfc/RPhvFOlwDeBue5+U7gq5fUE62lJlqooL+rUOCuAIX33rhisZCXS69UAr5vZXPadXOIriZ6g25NV2O/+FOALAO7eADSY2UxgeljsHuDvKFlltS2761m/vZZDhpZTnGQni71jreo5eIg6nIr0cnNoMRFusjJRsxpLMDDsbjObRNB18WpgqLs3zz+4ARiagdgkCc++VcXXH3qDF75xGqMHJjeZ7TGjB/DCN05jWD/NDSjS27l7lxfpTejJuJlNM7NLw/cVZja2C9eMAMcCt7v7MUA1QZPfHuHMva3O3mtms8xsgZktiEajXQhDuqor46xKCvMZPbCUgvzkO2eISM9gZg+GP980szdavpI5V4c1KzP7DsEyIROAuwkekt0HnJx86ECwPPI6d/9nuP0QQbLaaGbD3f0DMxsOVLX24XDp5UqAsrIyLVuSQV0ZZwVw5wsrGT2wlI8ePiyVYYlI9rg6/Pmxrp4okT9rLwDOI6gB4e7vA51+yBB2d19rZhPCXacT9L2fA1wS7ruEYHyXZLGaLiare/6xmsff1MozIr3YBgB3X9PaC8ASHLuSyDOrBnd3M/PwxGWdDnuv/wT+EPYEXAlcSpA4HwzniVpDMOhYslhdYxNFkTzy8jo3TmpIeTDWSkR6refM7GFgtrvvmUQ0/O6fRlAxeQ74XUcnSiRZPWhmvwb6m9m/E4yJ+k1nom7m7q8TNC22dHpXzivda+bRIzlqVP9Of35IeRFvb9yVuoBEJNvMIMgZ94d9HbYTzLqeDzwF/MLd/5XIiRJZIuRmMzsT2Enw3OpGd3+6k4FLLzJxRF8mjkh+QHCzIeVFvLhicwojEpFs4u51wG3AbWZWQLCYb627b0/2XAl1XQ+TkxKU7GPx+h00xZxJo/t36vND+hazuz5KXWNT0uO0RKRncfdGoNMPqTvsYNHKelY7zWytmf05nNRWctTPn1rO/3t0cac/f/m0sbz9w7OUqESykJnNMLPlZrYinFWorXLHmVnUzD6RzngSqVndArwP/B9gwEXAMIK5/O5i76wTkmNqG5s63RMQUJISyVJmlg/cCpxJMNxovpnNcfelrZT7CcHzp7RKpOv6DHf/tbvvcved4Tins939j4BW0MthtQ1NnRoQ3Gzz7npunL2Y197TfMUiWWYqsMLdV4ZT4j0AzGyl3H8CD9PGuNh4ZjbMzM4zs3PNLOnBlYkkq5iZXWhmeeErvku5BuXmsK7WrNzh9/9Yw+L1O1IYlYgkINI8E1D4mtXi+EiC5eibrQv37REupngBcHtHFzOzLwKvAh8HPgG8YmaXJRVwAmU+SzBL+m0EyekV4GIzKwGuSuZi0rvUNDRR2oWa1aCyQvLzTGOtRLpf1N1bGz6UjF8A17l7LIFxvV8HjnH3LQBmNgh4meBRUkLaTVZhe+SV7n5uG0VeTPRC0vv8/JOTKC/u/PIeeXnG4D6FVO2qS2FUIpIC64HRcdujwn3xpgAPhIlqMHC2mUXd/dFWzrcOiB9UuYt9a24d6mjxxSYzm5zMCSV3HD9uUJfPMaS8mKpdqlmJZJn5wPhwIO96go51n4kv4O57JjQ3s98Bj7WRqAjP8U8zm03QQjcTeNXMrgnPdUtHASXSDPgvM5sD/IlwfsDw5I8k8Fnppdydx9/cwGHDyxlX0afT5xnat5jaRs2eL5JN3D1qZlcBTxLMNnGXuy8xsyvC43ckecp3w1ez5rlfE55n1oLVONopYHZ3K7vd3ZN6OJYOZWVlXl1d3XFBSYmLvzWP+350ChDMC3jot5/guhmHcuX0gzp9TncnwXksRSRFzKzG3VMxz2u3SWS6pUu7IxDpWfbOuN619aiUqER6LzP7hbt/1cz+Qiu9x939vETPlch6VsXA5cDhBBMQNl8k4zUryZyuLLwY758rt3Dni6v48cePZHCfolSEJiLZ497w581dPVEifxbfSzBjxUeB5wl6hWiq7BxX2xA8ZyopTGh6yTZtq2nk6aUb2bBDPQJFeht3Xxi+XQC84O7Pu/vzBD3J5ydzrkSS1cHu/m2g2t3vAc4BjkzmItL71DbEgM4vvNhsSN+gNqXu6yK92lygNG67BHgmmRMk8mdxY/hzu5kdQbDy44HJXER6n3EVZTx85Ykc1IWegBD0BgTYqIHBIr1Zsbvvbt5w991mVtreB1pKJFlVmtkA4NsES8/3AW5MKkzpdcqKIkw+YGCXzzOkvIg8gw+216YgKhHJUtVmdqy7vwYQjt9N6h99Ir0B7wzfPg9oSRABYM2Wal5dtZWPHjGMvl2YxaIgP48jRvYjL0+9AkV6sa8CfzKz9wlW7xgGfCqZEyTSG7AI+DeCpr895d39+8lcSHqXhWu28fWH3mDq2IFdSlYAc66alqKoRCQbuft8MzuUYLV5gOXhYowJS6QZcDawA1gI6MGCAHHjrLrYdV1Eer/w+dQ1wAHu/u9mNt7MJrj7Y4meI5FkNcrdZ3Q6SumVavcMCu56snp44Tp+/8oa/nzlSWoOFOmd7iao8JwYbq8nmMIv4WSVSNf1l81MXdVlH3sGBacgWdU0RFm0djubq1VxF+mlDnL3nxL2Lnf3GoJnVwlrs2ZlZm8STI8RAS41s5UEzYAWXMuP6mzU0vPVNDRRmJ9HJL9r0y0BjOhfAsD72+sYUl7cQWkR6YEawjUQHcDMDiLJx0rtNQN+rAuBSS/3xQ+N5YJjRnZcMAF7k1UtR4/un5JzikhW+Q7wBDDazP4AnAx8IZkTtJms3H0NgJmdACxx913hdl/gMGBN52KW3mBwn6KUzeU3ot/eZCUivYuZ5QEDCJa0P4Ggde5qd9+czHkSacO5Hdgdt7073Cc57JmlG3n0Xy0XDu2cviWRoAt8Sde6wItI9nH3GHCVu29x97+6+2PJJipIrDegedyiV+4eM7OuzV4qPd4D89/jgx11nJ+CpkAz48H/OLHjgiLSUz1tZtcCf2TfRXy3JnqCRJLOSjP7CntrU18CViYTpfQ+NQ1NKekJKCI5oXlJqS/H7XOSmBUpkWbAK4CTCPrFrwOOB2YlegHpnWobm1I6IPhXz77DGbc8n7LziUj2cPexrbySmr4vkbkBq4CLOh2l9Eq1DU1UpHixxBVVu6lrbKJYNTaRXiVcxPdLwDSCGtULwB3unvDaQB3WrMzsp2bW18wKzGyumW02s4s7HbX0CjUNTZSmsGYV331dRDLPzGaY2XIzW2Fm17dyfKaZvWFmr5vZAjNrb5LP3xOsNv+/wK/C9/e2U34/iTyz+oi7f8PMLiBoBvwk8BxwXzIXkt7l4StPIpUzIzUnq/XbaxnXxTWyRKRrzCwfuBU4k+B7f76ZzXH3pXHF5gJz3N3N7CjgQeDQNk45wd0nxW0/Z2aLkokpkWdWzQntHOD+ZHpvtMfM8s3sX2b2WLg90MyeNrN3wp8DUnEdSY+K8iIGpbAZcPTAYB2297bWpOycItJpU4EV7r7S3RuAB4CZ8QXcfXdcT/Eywtkp2vCvcMwuAGZ2PPBSMgElkqweM7O3gMnAXDOrAFKxBvnVwLK47euBue4+niBj71ftlOzg7vzP02/z6qqU/N0CwLC+xZx95DCG99N0SyLdIBI23TW/WnaaGwmsjdteF+7bh5ldEOaHv7K3x19rjieYZ3a1ma0G/gFMN7M3zeyNhALuqIC7X29mPwV2uHuTmVXTIsMmy8xGEdTUfkQwbTzhOaeH7+8B/g5c15XrSOpVVsIll8X45dx3KIzkMXVs11cLBsjPM2777OSUnEtEOhR19yldPYm7/xn4s5mdAvwAOKONol1euaO9iWw/7O7PmtnH4/bFF3mkC9f9BfANoDxu31B3/yB8vwEY2kZcswi7zhcWFnYhBOmsVC4P0lJ9tImiiHoDimTYemB03PaocF+r3H2emY0zs8GtzU7RPH1fV7TXDHhq+PPcVl6dnuTWzD4GVLn7wrbKhO2grbZ/unulu09x9ymRiCbSyIQ9y4OkeOHFnz7xFlN++AxxE6aISGbMB8ab2VgzKyQYvjQnvoCZHWxhDcbMjgWKgC3pCqi9iWy/E/68NMXXPBk4z8zOBoqBvmZ2H7DRzIa7+wdmNhyoSvF1JUWq64Nklcqu6wCD+hSxqy7KtppGBpap1iySKe4eNbOrgCeBfOAud19iZleEx+8A/g34vJk1ArXApzyNf2m21wx4TVvHANz9ls5c0N1vAG4IrzEduNbdLzaznwGXADeFP2d35vySfulqBjwg7BG4Zku1kpVIhrn748DjLfbdEff+J8BPuiue9trRmp8nTQCOY28V8FxgXhpiuQl40MwuJ1h+5MI0XENS4PARfXnzux9J+bOlAwbt7b5+zBiNXBCRvdprBvwegJk9BRwbt57Vd4E/peLi7v53gl5/uPsW4PRUnFfSKy/PKC9O/XIee8ZabdFYKxHZVyLjrMYADXHbDcCBaYlGeoQ31+3gR39dyubdSa1K3aHignyuOu1g1apEZD+JdKe7F3jVzP4cbp9PMA5KctSyDTv5zQur+PyJB6b83Nd+dELKzykiPV8ig4J/ZGZ/Az4U7rrU3f+V3rAkm9XURwEoK0r90IH6aBMfbK/jwMFlKT+3iPRcCX3buPtrwGtpjkV6iJrG9HRdB6h8fiU/f/pt3vrBDC0VIiJ7JPLMSmQfNfVN5BkURVL/6zNmkCa0FZH9KVlJ0uqjTZQWRlpOv5US4wYHy4Os3LQ75ecWkZ5L8xVJ0r51zkSuP+uwtJx7XEXwrOrdTdVpOb+I9EyqWUmn5Kdy5cU4ZUURhvcr5t0q1axEZC8lK+lQZeW+2799cRW3Prcibde74ezD+NRxozsuKCI5Q82AkrS5yzbS2BTjy6cdnJbznzdpRFrOKyI9l2pWkrSahiZKCtP3d87OukZefGczu+oa03YNEelZlKwkaTUNUcrSMMaq2ZvrdnDxb//Jm+t2pO0aItKzKFlJ0la+MDTlCy/GO6gi6L6+Qt3XRSSkZCVJi+QZ/UpSP+t6s6F9iygvjrB8w660XUNEehZ1sJCkXfORCcw6N33nNzMOHVauZCUie6hmJVlpQpis0rhKtoj0IEpWkpSGaBP3vbKG55ZXpfU6l508lvtnnYBylUhmmNkMM1tuZivM7PpWjn/WzN4wszfN7GUzm5TOeNQMKEmpa4yx5P0drN+W3uuMCztZiEj3M7N84FbgTGAdMN/M5rj70rhiq4BT3X2bmZ0FVALHpysm1awkKQ1NMQDKitK7fIe789DCdby0YnNaryMirZoKrHD3le7eADwAzIwv4O4vu3vzn62vAKPSGZCSlSSlPlzLqqQgvZVyM+N/nn6bB+avTet1RKRVI4H4f3zrwn1tuRz4WzoDUjOgJKWxKXiIlO6aFcDhI/qy5H0NDBZJg4iZLYjbrnT3yjZLt8PMTiNIVtNSElkblKwkKQ70Lymgb3H6xlk1O2pUP55aupFddY2Ud8P1RHJI1N2ntHN8PRA/m/SocN8+zOwo4E7gLHffktoQ96VmQEnK2MFlXHfWYUwa3T/t1zpyVHCNxet3pv1aIrKP+cB4MxtrZoXARcCc+AJmNgZ4BPicu7+d7oCUrCRrHTmyHwBvb9TgYJHu5O5R4CrgSWAZ8KC7LzGzK8zsirDYjcAg4DYze71Fs2LKqRlQkrJ4/Xbmr97Gpz8/Ku1NcwPLCpn/rTOoKC9K63VEZH/u/jjweIt9d8S9/yLwxe6KRzUrScqmXfW8vXEXhZHu+dVRohIRULKSJNVFY0Ty8iiKpL83IATLhXzpDwvZvLu+W64nItlJyUqSUtfYRHFB9/3aNDQ18fibG1iwOs1TZohIVlOykqTUNcYo6qYmQIAjRvajMJLHgtVbu+2aIpJ9lKwkKX2KIgzrV9Jt1yuK5HP0qP7MX6OalUguU29AScq5k0Z0+zWnHDiAynkrqWmIUlqoX1mRXNTtNSszG21mz5nZUjNbYmZXh/sHmtnTZvZO+HNAd8cm2Wnq2IEcOrycTbvUyUIkV2WiGTAKfM3dJwInAF82s4nA9cBcdx8PzA23Jcvc/dKqtK9l1dL0CUN47D8/xAGDyrr1uiKSPbo9Wbn7B+7+Wvh+F8Ho6JEE08/fExa7Bzi/u2OTjr23tYbdddGMXLsxXJ5ERHJPRjtYmNmBwDHAP4Gh7v5BeGgDMDRTcUnr3KE+2r1d15vNfn09k773FFs03kokJ2UsWZlZH+Bh4Kvuvs9Mpe7uBBN8t/a5WWa2wMwWRKOZ+Qs/18xbMw+AaFMMdygp6J4BwfEOGFRGTUMTL2oxRpGclJFkZWYFBInqD+7+SLh7o5kND48PB1p9MOLule4+xd2nRCLqGdad6pti1OUtyUiPvCNH9mNAaQHPvtW9z8tEJDtkojegAb8Flrn7LXGH5gCXhO8vAWZ3d2zSscF9ChlQ2v1rS+XnGWccNpRn36qiIapnVyK5JhM1q5OBzwEfDqeVf93MzgZuAs40s3eAM8JtySJ9iiJ8aHwFYyv6ZOT6M44Yxq66KP9YmdY13kQkC3V7e467vwhYG4dP785YpGc5+eDBXH36eMYNVhd2kVyjhz6SsFWbq3l3026OH9EEdH8ni+KCfP7rzEO6/boiknmaG1ASVtvQRHVdtNvWsmpNU8x59q2NvPae5goUySVKVpKwhqYYhZE8gj4ymeHuXP/wm9z23LsZi0FEup+SlbSrsnLv+/rGpj21qvj93SmSn8cFx4zk78ur2LizLjNBiEi3U7KShNU2xjIyILilzxw/hiZ37v3HmkyHItJrmdkMM1tuZivMbL+5Ws3sUDP7h5nVm9m16Y5HyUoSNrCskIry4j3bmapdHTCojDMPG8of/rmGusamzAQh0ouZWT5wK3AWMBH4dDjheLytwFeAm7sjJiUrSdhRo/oxfmifPdMvZdJl08ZSXJDPe1trMh2KSG80FVjh7ivdvQF4gGCy8T3cvcrd5wON3RGQuq5LQtw9mK0xc30r9nH82IH8/evTKYpkvllSpBcaCayN214HHJ+hWADVrCRBr6/dzl/eeD9rFkA0M4oi+dRHm3hj3fZMhyPS00SaJwQPX7MyHVBHVLOShKzfXks05hTmZ9ffN9+ds4RH//U+c792KiP6l2Q6HJGeIuruU9o5vh4YHbc9KtyXMdn1zSNZa0XVbgzoU7zv3zeZ6mTR7EvTD8Zxbpy9JGiqFJFUmA+MN7OxZlYIXEQw2XjGKFlJQlZU7aa0MJ/8vCx5aBUaPbCUaz8ygWeWbeTeV9SVXSQV3D0KXAU8SbCa+4PuvsTMrjCzKwDMbJiZrQOuAf6fma0zs77piknNgJKQFVW7KS/Ozl+Xy04ey0srNvPDx5Zx7JgBHDGyX6ZDEunx3P1x4PEW++6Ie7+BoHmwW6hmJW2Kb+KbefRIRmbpM6G8POPnFx7NyQcPorRQvQNFeiMlK2lX85iqK6cfxJhB2bs0x8CyQu6+dCrjKvoQizk7arpl6IeIdBMlK+lQbUMTO2rb//LPdEeLeN969E3Ov+0lVm2uznQoIpIiSlbSoTfWbefc/30x02Ek7BOTR7GjtpELbnuJF97ZlOlwRCQFlKykXe7Opl31TBs/ONOhJGzyAQN59EsnU9GniM/99lW+/5elmkNQpIdTspJWNTfrbd7dQGPMOfWQioQ/kw3GDCplzlXTuOTEA3hg/ntsq2nIdEgi0gVKVtKu9dtriOQZp4zvOFllm5LCfL438wjmfu1Uhvcrwd35zuzFPLF4A00xDSAW6UmUrKRNz616nvXb6hjer5iSFl3C25p5PZtqV82G9wu63G/YWcezy6u44r6FnHHL8/z2xVVs2Z0dcx2KSPuUrKRN+XnGqYcM5tDhrQ9Kz4alQpIxvF8Jz31tOrd+5lj6lxbwg8eWcsKP5/KPd7dkOjQR6UB2TkkgGdc8z16f4oIMR5Jakfw8zjlqOOccNZzlG3bxyGvrOHp0fwDufWUNS9/fwTlHjuCEcQOJZNmkvSK5TMlKWnX/oidZt62WyWMGUBDpnV/aE4aVc8PZh+3Z3rSzjtmvv8/9r65lYFkhHz18GOdNGsGJBw3KYJQiAmoGlBYqK4NBwEvW76SuoanD2kVPawpszzUfmcBr3z6TOy6ezMkHD2b26+u54/l39xx/7b1tNERjGYxQJHepZiX7+emTb1HT2MTkAwZgnZhkvbISZrWylFtb+7NJcUE+M44YxowjhlHb0MSW6qADRtWuOj5+28uUF0U4dUIFZ04cyvRDhtCvtHc1k4pkK9WsBNjbi+/+RU9y90urOaiiD4PLixL+fG+qYTUrKcxn1IBSAPoWF3Dn56dw9pHDeWXlFq5+4HWO/eHTPLF4A4DW0hJJM9WsBAiSzWVN03jrg52ccPgISizaqXOccsApaYgu84oL8jlj4lDOmDiUWMx5fd12nl66kUmjg+VIHlywlrtfWs0ZhwVljhrZj7wsW/tLpCdTzUqAoGYQyc/jpIMHc/cXjkvJF21zba2yct/3PV1ennHsmAFcN+PQPWO4BpYV0b+0gNuff5fzb32J4388lxseeYNok55xiaSCalY5blddI9//y1IWrtmGu1NSkE//0sJOn683167ac+bEoZw5cSjbqhv4+9tVPL10I+9WVe/poHLXi6sY0b+E6RMqKC7QmlsiyVKyymHPv72JGx5+gw076+hfGEGPXbpuQFkhFxwziguOGbXnOVZTzLnzhZW8v6OOPkURPjJxKOdOGsG08YMp0FgukYToX0qOqVxYyU9f+BWzfr+As7/6DKvmb+XhK09i4oi+KXvG0lZni/j9zU2D8a/4Y/Fl4ve1fB8v25oaLexKmZ9nzPvGadx3+fGcc+Rwnlm2kUt/N5//fXYFECSzmOYqFGlX1tWszGwG8EsgH7jT3W/KcEg9WuXC4Ju7sSlGTUMTi/52JPXRJtb228HE4eUcPKScn//6zbRce96aeczilH2SVPO+XBPJz2Pa+MFMGz+Y759/OPPe3syEoeUAzHt7E9/885t87KjhzDx6JIeP6Lsn0YlkSkffxRb8kv4SOBuoAb7g7q+lK56sSlZmlg/cCpwJrAPmm9kcd1+a2chSo3JhJbMmz9rvfXvlAWZNnrWnfPO+5v3x54o/1tgU46Rhn+LlFZt56dHD2LSrnj7FBUyfAEWRfF647lQuvTFzCyq2WvuqPIVZs8JjlXuTXHPCm8UpVFbuPQ7BuK3mmtQ+nwvP1bKW1byvvWMtNY8Na/m5+DFj8cc6GktWFMnnzIlD92z3LYkwcXhf7n5pNb95YRWD+xRx3IED+NknJ9GnKEK0Kaapn6RbJfhdfBYwPnwdD9we/kyLrEpWwFRghbuvBDCzB4CZQK9IVvHcg6Yfj9uGoMnIzGiK+Z6eZPXRJhqbYtRHm3B3zIyGaIy1W2vYXtPI2xt38eD8tTzz1kbOCL8Ef/mLYfxszMtsemMspYWNjBpYyrC+xeCAoWclWWTyAQP57RcGsr2mgSeXbOCVlVt5d9NuysKZ7r/+0Bu8uGIzYweVMbRfMUPLizhgcBmfO+EAABav30FDU4w+RRGKI/lE8o2SgnwGlAUdZeqjTeSZEQl/t0QSkMh38Uzg9x58eb1iZv3NbLi7f5COgLItWY0E1sZtryNNmXrx+h1c+Ot/7OlU0Jw2bv7kJD521Aiuf+IW7n5pNf38LIh7nPDrz03mnepHWfbBTv7y8kR25P2NvrGz2JH3NwC+OG0s4yr6MDT/HC77002UN81gV/4Tez6/fvsv+d7pV/PPVVv55p+/sl9c87/6Y5557/+Y984m/vZmMOD0p488wa78JfzskSeYEjuE4oJ8lr6/k+s2zqbiqL5semMEt/MieXYweUcOJ5Kfx7jB9Xz14iP5ze+XURLJhx7wHRXfRNjRc6+Wta7Wjrc8Fl++vWMtxccUXya+OTP+WGebOfuXFvKp48bwqePG7LP/lEMGE8kz1mytYfH6HTyzo47RA0v2JKvv/WUJ81dv2+czk0b1Y/ZV0wA4/9aXWfbBzn2OTzt4MPd9Mfin9eGb/857W2v2zFZiGGdMHMJtn50MwEk/nsuW6gbMgmMA500awU8+cRQAx/7gaepbrMT8qePGcOO5E4k2xZj0vaf2u9fLpo3lax+ZwI7aRk768dz9jv/n6eO54tSD+GBHLWf8/Pn9jl931qF8/sQDWVG1m5m/2r+F4Pszj+DfJo9i0drtfOY3r+x3/OcXTmLGEcN5+d3N/Ps9C/Y7fvvFkznlkArmLtvIV+7/137Hf3/58Uw+YACzX1/PNx/Zvxn9oStP4rDhfbn/1ff44WP7/639t6tPYcygUu58YSX/8/Tb+x2f943TGNSniF8+8w6V897d7/jCb5+Z7l6liXwXt1ZmJJCWZGXZNPLezD4BzHD3L4bbnwOOd/er4srMApobWo4FartwyQiQ/OjX3iGX7x1y+/5177mr+f5LgPjnS5XuvqcRPMHv4seAm9z9xXB7LnCdu++f/VMUeDZZD4yO2x4V7tsj/A+akv5eZrbA3aek4lw9TS7fO+T2/evec/PeIan77/C7OMEyKZNtDy7mA+PNbKyZFQIXAXMyHJOISK5J5Lt4DvB5C5wA7EjX8yrIspqVu0fN7CrgSYLukne5+5IMhyUiklPa+i42syvC43cAjxN0W19B0HX90nTGlFXJCsDdHyf4j9AdsmT4aEbk8r1Dbt+/7j13JXz/rX0Xh0mq+b0DX05daO3Lqg4WIiIircm2Z1YiIiL7yclkZWYzzGy5ma0ws+szHU+6mdldZlZlZovj9g00s6fN7J3w54BMxpguZjbazJ4zs6VmtsTMrg739/r7N7NiM3vVzBaF9/69cH+vv/dmZpZvZv8Ku1nn2r2vNrM3zex1M1sQ7uux959zySpuGpGzgInAp81sYmajSrvfATNa7LsemOvu44G54XZvFAW+5u4TgROAL4f/v3Ph/uuBD7v7JOBoYEbYaysX7r3Z1cCyuO1cuneA09z96Lju6j32/nMuWRE3jYi7NwDN04j0Wu4+D9jaYvdM4J7w/T3A+d0ZU3dx9w+aJ9d0910EX1wjyYH798DucLMgfDk5cO8AZjYKOAe4M253Ttx7O3rs/edismpripBcMzRuTMQGYGh7hXsDMzsQOAb4Jzly/2Ez2OtAFfC0u+fMvQO/AL4BxC/XnCv3DsEfJk+Z2cJw5h/owfefdV3Xpfu5u5tZr+4WamZ9gIeBr7r7zvgJXXvz/bt7E3C0mfUH/mxmR7Q43ivv3cw+BlS5+0Izm95amd5673Gmuft6MxsCPG1mb8Uf7Gn3n4s1q26dIiSLbTSz4QDhz6oMx5M2ZlZAkKj+4O6PhLtz5v4B3H078BzBs8tcuPeTgfPMbDVBU/+Hzew+cuPeAXD39eHPKuDPBI9Aeuz952Ky0pROgTnAJeH7S4DZGYwlbSyoQv0WWObut8Qd6vX3b2YVYY0KMyshWJvoLXLg3t39Bncf5e4HEvwbf9bdLyYH7h3AzMrMrLz5PfARYDE9+P5zclCwmZ1N0J7dPI3IjzIbUXqZ2f3AdGAwsBH4DvAo8CAwBlgDXOjuLTth9HhmNg14AXiTvc8uvknw3KpX37+ZHUXwED2f4A/TB939+2Y2iF5+7/HCZsBr3f1juXLvZjaOoDYFweOe/3P3H/Xk+8/JZCUiIj1LLjYDiohID6NkJSIiWU/JSkREsp6SlYiIZD0lKxERyXpKViIikvWUrCQnmVl/M/tS3PYIM3soTdc638xuDN//zsw+0YVzPWBm41MXnUjPoGQluao/sCdZufv77t7pJNKBbwC3JVrYzNqbs/P28HwiOUXJSnLVTcBB4cJ0PzOzA5sXpzSzL5jZo2b2FzNbZWZXmdk14SJ+r5jZwLDcQWb2RDir9QtmdmjLi5jZIUC9u2+O232Kmb1sZiuba1lmNj1cJPL/gDfC6XL+Gi6cuNjMPhV+9gXgjA4Smkivo194yVXXA0e4+9GwZ/mQeEcQLCdSDKwArnP3Y8zsf4DPE0zXVQlc4e7vmNnxBLWnD7c4z8nAay32DQemAYcSzNXW3Pw4NYxplZn9G/C+u58TxtcPwN1jZrYCmAQs7PTdi/QwSlYirXsuXKxxl5ntAP4S7n8TOCpccuQk4E9xy40UtXKe4cCmFvsedfcYsNTM4tcTetXdV8Vd5+dm9hPgMXd/Ia5cFTACJSvJIUpWIq2rj3sfi9uOEfy7yQO2N9fM2lEL9Gvn3Bb3vrr5jbu/bWbHAmcDPzazp9z9++Hh4vC8IjlDz6wkV+0Cyjv7YXffCawys09CsBSJmU1qpegy4OBkz29mI4Aad78PuBk4Nu7wIQTLPYjkDCUryUnuvgV4Key88LNOnuazwOVmtghYAsxspcw84BiLX5o4MUcCr4ZL0n8L+CFA2GxY6+4bOhmzSI+kJUJE0szMfgn8xd2fScG5/gvY6e6/7XpkIj2HalYi6fffQGmKzrWdYEFFkZyimpWIiGQ91axERCTrKVmJiEjWU7ISEZGsp2QlIiJZT8lKRESy3v8PwLT8m3Yo4mQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "\n",
    "############### Write code below ##################\n",
    "fig, ax = plt.subplots()\n",
    "ax2 = ax.twinx()\n",
    "ax2.bar(time, inc_prec, color=p_bar, alpha=al, width=dt)\n",
    "ax2.set_ylabel(\"precip (in)\")\n",
    "ax2.set_ylim([0,inc_prec.max()+0.1*inc_prec.max()])\n",
    "\n",
    "ax2.bar(time, inc_roff, color=r_bar, alpha=al, width=dt)\n",
    "## make sure both vectors have same dimensions\n",
    "dt = time[1]-time[0]\n",
    "q_time = time[:]\n",
    "while q_time.shape[0] < q_in.shape[0]:\n",
    "    q_time = np.append(q_time, q_time[-1]+dt)\n",
    "fig.legend(\"runoff hydrograph\")    \n",
    "ax.plot(q_time, q_in, \"--\")\n",
    "ax.set_xlabel(\"time (hrs)\")\n",
    "ax.set_ylabel(\"discharge (in)\")\n",
    "ax.set_ylim([0,q_in.max()+0.1*q_in.max()])\n",
    "print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93739966",
   "metadata": {},
   "source": [
    "#### How does precip amount affect the runoff hydrograph?\n",
    "Enter up to 5 precip depths between 1 and 10 inches into test in the code box below.  \n",
    "Precip depths must be enclosed in square brackets and separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "62df8ce9",
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "precip_depths = [1,2,3,4,10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "ae18730c",
   "metadata": {
    "hide_input": false,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       "    if (code_show){\n",
       "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "    } else {\n",
       "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "    }\n",
       "    code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "\n",
    "############### Write code below ##################\n",
    "## edit here #############################################################\n",
    "fig_title = 'Hydrographs by Precip Depths'\n",
    "v_arr = precip_depths.copy()\n",
    "v_min = 1\n",
    "v_max = 10\n",
    "v_old = pr\n",
    "## Don't edit here #############################################################\n",
    "\n",
    "## verify the input data\n",
    "v_arr = v_arr[0:6]\n",
    "if v_old not in v_arr:\n",
    "    v_arr.append(v_old)\n",
    "v_arr.sort()\n",
    "\n",
    "\n",
    "for v in v_arr:\n",
    "    if type(v) == \"string\":\n",
    "        curve_numbers.remove(v)\n",
    "    elif v<v_min or v>v_max:\n",
    "        curve_numbers.remove(v)\n",
    "\n",
    "dat = {}\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "for v in v_arr:\n",
    "    this_v ={}\n",
    "    ## Edit variable we're testing ######################################################################\n",
    "    t_peak, q_peak, time, precip, tot_roff, inc_roff, q_in = main(v, cnum, area, slp, pf, ia=iabs, fl=flen )\n",
    "    #####################################################################################################\n",
    "    ## make sure both vectors have same dimensions\n",
    "    dt = time[1]-time[0]\n",
    "    q_time = time[:]\n",
    "    while q_time.shape[0] < q_in.shape[0]:\n",
    "        q_time = np.append(q_time, q_time[-1]+dt)\n",
    "        \n",
    "    this_v[\"t_peak\"]=t_peak\n",
    "    this_v[\"q_peak\"]=q_peak\n",
    "    this_v[\"t\"] = q_time\n",
    "    this_v[\"q\"] = q_in\n",
    "    dat[v]=this_v\n",
    "\n",
    "## debug code to print \n",
    "deb = 0\n",
    "if deb > 0:\n",
    "    print(\"\\nprf\\tpeak_runoff\\ttot_runoff\")\n",
    "for v in dat.keys():\n",
    "    ax.plot(dat[v][\"t\"], dat[v]['q'])\n",
    "    if deb > 0:\n",
    "        print(\"{0}\\t{1:0.1f}\\t{2:0.1f}\".format(v,dat[v]['q'].max(),dat[v]['q'].sum()))\n",
    "ax.set_xlim([10,40])\n",
    "ax.legend(dat.keys())\n",
    "ax.set_xlabel(\"Time\")\n",
    "ax.set_ylabel(\"Flow\")\n",
    "ax.set_title(fig_title)\n",
    "\n",
    "print(\"\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2453245",
   "metadata": {
    "hide_input": true
   },
   "source": [
    "#### How does curve number affect the runoff hydrograph?\n",
    "Enter up to 5 curve numbers between 40 and 100 into test in the code box below.  \n",
    "Curve numbers must be enclosed in square brackets and separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "49cf11d9",
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "curve_numbers = [40, 50, 70, 80, 95]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "b72935ae",
   "metadata": {
    "hide_input": false,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       "    if (code_show){\n",
       "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "    } else {\n",
       "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "    }\n",
       "    code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "\n",
    "############### Write code below ##################\n",
    "\n",
    "## edit here #############################################################\n",
    "fig_title = 'Hydrographs by Curve Number'\n",
    "v_arr = curve_numbers.copy()\n",
    "v_min = 35\n",
    "v_max = 100\n",
    "v_old = cnum\n",
    "## Don't edit here #############################################################\n",
    "\n",
    "## verify the input data\n",
    "v_arr = v_arr[0:6]\n",
    "if v_old not in v_arr:\n",
    "    v_arr.append(v_old)\n",
    "v_arr.sort()\n",
    "\n",
    "\n",
    "for v in v_arr:\n",
    "    if type(v) == \"string\":\n",
    "        curve_numbers.remove(v)\n",
    "    elif v<v_min or v>v_max:\n",
    "        curve_numbers.remove(v)\n",
    "\n",
    "dat = {}\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "for v in v_arr:\n",
    "    this_v ={}\n",
    "    ## Edit variable we're testing ######################################################################\n",
    "    t_peak, q_peak, time, precip, tot_roff, inc_roff, q_in = main(pr, v, area, slp, pf, ia=iabs, fl=flen )\n",
    "    #####################################################################################################\n",
    "    ## make sure both vectors have same dimensions\n",
    "    dt = time[1]-time[0]\n",
    "    q_time = time[:]\n",
    "    while q_time.shape[0] < q_in.shape[0]:\n",
    "        q_time = np.append(q_time, q_time[-1]+dt)\n",
    "        \n",
    "    this_v[\"t_peak\"]=t_peak\n",
    "    this_v[\"q_peak\"]=q_peak\n",
    "    this_v[\"t\"] = q_time\n",
    "    this_v[\"q\"] = q_in\n",
    "    dat[v]=this_v\n",
    "\n",
    "## debug code to print \n",
    "deb = 0\n",
    "if deb > 0:\n",
    "    print(\"\\nprf\\tpeak_runoff\\ttot_runoff\")\n",
    "for v in dat.keys():\n",
    "    ax.plot(dat[v][\"t\"], dat[v]['q'])\n",
    "    if deb > 0:\n",
    "        print(\"{0}\\t{1:0.1f}\\t{2:0.1f}\".format(v,dat[v]['q'].max(),dat[v]['q'].sum()))\n",
    "ax.set_xlim([10,40])\n",
    "ax.legend(dat.keys())\n",
    "ax.set_xlabel(\"Time\")\n",
    "ax.set_ylabel(\"Flow\")\n",
    "ax.set_title(fig_title)\n",
    "\n",
    "print(\"\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "326b3b2a",
   "metadata": {},
   "source": [
    "#### How does watershed area affect the runoff hydrograph?\n",
    "Enter up to 5 areas between 5 and 200 acres into test in the code box below.  \n",
    "Area must be enclosed in square brackets and separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "4fc1d313",
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "watershed_areas = [5, 10, 25, 100, 200]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "3e5077ba",
   "metadata": {
    "hide_input": false,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       "    if (code_show){\n",
       "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "    } else {\n",
       "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "    }\n",
       "    code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "############### Write code below ##################\n",
    "## edit here #############################################################\n",
    "fig_title = 'Hydrographs by Watershed Area'\n",
    "v_arr = watershed_areas.copy()\n",
    "v_min = 5\n",
    "v_max = 200\n",
    "v_old = area\n",
    "## Don't edit here #############################################################\n",
    "\n",
    "## verify the input data\n",
    "v_arr = v_arr[0:6]\n",
    "if v_old not in v_arr:\n",
    "    v_arr.append(v_old)\n",
    "v_arr.sort()\n",
    "\n",
    "\n",
    "for v in v_arr:\n",
    "    if type(v) == \"string\":\n",
    "        curve_numbers.remove(v)\n",
    "    elif v<v_min or v>v_max:\n",
    "        curve_numbers.remove(v)\n",
    "\n",
    "dat = {}\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "for v in v_arr:\n",
    "    this_v ={}\n",
    "    ## Edit variable we're testing ######################################################################\n",
    "    t_peak, q_peak, time, precip, tot_roff, inc_roff, q_in = main(pr, cnum, v, slp, pf, ia=iabs, fl=flen )\n",
    "    #####################################################################################################\n",
    "    ## make sure both vectors have same dimensions\n",
    "    dt = time[1]-time[0]\n",
    "    q_time = time[:]\n",
    "    while q_time.shape[0] < q_in.shape[0]:\n",
    "        q_time = np.append(q_time, q_time[-1]+dt)\n",
    "        \n",
    "    this_v[\"t_peak\"]=t_peak\n",
    "    this_v[\"q_peak\"]=q_peak\n",
    "    this_v[\"t\"] = q_time\n",
    "    this_v[\"q\"] = q_in\n",
    "    dat[v]=this_v\n",
    "\n",
    "## debug code to print \n",
    "deb = 0\n",
    "if deb > 0:\n",
    "    print(\"\\nprf\\tpeak_runoff\\ttot_runoff\")\n",
    "for v in dat.keys():\n",
    "    ax.plot(dat[v][\"t\"], dat[v]['q'])\n",
    "    if deb > 0:\n",
    "        print(\"{0}\\t{1:0.1f}\\t{2:0.1f}\".format(v,dat[v]['q'].max(),dat[v]['q'].sum()))\n",
    "ax.set_xlim([10,40])\n",
    "ax.legend(dat.keys())\n",
    "ax.set_xlabel(\"Time\")\n",
    "ax.set_ylabel(\"Flow\")\n",
    "ax.set_title(fig_title)\n",
    "\n",
    "print(\"\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d223c42",
   "metadata": {},
   "source": [
    "#### How does watershed slope affect the runoff hydrograph?\n",
    "Enter up to 5 slopes between 0.001 and 0.05 into test in the code box below.\n",
    "Slopes must be enclosed in square brackets and separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "b053115c",
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "watershed_slopes = [0.001, 0.005, 0.01, 0.02, 0.03]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "e80af99c",
   "metadata": {
    "hide_input": false,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       "    if (code_show){\n",
       "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "    } else {\n",
       "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "    }\n",
       "    code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "\n",
    "############### Write code below ##################\n",
    "## edit here #############################################################\n",
    "fig_title = 'Hydrographs by Watershed Slopes'\n",
    "v_arr = watershed_slopes.copy()\n",
    "v_min = 0.001\n",
    "v_max = 0.05\n",
    "v_old = slp\n",
    "## Don't edit here #############################################################\n",
    "\n",
    "## verify the input data\n",
    "v_arr = v_arr[0:6]\n",
    "if v_old not in v_arr:\n",
    "    v_arr.append(v_old)\n",
    "v_arr.sort()\n",
    "\n",
    "\n",
    "for v in v_arr:\n",
    "    if type(v) == \"string\":\n",
    "        curve_numbers.remove(v)\n",
    "    elif v<v_min or v>v_max:\n",
    "        curve_numbers.remove(v)\n",
    "\n",
    "dat = {}\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "for v in v_arr:\n",
    "    this_v ={}\n",
    "    ## Edit variable we're testing ######################################################################\n",
    "    t_peak, q_peak, time, precip, tot_roff, inc_roff, q_in = main(pr, cnum, area, v, pf, ia=iabs, fl=flen )\n",
    "    #####################################################################################################\n",
    "    ## make sure both vectors have same dimensions\n",
    "    dt = time[1]-time[0]\n",
    "    q_time = time[:]\n",
    "    while q_time.shape[0] < q_in.shape[0]:\n",
    "        q_time = np.append(q_time, q_time[-1]+dt)\n",
    "        \n",
    "    this_v[\"t_peak\"]=t_peak\n",
    "    this_v[\"q_peak\"]=q_peak\n",
    "    this_v[\"t\"] = q_time\n",
    "    this_v[\"q\"] = q_in\n",
    "    dat[v]=this_v\n",
    "\n",
    "## debug code to print \n",
    "deb = 0\n",
    "if deb > 0:\n",
    "    print(\"\\nprf\\tpeak_runoff\\ttot_runoff\")\n",
    "for v in dat.keys():\n",
    "    ax.plot(dat[v][\"t\"], dat[v]['q'])\n",
    "    if deb > 0:\n",
    "        print(\"{0}\\t{1:0.1f}\\t{2:0.1f}\".format(v,dat[v]['q'].max(),dat[v]['q'].sum()))\n",
    "ax.set_xlim([10,40])\n",
    "ax.legend(dat.keys())\n",
    "ax.set_xlabel(\"Time\")\n",
    "ax.set_ylabel(\"Flow\")\n",
    "ax.set_title(fig_title)\n",
    "\n",
    "print(\"\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e7615c0",
   "metadata": {},
   "source": [
    "#### How does initial abstraction affect the runoff hydrograph?\n",
    "Enter up to 5 initial abstraction coefficients between 0.01 and 0.5 into test in the code box below.\n",
    "Coefficients must be enclosed in square brackets and separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "d1f7d4ad",
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "init_abs = [0.05, 0.1, 0.3, 0.4, 0.5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "48e45152",
   "metadata": {
    "hide_input": false,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       "    if (code_show){\n",
       "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "    } else {\n",
       "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "    }\n",
       "    code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "\n",
    "############### Write code below ##################\n",
    "## edit here #############################################################\n",
    "fig_title = 'Hydrographs by Initial Abstraction'\n",
    "v_arr = init_abs.copy()\n",
    "v_min = 0.01\n",
    "v_max = 0.5\n",
    "v_old = iabs\n",
    "## Don't edit here #############################################################\n",
    "\n",
    "## verify the input data\n",
    "v_arr = v_arr[0:6]\n",
    "if v_old not in v_arr:\n",
    "    v_arr.append(v_old)\n",
    "v_arr.sort()\n",
    "\n",
    "\n",
    "for v in v_arr:\n",
    "    if type(v) == \"string\":\n",
    "        curve_numbers.remove(v)\n",
    "    elif v<v_min or v>v_max:\n",
    "        curve_numbers.remove(v)\n",
    "\n",
    "dat = {}\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "for v in v_arr:\n",
    "    this_v ={}\n",
    "    ## Edit variable we're testing ######################################################################\n",
    "    t_peak, q_peak, time, precip, tot_roff, inc_roff, q_in = main(pr, cnum, area, slp, pf, ia=v, fl=flen )\n",
    "    #####################################################################################################\n",
    "    ## make sure both vectors have same dimensions\n",
    "    dt = time[1]-time[0]\n",
    "    q_time = time[:]\n",
    "    while q_time.shape[0] < q_in.shape[0]:\n",
    "        q_time = np.append(q_time, q_time[-1]+dt)\n",
    "        \n",
    "    this_v[\"t_peak\"]=t_peak\n",
    "    this_v[\"q_peak\"]=q_peak\n",
    "    this_v[\"t\"] = q_time\n",
    "    this_v[\"q\"] = q_in\n",
    "    dat[v]=this_v\n",
    "\n",
    "## debug code to print \n",
    "deb = 0\n",
    "if deb > 0:\n",
    "    print(\"\\nprf\\tpeak_runoff\\ttot_runoff\")\n",
    "for v in dat.keys():\n",
    "    ax.plot(dat[v][\"t\"], dat[v]['q'])\n",
    "    if deb > 0:\n",
    "        print(\"{0}\\t{1:0.1f}\\t{2:0.1f}\".format(v,dat[v]['q'].max(),dat[v]['q'].sum()))\n",
    "ax.set_xlim([10,40])\n",
    "ax.legend(dat.keys())\n",
    "ax.set_xlabel(\"Time\")\n",
    "ax.set_ylabel(\"Flow\")\n",
    "ax.set_title(fig_title)\n",
    "\n",
    "print(\"\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e544777",
   "metadata": {
    "hide_input": false
   },
   "source": [
    "#### How do peak rate factors affect the runoff hydrograph?\n",
    "Enter up to 5 between 100 and 800 peak rate factors to test in the code box below.\n",
    "Peak factor values must be enclosed in square brackets and separated by commas. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "ee09a556",
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "peak_rate_factors = [300,375,425,475,600]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "5cecb137",
   "metadata": {
    "hide_input": false,
    "scrolled": true,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       "    if (code_show){\n",
       "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "    } else {\n",
       "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "    }\n",
       "    code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "\n",
    "############### Write code below ##################\n",
    "fig, ax = plt.subplots()\n",
    "for p in peak_rate_factors:\n",
    "    duh_t, duh_q = calc_gamma(p, 0.1)\n",
    "    ax.plot(duh_t,duh_q, \"-\")\n",
    "    ax.legend(peak_rate_factors)\n",
    "    ax.set_title('Dimensionless Unit Hydrographs by Peaking Factor')\n",
    "    ax.set_xlabel(\"duh_t\")\n",
    "    ax.set_ylabel(\"duh_q\")\n",
    "    ax.set_ylim([0,1.1*duh_q.max()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "5cfe2195",
   "metadata": {
    "hide_input": false,
    "scrolled": false,
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       "    if (code_show){\n",
       "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
       "    } else {\n",
       "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
       "    }\n",
       "    code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Taken from https://stackoverflow.com/questions/31517194/how-to-hide-one-specific-cell-input-or-output-in-ipython-notebook\n",
    "tag = HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    "    if (code_show){\n",
    "        $('div.cell.code_cell.rendered.selected div.input').hide();\n",
    "    } else {\n",
    "        $('div.cell.code_cell.rendered.selected div.input').show();\n",
    "    }\n",
    "    code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "To show/hide this cell's raw code input, click <a href=\"javascript:code_toggle()\">here</a>.''')\n",
    "display(tag)\n",
    "\n",
    "############### Write code below ##################\n",
    "## edit here #############################################################\n",
    "fig_title = 'Hydrographs by Peak Rate Factor'\n",
    "v_arr = peak_rate_factors.copy()\n",
    "v_min = 100\n",
    "v_max = 800\n",
    "v_old = pf\n",
    "## Don't edit here #############################################################\n",
    "\n",
    "## verify the input data\n",
    "v_arr = v_arr[0:6]\n",
    "if v_old not in v_arr:\n",
    "    v_arr.append(v_old)\n",
    "v_arr.sort()\n",
    "\n",
    "\n",
    "for v in v_arr:\n",
    "    if type(v) == \"string\":\n",
    "        curve_numbers.remove(v)\n",
    "    elif v<v_min or v>v_max:\n",
    "        curve_numbers.remove(v)\n",
    "\n",
    "dat = {}\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "for v in v_arr:\n",
    "    this_v ={}\n",
    "    ## Edit variable we're testing ######################################################################\n",
    "    t_peak, q_peak, time, precip, tot_roff, inc_roff, q_in = main(pr, cnum, area, slp, v, ia=iabs, fl=flen )\n",
    "    #####################################################################################################\n",
    "    ## make sure both vectors have same dimensions\n",
    "    dt = time[1]-time[0]\n",
    "    q_time = time[:]\n",
    "    while q_time.shape[0] < q_in.shape[0]:\n",
    "        q_time = np.append(q_time, q_time[-1]+dt)\n",
    "        \n",
    "    this_v[\"t_peak\"]=t_peak\n",
    "    this_v[\"q_peak\"]=q_peak\n",
    "    this_v[\"t\"] = q_time\n",
    "    this_v[\"q\"] = q_in\n",
    "    dat[v]=this_v\n",
    "\n",
    "## debug code to print \n",
    "deb = 0\n",
    "if deb > 0:\n",
    "    print(\"\\nprf\\tpeak_runoff\\ttot_runoff\")\n",
    "for v in dat.keys():\n",
    "    ax.plot(dat[v][\"t\"], dat[v]['q'])\n",
    "    if deb > 0:\n",
    "        print(\"{0}\\t{1:0.1f}\\t{2:0.1f}\".format(v,dat[v]['q'].max(),dat[v]['q'].sum()))\n",
    "ax.set_xlim([10,40])\n",
    "ax.legend(dat.keys())\n",
    "ax.set_xlabel(\"Time\")\n",
    "ax.set_ylabel(\"Flow\")\n",
    "ax.set_title(fig_title)\n",
    "\n",
    "print(\"\")"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}