iicd/simple-pv-simulator
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

Compare commits

base: iicd:060fa5bff19997672c89606d37cc643131abcb06
Branches Tags
iicd:main
iicd:0.0.7
iicd:0.0.6
..
compare: iicd:a330946f71f5966872058a50f5514d1c0d40bd4d
Branches Tags
iicd:main
iicd:0.0.7
iicd:0.0.6

No commits in common. "060fa5bff19997672c89606d37cc643131abcb06" and "a330946f71f5966872058a50f5514d1c0d40bd4d" have entirely different histories.
060fa5bff1 ... a330946f71

7 changed files with 35302 additions and 70560 deletions
Show Stats Expand all files Collapse all files

6
EnergySystem.py
View File

@ -35,8 +35,6 @@ class EnergySystem:
# 如果ESS也不足以满足需求，再从电网获取 - 当ESS中的存储电量也不足以补充时，再从电网购买剩余所需电量。 # 如果ESS也不足以满足需求，再从电网获取 - 当ESS中的存储电量也不足以补充时，再从电网购买剩余所需电量。
def simulate(self, data, time_interval): def simulate(self, data, time_interval):
total_benefit = 0 total_benefit = 0
total_netto_benefit = 0
total_gen = 0
for index, row in data.iterrows(): for index, row in data.iterrows():
time = row['time'] time = row['time']
sunlight_intensity = row['sunlight'] sunlight_intensity = row['sunlight']
@ -111,11 +109,9 @@ class EnergySystem:
# 工厂需求量-总能量 # 工厂需求量-总能量
# unmet_demand = max(0, factory_demand * time_interval - total_energy) # unmet_demand = max(0, factory_demand * time_interval - total_energy)
# benefit = (total_energy - unmet_demand) * electricity_price # benefit = (total_energy - unmet_demand) * electricity_price
total_gen += saved_energy
benefit = (saved_energy) * electricity_price benefit = (saved_energy) * electricity_price
cost = net_grid * electricity_price cost = net_grid * electricity_price
# print(f"time:{time} benefit: {benefit}, cost: {cost}") # print(f"time:{time} benefit: {benefit}, cost: {cost}")
total_netto_benefit += benefit
total_benefit += benefit - cost total_benefit += benefit - cost
# # spring # # spring
week_start = self.season_start week_start = self.season_start
@ -141,4 +137,4 @@ class EnergySystem:
# self.winter_week_gen.append(generated_pv_power) # self.winter_week_gen.append(generated_pv_power)
# self.winter_week_soc.append(self.ess.storage / self.ess.capacity) # self.winter_week_soc.append(self.ess.storage / self.ess.capacity)
return (total_benefit, total_netto_benefit, total_gen) return total_benefit

10
config.json
View File

