from config import pv_config, ess_config, grid_config
import pandas as pd
class EnergySystem:
def __init__(self, pv_type: pv_config, ess_type: ess_config, grid_type: grid_config):
self.pv = pv_type
self.ess = ess_type
self.grid = grid_type
self.day_generated = []
self.generated = 0
self.stored = 0
self.hour_stored = []
self.hour_stored_2 = []
self.afford = True
self.cost = self.ess.get_cost() + self.pv.get_cost()
self.overload_cnt = 0
self.spring_week_gen = []
self.summer_week_gen = []
self.autumn_week_gen = []
self.winter_week_gen = []
self.spring_week_soc = []
self.summer_week_soc = []
self.autumn_week_soc = []
self.winter_week_soc = []
self.factory_demand = []
self.buy_price_kWh = []
self.sell_price_kWh = []
self.pv_generated_kWh = []
self.grid_need_power_kW = []
self.time = []
self.ess_rest = 0
self.granularity = 4
self.season_step = self.granularity * 24 * 7 * 12
self.season_start= self.granularity * 24 * 7 * 2
self.week_length = self.granularity * 24 * 7
self.unmet = []
def get_cost(self):
return self.ess.get_cost()+self.pv.get_cost()
def simulate(self, data, time_interval):
"""
The program will use the PV to supply the factory first. If the PV output can meet the factory's demand, it will be directly powered, and the excess electrical energy will be used to charge the ESS. Program will use the PV to supply the Ess.
When the PV is insufficient, the ESS is used to supplement. If the PV output is not enough to meet the factory's demand, the required power is first obtained from the ESS.
If the ESS is also insufficient to meet the demand, it will be obtained from the grid. When the stored power in the ESS is also insufficient to supplement, the remaining required power will be purchased from the grid.
Args:
data: pandas.DataFrame
The data that contains the factory's demand, PV output, and electricity price.
time_interval: float
The time interval of the data in hours.
Returns:
tuple
The total benefit, total netto benefit, and total generated energy.
"""
total_benefit = 0
total_netto_benefit = 0
total_gen = 0
net_grid = 0.
for index, row in data.iterrows():
time = row['time']
self.time.append(time)
# sunlight_intensity = row['sunlight']
pv_yield = row['PV yield[kW/kWp]']
factory_demand = row['demand']
electricity_price = row['buy']
sell_price = row['sell']
# electricity_price = self.grid.get_price_for_time(time)
# if time == '00:00':
# self.day_generated.append(self.generated)
# self.generated = 0
# if time.endswith('14:00'):
# soc = self.ess.storage / self.ess.capacity
# self.hour_stored.append(soc)
# if time.endswith('08:00'):
# soc = self.ess.storage / self.ess.capacity
# self.hour_stored_2.append(soc)
# `generated_pv_power`: the power generated by the PV in kW
# `generated_pv_energy`: the energy generated by the PV in kWh
generated_pv_power = self.pv.capacity * pv_yield
generated_pv_energy = generated_pv_power * time_interval * self.pv.loss
self.pv_generated_kWh.append(generated_pv_energy)
self.factory_demand.append(factory_demand)
self.buy_price_kWh.append(electricity_price)
self.sell_price_kWh.append(sell_price)
self.generated += generated_pv_energy
# generated_pv_energy is larger than factory_demand energy
if generated_pv_energy >= factory_demand * time_interval:
"""
That means the generated energy is enough to power the factory.
The surplus energy will be used to charge the ESS.
surplus_energy: The energy that is left after powering the factory.
formula: generated_pv_energy - factory_demand * time_interval
charge_to_ess: The energy that will be charged to the ESS.
formula: min(surplus_energy, ess.charge_power * time_interval, ess.capacity - ess.storage)
surplus_after_ess: The energy that is left after charging the ESS.
"""
surplus_energy = generated_pv_energy - factory_demand * time_interval
charge_to_ess = min(surplus_energy, self.ess.charge_power * time_interval, self.ess.capacity - self.ess.storage)
self.ess.storage += charge_to_ess
surplus_after_ess = surplus_energy - charge_to_ess
"""
If there is still surplus energy after charging the ESS, and the generated PV power is greater than the sum of the ESS's charge power and the factory's demand power, the surplus energy will be sold to the grid.
"""
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 * sell_price
total_benefit += sell_income
"""
Saved energy is the energy that is saved by using the PV to power the factory.
"""
saved_energy = factory_demand * time_interval
self.grid_need_power_kW.append(0)
else:
"""
If the generated energy is not enough to power the factory, the ESS will be used to supplement the energy.
needed_from_ess: The energy that is needed from the ESS to power the factory.
formula: factory_demand * time_interval - generated_pv_energy
"""
needed_from_ess = factory_demand * time_interval - generated_pv_energy
"""
If the ESS has enough stored energy to power the factory, the energy will be taken from the ESS.
"""
if self.ess.storage * self.ess.loss >= needed_from_ess:
if self.ess.discharge_power * time_interval * self.ess.loss < needed_from_ess:
discharging_power = self.ess.discharge_power * time_interval
else:
discharging_power = needed_from_ess / self.ess.loss
self.ess.storage -= discharging_power
"""
In this case, the energy that is needed from the grid is 0.
"""
saved_energy = generated_pv_energy + discharging_power * self.ess.loss
self.grid_need_power_kW.append(0)
else:
"""
If the ESS does not have enough stored energy to power the factory, the energy will be taken from the grid.
"""
if self.grid.capacity * time_interval + generated_pv_energy + self.ess.storage * self.ess.loss < factory_demand * time_interval:
self.afford = False
self.overload_cnt+=1
self.unmet.append((index,time,factory_demand,generated_pv_power))
saved_energy = generated_pv_energy + self.ess.storage * self.ess.loss
self.ess.storage = 0
needed_from_grid = factory_demand * time_interval - saved_energy
net_grid = min(self.grid.capacity * time_interval, needed_from_grid) * self.grid.loss
self.grid_need_power_kW.append(needed_from_grid * 4)
total_gen += saved_energy
benefit = (saved_energy) * electricity_price
cost = net_grid * electricity_price
total_netto_benefit += benefit
total_benefit += benefit - cost
print_season_flag = False
if print_season_flag == True:
week_start = self.season_start
week_end = self.week_length + week_start
if index in range(week_start, week_end):
self.spring_week_gen.append(generated_pv_power)
self.spring_week_soc.append(self.ess.storage / self.ess.capacity)
self.ess_rest = self.ess.storage
# summer
week_start += self.season_step
week_end += self.season_step
if index in range(week_start, week_end):
self.summer_week_gen.append(generated_pv_power)
self.summer_week_soc.append(self.ess.storage / self.ess.capacity)
# # autumn
week_start += self.season_step
week_end += self.season_step
if index in range(week_start, week_end):
self.autumn_week_gen.append(generated_pv_power)
self.autumn_week_soc.append(self.ess.storage / self.ess.capacity)
week_start += self.season_step
week_end += self.season_step
if index in range(week_start, week_end):
self.winter_week_gen.append(generated_pv_power)
self.winter_week_soc.append(self.ess.storage / self.ess.capacity)
return (total_benefit, total_netto_benefit, total_gen)