adding energy supplier

app.py

@@ -3,10 +3,6 @@
 
 import numpy as np
 import pandas as pd
-
-import matplotlib.pyplot as plt
-import matplotlib.cm
-
 import gradio as gr
 
 from simulation import *
@@ -15,90 +11,10 @@ from visualization import *
 
 
 #@title ### Downloading the data
-# !wget "https://static.renyi.hu/ai-shared/daniel/pq/PL_44527.19-21.csv"
+# !wget "https://static.renyi.hu/ai-shared/daniel/pq/PL_44527.19-21.csv.gz"
 # !wget "https://static.renyi.hu/ai-shared/daniel/pq/pq_terheles_2021_adatok.tsv"
 
 
-
-matplotlib.rcParams['figure.figsize'] = [12, 8]
-
-
-
-
-
-
-
-
-
-
-def main():
-    parameters = Parameters()
-
-    met_2021_data, cons_2021_data = read_datasets()
-
-    add_production_field(met_2021_data, parameters)
-
-    all_2021_data = interpolate_and_join(met_2021_data, cons_2021_data)
-
-    results = simulator_with_solar(all_2021_data, parameters)
-
-    fig = visualize_simulation(results, date_range=("2021-02-01", "2021-03-01"))
-    plt.show()
-
-    consumptions_in_mwh = monthly_analysis(results)
-    monthly_visualization(consumptions_in_mwh)
-
-
-# main() ; exit()
-
-
-def evaluate_parameters(parameters, met_2021_data, cons_2021_data):
-    add_production_field(met_2021_data, parameters)
-    all_2021_data = interpolate_and_join(met_2021_data, cons_2021_data)
-    results = simulator_with_solar(all_2021_data, parameters)
-    consumptions_in_mwh = monthly_analysis(results)
-    return consumptions_in_mwh.sum(axis=0)
-
-
-def main_gridsearch():
-    fixed_consumption = False
-
-    parameters = Parameters()
-    met_2021_data, cons_2021_data = read_datasets()
-
-    if fixed_consumption:
-        cons_2021_data['Consumption'] = 10
-
-    N = 20
-    solar_cell_num_max = 4000
-    bess_nominal_capacity_max = 4000
-    solar_cell_nums = np.linspace(0, solar_cell_num_max, N)
-    bess_nominal_capacities = np.linspace(1e-6, bess_nominal_capacity_max, N)
-
-    mg_x, mg_y = np.meshgrid(solar_cell_nums, bess_nominal_capacities)
-
-    values = np.zeros((N, N))
-    for i, solar_cell_num in enumerate(solar_cell_nums):
-        for j, bess_nominal_capacity in enumerate(bess_nominal_capacities):
-            parameters.solar_cell_num = solar_cell_num
-            parameters.bess_nominal_capacity = bess_nominal_capacity
-            network, solar, bess = evaluate_parameters(parameters, met_2021_data, cons_2021_data)
-            satisfied = 1 - network / (network + solar + bess)
-            values[i, j] = satisfied
-
-    fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
-    surf = ax.plot_surface(mg_x, mg_y, values * 100, cmap=matplotlib.cm.coolwarm,
-                       linewidth=0, antialiased=False)
-    ax.set_xlabel("BESS nominal capacity [Ah]")
-    ax.set_ylabel("Solar cell number")
-    ax.set_zlabel("Percentage of consumption served without network")
-    fig.colorbar(surf, shrink=0.5, aspect=10)
-    plt.show()
-
-
-# main_gridsearch() ; exit()
-
-
 met_2021_data, cons_2021_data = read_datasets()
 
 

main.py