@ -17,12 +17,12 @@
"pv_capacities":{ "pv_capacities":{
"begin": 0, "begin": 0,
"end": 50000, "end": 50000,
"groups": 11 "groups": 5
}, },
"ess_capacities":{ "ess_capacities":{
"begin": 0, "begin": 0,
"end": 100000, "end": 100000,
"groups": 11 "groups": 10
}, },
"time_interval":{ "time_interval":{
"numerator": 15, "numerator": 15,
@ -31,8 +31,7 @@
"annotated": { "annotated": {
"unmet_prob": false, "unmet_prob": false,
"benefit": false, "benefit": false,
"cost": false, "cost": false
"roi": false
}, },
"figure_size":{ "figure_size":{
"height": 9, "height": 9,
@ -41,7 +40,6 @@
"plot_title":{ "plot_title":{
"unmet_prob": "Coverage Rate of Factory Electrical Demands", "unmet_prob": "Coverage Rate of Factory Electrical Demands",
"cost": "Costs of Microgrid system [m-EUR]", "cost": "Costs of Microgrid system [m-EUR]",
"benefit": "Financial Profit Based on Py & Ess Configuration (k-EUR / year)", "benefit": "Financial Profit Based on Py & Ess Configuration (k-EUR / year)"
"roi": "ROI"
} }
} }

70082
electricity_price_data.csv
View File

File diff suppressed because it is too large Load Diff

35041
electricity_price_data_sell.csv
View File

File diff suppressed because it is too large Load Diff

125
main.ipynb
View File

@ -52,7 +52,7 @@
"source": [ "source": [
"import json\n", "import json\n",
"\n", "\n",
"print(\"Version 0.0.5\")\n", "print(\"Version 0.0.4\")\n",
"\n", "\n",
"with open('config.json', 'r') as f:\n", "with open('config.json', 'r') as f:\n",
" js_data = json.load(f)\n", " js_data = json.load(f)\n",
@ -61,7 +61,6 @@
" \n", " \n",
"\n", "\n",
"time_interval = js_data[\"time_interval\"][\"numerator\"] / js_data[\"time_interval\"][\"denominator\"]\n", "time_interval = js_data[\"time_interval\"][\"numerator\"] / js_data[\"time_interval\"][\"denominator\"]\n",
"print(time_interval)\n",
"\n", "\n",
"pv_loss = js_data[\"pv\"][\"loss\"]\n", "pv_loss = js_data[\"pv\"][\"loss\"]\n",
"pv_cost_per_kW = js_data[\"pv\"][\"cost_per_kW\"]\n", "pv_cost_per_kW = js_data[\"pv\"][\"cost_per_kW\"]\n",
@ -86,13 +85,10 @@
"annot_unmet = js_data[\"annotated\"][\"unmet_prob\"]\n", "annot_unmet = js_data[\"annotated\"][\"unmet_prob\"]\n",
"annot_benefit = js_data[\"annotated\"][\"benefit\"]\n", "annot_benefit = js_data[\"annotated\"][\"benefit\"]\n",
"annot_cost = js_data[\"annotated\"][\"cost\"]\n", "annot_cost = js_data[\"annotated\"][\"cost\"]\n",
"annot_roi = js_data[\"annotated\"][\"roi\"]\n",
"\n", "\n",
"title_unmet = js_data[\"plot_title\"][\"unmet_prob\"]\n", "title_unmet = js_data[\"plot_title\"][\"unmet_prob\"]\n",
"title_cost = js_data[\"plot_title\"][\"cost\"]\n", "title_cost = js_data[\"plot_title\"][\"cost\"]\n",
"title_benefit = js_data[\"plot_title\"][\"benefit\"]\n", "title_benefit = js_data[\"plot_title\"][\"benefit\"]\n",
"title_roi = js_data[\"plot_title\"][\"roi\"]\n",
"\n",
"\n", "\n",
"figure_size = (js_data[\"figure_size\"][\"length\"], js_data[\"figure_size\"][\"height\"])\n", "figure_size = (js_data[\"figure_size\"][\"length\"], js_data[\"figure_size\"][\"height\"])\n",
"\n", "\n",
@ -185,59 +181,6 @@
" plt.savefig(filename)" " plt.savefig(filename)"
] ]
}, },
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def draw_roi(costs, results, filename, title_roi, days=365, annot_roi=False, figure_size=(10, 10)):\n",
" costs = costs.astype(float)\n",
" costs = costs / 365 \n",
" costs = costs * days\n",
"\n",
" df = results\n",
" df = costs / df\n",
" if 0 in df.index and 0 in df.columns:\n",
" df.loc[0,0] = 100\n",
" df[df > 80] = 100\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",
" min_value = df.min().min()\n",
" max_value = df.max().max()\n",
" print(max_value)\n",
" max_scale = max(abs(min_value), abs(max_value))\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)\n",
"\n",
" cmap = sns.color_palette(\"Greys\", as_cmap=True)\n",
" plt.figure(figsize=figure_size)\n",
" ax = sns.heatmap(df, fmt=\".1f\", cmap=cmap, vmin=0, vmax=100, 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_roi)\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", "cell_type": "code",
"execution_count": null, "execution_count": null,
@ -310,8 +253,8 @@
" ax = sns.heatmap(df, fmt=\".00%\", cmap=cmap, vmin=0, vmax=1, annot=annot_unmet)\n", " ax = sns.heatmap(df, fmt=\".00%\", cmap=cmap, vmin=0, vmax=1, annot=annot_unmet)\n",
"\n", "\n",
" cbar = ax.collections[0].colorbar\n", " cbar = ax.collections[0].colorbar\n",
" cbar.set_ticks([0, 0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90, 1])\n", " cbar.set_ticks([0, 0.25, 0.5, 0.75, 1])\n",
" cbar.set_ticklabels(['0%', '10%', '20%', '30%', '40%', '50%', '60%', '70%', '80%', '90%', '100%'])\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", " 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", " X, Y = np.meshgrid(np.arange(df.shape[1]), np.arange(df.shape[0]))\n",
"\n", "\n",
@ -346,7 +289,7 @@
"metadata": {}, "metadata": {},
"outputs": [], "outputs": [],
"source": [ "source": [
"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", "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", " pv = pv_config(capacity=pv_capacity, \n",
" cost_per_kW=pv_cost_per_kW,\n", " cost_per_kW=pv_cost_per_kW,\n",
" lifetime=pv_lifetime, \n", " lifetime=pv_lifetime, \n",
@ -363,11 +306,11 @@
" energySystem = EnergySystem(pv_type=pv, \n", " energySystem = EnergySystem(pv_type=pv, \n",
" ess_type=ess, \n", " ess_type=ess, \n",
" grid_type= grid)\n", " grid_type= grid)\n",
" (benefit, netto_benefit, gen_energy) = energySystem.simulate(data, time_interval)\n", " benefit = energySystem.simulate(data, time_interval)\n",
" results = cal_profit(energySystem, benefit, days)\n", " results = cal_profit(energySystem, benefit, days)\n",
" overload_cnt = energySystem.overload_cnt\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", " costs = energySystem.ess.capacity * energySystem.ess.cost_per_kW + energySystem.pv.capacity * energySystem.pv.cost_per_kW\n",
" return (results, overload_cnt, costs, netto_benefit, gen_energy, energySystem.generated)\n" " return (results, overload_cnt, costs)\n"
] ]
}, },
{ {
@ -379,38 +322,26 @@
"months_results = []\n", "months_results = []\n",
"months_costs = []\n", "months_costs = []\n",
"months_overload = []\n", "months_overload = []\n",
"months_nettos = []\n",
"months_gen_energy = []\n",
"months_gen_energy2 = []\n",
"for index, month_data in enumerate(months_data):\n", "for index, month_data in enumerate(months_data):\n",
" results = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n", " results = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
" costs = 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", " overload_cnt = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
" nettos = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
" gen_energies = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
" gen_energies2 = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
" for pv_capacity in pv_capacities:\n", " for pv_capacity in pv_capacities:\n",
" for ess_capacity in ess_capacities:\n", " for ess_capacity in ess_capacities:\n",
" (result, overload, cost, netto, gen_energy, gen_energy2) = 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", " (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", " results.loc[pv_capacity,ess_capacity] = result\n",
" overload_cnt.loc[pv_capacity,ess_capacity] = overload\n", " overload_cnt.loc[pv_capacity,ess_capacity] = overload\n",
" costs.loc[pv_capacity,ess_capacity] = cost\n", " costs.loc[pv_capacity,ess_capacity] = cost\n",
" nettos.loc[pv_capacity,ess_capacity] = netto\n",
" gen_energies.loc[pv_capacity, ess_capacity] = gen_energy\n",
" gen_energies2.loc[pv_capacity, ess_capacity] = gen_energy2\n",
" months_results.append(results)\n", " months_results.append(results)\n",
" months_costs.append(costs)\n", " months_costs.append(costs)\n",
" months_overload.append(overload_cnt)\n", " months_overload.append(overload_cnt)\n",
" months_nettos.append(nettos)\n",
" months_gen_energy.append(gen_energies)\n",
" months_gen_energy2.append(gen_energies2)\n",
" draw_results(results=results, \n", " draw_results(results=results, \n",
" filename=f'plots/pv-{pv_capacity}-ess-{ess_capacity}-month-{index+1}-benefit.png',\n", " filename=f'plots/pv-{pv_capacity}-ess-{ess_capacity}-{index}-benefit.png',\n",
" title_benefit=title_benefit,\n", " title_benefit=title_benefit,\n",
" annot_benefit=annot_benefit,\n", " annot_benefit=annot_benefit,\n",
" figure_size=figure_size)\n", " figure_size=figure_size)\n",
" draw_overload(overload_cnt=overload_cnt, \n", " draw_overload(overload_cnt=overload_cnt, \n",
" filename=f'plots/pv-{pv_capacity}-ess-{ess_capacity}-month-{index+1}-unmet.png',\n", " filename=f'plots/pv-{pv_capacity}-ess-{ess_capacity}-{index}-unmet.png',\n",
" title_unmet=title_unmet,\n", " title_unmet=title_unmet,\n",
" annot_unmet=annot_unmet,\n", " annot_unmet=annot_unmet,\n",
" figure_size=figure_size,\n", " figure_size=figure_size,\n",
@ -420,11 +351,6 @@
"annual_result = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n", "annual_result = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
"annual_costs = 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", "annual_overload = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
"annual_nettos = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
"annual_gen = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
"annual_gen2 = pd.DataFrame(index=pv_capacities, columns= ess_capacities)\n",
"\n",
"\n",
"\n", "\n",
"# get the yearly results\n", "# get the yearly results\n",
"for pv_capacity in pv_capacities:\n", "for pv_capacity in pv_capacities:\n",
@ -432,22 +358,13 @@
" results = 0\n", " results = 0\n",
" costs = 0\n", " costs = 0\n",
" overload_cnt = 0\n", " overload_cnt = 0\n",
" nettos = 0\n",
" gen = 0\n",
" gen2 = 0\n",
" for index, month_data in enumerate(months_data):\n", " for index, month_data in enumerate(months_data):\n",
" results += months_results[index].loc[pv_capacity,ess_capacity]\n", " results += months_results[index].loc[pv_capacity,ess_capacity]\n",
" costs += months_costs[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", " overload_cnt += months_overload[index].loc[pv_capacity, ess_capacity]\n",
" nettos += months_nettos[index].loc[pv_capacity, ess_capacity]\n",
" gen += months_gen_energy[index].loc[pv_capacity, ess_capacity]\n",
" gen2 += months_gen_energy[index].loc[pv_capacity, ess_capacity]\n",
" annual_result.loc[pv_capacity, ess_capacity] = results\n", " annual_result.loc[pv_capacity, ess_capacity] = results\n",
" annual_costs.loc[pv_capacity, ess_capacity] = costs\n", " annual_costs.loc[pv_capacity, ess_capacity] = costs\n",
" annual_overload.loc[pv_capacity, ess_capacity] = overload_cnt\n", " annual_overload.loc[pv_capacity, ess_capacity] = overload_cnt\n",
" annual_nettos.loc[pv_capacity, ess_capacity] = nettos\n",
" annual_gen.loc[pv_capacity, ess_capacity] = gen\n",
" annual_gen2.loc[pv_capacity, ess_capacity] = gen2\n",
"\n", "\n",
"draw_cost(costs=annual_costs,\n", "draw_cost(costs=annual_costs,\n",
" filename='plots/annual_cost.png',\n", " filename='plots/annual_cost.png',\n",
@ -486,27 +403,9 @@
"if not os.path.isdir('data'):\n", "if not os.path.isdir('data'):\n",
" os.makedirs('data')\n", " os.makedirs('data')\n",
"\n", "\n",
"save_data(annual_result, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-results')\n", "save_data(results, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-results')\n",
"save_data(annual_costs, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-costs')\n", "save_data(costs, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-costs')\n",
"save_data(annual_overload, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-overload_cnt')" "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": null,
"metadata": {},
"outputs": [],
"source": [
"draw_results(annual_result, 'plots/test.png', 'test', False)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"draw_roi(annual_costs, annual_nettos, 'plots/annual_roi.png', title_roi, 365, annot_benefit, figure_size)\n"
] ]
} }
], ],

