diff --git a/EnergySystem.py b/EnergySystem.py
index 18215ae..33d2ba7 100644
--- a/EnergySystem.py
+++ b/EnergySystem.py
@@ -39,7 +39,8 @@ class EnergySystem:
             time = row['time']
             sunlight_intensity = row['sunlight']
             factory_demand = row['demand']
-            electricity_price = row['price']
+            electricity_price = row['buy']
+            sell_price = row['sell']
             # electricity_price = self.grid.get_price_for_time(time)
 
             if time == '00:00':
@@ -66,7 +67,7 @@ class EnergySystem:
                 # 如果还有电量盈余,且pv功率大于ess的充电功率+工厂的需求功率则准备卖电
                 if surplus_after_ess > 0 and generated_pv_power > self.ess.charge_power + factory_demand:
                     sold_to_grid = surplus_after_ess
-                    sell_income = sold_to_grid * self.grid.sell_price
+                    sell_income = sold_to_grid * sell_price
                     total_benefit += sell_income
                 # 节省的能量 = 工厂需求的能量 * 时间段
                 # total_energy = factory_demand * time_interval
diff --git a/config.py b/config.py
index f1c8cd7..7714f39 100644
--- a/config.py
+++ b/config.py
@@ -15,7 +15,7 @@ class ess_config:
         self.cost_per_kW = cost_per_kW
         self.lifetime = lifetime
         self.loss = loss
-        self.storage = 100
+        self.storage = 0
         self.charge_power = charge_power
         self.discharge_power = discharge_power
     def get_cost(self):
diff --git a/main.ipynb b/main.ipynb
index 682bf29..724b31b 100644
--- a/main.ipynb
+++ b/main.ipynb
@@ -2,13 +2,22 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "import os\n",
     "import glob\n",
     "import shutil\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.ticker as ticker\n",
+    "from matplotlib.ticker import FuncFormatter\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import os\n",
+    "import seaborn as sns\n",
+    "import json\n",
+    "from matplotlib.colors import LinearSegmentedColormap\n",
     "\n",
     "def clear_folder_make_ess_pv(folder_path):\n",
     "    if os.path.isdir(folder_path):\n",
@@ -23,7 +32,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -37,26 +46,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Version 0.0.2\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import json\n",
     "\n",
-    "print(\"Version 0.0.2\")\n",
+    "print(\"Version 0.0.4\")\n",
     "\n",
     "with open('config.json', 'r') as f:\n",
     "    js_data = json.load(f)\n",
     "\n",
-    "data = pd.read_csv('combined_data.csv')\n",
+    "\n",
+    "    \n",
+    "\n",
     "time_interval = js_data[\"time_interval\"][\"numerator\"] / js_data[\"time_interval\"][\"denominator\"]\n",
     "\n",
     "pv_loss = js_data[\"pv\"][\"loss\"]\n",
@@ -89,17 +92,37 @@
     "\n",
     "figure_size = (js_data[\"figure_size\"][\"length\"], js_data[\"figure_size\"][\"height\"])\n",
     "\n",
+    "data = pd.read_csv('combined_data.csv')\n",
+    "\n",
+    "granularity = js_data[\"time_interval\"][\"numerator\"]\n",
+    "\n",
+    "months_days = [31,28,31,30,31,30,31,31,30,31,30,31]\n",
+    "def get_month_coe(num, granularity):\n",
+    "    return 60 / granularity * 24 * months_days[num]\n",
+    "\n",
+    "months_index = [get_month_coe(num, granularity) for num in range(12)]\n",
+    "months_data = []\n",
+    "for i in range(1,12):\n",
+    "    months_index[i] += months_index[i-1]\n",
+    "for i in range(12):\n",
+    "    start = 0 if i == 0 else months_index[i-1]\n",
+    "    end = months_index[i]\n",
+    "    months_data.append(data.iloc[int(start):int(end)])\n",
+    "    \n",
+    "\n",
+    "\n",
+    "\n",
     "pv_capacities = np.linspace(pv_begin, pv_end, pv_groups)\n",
     "ess_capacities = np.linspace(ess_begin, ess_end, ess_groups)\n",
