capacity_simulator_v0.5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hospital Capacity Simulator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import datetime\n",
    "from datetime import datetime, timedelta, date\n",
    "\n",
    "\n",
    "from numpy import random\n",
    "\n",
    "from ipywidgets import *\n",
    "from IPython.display import display\n",
    "\n",
    "pd.set_option('display.max_columns', None)\n",
    "pd.set_option(\"display.max_rows\", None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Admission Data\n",
    "\n",
    "- Generate and plot random data for planned and unplanned admissions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Sliders #### \n",
    "\n",
    "num_beds = IntSlider(value=275, min=100, max=500, description='Beds',  continuous_update=False)\n",
    "unplan_adm_rate = FloatSlider(value=0.3, min=0.0, max=1.0, step=0.05, description='adm rate (%)', continuous_update=False)\n",
    "\n",
    "pl_los_avg = FloatSlider(value=56.0, min=0.0, max=240.0, step=1.0,  description='avg', continuous_update=False)\n",
    "pl_los_std = FloatSlider(value=24.0, min=0.0, max=60.0, step=0.1,  description='std', continuous_update=False)\n",
    "\n",
    "unpl_los_avg = FloatSlider(value=48.0, min=0.0, max=120.0, step=0.5,  description='avg', continuous_update=False)\n",
    "unpl_los_std = FloatSlider(value=16.0, min=0.0, max=60.0, step=0.1,  description='std', continuous_update=False)\n",
    "\n",
    "pl_adm_bias_avg =   FloatSlider(value=0.0, min=-10.0, max=10.0, step=0.5,  description='avg', continuous_update=False)\n",
    "# pl_adm_bias_std =   FloatSlider(value=0.0, min=-10.0, max=10.0, step=0.1,  description='std', continuous_update=False)\n",
    "\n",
    "unpl_adm_bias_avg = FloatSlider(value=2.0, min=-10.0, max=10.0, step=0.5,  description='avg', continuous_update=False)\n",
    "# unpl_adm_bias_std = FloatSlider(value=0.0, min=-10.0, max=10.0, step=0.1,  description='std', continuous_update=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Dates selectors ####\n",
    "today = date.today()\n",
    "start = DatePicker( description='Begin:', disabled=False)\n",
    "start.value = today-timedelta(days=7)\n",
    "start_data = start.value-timedelta(days=21)\n",
    "end = DatePicker(description='End:', disabled=False)\n",
    "end.value = today"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Arrival Stats #### \n",
    "plan_hrly_means = np.array([0.2, 0.2, 0.2, 0.2, 0.2, 1.5, 2.0, 2.4, 3.2, 3.5, 3.9, 3.1, 3.1, 2.8, 2.3, 2.5, 2.4, 2.1, 2.0, 1.0, \n",
    "                             0.2, 0.2, 0.2, 0.2])\n",
    "\n",
    "plan_hrly_std = np.array([.15, .11, .1, .1, .1, .35, .2, .5, .4, .7, .5, .4, .6, .4, .7, .6, .3, .3, .2, .2, .1, .1, .1, .1])\n",
    "\n",
    "unplan_hrly_means = np.array([3.5, 3.1 ,2.7, 2.6, 2.4, 2.35, 2.2, 4.5, 5.9, 6.7, 6.5, 5.4, 5.6, 5.8, 5.7, 5.6, 5.3, 5.2, 5.3, 6,\n",
    "                         6.5, 5.2, 4.3, 3.9])\n",
    "\n",
    "unplan_hrly_std = np.array([0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 1.5, 2.5, 2.5, 2.5, 3.0, 2.5, 2.5, 1.5, 1.75, 1.5, 1.25, 1.25, .75, 0.55, \n",
    "                        0.55, 0.55, 0.55, 0.55])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Generators and Plots #### \n",
    "\n",
    "def gen_day_normal(hrly_means, hrly_std, bias, rate=None):\n",
    "    if not rate: rate=1.0\n",
    "    patients = [round(random.poisson(o+bias)*rate) for o in hrly_means]\n",
    "#     patients = [int(random.normal(loc=m.item(), scale=s.item())*rate) for m,s in zip(hrly_means + bias, hrly_std)]\n",
    "    \n",
    "    return [p if p>=0 else 0 for p in patients]\n",
    "\n",
    "\n",
    "def gen_hrly_los(patients, avg, std):\n",
    "    return [[int(random.normal(loc=avg, scale=std)) for x in range(a)] for a in patients]\n",
    "\n",
    "def count_days(start, end):\n",
    "    if start.value and end.value:\n",
    "        delta = end.value - start.value\n",
    "        return delta.days\n",
    "\n",
    "def get_random_admission(start_date, end_date):\n",
    "    num_days = count_days(start_date, end_date)\n",
    "    string_dates = [(start_date.value + timedelta(days=i)).isoformat() for i in range(0,num_days)]\n",
    "    tot_planned, tot_unplanned, hrly_pl, hrly_upl = gen_random_admissions(num_days)\n",
    "    return string_dates, tot_planned, tot_unplanned, hrly_pl, hrly_upl\n",
    "\n",
    "def plot_one_day():\n",
    "    fig, ax = plt.subplots(1,2, figsize=(15,5))\n",
    "\n",
    "    sns.barplot(x=np.arange(0,24,1), y=gen_day_normal(plan_hrly_means, \n",
    "                                                      plan_hrly_std, \n",
    "                                                      pl_adm_bias_avg.value), ax=ax[0]);\n",
    "    ax[0].set(xlabel='Hour of the Day', ylabel='# of Patients')\n",
    "    ax[0].set_title(\"Random Planned Admissions per Hour\")\n",
    "\n",
    "    sns.barplot(x=np.arange(0,24,1), y=gen_day_normal(unplan_hrly_means, \n",
    "                                              unplan_hrly_std, \n",
    "                                              unpl_adm_bias_avg.value , \n",
    "                                              unplan_adm_rate.value), ax=ax[1])\n",
    "\n",
    "    ax[1].set(xlabel='Hour of the Day', ylabel='# of Patients')\n",
    "    ax[1].set_title(\"Random Unplanned Admissions per Hour\")\n",
    "    plt.show();\n",
    "\n",
    "def gen_random_admissions(num_days):\n",
    "    tot_planned, tot_unplanned = [],[]\n",
    "    hrly_pln, hrly_unpln = [],[]\n",
    "    \n",
    "    for day in range(num_days):\n",
    "        rand_plan = gen_day_normal(plan_hrly_means, \n",
    "                                   plan_hrly_std, \n",
    "                                   pl_adm_bias_avg.value)\n",
    "        \n",
    "        rand_unplan = gen_day_normal(unplan_hrly_means, \n",
    "                                     unplan_hrly_std, \n",
    "                                     unpl_adm_bias_avg.value, \n",
    "                                     unplan_adm_rate.value)\n",
    "\n",
    "\n",
    "        plan_los = gen_hrly_los(rand_plan, pl_los_avg.value, pl_los_std.value)\n",
    "        unplan_los = gen_hrly_los(rand_unplan, unpl_los_avg.value, unpl_los_std.value)\n",
    "        \n",
    "        hrly_pln.append(plan_los)\n",
    "        hrly_unpln.append(unplan_los)\n",
    "        \n",
    "        tot_unplanned.append(sum(rand_unplan))\n",
    "        tot_planned.append(sum(rand_plan))\n",
    "    \n",
    "    return tot_planned, tot_unplanned, hrly_pln, hrly_unpln\n",
    "\n",
    "def autolabel(ax, rects, xpos='center'):\n",
    "    ha = {'center': 'center', 'right': 'left', 'left': 'right'}\n",
    "    offset = {'center': 0, 'right': 1, 'left': -1}\n",
    "\n",
    "    for rect in rects:\n",
    "        height = rect.get_height()\n",
    "        ax.annotate('{}'.format(height),\n",
    "                    xy=(rect.get_x() + rect.get_width() / 2, height),\n",
    "                    xytext=(offset[xpos]*3, 3),  # use 3 points offset\n",
    "                    textcoords=\"offset points\",  # in both directions\n",
    "                    ha=ha[xpos], va='bottom')\n",
    "\n",
    "def plot_admissions(string_dates, tot_planned, tot_unplanned):\n",
    "    \n",
    "    ind = np.arange(len(tot_planned))  # the x locations for the groups\n",
    "    width = 0.35  # the width of the bars\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(12, 7))\n",
    "    rects1 = ax.bar(ind - width/2, tot_planned, width, label='Planned')\n",
    "    rects2 = ax.bar(ind + width/2, tot_unplanned, width, label='Unplanned')\n",
    "\n",
    "    # Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "    ax.set_ylabel('# of patients')\n",
    "    ax.set_title('Admissions Per Day')\n",
    "    ax.set_xticks(ind)\n",
    "    ax.set_xticklabels(string_dates)\n",
    "    fig.autofmt_xdate()\n",
    "    ax.legend()\n",
    "\n",
    "    autolabel(ax, rects1, \"left\")\n",
    "    autolabel(ax, rects2, \"right\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "#### LOS ####\n",
    "def los_df(hrly_los, string_dates):\n",
    "    \n",
    "    df = pd.DataFrame(columns=[\"admit\",\"discharge\", \"LOS\"])\n",
    "    \n",
    "    for day in range(len(hrly_los)):\n",
    "        for hr in range(len(hrly_los[day])):\n",
    "            for los in hrly_los[day][hr]:\n",
    "                s = string_dates[day]+ f' {hr}:00:00' \n",
    "                admit = datetime.strptime(s, \"%Y-%m-%d %H:%M:%S\")\n",
    "                discharge = admit + timedelta(hours=los)\n",
    "                row = {\"admit\":admit ,\"discharge\":discharge, \"LOS\":los}\n",
    "                df = df.append(row, ignore_index=True)\n",
    "        \n",
    "    return df\n",
    "\n",
    "def bed_capacity(start, end, df):\n",
    "    num_days = count_days(start, end)\n",
    "    timestrings = []\n",
    "    occupied = []\n",
    "    \n",
    "    for day in range(num_days):\n",
    "        current = start.value + timedelta(days=day)\n",
    "        for hr in range(24): \n",
    "            hour = pd.Timestamp(current.strftime(\"%Y-%m-%d\") + f' {hr}:00:00')\n",
    "            discharges = len(df[(df['discharge']<=hour)])\n",
    "            admits = len(df[(df['admit']<=hour)])\n",
    "            timestrings.append(hour.strftime(\"%m-%d-%Y %H:%M:%S\"))\n",
    "            occupied.append(admits - discharges)\n",
    "    return timestrings, occupied\n",
    "\n",
    "def plot_beds(times, occupied1, occupied2):\n",
    "\n",
    "    occupied = np.add(np.array(occupied1),np.array(occupied2))\n",
    "    \n",
    "    fig, ax = plt.subplots(1, figsize=(15,6))\n",
    "    ax.plot(times, occupied)\n",
    "    \n",
    "    max_beds = float(num_beds.value)\n",
    "    plt.axhline(y=max_beds, color='r', linestyle='-')\n",
    "    \n",
    "    ax.set_ylabel('# of patients')\n",
    "    ax.legend(['Total Beds Occupied', \"Max Bed Capacity\"])\n",
    "    \n",
    "    ax.fill_between(times, occupied, max_beds, where= occupied >= max_beds, alpha=0.50,  facecolor='r', edgecolor='r', interpolate=True)\n",
    "    \n",
    "    plt.xticks(np.arange(0, len(times), 12.0), rotation=45)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bed_capacity_matrix(start, end, df1, df2, hours_back=24):\n",
    "    \n",
    "    matrix_df = pd.DataFrame() \n",
    "    num_days = count_days(start, end)\n",
    "    df = df1.append(df2, ignore_index=True).sort_values('admit')\n",
    "    count=0\n",
    "    \n",
    "    # for each day in date range\n",
    "    for day in range(num_days):\n",
    "        current_day = start.value + timedelta(days=day)\n",
    "        \n",
    "        # for each hour in 24 hour day\n",
    "        for hr in range(24):\n",
    "            \n",
    "            col = str(hr)+current_day.strftime(\" %m-%d\")\n",
    "            matrix_df.insert(count, col, None)\n",
    "            count+=1\n",
    "            current_hr = datetime(year=current_day.year, month=current_day.month, \n",
    "                                  day=current_day.day, hour=0, minute=0, second=0)  + timedelta(hours=hr)\n",
    "            patients = []\n",
    "            \n",
    "            # go hours back \n",
    "            for i in range(hours_back): \n",
    "                past = pd.Timestamp((current_hr - timedelta(hours=i)).strftime(\"%m-%d-%Y %H:%M:%S\"))\n",
    "                patients.append(len(df[(df['admit']<=past)]) - len(df[(df['discharge']<=past)]))\n",
    "                \n",
    "           \n",
    "            matrix_df[col] = patients\n",
    "                \n",
    "            \n",
    "    return matrix_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Buttons #### \n",
    "gen_button = Button(description=\"Refresh\")\n",
    "beds_button = Button(description=\"Bed Capacity Calc\")    \n",
    "\n",
    "output = Output()\n",
    "output2 = Output()\n",
    "output3 = Output()\n",
    "output4 = Output()\n",
    "\n",
    "output.layout.height = '450px'\n",
    "output2.layout.height = '450px'\n",
    "output3.layout.height = '450px'\n",
    "output4.layout.height = '450px'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def on_change(b):\n",
    "    string_dates, tot_pl, tot_unpl, hrly_pl, hrly_upl = get_random_admission(start, end)\n",
    "    \n",
    "    pl_df = los_df(hrly_pl, string_dates)\n",
    "    unpl_df = los_df(hrly_upl, string_dates)\n",
    "    \n",
    "    times, occupied = bed_capacity(start, end, pl_df)\n",
    "    _ , occupied2 = bed_capacity(start, end, unpl_df)\n",
    "    \n",
    "    df = bed_capacity_matrix(start, end, pl_df, unpl_df)\n",
    "    \n",
    "    \n",
    "    output.clear_output() \n",
    "    with output:\n",
    "        plot_one_day()\n",
    "    \n",
    "    output2.clear_output()\n",
    "    with output2:\n",
    "        plot_admissions(string_dates, tot_pl, tot_unpl) \n",
    "        \n",
    "    output3.clear_output()\n",
    "    with output3:\n",
    "        plot_beds(times, occupied, occupied2)\n",
    "    \n",
    "    output4.clear_output()\n",
    "    with output4:\n",
    "         display(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "gen_button.on_click(on_change)\n",
    "beds_button.on_click(on_change)\n",
    "\n",
    "start.observe(on_change)\n",
    "end.observe(on_change)\n",
    "\n",
    "\n",
    "unplan_adm_rate.observe(on_change, names=['value'])\n",
    "\n",
    "pl_adm_bias_avg.observe(on_change, names=['value'])\n",
    "unpl_adm_bias_avg.observe(on_change, names=['value'])\n",
    "\n",
    "pl_los_avg.observe(on_change, names=['value'])\n",
    "pl_los_std.observe(on_change, names=['value'])\n",
    "\n",
    "unpl_los_avg.observe(on_change, names=['value'])\n",
    "unpl_los_std.observe(on_change, names=['value'])\n",
    "\n",
    "num_beds.observe(on_change, names=['value'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Forms #### \n",
    "\n",
    "stats_items = [HTML(value=\"<b>Planned Admissions:</b>\"), pl_adm_bias_avg,\n",
    "               HTML(value=\"<b>Unplanned Admissions:</b>\"), unpl_adm_bias_avg,\n",
    "               unplan_adm_rate,\n",
    "               gen_button]\n",
    "               \n",
    "\n",
    "stats_sidebar = Box(stats_items, layout=Layout(display='flex-grow',\n",
    "                                               flex_flow='column',\n",
    "                                               align_items='center',\n",
    "                                               justify_content='center'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "dates = Box([HBox([start, end])], layout=Layout(display='flex', flex_flow='row',\n",
    "                                                            height=\"auto\", align_items='center', \n",
    "                                                            justify_content='center', width='auto'))\n",
    "\n",
    "gen_adms = Box([gen_button], layout=Layout(display='flex', flex_flow='row',\n",
    "                                             height=\"auto\", align_items='center', \n",
    "                                             justify_content='center', width='auto'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab = Tab()\n",
    "tab.children = [output, output2]\n",
    "tab.set_title(0, 'Sample Days')\n",
    "tab.set_title(1, 'Admissions Per Day')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ad5b6fe768da41f5a00eba202cc15a85",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "AppLayout(children=(Box(children=(HBox(children=(DatePicker(value=datetime.date(2020, 9, 4), description='Begi…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "AppLayout(header = dates,\n",
    "          left_sidebar=stats_sidebar,\n",
    "          center=tab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bed Capacity Calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "sidebar2_items = [HTML(value=\"<b>Total Beds:</b>\"), num_beds,\n",
    "                  HTML(value=\"<b>Planned LOS:</b>\"), pl_los_avg, pl_los_std,\n",
    "                  HTML(value=\"<b>Unplanned LOS:</b>\"), unpl_los_avg, unpl_los_std]\n",
    "\n",
    "sidebar2 = Box(sidebar2_items, layout=Layout(display='flex-grow',\n",
    "                                               flex_flow='column',\n",
    "                                               align_items='center',\n",
    "                                               justify_content='center'))\n",
    "\n",
    "\n",
    "footer2 = Box([beds_button], layout=Layout(display='flex-grow',\n",
    "                                               flex_flow='row',\n",
    "                                               align_items='center',\n",
    "                                               justify_content='center',\n",
    "                                               width=\"auto\"))\n",
    "\n",
    "\n",
    "center2 = Box([output3], layout=Layout(display='flex-grow',\n",
    "                                               flex_flow='column',\n",
    "                                               align_items='flex-start',\n",
    "                                               height='auto',\n",
    "                                               width=\"auto\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab2 = Tab()\n",
    "tab2.children = [output3, output4]\n",
    "tab2.set_title(0, 'Bed Cap. Daily')\n",
    "tab2.set_title(1, 'Bed Cap. Hourly')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2f28b8b7d3d64668a1cc704c31410a98",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "AppLayout(children=(Box(children=(Button(description='Bed Capacity Calc', style=ButtonStyle()),), layout=Layou…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "AppLayout(left_sidebar=sidebar2,\n",
    "          center=tab2,\n",
    "         footer=footer2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "on_change(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}