560
main.py
View File

@ -1,21 +1,12 @@
#!/usr/bin/env python #!/usr/bin/env python
# coding: utf-8 # coding: utf-8
# In[ ]: # In[14]:
import os import os
import glob import glob
import shutil import shutil
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
from matplotlib.ticker import FuncFormatter
import numpy as np
import pandas as pd
import os
import seaborn as sns
import json
from matplotlib.colors import LinearSegmentedColormap
def clear_folder_make_ess_pv(folder_path): def clear_folder_make_ess_pv(folder_path):
if os.path.isdir(folder_path): if os.path.isdir(folder_path):
@ -28,7 +19,7 @@ folder_path = 'plots'
clear_folder_make_ess_pv(folder_path) clear_folder_make_ess_pv(folder_path)
# In[ ]: # In[15]:
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
@ -39,21 +30,18 @@ from EnergySystem import EnergySystem
from config import pv_config, grid_config, ess_config from config import pv_config, grid_config, ess_config
# In[ ]: # In[16]:
import json import json
print("Version 0.0.5") print("Version 0.0.2")
with open('config.json', 'r') as f: with open('config.json', 'r') as f:
js_data = json.load(f) js_data = json.load(f)
data = pd.read_csv('combined_data.csv')
time_interval = js_data["time_interval"]["numerator"] / js_data["time_interval"]["denominator"] time_interval = js_data["time_interval"]["numerator"] / js_data["time_interval"]["denominator"]
print(time_interval)
pv_loss = js_data["pv"]["loss"] pv_loss = js_data["pv"]["loss"]
pv_cost_per_kW = js_data["pv"]["cost_per_kW"] pv_cost_per_kW = js_data["pv"]["cost_per_kW"]
@ -78,45 +66,22 @@ ess_groups = js_data["ess_capacities"]["groups"]
annot_unmet = js_data["annotated"]["unmet_prob"] annot_unmet = js_data["annotated"]["unmet_prob"]
annot_benefit = js_data["annotated"]["benefit"] annot_benefit = js_data["annotated"]["benefit"]
annot_cost = js_data["annotated"]["cost"] annot_cost = js_data["annotated"]["cost"]
annot_roi = js_data["annotated"]["roi"]
title_unmet = js_data["plot_title"]["unmet_prob"] title_unmet = js_data["plot_title"]["unmet_prob"]
title_cost = js_data["plot_title"]["cost"] title_cost = js_data["plot_title"]["cost"]
title_benefit = js_data["plot_title"]["benefit"] title_benefit = js_data["plot_title"]["benefit"]
title_roi = js_data["plot_title"]["roi"]
figure_size = (js_data["figure_size"]["length"], js_data["figure_size"]["height"]) figure_size = (js_data["figure_size"]["length"], js_data["figure_size"]["height"])
data = pd.read_csv('combined_data.csv')
granularity = js_data["time_interval"]["numerator"]
months_days = [31,28,31,30,31,30,31,31,30,31,30,31]
def get_month_coe(num, granularity):
return 60 / granularity * 24 * months_days[num]
months_index = [get_month_coe(num, granularity) for num in range(12)]
months_data = []
for i in range(1,12):
months_index[i] += months_index[i-1]
for i in range(12):
start = 0 if i == 0 else months_index[i-1]
end = months_index[i]
months_data.append(data.iloc[int(start):int(end)])
pv_capacities = np.linspace(pv_begin, pv_end, pv_groups) pv_capacities = np.linspace(pv_begin, pv_end, pv_groups)
ess_capacities = np.linspace(ess_begin, ess_end, ess_groups) ess_capacities = np.linspace(ess_begin, ess_end, ess_groups)
# results = pd.DataFrame(index=pv_capacities, columns= ess_capacities) results = pd.DataFrame(index=pv_capacities, columns= ess_capacities)
# affords = pd.DataFrame(index=pv_capacities, columns= ess_capacities) affords = pd.DataFrame(index=pv_capacities, columns= ess_capacities)
# costs = pd.DataFrame(index=pv_capacities, columns= ess_capacities) costs = pd.DataFrame(index=pv_capacities, columns= ess_capacities)
# overload_cnt = pd.DataFrame(index=pv_capacities, columns= ess_capacities) overload_cnt = pd.DataFrame(index=pv_capacities, columns= ess_capacities)
# In[ ]: # In[17]:
hour_demand = [] hour_demand = []
@ -132,309 +97,164 @@ plt.savefig('plots/demand.png')
plt.close() plt.close()
# In[ ]: # In[18]:
def draw_results(results, filename, title_benefit, annot_benefit=False, figure_size=(10, 10)): def cal_profit(es: EnergySystem, saved_money):
df=results profit = saved_money - es.ess.get_cost_per_year() - es.pv.get_cost_per_year()
df = df.astype(float)
df.index = df.index / 1000
df.index = df.index.map(int)
df.columns = df.columns / 1000
df.columns = df.columns.map(int)
min_value = df.min().min()
max_value = df.max().max()
max_scale = max(abs(min_value/1000), abs(max_value/1000))
df[df.columns[-1] + 1] = df.iloc[:, -1]
new_Data = pd.DataFrame(index=[df.index[-1] + 1], columns=df.columns)
for i in df.columns:
new_Data[i] = df[i].iloc[-1]
df = pd.concat([df, new_Data])
X, Y = np.meshgrid(np.arange(df.shape[1]), np.arange(df.shape[0]))
def fmt(x,pos):
return '{:.0f}'.format(x/1000)
cmap = sns.color_palette("coolwarm", as_cmap=True)
plt.figure(figsize=figure_size)
ax = sns.heatmap(df/1000, fmt=".1f", cmap=cmap, vmin=-max_scale, vmax=max_scale, annot=annot_benefit)
CS = ax.contour(X, Y, df, colors='black', alpha=0.5)
ax.clabel(CS, inline=True, fontsize=10, fmt=FuncFormatter(fmt))
plt.title(title_benefit)
plt.gca().invert_yaxis()
plt.xlim(0, df.shape[1] - 1)
plt.ylim(0, df.shape[0] - 1)
plt.xlabel('ESS Capacity (MWh)')
plt.ylabel('PV Capacity (MW)')
plt.savefig(filename)
# In[ ]:
def draw_roi(costs, results, filename, title_roi, days=365, annot_roi=False, figure_size=(10, 10)):
costs = costs.astype(float)
costs = costs / 365
costs = costs * days
df = results
df = costs / df
if 0 in df.index and 0 in df.columns:
df.loc[0,0] = 100
df[df > 80] = 100
print(df)
df = df.astype(float)
df.index = df.index / 1000
df.index = df.index.map(int)
df.columns = df.columns / 1000
df.columns = df.columns.map(int)
min_value = df.min().min()
max_value = df.max().max()
print(max_value)
max_scale = max(abs(min_value), abs(max_value))
df[df.columns[-1] + 1] = df.iloc[:, -1]
new_Data = pd.DataFrame(index=[df.index[-1] + 1], columns=df.columns)
for i in df.columns:
new_Data[i] = df[i].iloc[-1]
df = pd.concat([df, new_Data])
X, Y = np.meshgrid(np.arange(df.shape[1]), np.arange(df.shape[0]))
def fmt(x,pos):
return '{:.0f}'.format(x)
cmap = sns.color_palette("Greys", as_cmap=True)
plt.figure(figsize=figure_size)
ax = sns.heatmap(df, fmt=".1f", cmap=cmap, vmin=0, vmax=100, annot=annot_benefit)
CS = ax.contour(X, Y, df, colors='black', alpha=0.5)
ax.clabel(CS, inline=True, fontsize=10, fmt=FuncFormatter(fmt))
plt.title(title_roi)
plt.gca().invert_yaxis()
plt.xlim(0, df.shape[1] - 1)
plt.ylim(0, df.shape[0] - 1)
plt.xlabel('ESS Capacity (MWh)')
plt.ylabel('PV Capacity (MW)')
plt.savefig(filename)
# In[ ]:
def draw_cost(costs, filename, title_cost, annot_cost=False, figure_size=(10, 10)):
df = costs
df = df.astype(int)
df.index = df.index / 1000
df.index = df.index.map(int)
df.columns = df.columns / 1000
df.columns = df.columns.map(int)
df[df.columns[-1] + 1] = df.iloc[:, -1]
new_Data = pd.DataFrame(index=[df.index[-1] + 1], columns=df.columns)
for i in df.columns:
new_Data[i] = df[i].iloc[-1]
df = pd.concat([df, new_Data])
X, Y = np.meshgrid(np.arange(df.shape[1]), np.arange(df.shape[0]))
def fmt(x, pos):
return '{:.0f}'.format(x / 1000000)
plt.figure(figsize=figure_size)
ax = sns.heatmap(df/1000000, fmt=".1f", cmap='viridis', annot=annot_cost)
CS = ax.contour(X, Y, df, colors='black', alpha=0.5)
ax.clabel(CS, inline=True, fontsize=10, fmt=FuncFormatter(fmt))
plt.title(title_cost)
plt.gca().invert_yaxis()
plt.xlim(0, df.shape[1] - 1)
plt.ylim(0, df.shape[0] - 1)
plt.xlabel('ESS Capacity (MWh)')
plt.ylabel('PV Capacity (MW)')
plt.savefig(filename)
# In[ ]:
def draw_overload(overload_cnt, filename, title_unmet, annot_unmet=False, figure_size=(10, 10), days=365, granularity=15):
df = overload_cnt
print(days, granularity)
coef = 60 / granularity * days * 24
print(coef)
print(df)
df = ( coef - df) / coef
print(df)
df = df.astype(float)
df.index = df.index / 1000
df.index = df.index.map(int)
df.columns = df.columns / 1000
df.columns = df.columns.map(int)
df[df.columns[-1] + 1] = df.iloc[:, -1]
new_Data = pd.DataFrame(index=[df.index[-1] + 1], columns=df.columns)
for i in df.columns:
new_Data[i] = df[i].iloc[-1]
# print(new_Data)
df = pd.concat([df, new_Data])
plt.figure(figsize=figure_size)
cmap = LinearSegmentedColormap.from_list("", ["white", "blue"])
ax = sns.heatmap(df, fmt=".00%", cmap=cmap, vmin=0, vmax=1, annot=annot_unmet)
cbar = ax.collections[0].colorbar
cbar.set_ticks([0, 0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90, 1])
cbar.set_ticklabels(['0%', '10%', '20%', '30%', '40%', '50%', '60%', '70%', '80%', '90%', '100%'])
cbar.ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, pos: f'{x:.0%}'))
X, Y = np.meshgrid(np.arange(df.shape[1]), np.arange(df.shape[0]))
def fmt(x, pos):
return '{:.0f}%'.format(x * 100)
CS = ax.contour(X, Y, df, colors='black', alpha=0.5)
ax.clabel(CS, inline=True, fontsize=10, fmt=FuncFormatter(fmt))
plt.xlim(0, df.shape[1] - 1)
plt.ylim(0, df.shape[0] - 1)
plt.title(title_unmet)
plt.xlabel('ESS Capacity (MWh)')
plt.ylabel('PV Capacity (MW)')
plt.savefig(filename)
# In[ ]:
def cal_profit(es: EnergySystem, saved_money, days):
profit = saved_money - es.ess.get_cost_per_year() / 365 * days - es.pv.get_cost_per_year() / 365 * days
return profit return profit
# In[ ]: # In[24]:
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): for ess_capacity in ess_capacities:
pv = pv_config(capacity=pv_capacity, print(f"ess_capacity:{ess_capacity}")
cost_per_kW=pv_cost_per_kW,
lifetime=pv_lifetime,
loss=pv_loss)
ess = ess_config(capacity=ess_capacity,
cost_per_kW=ess_cost_per_kW,
lifetime=ess_lifetime,
loss=ess_loss,
charge_power=ess_capacity,
discharge_power=ess_capacity)
grid = grid_config(capacity=grid_capacity,
grid_loss=grid_loss,
sell_price= sell_price)
energySystem = EnergySystem(pv_type=pv,
ess_type=ess,
grid_type= grid)
(benefit, netto_benefit, gen_energy) = energySystem.simulate(data, time_interval)
results = cal_profit(energySystem, benefit, days)
overload_cnt = energySystem.overload_cnt
costs = energySystem.ess.capacity * energySystem.ess.cost_per_kW + energySystem.pv.capacity * energySystem.pv.cost_per_kW
return (results, overload_cnt, costs, netto_benefit, gen_energy, energySystem.generated)
# In[ ]:
months_results = []
months_costs = []
months_overload = []
months_nettos = []
months_gen_energy = []
months_gen_energy2 = []
for index, month_data in enumerate(months_data):
results = pd.DataFrame(index=pv_capacities, columns= ess_capacities)
costs = pd.DataFrame(index=pv_capacities, columns= ess_capacities)
overload_cnt = pd.DataFrame(index=pv_capacities, columns= ess_capacities)
nettos = pd.DataFrame(index=pv_capacities, columns= ess_capacities)
gen_energies = pd.DataFrame(index=pv_capacities, columns= ess_capacities)
gen_energies2 = pd.DataFrame(index=pv_capacities, columns= ess_capacities)
for pv_capacity in pv_capacities: for pv_capacity in pv_capacities:
for ess_capacity in ess_capacities: print(f"pv_capacity:{pv_capacity}")
(result, overload, cost, netto, gen_energy, gen_energy2) = 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]) pv = pv_config(capacity=pv_capacity,
results.loc[pv_capacity,ess_capacity] = result cost_per_kW=pv_cost_per_kW,
overload_cnt.loc[pv_capacity,ess_capacity] = overload lifetime=pv_lifetime,
costs.loc[pv_capacity,ess_capacity] = cost loss=pv_loss)
nettos.loc[pv_capacity,ess_capacity] = netto ess = ess_config(capacity=ess_capacity,
gen_energies.loc[pv_capacity, ess_capacity] = gen_energy cost_per_kW=ess_cost_per_kW,
gen_energies2.loc[pv_capacity, ess_capacity] = gen_energy2 lifetime=ess_lifetime,
months_results.append(results) loss=ess_loss,
months_costs.append(costs) charge_power=ess_capacity,
months_overload.append(overload_cnt) discharge_power=ess_capacity)
months_nettos.append(nettos) grid = grid_config(capacity=grid_capacity,
months_gen_energy.append(gen_energies) grid_loss=grid_loss,
months_gen_energy2.append(gen_energies2) sell_price= sell_price)
draw_results(results=results, energySystem = EnergySystem(pv_type=pv,
filename=f'plots/pv-{pv_capacity}-ess-{ess_capacity}-month-{index+1}-benefit.png', ess_type=ess,
title_benefit=title_benefit, grid_type= grid)
annot_benefit=annot_benefit, benefit = energySystem.simulate(data, time_interval)
figure_size=figure_size) results.loc[pv_capacity,ess_capacity] = cal_profit(energySystem, benefit)
draw_overload(overload_cnt=overload_cnt, affords.loc[pv_capacity,ess_capacity] = energySystem.afford
filename=f'plots/pv-{pv_capacity}-ess-{ess_capacity}-month-{index+1}-unmet.png', overload_cnt.loc[pv_capacity,ess_capacity] = energySystem.overload_cnt
title_unmet=title_unmet, costs.loc[pv_capacity,ess_capacity] = energySystem.ess.capacity * energySystem.ess.cost_per_kW + energySystem.pv.capacity * energySystem.pv.cost_per_kW
annot_unmet=annot_unmet, pv_generated = energySystem.day_generated
figure_size=figure_size, ess_generated = energySystem.hour_stored
days=months_days[index], ess_generated_2 = energySystem.hour_stored_2
granularity=granularity) plt.figure(figsize=(10,8));
plt.plot(ess_generated)
plt.xlabel('day #')
plt.ylabel('SoC %')
plt.title(f'14:00 ESS SoC \n PV cap:{pv_capacity}, ESS cap:{ess_capacity}')
plt.savefig(f'plots/ess/1400-{pv_capacity}-{ess_capacity}.png')
plt.close()
plt.figure(figsize=(10,8));
plt.plot(ess_generated_2)
plt.xlabel('day #')
plt.ylabel('SoC%')
plt.title(f'08:00 ESS SoC \n PV cap:{pv_capacity}, ESS cap:{ess_capacity}')
plt.savefig(f'plots/ess/0800-{pv_capacity}-{ess_capacity}.png')
plt.close()
# print(energySystem.unmet)
# spring_week_start = energySystem.season_start
# spring_week_end = spring_week_start + energySystem.week_length
# summer_week_start = energySystem.season_start + 1 * energySystem.season_step
# summer_week_end = summer_week_start + energySystem.week_length
# autumn_week_start = energySystem.season_start + 2 * energySystem.season_step
# autumn_week_end = autumn_week_start + energySystem.week_length
# winter_week_start = energySystem.season_start + 3 * energySystem.season_step
# winter_week_end = winter_week_start+ energySystem.week_length
annual_result = pd.DataFrame(index=pv_capacities, columns= ess_capacities) # spring_consume_data = []
annual_costs = pd.DataFrame(index=pv_capacities, columns= ess_capacities) # summer_consume_data = []
annual_overload = pd.DataFrame(index=pv_capacities, columns= ess_capacities) # autumn_consume_data = []
annual_nettos = pd.DataFrame(index=pv_capacities, columns= ess_capacities) # winter_consume_data = []
annual_gen = pd.DataFrame(index=pv_capacities, columns= ess_capacities) # for index, row in data.iterrows():
annual_gen2 = pd.DataFrame(index=pv_capacities, columns= ess_capacities) # if index in range(spring_week_start, spring_week_end):
# spring_consume_data.append(row['demand'])
# elif index in range(summer_week_start, summer_week_end):
# summer_consume_data.append(row['demand'])
# elif index in range(autumn_week_start, autumn_week_end):
# autumn_consume_data.append(row['demand'])
# elif index in range(winter_week_start, winter_week_end):
# winter_consume_data.append(row['demand'])
# spring_week_time = list(range(spring_week_start, spring_week_end))
# summer_week_time = list(range(summer_week_start, summer_week_end))
# autumn_week_time = list(range(autumn_week_start, autumn_week_end))
# winter_week_time = list(range(winter_week_start, winter_week_end))
# spring_pv_generated = energySystem.spring_week_gen
# summer_pv_generated = energySystem.summer_week_gen
# autumn_pv_generated = energySystem.autumn_week_gen
# winter_pv_generated = energySystem.winter_week_gen
# spring_soc = energySystem.spring_week_soc
# summer_soc = energySystem.summer_week_soc
# autumn_soc = energySystem.autumn_week_soc
# winter_soc = energySystem.winter_week_soc
# fig, ax1 = plt.subplots()
# get the yearly results # plt.plot(spring_week_time, spring_pv_generated, label = 'pv generation')
for pv_capacity in pv_capacities: # plt.plot(spring_week_time, spring_consume_data, label = 'factory consume')
for ess_capacity in ess_capacities: # plt.ylabel('Power / kW')
results = 0 # plt.xlabel('15 min #')
costs = 0 # plt.title(f'ess: {energySystem.ess.capacity/1000 } MWh pv: {energySystem.pv.capacity/1000 } MW spring week generate condition')
overload_cnt = 0 # plt.legend()
nettos = 0 # plt.savefig(f'plots/{energySystem.ess.capacity}-{energySystem.pv.capacity}-spring.png')
gen = 0 # plt.close()
gen2 = 0
for index, month_data in enumerate(months_data):
results += months_results[index].loc[pv_capacity,ess_capacity]
costs += months_costs[index].loc[pv_capacity,ess_capacity]
overload_cnt += months_overload[index].loc[pv_capacity, ess_capacity]
nettos += months_nettos[index].loc[pv_capacity, ess_capacity]
gen += months_gen_energy[index].loc[pv_capacity, ess_capacity]
gen2 += months_gen_energy[index].loc[pv_capacity, ess_capacity]
annual_result.loc[pv_capacity, ess_capacity] = results
annual_costs.loc[pv_capacity, ess_capacity] = costs
annual_overload.loc[pv_capacity, ess_capacity] = overload_cnt
annual_nettos.loc[pv_capacity, ess_capacity] = nettos
annual_gen.loc[pv_capacity, ess_capacity] = gen
annual_gen2.loc[pv_capacity, ess_capacity] = gen2
draw_cost(costs=annual_costs, # plt.plot(summer_week_time, summer_pv_generated, label = 'pv generation')
filename='plots/annual_cost.png', # plt.plot(summer_week_time, summer_consume_data, label = 'factory consume')
title_cost=title_cost, # plt.ylabel('Power / kW')
annot_cost=annot_cost, # plt.xlabel('15 min #')
figure_size=figure_size) # plt.title(f'ess: {energySystem.ess.capacity/1000 } MWh pv: {energySystem.pv.capacity/1000 } MW summer week generate condition')
draw_results(results=annual_result, # plt.legend()
filename='plots/annual_benefit.png', # plt.savefig(f'plots/{energySystem.ess.capacity}-{energySystem.pv.capacity}-summer.png')
title_benefit=title_benefit, # plt.close()
annot_benefit=annot_benefit,
figure_size=figure_size) # plt.plot(autumn_week_time, autumn_pv_generated, label = 'pv generation')
draw_overload(overload_cnt=annual_overload, # plt.plot(autumn_week_time, autumn_consume_data, label = 'factory consume')
filename='plots/annual_unmet.png', # plt.ylabel('Power / kW')
title_unmet=title_unmet, # plt.xlabel('15 min #')
annot_unmet=annot_unmet, # plt.title(f'ess: {energySystem.ess.capacity/1000 } MWh pv: {energySystem.pv.capacity/1000 } MW autumn week generate condition')
figure_size=figure_size) # plt.legend()
# plt.savefig(f'plots/{energySystem.ess.capacity}-{energySystem.pv.capacity}-autumn.png')
# plt.close()
# plt.plot(winter_week_time, winter_pv_generated, label = 'pv generation')
# plt.plot(winter_week_time, winter_consume_data, label = 'factory consume')
# plt.ylabel('Power / kW')
# plt.xlabel('15 min #')
# plt.title(f'ess: {energySystem.ess.capacity/1000 } MWh pv: {energySystem.pv.capacity/1000 } MW winter week generate condition')
# plt.legend()
# plt.savefig(f'plots/{energySystem.ess.capacity}-{energySystem.pv.capacity}-winter.png')
# plt.close()
# plt.figure();
# plt.plot(pv_generated)
# plt.xlabel('day #')
# plt.ylabel('Electricity kWh')
# plt.title(f'PV generated pv cap:{pv_capacity}, ess cap:{ess_capacity}')
# plt.savefig(f'plots/pv/{pv_capacity}-{ess_capacity}.png')
# plt.close()
# In[ ]: # plt.show()
# results = results.astype(float)
# pv = pv_config(capacity=100000,cost_per_kW=200,lifetime=25,loss=0.95)
# ess = ess_config(capacity=100000,cost_per_kW=300,lifetime=25,loss=0.95,charge_power=100000,discharge_power=100000)
# grid = grid_config(price_schedule=price_schedule, capacity=5000, grid_loss=0.95, sell_price=0.4)
# grid = grid_config(capacity=50000, grid_loss=0.95, sell_price=0.4)
# print(benefit)
# In[20]:
def save_data(data, filename): def save_data(data, filename):
@ -442,25 +262,83 @@ def save_data(data, filename):
data.to_json(filename + '.json') data.to_json(filename + '.json')
# In[ ]: # In[21]:
import matplotlib.ticker as ticker
if not os.path.isdir('data'): if not os.path.isdir('data'):
os.makedirs('data') os.makedirs('data')
save_data(annual_result, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-results') save_data(results, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-results')
save_data(annual_costs, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-costs') save_data(costs, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-costs')
save_data(annual_overload, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-overload_cnt') save_data(overload_cnt, f'data/{pv_begin}-{pv_end}-{pv_groups}-{ess_begin}-{ess_end}-{ess_groups}-overload_cnt')
df=results
df = df.astype(float)
df.index = df.index / 1000
df.columns = df.columns / 1000
min_value = df.min().min()
max_value = df.max().max()
max_scale = max(abs(min_value/1000), abs(max_value/1000))
plt.figure(figsize=figure_size)
cmap = sns.color_palette("coolwarm", as_cmap=True)
ax = sns.heatmap(df/1000, fmt=".1f", cmap=cmap, vmin=-max_scale, vmax=max_scale, annot=annot_benefit)
# ax.yaxis.set_major_formatter(ticker.FormatStrFormatter('%.1f'))
plt.title(title_benefit)
plt.gca().invert_yaxis()
plt.xlabel('ESS Capacity (MWh)')
plt.ylabel('PV Capacity (MW)')
plt.savefig('plots/benefit.png')
# In[ ]: # In[22]:
draw_results(annual_result, 'plots/test.png', 'test', False) df = costs
df = df.astype(int)
df.index = df.index / 1000
df.columns = df.columns / 1000
plt.figure(figsize=figure_size)
sns.heatmap(df/1000000, fmt=".1f", cmap='viridis', annot=annot_cost)
plt.title(title_cost)
plt.gca().invert_yaxis()
plt.xlabel('ESS Capacity (MWh)')
plt.ylabel('PV Capacity (MW)')
plt.savefig('plots/costs.png')
# pv = pv_config(capacity=100000,cost_per_kW=200,lifetime=25,loss=0.95)
# ess = ess_config(capacity=100000,cost_per_kW=300,lifetime=25,loss=0.95,charge_power=100000,discharge_power=100000)
# grid = grid_config(price_schedule=price_schedule, capacity=5000, grid_loss=0.95, sell_price=0.4)
# grid = grid_config(capacity=50000, grid_loss=0.95, sell_price=0.4)
# In[ ]: # print(benefit)
draw_roi(annual_costs, annual_nettos, 'plots/annual_roi.png', title_roi, 365, annot_benefit, figure_size) # In[23]:
from matplotlib.colors import LinearSegmentedColormap
df = overload_cnt
df = df.astype(int)
df.index = df.index / 1000
df.columns = df.columns / 1000
min_value = df.min().min()
max_value = df.max().max()
max_scale = max(abs(min_value/1000), abs(max_value/1000))
plt.figure(figsize=figure_size)
cmap = LinearSegmentedColormap.from_list("", ["white", "blue"])
ax = sns.heatmap(df/(4*24*365), fmt=".00%", cmap=cmap, vmin=0, vmax=1, annot=annot_unmet)
cbar = ax.collections[0].colorbar
cbar.set_ticks([0, 0.25, 0.5, 0.75, 1])
cbar.set_ticklabels(['0%', '25%', '50%', '75%', '100%'])
cbar.ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, pos: f'{x:.0%}'))
plt.title(title_unmet)
plt.gca().invert_yaxis()
plt.xlabel('ESS Capacity (MWh)')
plt.ylabel('PV Capacity (MW)')
plt.savefig('plots/unmet.png')