@@ -0,0 +1,79 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib
+import matplotlib.cm
+
+from simulation import *
+from data_processing import *
+from visualization import *
+from supplier import Supplier
+
+
+matplotlib.rcParams['figure.figsize'] = [12, 8]
+
+
+def main():
+    parameters = Parameters()
+
+    met_2021_data, cons_2021_data = read_datasets()
+
+    add_production_field(met_2021_data, parameters)
+
+    all_2021_data = interpolate_and_join(met_2021_data, cons_2021_data)
+
+    results = simulator_with_solar(all_2021_data, parameters)
+    consumption_from_network = results["consumption_from_network"]
+    supplier = Supplier(price=70) # HUF/kWh
+    supplier.set_price_for_daily_interval_on_workdays(start=6, end=22, price=100)
+    print("Energy supplier charges", int(supplier.fee(consumption_from_network)), "HUF between", results.index[0], "and", results.index[-1])
+    return
+
+    fig = visualize_simulation(results, date_range=("2021-02-01", "2021-03-01"))
+    plt.show()
+
+    consumptions_in_mwh = monthly_analysis(results)
+    monthly_visualization(consumptions_in_mwh)
+
+
+main() ; exit()
+
+
+
+def main_gridsearch():
+    fixed_consumption = False
+
+    parameters = Parameters()
+    met_2021_data, cons_2021_data = read_datasets()
+
+    if fixed_consumption:
+        cons_2021_data['Consumption'] = 10
+
+    N = 20
+    solar_cell_num_max = 4000
+    bess_nominal_capacity_max = 4000
+    solar_cell_nums = np.linspace(0, solar_cell_num_max, N)
+    bess_nominal_capacities = np.linspace(1e-6, bess_nominal_capacity_max, N)
+
+    mg_x, mg_y = np.meshgrid(solar_cell_nums, bess_nominal_capacities)
+
+    values = np.zeros((N, N))
+    for i, solar_cell_num in enumerate(solar_cell_nums):
+        print(f"{solar_cell_num} / {solar_cell_nums[-1]}")
+        for j, bess_nominal_capacity in enumerate(bess_nominal_capacities):
+            parameters.solar_cell_num = solar_cell_num
+            parameters.bess_nominal_capacity = bess_nominal_capacity
+            network, solar, bess = evaluate_parameters(parameters, met_2021_data, cons_2021_data)
+            satisfied = 1 - network / (network + solar + bess)
+            values[i, j] = satisfied
+
+    fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+    surf = ax.plot_surface(mg_x, mg_y, values * 100, cmap=matplotlib.cm.coolwarm,
+                       linewidth=0, antialiased=False)
+    ax.set_xlabel("BESS nominal capacity [Ah]")
+    ax.set_ylabel("Solar cell number")
+    ax.set_zlabel("Percentage of consumption served without network")
+    fig.colorbar(surf, shrink=0.5, aspect=10)
+    plt.show()
+
+
+main_gridsearch() ; exit()

simulation.py

@@ -1,6 +1,8 @@
 import pandas as pd
 import numpy as np
 
+from data_processing import add_production_field, interpolate_and_join, monthly_analysis
+
 
 def simulator_with_solar(all_data, parameters):
     demand_np = all_data['Consumption'].to_numpy()
@@ -136,3 +138,11 @@ def simulator_with_solar(all_data, parameters):
                             })
     results = results.set_index(all_data.index)
     return results
+
+
+def evaluate_parameters(parameters, met_2021_data, cons_2021_data):
+    add_production_field(met_2021_data, parameters)
+    all_2021_data = interpolate_and_join(met_2021_data, cons_2021_data)
+    results = simulator_with_solar(all_2021_data, parameters)
+    consumptions_in_mwh = monthly_analysis(results)
+    return consumptions_in_mwh.sum(axis=0)

supplier.py

