copied supplier

v2/architecture.py

@@ -13,10 +13,12 @@ STEPS_PER_HOUR = 12
 
 # SOC is normalized so that minimal_depth_of_discharge = 0 and maximal_depth_of_discharge = 1.
 # please set capacity_Ah = nominal_capacity_Ah * (max_dod - min_dod)
+#
+# TODO efficiency multiplier is not currently used, where best to put it?
 class BatteryModel:
     def __init__(self, capacity_Ah, time_interval_h):
         self.capacity_Ah = capacity_Ah
-        self.efficiency = 0.95 # [dimensionless]
+        self.efficiency = 0.9 # [dimensionless]
         self.voltage_V = 600
         self.charge_kW = 50
         self.discharge_kW = 60
@@ -94,7 +96,6 @@ class Decision(IntEnum):
 class Decider:
     def __init__(self):
         self.input_window_size = STEPS_PER_HOUR * 24 # day long window.
-        self.output_window_size = STEPS_PER_HOUR # only output decisions for the next hour
         self.random_seed = 0
 
     # prod_cons_pred is a dataframe starting at now, containing
@@ -123,16 +124,6 @@ class DummyPredictor:
         return prediction
 
 
-'''
-    bess_nominal_capacity: float = 330 # [Ah]
-    bess_charge: float = 50 # [kW]
-    bess_discharge: float = 60 # [kW]
-    voltage: float = 600 # [V]
-    maximal_depth_of_discharge: float = 0.75 # [dimensionless]
-    energy_loss: float = 0.1 # [dimensionless]
-    bess_present: bool = True # [boolean]
-'''
-
 # this function does not mutate its inputs.
 # it makes a clone of battery_model and modifies that.
 def simulator(battery_model, supplier, prod_cons, prod_predictor, cons_predictor, decider):
@@ -215,6 +206,7 @@ def simulator(battery_model, supplier, prod_cons, prod_predictor, cons_predictor
         else:
             consumption_from_network_to_bess = 0
 
+        supplier.(consumption_from_network)
         soc_series.append(battery_model.soc)
         consumption_from_solar_series.append(consumption_from_solar)
         consumption_from_network_series.append(consumption_from_network)

v2/supplier.py

@@ -1 +0,0 @@
-../supplier.py

v2/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()