demand charge measured in kwh/15min

v2/architecture.py

@@ -227,10 +227,16 @@ def simulator(battery_model, supplier, prod_cons, decider):
     consumption_from_bess_series = np.array(consumption_from_bess_series)
     discarded_production_series = np.array(discarded_production_series)
 
+    consumption_from_network_pandas_series = pd.Series(consumption_from_network_series, index=prod_cons.index)
     total_charge, consumption_charge_series, demand_charges = supplier.fee(
-        pd.Series(consumption_from_network_series, index=prod_cons.index),
+        consumption_from_network_pandas_series,
         provide_detail=True)
     print(f"All in all we have paid {total_charge} to network.")
+    fifteen_minute_peaks = consumption_from_network_pandas_series.resample('15T').sum()
+    demand_charges = pd.Series(demand_charges, index=fifteen_minute_peaks.index)
+    demand_charges.plot()
+    import matplotlib.pyplot as plt
+    plt.show()
 
     results = pd.DataFrame({'soc_series': soc_series, 'consumption_from_solar': consumption_from_solar_series,
                             'consumption_from_network': consumption_from_network_series,
@@ -248,6 +254,9 @@ def main():
 
     supplier = Supplier(price=100) # Ft/kWh
     supplier.set_price_for_interval(9, 17, 150) # nine-to-five increased price.
+    # peak_demand dimension is kWh, but it's interpreted as the full consumption
+    # during a 15 minute timestep.
+    supplier.set_demand_charge(peak_demand=25, surcharge_per_kwh=200) # kWh in a 15 minutes interval, Ft/kWh
 
     parameters = SolarParameters()
 
@@ -267,7 +276,6 @@ def main():
     results = simulator(battery_model, supplier, all_data_with_predictions, decider)
     print("Simulation runtime", time.perf_counter() - t, "seconds.")
 
-    return
     import matplotlib.pyplot as plt
     results['soc_series'].plot()
     plt.show()

v2/supplier.py

@@ -9,11 +9,11 @@ import unittest
 class Supplier:
     # price [HUF/kWh]
     # peak_demand kW
-    # surcharge_per_kw [HUF/kW for each 15 minute timeframe]
+    # surcharge_per_kwh [HUF/kWh 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
+        self.peak_demand = np.inf # [kWh] (!) no demand_charge by default
+        self.surcharge_per_kwh = 0
 
     # start and end are indices of hours starting from Monday 00:00.
     def set_price_for_interval(self, start, end, price):
@@ -30,10 +30,10 @@ class Supplier:
             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]
+    def set_demand_charge(self, peak_demand, surcharge_per_kwh):
+        self.peak_demand = peak_demand # [kWh]
         # the HUF charged per kW of demand exceeding peak_demand during a 15 minutes timeframe.
-        self.surcharge_per_kw = surcharge_per_kw # [HUF/kW]
+        self.surcharge_per_kwh = surcharge_per_kwh # [HUF/kWh]
 
     @staticmethod
     def hour_of_date(date):
@@ -46,12 +46,12 @@ class Supplier:
     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:
+    # demand is the maximum demand in kWh during a 15 minute interval
+    def demand_charge(self, demand_in_kwh):
+        if demand_in_kwh <= self.peak_demand:
             return 0.0
         else:
-            return (demand - self.peak_demand) * self.surcharge_per_kw
+            return (demand_in_kwh - self.peak_demand) * self.surcharge_per_kwh
 
     # demand_series is pandas series indexed by time.
     # during each time step demand [kW] is assumed to be constant.
@@ -70,8 +70,8 @@ class Supplier:
         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]
+        fifteen_minute_demands_in_kwh = demand_series.resample('15T').sum() * step_in_hour
+        demand_charges = [self.demand_charge(demand_in_kwh) for demand_in_kwh in fifteen_minute_demands_in_kwh]
         total_demand_charge = sum(demand_charges)
         total_charge = consumption_charge + total_demand_charge
         if provide_detail:
@@ -131,9 +131,9 @@ class TestSupplier(unittest.TestCase):
         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,
+        # now the (1000-500) kW above 500 kW is surcharged for (1000-500 kW) * 10 HUF/kWh/15mins, for 1 hour,
         # that is 500*10*4=20000 demand_charge.
-        self.supplier.set_demand_charge(peak_demand=500, surcharge_per_kw=10)
+        self.supplier.set_demand_charge(peak_demand=500, surcharge_per_kwh=10)
         expected_fee += 20000
         self.assertEqual(self.supplier.fee(demand_series), expected_fee)