@@ -0,0 +1,136 @@
+# modeling an energy supplier for the purposes of peak shaving
+
+import numpy as np
+import pandas as pd
+import datetime
+import unittest
+
+
+class Supplier:
+    # price [HUF/kWh]
+    # peak_demand kW
+    # surcharge_per_kw [HUF/kW for each 15 minute timeframe]
+    def __init__(self, price):
+        self.hourly_prices = np.ones(168) * price
+        self.peak_demand = np.inf # no demand_charge by default
+        self.surcharge_per_kw = 0
+
+    # start and end are indices of hours starting from Monday 00:00.
+    def set_price_for_interval(self, start, end, price):
+        self.hourly_prices[start:end] = price
+
+    # start and end are indices of hours of the day. for each day, this interval is set to price
+    def set_price_for_daily_interval(self, start, end, price):
+        for day in range(7):
+            h = day * 24
+            self.set_price_for_interval(h + start, h + end, price)
+
+    def set_price_for_daily_interval_on_workdays(self, start, end, price):
+        for day in range(5):
+            h = day * 24
+            self.set_price_for_interval(h + start, h + end, price)
+
+    def set_demand_charge(self, peak_demand, surcharge_per_kw):
+        self.peak_demand = peak_demand # [kW]
+        # the HUF charged per kW of demand exceeding peak_demand during a 15 minutes timeframe.
+        self.surcharge_per_kw = surcharge_per_kw # [HUF/kW]
+
+    @staticmethod
+    def hour_of_date(date):
+        hours_since_midnight = (date - datetime.datetime(date.year, date.month, date.day, 0, 0, 0)).total_seconds() / 3600
+        # weekday() calculates from sunday morning:
+        hungarian_weekday = (date.weekday() + 0) % 7
+        hours_elapsed_in_previous_days = hungarian_weekday * 24
+        return int(hours_since_midnight) + hours_elapsed_in_previous_days
+
+    def price(self, date):
+        return self.hourly_prices[self.hour_of_date(date)]
+
+    # demand is the maximum demand in kW during a 15 minute interval
+    def demand_charge(self, demand):
+        if demand <= self.peak_demand:
+            return 0.0
+        else:
+            return (demand - self.peak_demand) * self.surcharge_per_kw
+
+    # demand_series is pandas series indexed by time.
+    # during each time step demand [kW] is assumed to be constant.
+    def fee(self, demand_series):
+        prices = [self.price(date) for date in demand_series.index]
+        prices_series = pd.Series(data=prices, index=demand_series.index)
+        # prices are HUF/kWh, demand is kW. note the missing h.
+
+        step_in_hour = demand_series.index.freq.n / 60 # [hour], the length of a time step.
+        # for each step the product tells the fee IF the step was 1 hour long. it's actually step_in_hour long:
+        consumption_charge = demand_series.dot(prices_series) * step_in_hour
+
+        # 15 minutes (the demand charge calculation interval) should be a multiple of the series time step.
+        assert 15 % demand_series.index.freq.n == 0
+        time_steps_per_demand_charge_evaluation = 15 // demand_series.index.freq.n
+        # fifteen_minute_peaks [kW] tells the maximum demand in a 15 minutes timeframe:
+        fifteen_minute_peaks = demand_series.resample('15T').max()
+        demand_charges = [self.demand_charge(demand) for demand in fifteen_minute_peaks]
+        total_demand_charge = sum(demand_charges)
+        return consumption_charge + total_demand_charge
+
+
+class TestSupplier(unittest.TestCase):
+
+    def setUp(self):
+        self.constant_price = 10
+        self.supplier = Supplier(self.constant_price)
+
+    def test_hourly_prices(self):
+        expected_hourly_prices = np.ones(168) * self.constant_price
+        self.assertTrue(np.array_equal(self.supplier.hourly_prices, expected_hourly_prices))
+
+    def test_set_price_for_interval(self):
+        self.supplier.set_price_for_interval(0, 24, 20)
+        expected_hourly_prices = np.ones(168) * self.constant_price
+        expected_hourly_prices[0:24] = 20
+        self.assertTrue(np.array_equal(self.supplier.hourly_prices, expected_hourly_prices))
+
+    def test_price(self):
+        increased_price = 20
+        self.supplier.set_price_for_interval(0, 24, increased_price)
+
+        date = datetime.datetime(2023, 4, 30, 12, 0, 0)  # Sunday noon
+        expected_price = self.constant_price
+        self.assertEqual(self.supplier.price(date), expected_price)
+
+        date = datetime.datetime(2023, 5, 1, 12, 0, 0)  # Monday noon
+        expected_price = increased_price
+        self.assertEqual(self.supplier.price(date), expected_price)
+
+        date = datetime.datetime(2023, 5, 2, 12, 0, 0)  # Tuesday noon
+        expected_price = self.constant_price
+        self.assertEqual(self.supplier.price(date), expected_price)
+
+    def test_fee(self):
+        start = pd.Timestamp('2021-04-28')
+        end = start + pd.Timedelta(days=1)
+        freq = '5T' # 5 minutes
+        time_index = pd.date_range(start=start, end=end, freq=freq, inclusive='left')
+        constant_demand = 100
+        demand_in_kw = [constant_demand] * len(time_index)
+
+        demand_series = pd.Series(data=demand_in_kw, index=time_index)
+        # 24 because it's a 24 hour period with constant demand:
+        self.assertEqual(self.supplier.fee(demand_series), constant_demand * 24 * self.constant_price)
+
+        extreme_demand = 1000
+        demand_series[12:24] = extreme_demand # in second hour we set extreme demand.
+
+        expected_fee = (constant_demand * 23 + extreme_demand) * self.constant_price
+        self.assertEqual(self.supplier.fee(demand_series), expected_fee)
+
+        # now the (1000-500) kW above 500 kW is surcharged for (1000-500 kW) * 10 HUF/kW/15mins, for 1 hour,
+        # that is 500*10*4=20000 demand_charge.
+        self.supplier.set_demand_charge(peak_demand=500, surcharge_per_kw=10)
+        expected_fee += 20000
+        self.assertEqual(self.supplier.fee(demand_series), expected_fee)
+
+
+
+if __name__ == '__main__':
+    unittest.main()