results_plotter.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import glob\n",
    "import os\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_periods(db_conn):\n",
    "    \"\"\"\n",
    "    This function returns a list of simulated\n",
    "    years.\n",
    "    \"\"\"\n",
    "\n",
    "    command = \"SELECT * FROM time_periods WHERE flag is 'f'\"\n",
    "\n",
    "    cur = db_conn.cursor()\n",
    "    cur.execute(command)\n",
    "    periods = [y[0] for y in cur.fetchall()]\n",
    "\n",
    "    return periods[:-1]\n",
    "def get_regional_techs(db_conn, outcomm, region):\n",
    "    \"\"\"\n",
    "    This function returns a list of technologies\n",
    "    in a given sector.\n",
    "    \"\"\"\n",
    "\n",
    "    cur = db_conn.cursor()\n",
    "\n",
    "    if type(outcomm) == list:\n",
    "        command = (f\"SELECT tech FROM Output_VFlow_Out WHERE regions LIKE '%{region}' \"\n",
    "                   f\"AND (output_comm IS '{outcomm[0]}' OR output_comm IS '{outcomm[1]}')\" )\n",
    "    else:\n",
    "        command = (f\"SELECT tech FROM Output_VFlow_Out WHERE regions LIKE '%{region}' \"\n",
    "                   f\"AND output_comm IS '{outcomm}' \")\n",
    "\n",
    "\n",
    "    cur.execute(command)\n",
    "\n",
    "    regional_techs = np.unique([t[0] for t in cur.fetchall()])\n",
    "\n",
    "    return regional_techs\n",
    "def get_annual_capacity(db_conn, region, outcomm, scenario=None):\n",
    "    \"\"\"\n",
    "    Retrieves the annual capacity of each technology.\n",
    "    \"\"\"\n",
    "\n",
    "    periods = get_periods(db_conn)\n",
    "    all_techs = get_regional_techs(db_conn, outcomm, region)\n",
    "\n",
    "    cur = db_conn.cursor()\n",
    "\n",
    "    cap_dict = {}\n",
    "    for tech in all_techs:\n",
    "        if scenario == None:\n",
    "            command = (f\"SELECT t_periods, capacity \"\n",
    "                       f\"FROM Output_CapacityByPeriodAndTech \"\n",
    "                       f\"WHERE tech IS '{tech}' \"\n",
    "                       f\"AND regions LIKE '%{region}' \"\n",
    "                       f\"ORDER BY Output_CapacityByPeriodAndTech.t_periods\")\n",
    "        else:\n",
    "            command = (f\"SELECT t_periods, capacity \"\n",
    "                       f\"FROM Output_CapacityByPeriodAndTech \"\n",
    "                       f\"WHERE tech IS '{tech}' \"\n",
    "                       f\"AND regions LIKE '%{region}' \"\n",
    "                       f\"AND scenario LIKE '%{scenario}' \"\n",
    "                       f\"ORDER BY Output_CapacityByPeriodAndTech.t_periods\")\n",
    "        cur.execute(command)\n",
    "        cap_tech = cur.fetchall()\n",
    "\n",
    "        diff = np.diff(periods).astype('int')[0]\n",
    "        first_year = int(min(periods))\n",
    "\n",
    "        caps = np.zeros(len(periods))\n",
    "        for i, tup in enumerate(cap_tech):\n",
    "            year = tup[0]\n",
    "            cap = tup[1]\n",
    "            j = int((year-first_year)/diff)\n",
    "            caps[j] = cap\n",
    "        cap_dict[tech] = caps\n",
    "    cap_dict['year'] = periods\n",
    "\n",
    "    cap_df = pd.DataFrame(cap_dict)\n",
    "    cap_df.set_index('year', inplace=True)\n",
    "    return cap_df\n",
    "def get_annual_generation(db_conn, region, outcomm, scenario=None):\n",
    "    \"\"\"\n",
    "    Retrieves the annual generation of each technology.\n",
    "    \"\"\"\n",
    "\n",
    "    periods = get_periods(db_conn)\n",
    "    all_techs = get_regional_techs(db_conn, outcomm, region)\n",
    "\n",
    "    cur = db_conn.cursor()\n",
    "\n",
    "    cap_dict = {}\n",
    "    for tech in all_techs:\n",
    "        if scenario == None:\n",
    "            command = (f\"SELECT t_periods, SUM(vflow_out), tech \"\n",
    "                           f\"FROM Output_VFlow_Out \"\n",
    "                           f\"WHERE tech IS '{tech}' \"\n",
    "                           f\"AND regions LIKE '%{region}' \"\n",
    "                           f\"GROUP BY Output_VFlow_Out.t_periods\")\n",
    "        else:\n",
    "            command = (f\"SELECT t_periods, SUM(vflow_out), tech \"\n",
    "                           f\"FROM Output_VFlow_Out \"\n",
    "                           f\"WHERE tech IS '{tech}' \"\n",
    "                           f\"AND regions LIKE '%{region}' \"\n",
    "                           f\"AND scenario LIKE '%{scenario}' \"\n",
    "                           f\"GROUP BY Output_VFlow_Out.t_periods\")\n",
    "        cur.execute(command)\n",
    "        cap_tech = cur.fetchall()\n",
    "\n",
    "        diff = np.diff(periods).astype('int')[0]\n",
    "        first_year = int(min(periods))\n",
    "\n",
    "        caps = np.zeros(len(periods))\n",
    "        for i, tup in enumerate(cap_tech):\n",
    "            year = tup[0]\n",
    "            cap = tup[1]\n",
    "            j = int((year-first_year)/diff)\n",
    "            caps[j] = cap\n",
    "        cap_dict[tech] = caps\n",
    "    cap_dict['year'] = periods\n",
    "\n",
    "    cap_df = pd.DataFrame(cap_dict)\n",
    "    cap_df.set_index('year', inplace=True)\n",
    "    return cap_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = 'pygen_test/bakery_test_kitchen_02.sqlite'\n",
    "conn = sqlite3.connect(path)\n",
    "cursor = conn.cursor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Objective Function Value = $4005.176\n"
     ]
    }
   ],
   "source": [
    "command = \"SELECT total_system_cost FROM Output_Objective\"\n",
    "cursor.execute(command)\n",
    "res = cursor.fetchall()\n",
    "\n",
    "print(f'Objective Function Value = ${round(res[0][0],3)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = get_annual_capacity(conn, 'MyBakery', 'COOKIES', scenario='test_kitchen')\n",
    "gdf= get_annual_generation(conn, 'MyBakery', 'DOUGH', scenario='test_kitchen')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      MIXER_ELC\n",
      "year           \n",
      "2020      100.0\n",
      "2021      100.0\n",
      "            STORE\n",
      "year             \n",
      "2020  4799.999997\n",
      "2021  4799.999997\n",
      "      IMP_EGG\n",
      "year         \n",
      "2020   25.075\n",
      "2021   25.075\n",
      "         IMP_FLR\n",
      "year            \n",
      "2020  200.175001\n",
      "2021  200.175001\n",
      "      IMP_SGR\n",
      "year         \n",
      "2020   99.875\n",
      "2021   99.875\n",
      "      IMP_BTR\n",
      "year         \n",
      "2020   99.875\n",
      "2021   99.875\n",
      "       CONV_OVEN  REFRIGERATOR\n",
      "year                          \n",
      "2020  4800.00002   3508.782461\n",
      "2021  4800.00002   3508.782461\n"
     ]
    }
   ],
   "source": [
    "list_items = ['DOUGH', 'COOKIES_DEM', 'EGG', 'FLOUR', 'SUGAR', 'BUTTER', 'COOKIES']\n",
    "for item in list_items:\n",
    "    print(get_annual_generation(conn, 'MyBakery', item, scenario='test_kitchen'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='year'>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(6,4), facecolor='w', edgecolor='k')\n",
    "df.plot.bar(ax=ax)"
   ]
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}