-    "results = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
-    "affords = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
-    "costs = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
-    "overload_cnt = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n"
+    "# results = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
+    "# affords = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
+    "# costs = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
+    "# overload_cnt = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -118,257 +141,251 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "def cal_profit(es: EnergySystem, saved_money):\n",
-    "    profit = saved_money - es.ess.get_cost_per_year() - es.pv.get_cost_per_year()\n",
+    "def draw_results(results, filename, title_benefit, annot_benefit=False, figure_size=(10, 10)):\n",
+    "    df=results\n",
+    "    df = df.astype(float)\n",
+    "    df.index = df.index / 1000\n",
+    "    df.index = df.index.map(int)\n",
+    "    df.columns = df.columns / 1000\n",
+    "    df.columns = df.columns.map(int)\n",
+    "    min_value = df.min().min()\n",
+    "    max_value = df.max().max()\n",
+    "    max_scale = max(abs(min_value/1000), abs(max_value/1000))\n",
+    "\n",
+    "    df[df.columns[-1] + 1] = df.iloc[:, -1] \n",
+    "    new_Data = pd.DataFrame(index=[df.index[-1] + 1], columns=df.columns)\n",
+    "    for i in df.columns:\n",
+    "        new_Data[i] = df[i].iloc[-1]\n",
+    "    df = pd.concat([df, new_Data])\n",
+    "\n",
+    "    X, Y = np.meshgrid(np.arange(df.shape[1]), np.arange(df.shape[0]))\n",
+    "\n",
+    "    def fmt(x,pos):\n",
+    "        return '{:.0f}'.format(x/1000)\n",
+    "\n",
+    "    cmap = sns.color_palette(\"coolwarm\", as_cmap=True)\n",
+    "    plt.figure(figsize=figure_size)\n",
+    "    ax = sns.heatmap(df/1000, fmt=\".1f\", cmap=cmap, vmin=-max_scale, vmax=max_scale, annot=annot_benefit)\n",
+    "    CS = ax.contour(X, Y, df,  colors='black', alpha=0.5)\n",
+    "    ax.clabel(CS, inline=True, fontsize=10, fmt=FuncFormatter(fmt))\n",
+    "    plt.title(title_benefit)\n",
+    "    plt.gca().invert_yaxis()\n",
+    "    plt.xlim(0, df.shape[1] - 1)\n",
+    "    plt.ylim(0, df.shape[0] - 1)\n",
+    "    plt.xlabel('ESS Capacity (MWh)')\n",
+    "    plt.ylabel('PV Capacity (MW)')\n",
+    "    plt.savefig(filename)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def draw_cost(costs, filename, title_cost, annot_cost=False, figure_size=(10, 10)):\n",
+    "    df = costs\n",
+    "    df = df.astype(int)\n",
+    "    df.index = df.index / 1000\n",
+    "    df.index = df.index.map(int)\n",
+    "    df.columns = df.columns / 1000\n",
+    "    df.columns = df.columns.map(int)\n",
+    "\n",
+    "    df[df.columns[-1] + 1] = df.iloc[:, -1] \n",
+    "    new_Data = pd.DataFrame(index=[df.index[-1] + 1], columns=df.columns)\n",
+    "    for i in df.columns:\n",
+    "        new_Data[i] = df[i].iloc[-1]\n",
+    "    df = pd.concat([df, new_Data])\n",
+    "    X, Y = np.meshgrid(np.arange(df.shape[1]), np.arange(df.shape[0]))\n",
+    "\n",
+    "    def fmt(x, pos):\n",
+    "        return '{:.0f}'.format(x / 1000000)\n",
+    "\n",
+    "    plt.figure(figsize=figure_size)\n",
+    "    ax = sns.heatmap(df/1000000,  fmt=\".1f\", cmap='viridis', annot=annot_cost)\n",
+    "    CS = ax.contour(X, Y, df,  colors='black', alpha=0.5)\n",
+    "    ax.clabel(CS, inline=True, fontsize=10, fmt=FuncFormatter(fmt))\n",
+    "    plt.title(title_cost)\n",
+    "    plt.gca().invert_yaxis()\n",
+    "    plt.xlim(0, df.shape[1] - 1)\n",
+    "    plt.ylim(0, df.shape[0] - 1)\n",
+    "    plt.xlabel('ESS Capacity (MWh)')\n",
+    "    plt.ylabel('PV Capacity (MW)')\n",
+    "    plt.savefig(filename)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def draw_overload(overload_cnt, filename, title_unmet, annot_unmet=False, figure_size=(10, 10), days=365, granularity=15):\n",
+    "    df = overload_cnt\n",
+    "    print(days, granularity)\n",
+    "    coef = 60 / granularity * days * 24\n",
+    "    print(coef)\n",
+    "    print(df)\n",
+    "    df = ( coef - df) / coef\n",
+    "    print(df)\n",
+    "\n",
+    "    df = df.astype(float)\n",
+    "    df.index = df.index / 1000\n",
+    "    df.index = df.index.map(int)\n",
+    "    df.columns = df.columns / 1000\n",
+    "    df.columns = df.columns.map(int)\n",
+    "\n",
+    "\n",
+    "    df[df.columns[-1] + 1] = df.iloc[:, -1] \n",
+    "    new_Data = pd.DataFrame(index=[df.index[-1] + 1], columns=df.columns)\n",
+    "    for i in df.columns:\n",
+    "        new_Data[i] = df[i].iloc[-1]\n",
+    "    # print(new_Data)\n",
+    "    df = pd.concat([df, new_Data])\n",
+    "\n",
+    "\n",
+    "    plt.figure(figsize=figure_size)\n",
+    "    cmap = LinearSegmentedColormap.from_list(\"\", [\"white\", \"blue\"])\n",
+    "    ax = sns.heatmap(df, fmt=\".00%\", cmap=cmap, vmin=0, vmax=1, annot=annot_unmet)\n",
+    "\n",
+    "    cbar = ax.collections[0].colorbar\n",
+    "    cbar.set_ticks([0, 0.25, 0.5, 0.75, 1])\n",
+    "    cbar.set_ticklabels(['0%', '25%', '50%', '75%', '100%'])\n",
+    "    cbar.ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, pos: f'{x:.0%}'))\n",
+    "    X, Y = np.meshgrid(np.arange(df.shape[1]), np.arange(df.shape[0]))\n",
+    "\n",
+    "    def fmt(x, pos):\n",
+    "        return '{:.0f}%'.format(x * 100)\n",
+    "    CS = ax.contour(X, Y, df,  colors='black', alpha=0.5)\n",
+    "\n",
+    "    ax.clabel(CS, inline=True, fontsize=10, fmt=FuncFormatter(fmt))\n",
+    "\n",
+    "    plt.xlim(0, df.shape[1] - 1)\n",
+    "    plt.ylim(0, df.shape[0] - 1)\n",
+    "    plt.title(title_unmet)\n",
+    "    plt.xlabel('ESS Capacity (MWh)')\n",
+    "    plt.ylabel('PV Capacity (MW)')\n",
+    "    plt.savefig(filename)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cal_profit(es: EnergySystem, saved_money, days):\n",
+    "    profit = saved_money - es.ess.get_cost_per_year() / 365 * days - es.pv.get_cost_per_year() / 365 * days\n",
     "    return profit"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "ess_capacity:0.0\n",
