capacity_simulator_v1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "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",
    "\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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "avg_plan_hrly = np.array([0.2, 0.2, 0.2, 0.2, 0.2, 1.5, 2.0, 2.1, 2.2, 2.2, 3.2, 3.1, 2.1, 2.1, 2.0, 1.5, 1.4, 1.1, 1.0, 1.0, \n",
    "                             0.2, 0.2, 0.2, 0.2])\n",
    "\n",
    "avg_pl_hrly_sliders = [FloatSlider(value=n, min=0.0, max=20.0, step=0.25,  description=str(h), continuous_update=False, \n",
    "                                   orientation=\"vertical\", layout=Layout(width=\"110%\")) for n,h in zip(avg_plan_hrly, np.arange(0,24, 1))]\n",
    "\n",
    "avg_unplan_hrly = np.array([4.5, 4.1 ,3.9, 3.8, 3.64, 3.45, 3.4, 5.5, 6.9, 7.7, 7.5, 6.4, 6.6, 6.8, 6.7, 6.6, 6.3, 6.2, 6.3, 7,\n",
    "                         7.5, 6.2, 5.3, 4.9])\n",
    "\n",
    "avg_upl_hrly_sliders = [FloatSlider(value=n, min=0.0, max=30.0, step=0.25,  description=str(h), continuous_update=False, \n",
    "                                    orientation=\"vertical\", layout=Layout(width=\"100%\")) for n,h in zip(avg_unplan_hrly, np.arange(0,24, 1))]\n",
    "\n",
    "#### Dates selectors ####\n",
    "today = datetime.date.today()\n",
    "\n",
    "start = DatePicker( description='Begin:', disabled=False)\n",
    "start.value = today - datetime.timedelta(days=7)\n",
    "\n",
    "end = DatePicker(description='End:', disabled=False)\n",
    "end.value = today\n",
    "\n",
    "unplan_adm_rate = FloatSlider(value=0.3, min=0.0, max=1.0, step=0.05, description='(%)', continuous_update=False)\n",
    "\n",
    "#### Sliders #### \n",
    "\n",
    "num_beds = IntSlider(value=250, min=100, max=500, description='Beds',  continuous_update=False)\n",
    "\n",
    "pl_los_avg = FloatSlider(value=72.0, min=0.0, max=240.0, step=1.0,  description='avg', continuous_update=False)\n",
    "pl_los_std = FloatSlider(value=36.0, min=0.0, max=100.0, step=1.0,  description='std', continuous_update=False)\n",
    "\n",
    "unpl_los_avg = FloatSlider(value=56.0, min=0.0, max=120.0, step=1.0,  description='avg', continuous_update=False)\n",
    "unpl_los_std = FloatSlider(value=24.0, min=0.0, max=60.0, step=1.0,  description='std', continuous_update=False)\n",
    "\n",
    "\n",
    "hrs_back = IntSlider(value=90, min=0.0, max=180.0, step=1,\n",
    "                     description='Hours', continuous_update=False)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_hrly_avgs(sliders, label, color):\n",
    "    ind = np.arange(24)\n",
    "    width = 0.75\n",
    "\n",
    "    fig, ax = plt.subplots(1, figsize=(12, 5))\n",
    "    rects1 = ax.bar(ind, [i.value for i in sliders],\n",
    "                    width, label=label, color=color)\n",
    "\n",
    "    ax.set_ylabel('avg # of patients')\n",
    "    ax.set_xlabel('hour of day')\n",
    "\n",
    "    ax.set_xticks(ind)\n",
    "    ax.legend()\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def p_los_gen(x):\n",
    "    times = []\n",
    "    for i in range(x['Unplanned']):\n",
    "        times.append(x['Datetime'] + pd.Timedelta(value=abs(round(\n",
    "            random.normal(loc=pl_los_avg.value, scale=pl_los_std.value))), unit='hours'))\n",
    "    return times\n",
    "\n",
    "\n",
    "def up_los_gen(x):\n",
    "    times = []\n",
    "    for i in range(x['Planned']):\n",
    "        times.append(x['Datetime'] + pd.Timedelta(value=abs(round(random.normal(\n",
    "            loc=unpl_los_avg.value, scale=unpl_los_std.value))), unit='hours'))\n",
    "    return times\n",
    "\n",
    "\n",
    "def gen_los(df):\n",
    "\n",
    "    df_los = df[['Datetime', 'Discharge Time']].explode(\n",
    "        'Discharge Time').dropna().reset_index(drop=True)\n",
    "\n",
    "    dis = []\n",
    "\n",
    "    for time in df['Datetime']:\n",
    "        dis.append(len(df_los['Discharge Time']\n",
    "                       [df_los['Discharge Time'] == time].tolist()))\n",
    "\n",
    "    df['Discharge'] = dis\n",
    "\n",
    "    return df\n",
    "\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",
    "\n",
    "\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",
    "\n",
    "def plot_adms(df):\n",
    "    df = df[(df['Datetime'] > pd.Timestamp(start.value))]\n",
    "    ind = np.arange(df['Datetime'].dt.day.nunique())\n",
    "    width = 0.35\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(12, 7))\n",
    "    rects1 = ax.bar(ind - width/2, df['Planned'].resample(\n",
    "        'D').sum().tolist(), width, label='Planned', color='b')\n",
    "    rects2 = ax.bar(ind + width/2, df['Unplanned'].resample(\n",
    "        'D').sum().tolist(), width, label='Unplanned', color='r')\n",
    "\n",
    "    ax.set_ylabel('# of patients')\n",
    "    ax.set_title('Admissions Per Day')\n",
    "    ax.set_xticks(ind)\n",
    "    ax.set_xticklabels(np.unique(df['Datetime'].dt.date))\n",
    "    fig.autofmt_xdate()\n",
    "    ax.legend()\n",
    "\n",
    "    autolabel(ax, rects1, \"left\")\n",
    "    autolabel(ax, rects2, \"right\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def plot_ed_vol(df):\n",
    "    df = df[(df['Datetime'] > pd.Timestamp(start.value))]\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(12, 7))\n",
    "    bars = ax.bar(df['Datetime'], df['ED Volume'],\n",
    "                  label='ED Volume',  align='center', width=0.02)\n",
    "\n",
    "    for bar in bars:\n",
    "        bar.set_edgecolor(\"black\")\n",
    "        bar.set_linewidth(1)\n",
    "\n",
    "    ax.set_ylabel('# of patients')\n",
    "    ax.set_title('ED Volume by hour')\n",
    "\n",
    "    fig.autofmt_xdate()\n",
    "    ax.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def plot_beds(df):\n",
    "    df = df[(df['Datetime'] > pd.Timestamp(start.value))]\n",
    "    max_beds = float(num_beds.value)\n",
    "    fig, ax = plt.subplots(1, figsize=(12, 7))\n",
    "    ax.plot(df['Datetime'], df['Occupied'])\n",
    "    plt.axhline(y=max_beds, color='r', linestyle='-')\n",
    "    ax.set_ylabel('# of patients')\n",
    "    ax.fill_between(df['Datetime'], df['Occupied'], max_beds, where=df['Occupied']\n",
    "                    >= max_beds, alpha=0.50,  facecolor='r', edgecolor='r', interpolate=True)\n",
    "    set_max = df['Occupied'].max(\n",
    "    ) + 25 if df['Occupied'].max() > max_beds else max_beds + 25\n",
    "    set_min = df['Occupied'].min(\n",
    "    ) - 25 if df['Occupied'].min() < max_beds else max_beds - 25\n",
    "    ax.set_ylim(set_min, set_max)\n",
    "    ax.set_title('Beds Occupied per hour')\n",
    "    fig.autofmt_xdate()\n",
    "    ax.legend(['Total Beds Occupied', \"Max Bed Capacity\"])\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def plot_beds_util(df):\n",
    "    df = df[(df['Datetime'] > pd.Timestamp(start.value))]\n",
    "    max_beds = float(num_beds.value)\n",
    "    fig, ax = plt.subplots(1, figsize=(12, 7))\n",
    "    percents = (df['Occupied']/max_beds)*100\n",
    "    ax.plot(df['Datetime'], percents)\n",
    "    plt.axhline(y=100, color='r', linestyle='-')\n",
    "    ax.set_ylabel('% of occupied beds')\n",
    "    ax.set_ylim(0.0, 150)\n",
    "    ax.fill_between(df['Datetime'], percents, max_beds, where=percents >=\n",
    "                    max_beds, alpha=0.50,  facecolor='r', edgecolor='r', interpolate=True)\n",
    "    fig.autofmt_xdate()\n",
    "    ax.set_title('Percentage of Beds Occupied per Hour')\n",
    "    ax.legend([\"% of Bed Utilization\"])\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def plot_moving_avg(df, window=12):\n",
    "    df = df[pd.Timestamp(start.value):]\n",
    "    p_roll = df['Planned'].rolling(window, win_type='gaussian').sum(std=3)\n",
    "    up_roll = df['Unplanned'].rolling(window, win_type='gaussian').sum(std=3)\n",
    "\n",
    "    fig, ax = plt.subplots(1, figsize=(12, 7))\n",
    "    ax.plot(df['Datetime'], p_roll)\n",
    "    ax.plot(df['Datetime'], up_roll)\n",
    "\n",
    "    ax.set_title('Planned and Unplanned Rolling Averages')\n",
    "    fig.autofmt_xdate()\n",
    "    ax.legend(['Planned', 'Unplanned'])\n",
    "    plt.grid(True)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def bed_matrix(df, hours_back=24):\n",
    "\n",
    "    back = []\n",
    "\n",
    "    for hour in range(hours_back, len(df)):\n",
    "        p = df['Occupied'].iloc[hour-hours_back:hour] - df['Discharge'].iloc[hour-hours_back:hour]\n",
    "\n",
    "        if not p.empty:\n",
    "            back.append(p.reindex(index=p.index[::-1]))\n",
    "            \n",
    "    bc_df = pd.DataFrame(data = np.hstack([s.values.reshape(-1, 1) for s in back]), columns = [s.index[0] for s in back])\n",
    "    \n",
    "    return bc_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_adm_df(avg_p_sliders, avg_up_sliders, start_wid, end_wid, back=21):\n",
    "\n",
    "    num_days = count_days(start_wid, end_wid)\n",
    "    backdate = start.value - datetime.timedelta(days=back)\n",
    "    datetime_index = [pd.Timestamp((backdate + datetime.timedelta(days=day)).strftime(\n",
    "        \"%Y-%m-%d\") + f' {hr}:00:00') for day in range(num_days+back) for hr in range(24)]\n",
    "\n",
    "    df = pd.DataFrame(\n",
    "        columns=[\"ED Volume\", \"Unplanned\", \"Planned\"], index=datetime_index)\n",
    "\n",
    "    df['Planned'] = [(random.poisson(p.value))\n",
    "                     for days in range(num_days+back) for p in avg_p_sliders]\n",
    "    df['ED Volume'] = [round(random.poisson(up.value))\n",
    "                       for days in range(num_days+back) for up in avg_up_sliders]\n",
    "    df['Unplanned'] = round(\n",
    "        df['ED Volume'] * unplan_adm_rate.value).astype(int)\n",
    "    df['Admit'] = df['Planned'] + df['Unplanned']\n",
    "    df['Datetime'] = df.index\n",
    "    df['Discharge Time'] = df.apply(\n",
    "        p_los_gen, axis=1) + df.apply(up_los_gen, axis=1)\n",
    "\n",
    "    df = gen_los(df)\n",
    "    df['Admitted'] = df['Admit'].cumsum()\n",
    "    df['Discharged'] = df['Discharge'].cumsum()\n",
    "\n",
    "    df['Occupied'] = df['Admitted'] - df['Discharged']\n",
    "\n",
    "    return df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hrly_avg_change(b):\n",
    "    output1.clear_output()\n",
    "    with output1:\n",
    "        plot_hrly_avgs(avg_pl_hrly_sliders, \"Planned\", \"b\")\n",
    "    \n",
    "    output2.clear_output()\n",
    "    with output2:\n",
    "        plot_hrly_avgs(avg_upl_hrly_sliders, \"Unplanned\", \"r\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "output1 = Output(wait=True)\n",
    "output2 = Output()\n",
    "\n",
    "output1.layout.height = '350px'\n",
    "output2.layout.height = '350px'\n",
    "\n",
    "_ = [i.observe(hrly_avg_change, names=['value']) for i in avg_pl_hrly_sliders]\n",
    "_ = [i.observe(hrly_avg_change, names=['value']) for i in avg_upl_hrly_sliders]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "center_layout = Layout(align_items=\"center\", justify_content='center')\n",
    "\n",
    "plt_tabs = [VBox([output1, HBox(avg_pl_hrly_sliders)], layout=center_layout), \n",
    "      VBox([output2, HBox(avg_upl_hrly_sliders)], layout=center_layout)]\n",
    "\n",
    "plt_tab = Tab()\n",
    "plt_tab.children = plt_tabs\n",
    "plt_tab.set_title(0, 'Planned Adm Hrly')\n",
    "plt_tab.set_title(1, 'Unplanned Adm Hrly')\n",
    "\n",
    "\n",
    "sidebar1 = VBox([HTML(value=\"<H3>Admission Statistics:</H3>\"), HTML(value=\"<p>Set hourly averages for gross planned and unplanned admissions </p>\")])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "AppLayout(left_sidebar=sidebar1,\n",
    "          center=plt_tab)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hrly_avg_change(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def on_change(b):\n",
    "    df = gen_adm_df(avg_pl_hrly_sliders, avg_upl_hrly_sliders, start, end)\n",
    "    \n",
    "    output3.clear_output()\n",
    "    with output3:\n",
    "        plot_adms(df)\n",
    "    \n",
    "    output4.clear_output()\n",
    "    with output4:\n",
    "        plot_ed_vol(df)\n",
    "    \n",
    "    output5.clear_output()\n",
    "    with output5:\n",
    "        plot_beds(df)\n",
    "    \n",
    "    output6.clear_output()\n",
    "    with output6:\n",
    "        plot_beds_util(df)\n",
    "    \n",
    "    output8.clear_output()\n",
    "    with output8:\n",
    "        plot_moving_avg(df, 12)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gen_button = Button(description=\"Generate Data\")\n",
    "\n",
    "output3 = Output()\n",
    "output4 = Output()\n",
    "output5 = Output()\n",
    "output6 = Output()\n",
    "output8 = Output()\n",
    "\n",
    "\n",
    "output3.layout.height = '450px'\n",
    "output4.layout.height = '450px'\n",
    "output5.layout.height = '450px'\n",
    "output6.layout.height = '450px'\n",
    "output8.layout.height = '450px'\n",
    "\n",
    "gen_button.on_click(on_change)\n",
    "start.observe(on_change, names=['value'])\n",
    "end.observe(on_change, names=['value'])\n",
    "unplan_adm_rate.observe(on_change, names=['value'])\n",
    "hrs_back.observe(on_change, names=['value'])\n",
    "\n",
    "num_beds.observe(on_change, names=['value'])\n",
    "unpl_los_avg.observe(on_change, names=['value'])\n",
    "unpl_los_std.observe(on_change, names=['value'])\n",
    "pl_los_avg.observe(on_change, names=['value'])\n",
    "pl_los_std.observe(on_change, names=['value'])\n",
    "hrs_back.observe(on_change, names=['value'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tabs2 = [HBox([output3], layout=center_layout), HBox([output4], layout=center_layout),  HBox([output8], layout=center_layout)]\n",
    "tab2 = Tab()\n",
    "tab2.children = tabs2\n",
    "tab2.set_title(0, 'Admissions Per Day')\n",
    "tab2.set_title(1, 'ED Volume')\n",
    "tab2.set_title(2, 'Rolling Averages')\n",
    "\n",
    "sidebar2 = VBox([HTML(value=\"<b>Unplanned Admission Rate:</b>\"), unplan_adm_rate ])\n",
    "\n",
    "dates = VBox([HTML(value=\"<H3>Generate Admission Data:</H3>\"), \n",
    "              HBox([start, end], layout=Layout(justify_content='center', align_items='center'))])\n",
    "footer = HBox([gen_button], layout=center_layout)\n",
    "\n",
    "AppLayout(header=dates,\n",
    "          left_sidebar=sidebar2,\n",
    "          center=tab2,\n",
    "          footer=footer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tabs3 = [HBox([output5], layout=center_layout), HBox([output6], layout=center_layout)]\n",
    "tab3 = Tab()\n",
    "tab3.children = tabs3\n",
    "tab3.set_title(0, 'Occupied Beds')\n",
    "tab3.set_title(1, 'Bed Utilization')\n",
    "\n",
    "los_sidebar = VBox([HTML(value=\"<H3>Bed Capacity Calculations:</H3>\"),\n",
    "                    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",
    "AppLayout(left_sidebar=los_sidebar, \n",
    "         center=tab3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "on_change(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HTML(value=\"<H3>Bed Capacity Matrix:</H3>\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bed_finder(time, beds_df, df):\n",
    "    try:\n",
    "        _ = df.loc[time-pd.Timedelta(1, unit='hours')]\n",
    "        cycle = time-pd.Timedelta(1, unit='hours')\n",
    "    except:\n",
    "        cycle = time\n",
    "    \n",
    "    for bed in range(num_beds.value):\n",
    "        if beds_df.loc[bed, time] == 0.0 and beds_df.loc[bed, cycle] == 0.0:\n",
    "            break\n",
    "            \n",
    "    return bed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hour_cols(start, end):\n",
    "    days = (end-start).days * 24\n",
    "    hours = (end-start).seconds//3600\n",
    "    \n",
    "    cols = [start]\n",
    "    s = start\n",
    "    \n",
    "    for i in range(days+hours):\n",
    "        s += pd.Timedelta(1, unit='hour')\n",
    "        cols.append(s)\n",
    "    \n",
    "    return cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bed_df(df, df_los):\n",
    "    \n",
    "    beds_cols = hour_cols(df['Datetime'].min(), df_los['Discharge Time'].max())\n",
    "\n",
    "    beds_df = pd.DataFrame(data=np.zeros((num_beds.value, len(beds_cols))), columns=beds_cols)\n",
    "\n",
    "    for row in range(len(df_los)):\n",
    "        patient_id = df_los.index.values[row]\n",
    "        patient_admit = df_los['Datetime'][row]\n",
    "        patient_discharge = df_los['Discharge Time'][row]\n",
    "\n",
    "        bed_num = bed_finder(patient_admit, beds_df, df)\n",
    "\n",
    "        if type(bed_num) == int:\n",
    "            beds_df.loc[bed_num, patient_admit:patient_discharge] = np.ones((1,beds_df.loc[bed_num, patient_admit:patient_discharge].shape[0]))\n",
    "        else:\n",
    "            print('boarding')\n",
    "\n",
    "    \n",
    "    return beds_df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df = gen_adm_df(avg_pl_hrly_sliders, avg_upl_hrly_sliders, start, end)\n",
    "\n",
    "# df_los = df[['Datetime','Discharge Time']].explode('Discharge Time').dropna().reset_index(drop=True)\n",
    "\n",
    "# df_beds = bed_df(df, df_los)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# occcupied = np.array([beds_df[col].sum() for col in beds_df.columns])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bed_matrix2(bed_df, hours_back=24):\n",
    "\n",
    "    back = []\n",
    "\n",
    "    for hour in range(hours_back, len(bed_df.columns)):\n",
    "        p = df['Occupied'].iloc[hour-hours_back:hour] - df['Discharge'].iloc[hour-hours_back:hour]\n",
    "\n",
    "        if not p.empty:\n",
    "            back.append(p.reindex(index=p.index[::-1]))\n",
    "            \n",
    "    bc_df = pd.DataFrame(data = np.hstack([s.values.reshape(-1, 1) for s in back]), columns = [s.index[0] for s in back])\n",
    "    \n",
    "    return bc_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def beds_on_change(b):\n",
    "    output7.clear_output()\n",
    "    with output7:\n",
    "        df_los = df[['Datetime','Discharge Time']].explode('Discharge Time').dropna().reset_index(drop=True)\n",
    "        df_beds = bed_df(df, df_los)\n",
    "        display(df_beds.loc[:, pd.Timestamp(start.value):pd.Timestamp(end.value)].style.background_gradient(cmap='ocean'))\n",
    "        \n",
    "#         bc_df = bed_matrix(df, hours_back=hrs_back.value)\n",
    "#         display(bc_df.loc[:, pd.Timestamp(start.value):].style.background_gradient(cmap='YlGn'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# display(HTML(value=\"<b>Beds Occupied by Hour:</b>\"), output7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 'Accent', 'Accent_r', 'Blues', 'Blues_r', 'BrBG', 'BrBG_r', 'BuGn', 'BuGn_r', 'BuPu', 'BuPu_r', 'CMRmap', \n",
    "# 'CMRmap_r', 'Dark2', 'Dark2_r', 'GnBu', 'GnBu_r', 'Greens', 'Greens_r', 'Greys', 'Greys_r', 'OrRd', 'OrRd_r', \n",
    "# 'Oranges', 'Oranges_r', 'PRGn', 'PRGn_r', 'Paired', 'Paired_r', 'Pastel1', 'Pastel1_r', 'Pastel2', 'Pastel2_r', \n",
    "# 'PiYG', 'PiYG_r', 'PuBu', 'PuBuGn', 'PuBuGn_r', 'PuBu_r', 'PuOr', 'PuOr_r', 'PuRd', 'PuRd_r', 'Purples', 'Purples_r', \n",
    "# 'RdBu', 'RdBu_r', 'RdGy', 'RdGy_r', 'RdPu', 'RdPu_r', 'RdYlBu', 'RdYlBu_r', 'RdYlGn', 'RdYlGn_r', 'Reds', 'Reds_r', \n",
    "# 'Set1', 'Set1_r', 'Set2', 'Set2_r', 'Set3', 'Set3_r', 'Spectral', 'Spectral_r', 'Wistia', 'Wistia_r', 'YlGn', 'YlGnBu', \n",
    "# 'YlGnBu_r', 'YlGn_r', 'YlOrBr', 'YlOrBr_r', 'YlOrRd', 'YlOrRd_r', 'afmhot', 'afmhot_r', 'autumn', 'autumn_r', 'binary', \n",
    "# 'binary_r', 'bone', 'bone_r', 'brg', 'brg_r', 'bwr', 'bwr_r', 'cividis', 'cividis_r', 'cool', 'cool_r', 'coolwarm', \n",
    "# 'coolwarm_r', 'copper', 'copper_r', 'cubehelix', 'cubehelix_r', 'flag', 'flag_r', 'gist_earth', 'gist_earth_r', 'gist_gray', \n",
    "# 'gist_gray_r', 'gist_heat', 'gist_heat_r', 'gist_ncar', 'gist_ncar_r', 'gist_rainbow', 'gist_rainbow_r', 'gist_stern', \n",
    "# 'gist_stern_r', 'gist_yarg', 'gist_yarg_r', 'gnuplot', 'gnuplot2', 'gnuplot2_r', 'gnuplot_r', 'gray', 'gray_r', 'hot',\n",
    "# 'hot_r', 'hsv', 'hsv_r', 'icefire', 'icefire_r', 'inferno', 'inferno_r', 'jet', 'jet_r', 'magma', 'magma_r', 'mako', \n",
    "# 'mako_r', 'nipy_spectral', 'nipy_spectral_r', 'ocean', 'ocean_r', 'pink', 'pink_r', 'plasma', 'plasma_r', 'prism',\n",
    "# 'prism_r', 'rainbow', 'rainbow_r', 'rocket', 'rocket_r', 'seismic', 'seismic_r', 'spring', 'spring_r', 'summer', \n",
    "# 'summer_r', 'tab10', 'tab10_r', 'tab20', 'tab20_r', 'tab20b', 'tab20b_r', 'tab20c', 'tab20c_r', 'terrain', 'terrain_r', \n",
    "# 'turbo', 'turbo_r', 'twilight', 'twilight_r', 'twilight_shifted', 'twilight_shifted_r', 'viridis', 'viridis_r', 'vlag', \n",
    "# 'vlag_r', 'winter', 'winter_r'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HTML(value=\"<H3>Room Cycle:</H3>\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HTML(value=\"<H3>Administrator Playground:</H3>\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "HTML(value=\"<H3>Forecasting:</H3>\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from statsmodels.tsa.arima.model import ARIMA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# model = ARIMA(df['Occupied'], order=(12,4,1), freq='H')\n",
    "\n",
    "# model_fit = model.fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model_fit.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# residuals = pd.DataFrame(model_fit.resid)\n",
    "# residuals.plot(figsize=(12,7))\n",
    "# plt.show()\n",
    "# residuals.plot(kind='kde', figsize=(12,7))\n",
    "# plt.show()\n",
    "# print(residuals.describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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
}