38
read_data.py
View File

@ -5,7 +5,6 @@ import csv
sunlight_file_name = 'lightintensity.xlsx' sunlight_file_name = 'lightintensity.xlsx'
factory_demand_file_name = 'factory_power1.xlsx' factory_demand_file_name = 'factory_power1.xlsx'
electricity_price_data = 'electricity_price_data.csv' electricity_price_data = 'electricity_price_data.csv'
electricity_price_data_sell = 'electricity_price_data_sell.csv'
df_sunlight = pd.read_excel(sunlight_file_name, header=None, names=['SunlightIntensity']) df_sunlight = pd.read_excel(sunlight_file_name, header=None, names=['SunlightIntensity'])
@ -27,28 +26,41 @@ print(df_power.head())
df_combined = df_sunlight_resampled.join(df_power) df_combined = df_sunlight_resampled.join(df_power)
price_df = pd.read_csv(electricity_price_data, index_col='Time', usecols=['Time', 'ElectricityBuy']) df_combined.to_csv('combined_data.csv', index=True, index_label='Time')
def read_csv(file_path):
return pd.read_csv(file_path, index_col='Time', usecols=['Time', 'ElectricityPrice'])
# price_data = np.random.uniform(0.3, 0.3, len(times))
# 创建DataFrame
price_df = read_csv(electricity_price_data)
price_df.index = pd.to_datetime(price_df.index) price_df.index = pd.to_datetime(price_df.index)
price_df = price_df.reindex(df_combined.index) price_df = price_df.reindex(df_combined.index)
# price_df.set_index('Time', inplace=True)
# 保存到CSV文件
# price_df.to_csv('electricity_price_data.csv', index=True)
print("price____")
print(price_df.index)
print("df_combined____")
print(df_combined.index)
print("Electricity price data generated and saved.") print("Electricity price data generated and saved.")
df_combined2 = df_combined.join(price_df) df_combined2 = df_combined.join(price_df)
print(df_combined2.head())
sell_df = pd.read_csv(electricity_price_data_sell, index_col='Time', usecols=['Time', 'ElectricitySell']) # 保存结果
sell_df.index = pd.to_datetime(sell_df.index)
sell_df = sell_df.reindex(df_combined.index)
df_combined3 = df_combined2.join(sell_df)
with open('combined_data.csv', 'w', newline='') as file: with open('combined_data.csv', 'w', newline='') as file:
writer = csv.writer(file) writer = csv.writer(file)
writer.writerow(['time', 'sunlight', 'demand','buy', 'sell']) writer.writerow(['time', 'sunlight', 'demand','price'])
cnt = 0 cnt = 0
for index, row in df_combined3.iterrows(): for index, row in df_combined2.iterrows():
time_formatted = index.strftime('%H:%M') time_formatted = index.strftime('%H:%M')
writer.writerow([time_formatted, row['SunlightIntensity'], row['FactoryPower'],row['ElectricityBuy'], row['ElectricitySell']]) writer.writerow([time_formatted, row['SunlightIntensity'], row['FactoryPower'],row['ElectricityPrice']])
print('The file is written to combined_data.csv') print('The file is written to combined_data.csv')