-      "pv_capacity:0.0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/stud/hanzhang/simple-pv-simulator/EnergySystem.py:52: RuntimeWarning: invalid value encountered in scalar divide\n",
-      "  soc = self.ess.storage / self.ess.capacity\n",
-      "/home/stud/hanzhang/simple-pv-simulator/EnergySystem.py:95: RuntimeWarning: invalid value encountered in scalar divide\n",
-      "  log = f\"index: {index}, time: {time}, SoC:{self.ess.storage / self.ess.capacity}%, storage: {self.ess.storage}, pv_gen:{generated_pv_power}, power_demand: {factory_demand}, overload_cnt:{self.overload_cnt}, day:{int(index/96) + 1}\"\n",
-      "/home/stud/hanzhang/simple-pv-simulator/EnergySystem.py:49: RuntimeWarning: invalid value encountered in scalar divide\n",
-      "  soc = self.ess.storage / self.ess.capacity\n",
-      "/home/stud/hanzhang/simple-pv-simulator/EnergySystem.py:120: RuntimeWarning: invalid value encountered in scalar divide\n",
-      "  self.spring_week_soc.append(self.ess.storage / self.ess.capacity)\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "pv_capacity:12500.0\n",
-      "pv_capacity:25000.0\n",
-      "pv_capacity:37500.0\n",
-      "pv_capacity:50000.0\n",
-      "ess_capacity:11111.111111111111\n",
-      "pv_capacity:0.0\n",
-      "pv_capacity:12500.0\n",
-      "pv_capacity:25000.0\n",
-      "pv_capacity:37500.0\n",
-      "pv_capacity:50000.0\n",
-      "ess_capacity:22222.222222222223\n",
-      "pv_capacity:0.0\n",
-      "pv_capacity:12500.0\n",
-      "pv_capacity:25000.0\n",
-      "pv_capacity:37500.0\n",
-      "pv_capacity:50000.0\n",
-      "ess_capacity:33333.333333333336\n",
-      "pv_capacity:0.0\n",
-      "pv_capacity:12500.0\n",
-      "pv_capacity:25000.0\n",
-      "pv_capacity:37500.0\n",
-      "pv_capacity:50000.0\n",
-      "ess_capacity:44444.444444444445\n",
-      "pv_capacity:0.0\n",
-      "pv_capacity:12500.0\n",
-      "pv_capacity:25000.0\n",
-      "pv_capacity:37500.0\n",
-      "pv_capacity:50000.0\n",
-      "ess_capacity:55555.555555555555\n",
-      "pv_capacity:0.0\n",
-      "pv_capacity:12500.0\n",
-      "pv_capacity:25000.0\n",
-      "pv_capacity:37500.0\n",
-      "pv_capacity:50000.0\n",
-      "ess_capacity:66666.66666666667\n",
-      "pv_capacity:0.0\n",
-      "pv_capacity:12500.0\n",
-      "pv_capacity:25000.0\n",
-      "pv_capacity:37500.0\n",
-      "pv_capacity:50000.0\n",
-      "ess_capacity:77777.77777777778\n",
-      "pv_capacity:0.0\n",
-      "pv_capacity:12500.0\n",
-      "pv_capacity:25000.0\n",
-      "pv_capacity:37500.0\n",
-      "pv_capacity:50000.0\n",
-      "ess_capacity:88888.88888888889\n",
-      "pv_capacity:0.0\n",
-      "pv_capacity:12500.0\n",
-      "pv_capacity:25000.0\n",
-      "pv_capacity:37500.0\n",
-      "pv_capacity:50000.0\n",
-      "ess_capacity:100000.0\n",
-      "pv_capacity:0.0\n",
-      "pv_capacity:12500.0\n",
-      "pv_capacity:25000.0\n",
-      "pv_capacity:37500.0\n",
-      "pv_capacity:50000.0\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "for ess_capacity in ess_capacities:\n",
-    "    print(f\"ess_capacity:{ess_capacity}\")\n",
-    "    for pv_capacity in pv_capacities:\n",
-    "        print(f\"pv_capacity:{pv_capacity}\")\n",
-    "        pv = pv_config(capacity=pv_capacity, \n",
-    "                        cost_per_kW=pv_cost_per_kW,\n",
-    "                        lifetime=pv_lifetime, \n",
-    "                        loss=pv_loss)\n",
-    "        ess = ess_config(capacity=ess_capacity, \n",
-    "                            cost_per_kW=ess_cost_per_kW, \n",
-    "                            lifetime=ess_lifetime, \n",
-    "                            loss=ess_loss,\n",
-    "                            charge_power=ess_capacity,\n",
-    "                            discharge_power=ess_capacity)\n",
-    "        grid = grid_config(capacity=grid_capacity, \n",
-    "                            grid_loss=grid_loss,\n",
-    "                            sell_price= sell_price)\n",
-    "        energySystem = EnergySystem(pv_type=pv, \n",
-    "                                    ess_type=ess, \n",
-    "                                    grid_type= grid)\n",
-    "        benefit = energySystem.simulate(data, time_interval)\n",
-    "        results.loc[pv_capacity,ess_capacity] = cal_profit(energySystem, benefit)\n",
-    "        affords.loc[pv_capacity,ess_capacity] = energySystem.afford\n",
-    "        overload_cnt.loc[pv_capacity,ess_capacity] = energySystem.overload_cnt\n",
-    "        costs.loc[pv_capacity,ess_capacity] = energySystem.ess.capacity * energySystem.ess.cost_per_kW + energySystem.pv.capacity * energySystem.pv.cost_per_kW\n",
-    "        pv_generated = energySystem.day_generated\n",
-    "        ess_generated = energySystem.hour_stored\n",
-    "        ess_generated_2 = energySystem.hour_stored_2\n",
-    "    plt.figure(figsize=(10,8));\n",
-    "    plt.plot(ess_generated)\n",
-    "    plt.xlabel('day #')\n",
-    "    plt.ylabel('SoC %')\n",
-    "    plt.title(f'14:00 ESS SoC \\n PV cap:{pv_capacity}, ESS cap:{ess_capacity}')\n",
-    "    plt.savefig(f'plots/ess/1400-{pv_capacity}-{ess_capacity}.png')\n",
-    "    plt.close()\n",
-    "    plt.figure(figsize=(10,8));\n",
-    "    plt.plot(ess_generated_2)\n",
-    "    plt.xlabel('day #')\n",
-    "    plt.ylabel('SoC%')\n",
-    "    plt.title(f'08:00 ESS SoC \\n PV cap:{pv_capacity}, ESS cap:{ess_capacity}')\n",
-    "    plt.savefig(f'plots/ess/0800-{pv_capacity}-{ess_capacity}.png')\n",
-    "    plt.close()\n",
-    "        # print(energySystem.unmet)\n",
-    "        # spring_week_start = energySystem.season_start\n",
-    "        # spring_week_end = spring_week_start + energySystem.week_length\n",
-    "        # summer_week_start = energySystem.season_start + 1 * energySystem.season_step\n",
-    "        # summer_week_end = summer_week_start + energySystem.week_length\n",
-    "        # autumn_week_start = energySystem.season_start + 2 * energySystem.season_step\n",
-    "        # autumn_week_end = autumn_week_start + energySystem.week_length\n",
-    "        # winter_week_start = energySystem.season_start + 3 * energySystem.season_step\n",
-    "        # winter_week_end = winter_week_start+ energySystem.week_length\n",
-    "\n",
-    "        # spring_consume_data = []\n",
-    "        # summer_consume_data = []\n",
-    "        # autumn_consume_data = []\n",
-    "        # winter_consume_data = []\n",
-    "        # for index, row in data.iterrows():\n",
-    "            # if index in range(spring_week_start, spring_week_end):\n",
-    "                # spring_consume_data.append(row['demand'])\n",
-    "        #     elif index in range(summer_week_start, summer_week_end):\n",
-    "        #         summer_consume_data.append(row['demand'])\n",
-    "        #     elif index in range(autumn_week_start, autumn_week_end):\n",
-    "        #         autumn_consume_data.append(row['demand'])\n",
-    "        #     elif index in range(winter_week_start, winter_week_end):\n",
-    "        #         winter_consume_data.append(row['demand'])\n",
-    "\n",
-    "        # spring_week_time = list(range(spring_week_start, spring_week_end))\n",
-    "        # summer_week_time = list(range(summer_week_start, summer_week_end))\n",
-    "        # autumn_week_time = list(range(autumn_week_start, autumn_week_end))\n",
-    "        # winter_week_time = list(range(winter_week_start, winter_week_end))\n",
-    "\n",
-    "        # spring_pv_generated = energySystem.spring_week_gen\n",
-    "        # summer_pv_generated = energySystem.summer_week_gen\n",
-    "        # autumn_pv_generated = energySystem.autumn_week_gen\n",
-    "        # winter_pv_generated = energySystem.winter_week_gen\n",
-    "\n",
-    "        # spring_soc = energySystem.spring_week_soc\n",
-    "        # summer_soc = energySystem.summer_week_soc\n",
-    "        # autumn_soc = energySystem.autumn_week_soc\n",
-    "        # winter_soc = energySystem.winter_week_soc\n",
-    "\n",
-    "\n",
-    "        # fig, ax1 = plt.subplots()\n",
-    "\n",
-    "        # plt.plot(spring_week_time, spring_pv_generated, label = 'pv generation')\n",
-    "        # plt.plot(spring_week_time, spring_consume_data, label = 'factory consume')\n",
-    "        # plt.ylabel('Power / kW')\n",
-    "        # plt.xlabel('15 min #')\n",
-    "        # plt.title(f'ess: {energySystem.ess.capacity/1000 } MWh pv: {energySystem.pv.capacity/1000 } MW spring week generate condition')\n",
-    "        # plt.legend()\n",
-    "        # plt.savefig(f'plots/{energySystem.ess.capacity}-{energySystem.pv.capacity}-spring.png')\n",
-    "        # plt.close()\n",
-    "\n",
-    "        # plt.plot(summer_week_time, summer_pv_generated, label = 'pv generation')\n",
-    "        # plt.plot(summer_week_time, summer_consume_data, label = 'factory consume')\n",
-    "        # plt.ylabel('Power / kW')\n",
-    "        # plt.xlabel('15 min #')\n",
-    "        # plt.title(f'ess: {energySystem.ess.capacity/1000 } MWh pv: {energySystem.pv.capacity/1000 } MW summer week generate condition')\n",
-    "        # plt.legend()\n",
-    "        # plt.savefig(f'plots/{energySystem.ess.capacity}-{energySystem.pv.capacity}-summer.png')\n",
-    "        # plt.close()\n",
-    "\n",
-    "        # plt.plot(autumn_week_time, autumn_pv_generated, label = 'pv generation')\n",
-    "        # plt.plot(autumn_week_time, autumn_consume_data, label = 'factory consume')\n",
-    "        # plt.ylabel('Power / kW')\n",
-    "        # plt.xlabel('15 min #')\n",
-    "        # plt.title(f'ess: {energySystem.ess.capacity/1000 } MWh pv: {energySystem.pv.capacity/1000 } MW autumn week generate condition')\n",
-    "        # plt.legend()\n",
-    "        # plt.savefig(f'plots/{energySystem.ess.capacity}-{energySystem.pv.capacity}-autumn.png')\n",
-    "        # plt.close()\n",
-    "\n",
-    "        # plt.plot(winter_week_time, winter_pv_generated, label = 'pv generation')\n",
-    "        # plt.plot(winter_week_time, winter_consume_data, label = 'factory consume')\n",
-    "        # plt.ylabel('Power / kW')\n",
-    "        # plt.xlabel('15 min #')\n",
-    "        # plt.title(f'ess: {energySystem.ess.capacity/1000 } MWh pv: {energySystem.pv.capacity/1000 } MW winter week generate condition')\n",
-    "        # plt.legend()\n",
-    "        # plt.savefig(f'plots/{energySystem.ess.capacity}-{energySystem.pv.capacity}-winter.png')\n",
-    "        # plt.close()\n",
-    "\n",
-    "    # plt.figure();\n",
-    "    # plt.plot(pv_generated)\n",
-    "    # plt.xlabel('day #')\n",
-    "    # plt.ylabel('Electricity kWh')\n",
-    "    # plt.title(f'PV generated pv cap:{pv_capacity}, ess cap:{ess_capacity}')\n",
-    "    # plt.savefig(f'plots/pv/{pv_capacity}-{ess_capacity}.png')\n",
-    "    # plt.close()\n",
-    "\n",
-    "\n",
-    "        # plt.show()\n",
-    "\n",
-    "\n",
-    "        \n",
-    "\n",
-    "# results = results.astype(float)\n",
-    "\n",
-    "\n",
-    "# pv = pv_config(capacity=100000,cost_per_kW=200,lifetime=25,loss=0.95)\n",
-    "# ess = ess_config(capacity=100000,cost_per_kW=300,lifetime=25,loss=0.95,charge_power=100000,discharge_power=100000)\n",
-    "# grid = grid_config(price_schedule=price_schedule, capacity=5000, grid_loss=0.95, sell_price=0.4)\n",
-    "# grid = grid_config(capacity=50000, grid_loss=0.95, sell_price=0.4)\n",
-    "\n",
-    "\n",
-    "    # print(benefit)\n"
+    "def generate_data(pv_capacity, pv_cost_per_kW, pv_lifetime, pv_loss, ess_capacity, ess_cost_per_kW, ess_lifetime, ess_loss, grid_capacity, grid_loss, sell_price,time_interval, data, days):\n",
+    "    pv = pv_config(capacity=pv_capacity, \n",
+    "                    cost_per_kW=pv_cost_per_kW,\n",
+    "                    lifetime=pv_lifetime, \n",
+    "                    loss=pv_loss)\n",
+    "    ess = ess_config(capacity=ess_capacity, \n",
+    "                        cost_per_kW=ess_cost_per_kW, \n",
+    "                        lifetime=ess_lifetime, \n",
+    "                        loss=ess_loss,\n",
+    "                        charge_power=ess_capacity,\n",
+    "                        discharge_power=ess_capacity)\n",
+    "    grid = grid_config(capacity=grid_capacity, \n",
+    "                        grid_loss=grid_loss,\n",
+    "                        sell_price= sell_price)\n",
+    "    energySystem = EnergySystem(pv_type=pv, \n",
+    "                                ess_type=ess, \n",
+    "                                grid_type= grid)\n",
+    "    benefit = energySystem.simulate(data, time_interval)\n",
+    "    results = cal_profit(energySystem, benefit, days)\n",
+    "    overload_cnt = energySystem.overload_cnt\n",
+    "    costs = energySystem.ess.capacity * energySystem.ess.cost_per_kW + energySystem.pv.capacity * energySystem.pv.cost_per_kW\n",
+    "    return (results, overload_cnt, costs)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "months_results = []\n",
+    "months_costs = []\n",
+    "months_overload = []\n",
+    "for index, month_data in enumerate(months_data):\n",
+    "    results = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
+    "    costs = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
+    "    overload_cnt = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
+    "    for pv_capacity in pv_capacities:\n",
+    "        for ess_capacity in ess_capacities:\n",
+    "            (result, overload, cost) = generate_data(pv_capacity=pv_capacity,pv_cost_per_kW=pv_cost_per_kW, pv_lifetime=pv_lifetime, pv_loss=pv_loss, ess_capacity=ess_capacity, ess_cost_per_kW=ess_cost_per_kW, ess_lifetime=ess_lifetime, ess_loss=ess_loss, grid_capacity=grid_capacity, grid_loss=grid_loss, sell_price=sell_price, time_interval=time_interval, data=month_data, days=months_days[index])\n",
+    "            results.loc[pv_capacity,ess_capacity] = result\n",
+    "            overload_cnt.loc[pv_capacity,ess_capacity] = overload\n",
+    "            costs.loc[pv_capacity,ess_capacity] = cost\n",
+    "    months_results.append(results)\n",
+    "    months_costs.append(costs)\n",
+    "    months_overload.append(overload_cnt)\n",
+    "    draw_results(results=results, \n",
+    "                    filename=f'plots/pv-{pv_capacity}-ess-{ess_capacity}-{index}-benefit.png',\n",
+    "                    title_benefit=title_benefit,\n",
+    "                    annot_benefit=annot_benefit,\n",
+    "                    figure_size=figure_size)\n",
+    "    draw_overload(overload_cnt=overload_cnt, \n",
+    "                    filename=f'plots/pv-{pv_capacity}-ess-{ess_capacity}-{index}-unmet.png',\n",
+    "                    title_unmet=title_unmet,\n",
+    "                    annot_unmet=annot_unmet,\n",
+    "                    figure_size=figure_size,\n",
+    "                    days=months_days[index],\n",
+    "                    granularity=granularity)\n",
+    "\n",
+    "annual_result = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
+    "annual_costs = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
+    "annual_overload = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
+    "\n",
+    "# get the yearly results\n",
+    "for pv_capacity in pv_capacities:\n",
+    "    for ess_capacity in ess_capacities:\n",
+    "        results = 0\n",
+    "        costs = 0\n",
+    "        overload_cnt = 0\n",
+    "        for index, month_data in enumerate(months_data):\n",
+    "            results += months_results[index].loc[pv_capacity,ess_capacity]\n",
+    "            costs += months_costs[index].loc[pv_capacity,ess_capacity]\n",
+    "            overload_cnt += months_overload[index].loc[pv_capacity, ess_capacity]\n",
+    "        annual_result.loc[pv_capacity, ess_capacity] = results\n",
+    "        annual_costs.loc[pv_capacity, ess_capacity] = costs\n",
+    "        annual_overload.loc[pv_capacity, ess_capacity] = overload_cnt\n",
+    "\n",
+    "draw_cost(costs=annual_costs,\n",
+    "          filename='plots/annual_cost.png',\n",
+    "        title_cost=title_cost,\n",
+    "        annot_cost=annot_cost,\n",
+    "        figure_size=figure_size)\n",
+    "draw_results(results=annual_result,\n",
+    "                filename='plots/annual_benefit.png',\n",
+    "                title_benefit=title_benefit,\n",
+    "                annot_benefit=annot_benefit,\n",
+    "                figure_size=figure_size)\n",
+    "draw_overload(overload_cnt=annual_overload,\n",
+    "                filename='plots/annual_unmet.png',\n",
+    "                title_unmet=title_unmet,\n",
+    "                annot_unmet=annot_unmet,\n",
+    "                figure_size=figure_size)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -379,14 +396,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "import matplotlib.ticker as ticker\n",
-    "from matplotlib.ticker import MaxNLocator, MultipleLocator, FuncFormatter\n",
-    "from matplotlib.colors import LinearSegmentedColormap\n",
-    "\n",
     "if not os.path.isdir('data'):\n",
     "    os.makedirs('data')\n",
     "\n",
@@ -394,215 +407,6 @@
     "save_data(costs, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-costs')\n",
     "save_data(overload_cnt, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-overload_cnt')"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "         0         11        22        33        44        55        66   \\\n",
-      "51  0.674686  0.695805  0.716781  0.735074  0.756564  0.776056  0.790582   \n",
-      "\n",
-      "         77        88        100       101  \n",
-      "51  0.799429  0.804937  0.809189  0.809189  \n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x900 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Coverage Rate\n",
-    "df = overload_cnt\n",
-    "df = (4 * 24 * 365 - df) / (4 * 24 * 365)\n",
-    "df = df.astype(float)\n",
-    "df.index = df.index / 1000\n",
-    "df.index = df.index.map(int)\n",
-    "df.columns = df.columns / 1000\n",
-    "df.columns = df.columns.map(int)\n",
-    "xl = df.columns[-1]\n",
-    "yl = df.index[-1]\n",
-    "min_value = df.min().min()\n",
-    "max_value = df.max().max()\n",
-    "max_scale = max(abs(min_value/1000), abs(max_value/1000))\n",
-    "\n",
-    "\n",
-    "df[df.columns[-1] + 1] = df.iloc[:, -1] \n",
-    "new_Data = pd.DataFrame(index=[df.index[-1] + 1], columns=df.columns)\n",
-    "for i in df.columns:\n",
-    "    new_Data[i] = df[i].iloc[-1]\n",
-    "print(new_Data)\n",
-    "df = pd.concat([df, new_Data])\n",
-    "\n",
-    "\n",
-    "plt.figure(figsize=figure_size)\n",
-    "cmap = LinearSegmentedColormap.from_list(\"\", [\"white\", \"blue\"])\n",
-    "ax = sns.heatmap(df, fmt=\".00%\", cmap=cmap, vmin=0, vmax=1, annot=annot_unmet)\n",
-    "\n",
-    "cbar = ax.collections[0].colorbar\n",
-    "cbar.set_ticks([0, 0.25, 0.5, 0.75, 1])\n",
-    "cbar.set_ticklabels(['0%', '25%', '50%', '75%', '100%'])\n",
-    "cbar.ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, pos: f'{x:.0%}'))\n",
-    "X, Y = np.meshgrid(np.arange(df.shape[1]), np.arange(df.shape[0]))\n",
-    "\n",
-    "def fmt(x, pos):\n",
-    "    return '{:.0f}%'.format(x * 100)\n",
-    "CS = ax.contour(X, Y, df,  colors='black', alpha=0.5)\n",
-    "\n",
-    "ax.clabel(CS, inline=True, fontsize=10, fmt=FuncFormatter(fmt))\n",
-    "\n",
-    "plt.xlim(0, df.shape[1] - 1)\n",
-    "plt.ylim(0, df.shape[0] - 1)\n",
-    "plt.title(title_unmet)\n",
-    "plt.xlabel('ESS Capacity (MWh)')\n",
-    "plt.ylabel('PV Capacity (MW)')\n",
-    "plt.savefig('plots/unmet.png')\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "             0             11            22             33             44   \\\n",
-      "51  6.170524e+06  5.094775e+06  2.957805e+06  644566.934623 -540090.862772   \n",
-      "\n",
-      "             55             66            77            88            100  \\\n",
-      "51 -700903.75164 -966484.874197 -1.209738e+06 -1.450976e+06 -1.785978e+06   \n",
-      "\n",
-      "             101  \n",
-      "51 -1.785978e+06  \n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x900 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Profit\n",
-    "df=results\n",
-    "df = df.astype(float)\n",
-    "df.index = df.index / 1000\n",
-    "df.index = df.index.map(int)\n",
-    "df.columns = df.columns / 1000\n",
-    "df.columns = df.columns.map(int)\n",
-    "min_value = df.min().min()\n",
-    "max_value = df.max().max()\n",
-    "max_scale = max(abs(min_value/1000), abs(max_value/1000))\n",
-    "\n",
-    "df[df.columns[-1] + 1] = df.iloc[:, -1] \n",
-    "new_Data = pd.DataFrame(index=[df.index[-1] + 1], columns=df.columns)\n",
-    "for i in df.columns:\n",
-    "    new_Data[i] = df[i].iloc[-1]\n",
-    "print(new_Data)\n",
-    "df = pd.concat([df, new_Data])\n",
-    "\n",
-    "X, Y = np.meshgrid(np.arange(df.shape[1]), np.arange(df.shape[0]))\n",
-    "\n",
-    "\n",
-    "plt.figure(figsize=figure_size)\n",
-    "cmap = sns.color_palette(\"coolwarm\", as_cmap=True)\n",
-    "ax = sns.heatmap(df/1000, fmt=\".1f\", cmap=cmap, vmin=-max_scale, vmax=max_scale, annot=annot_benefit)\n",
-    "plt.gca().invert_yaxis()\n",
-    "\n",
-    "def fmt(x, pos):\n",
-    "    return '{:.0f}%'.format(x * 100)\n",
-    "\n",
-    "CS = ax.contour(X, Y, df,  colors='black', alpha=0.5)\n",
-    "def fmt(x,pos):\n",
-    "    return '{:.0f}'.format(x/1000)\n",
-    "ax.clabel(CS, inline=True, fontsize=10, fmt=FuncFormatter(fmt))\n",
-    "\n",
-    "plt.xlim(0, df.shape[1] - 1)\n",
-    "plt.ylim(0, df.shape[0] - 1)\n",
-    "\n",
-    "plt.title(title_benefit)\n",
-    "plt.xlabel('ESS Capacity (MWh)')\n",
-    "plt.ylabel('PV Capacity (MW)')\n",
-    "plt.savefig('plots/benefit.png')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "         0         11        22        33        44        55        66   \\\n",
-      "51  10000000  13333333  16666666  20000000  23333333  26666666  30000000   \n",
-      "\n",
-      "         77        88        100       101  \n",
-      "51  33333333  36666666  40000000  40000000  \n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1000x900 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Costs\n",
-    "df = costs\n",
-    "df = df.astype(int)\n",
-    "df.index = df.index / 1000\n",
-    "df.index = df.index.map(int)\n",
-    "df.columns = df.columns / 1000\n",
-    "df.columns = df.columns.map(int)\n",
-    "\n",
-    "df[df.columns[-1] + 1] = df.iloc[:, -1] \n",
-    "new_Data = pd.DataFrame(index=[df.index[-1] + 1], columns=df.columns)\n",
-    "for i in df.columns:\n",
-    "    new_Data[i] = df[i].iloc[-1]\n",
-    "print(new_Data)\n",
-    "df = pd.concat([df, new_Data])\n",
-    "X, Y = np.meshgrid(np.arange(df.shape[1]), np.arange(df.shape[0]))\n",
-    "\n",
-    "def fmt(x, pos):\n",
-    "    return '{:.0f}'.format(x / 1000000)\n",
-    "\n",
-    "plt.figure(figsize=figure_size)\n",
-    "ax = sns.heatmap(df/1000000,  fmt=\".1f\", cmap='viridis', annot=annot_cost)\n",
-    "CS = ax.contour(X, Y, df,  colors='black', alpha=0.5)\n",
-    "ax.clabel(CS, inline=True, fontsize=10, fmt=FuncFormatter(fmt))\n",
-    "plt.title(title_cost)\n",
-    "plt.gca().invert_yaxis()\n",
-    "plt.xlim(0, df.shape[1] - 1)\n",
-    "plt.ylim(0, df.shape[0] - 1)\n",
-    "plt.xlabel('ESS Capacity (MWh)')\n",
-    "plt.ylabel('PV Capacity (MW)')\n",
-    "plt.savefig('plots/costs.png')\n"
-   ]
   }
  ],
  "metadata": {