precalculated supplier, spaghetti but fast

v2/architecture.py

@@ -6,7 +6,7 @@ from enum import IntEnum
 import matplotlib.pyplot as plt
 
 # it's really just a network pricing model
-from supplier import Supplier
+from supplier import Supplier, precalculate_supplier
 from data_processing import read_datasets, add_production_field, interpolate_and_join, SolarParameters
 
 
@@ -98,18 +98,18 @@ class Decision(IntEnum):
 # mock class as usual
 # output_window_size is not yet used, always decides one timestep.
 class Decider:
-    def __init__(self, supplier):
+    def __init__(self, precalculated_supplier):
         self.input_window_size = STEPS_PER_HOUR * 24 # day long window.
         self.random_seed = 0
-        self.supplier = supplier
+        self.precalculated_supplier = precalculated_supplier
 
     # prod_cons_pred is a dataframe starting at now, containing
     # fields Production and Consumption.
     # this function does not mutate its inputs.
     # battery_model is just queried for capacity and current soc.
     # the method returns a pd.Series of Decisions as integers.
-    def decide(self, prod_pred, cons_pred, battery_model):
-        return Decision.DISCHARGE
+    def decide(self, prod_pred, cons_pred, fees, battery_model):
+        return Decision.PASSIVE
         next_prod = prod_pred[0]
         next_cons = cons_pred[0]
         deficit = next_cons - next_prod
@@ -143,17 +143,19 @@ class DummyPredictor:
 
 # this function does not mutate its inputs.
 # it makes a clone of battery_model and modifies that.
-def simulator(battery_model, supplier, prod_cons, decider):
+def simulator(battery_model, prod_cons, decider):
     battery_model = copy.copy(battery_model)
 
     demand_np = prod_cons['Consumption'].to_numpy()
     production_np = prod_cons['Production'].to_numpy()
-    demand_prediction_np = demand_np # prod_cons['Consumption_prediction'].to_numpy()
-    production_prediction_np = production_np # prod_cons['Production_prediction'].to_numpy()
+    demand_prediction_np = prod_cons['Consumption_prediction'].to_numpy()
+    production_prediction_np = prod_cons['Production_prediction'].to_numpy()
     assert len(demand_np) == len(production_np)
     step_in_minutes = prod_cons.index.freq.n
     assert step_in_minutes == 5
 
+    consumption_fees_np = prod_cons['Consumption_fees'].to_numpy()
+
     print("Simulating for", len(demand_np), "time steps. Each step is", step_in_minutes, "minutes.")
     soc_series = []
     # by convention, we only call end user demand, demand,
@@ -194,7 +196,8 @@ def simulator(battery_model, supplier, prod_cons, decider):
         # 3. there should not be two of them.
         prod_prediction = production_prediction_np[i: i + decider.input_window_size]
         cons_prediction = demand_prediction_np[i: i + decider.input_window_size]
-        decision = decider.decide(prod_prediction, cons_prediction, battery_model)
+        consumption_fees = consumption_fees_np[i: i + decider.input_window_size]
+        decision = decider.decide(prod_prediction, cons_prediction, consumption_fees, battery_model)
 
         production_used_to_charge = 0
         if unsatisfied_demand >= remaining_production:
@@ -243,9 +246,19 @@ def simulator(battery_model, supplier, prod_cons, decider):
     discarded_production_series = np.array(discarded_production_series)
 
     consumption_from_network_pandas_series = pd.Series(consumption_from_network_series, index=prod_cons.index)
+
+    # TODO badly duplicating functionality
+    '''
     total_charge, consumption_charge_series, demand_charges = supplier.fee(
         consumption_from_network_pandas_series,
         provide_detail=True)
+    '''
+    consumption_charge_series = consumption_fees_np * consumption_from_network_pandas_series.to_numpy()
+    step_in_hour = consumption_from_network_pandas_series.index.freq.n / 60 # [hour], the length of a time step.
+    fifteen_minute_demands_in_kwh = consumption_from_network_pandas_series.resample('15T').sum() * step_in_hour
+    fifteen_minute_surdemands_in_kwh = (fifteen_minute_demands_in_kwh - decider.precalculated_supplier.peak_demand).clip(lower=0)
+    demand_charges = fifteen_minute_surdemands_in_kwh * decider.precalculated_supplier.surcharge_per_kwh
+    total_charge = consumption_charge_series.sum() + demand_charges.sum()
     print(f"All in all we have paid {total_charge} to network.")
 
     if DO_VIS:
@@ -266,9 +279,11 @@ def simulator(battery_model, supplier, prod_cons, decider):
 
 
 def main():
-
     supplier = Supplier(price=100) # Ft/kWh
-    supplier.set_price_for_interval(9, 17, 150) # nine-to-five increased price.
+    # nine-to-five increased price.
+    supplier.set_price_for_daily_interval(9, 17, 150)
+    # midnight-to-three decreased price, to test network charge.
+    supplier.set_price_for_daily_interval(0, 3, 20)
     # 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=500) # kWh in a 15 minutes interval, Ft/kWh
@@ -279,16 +294,28 @@ def main():
     add_production_field(met_2021_data, parameters)
     all_data = interpolate_and_join(met_2021_data, cons_2021_data)
 
+    # we have perfect foresight, yet:
     all_data_with_predictions = all_data.copy()
+    all_data_with_predictions['Consumption_prediction'] = all_data_with_predictions['Consumption']
+    all_data_with_predictions['Production_prediction'] = all_data_with_predictions['Production']
+
+    precalculated_supplier = precalculate_supplier(supplier, all_data.index)
+    # we delete the supplier to avoid accidentally calling it instead of precalculated_supplier
+    supplier = None
+
+    all_data_with_predictions['Consumption_fees'] = precalculated_supplier.consumption_fees # [HUF / kWh]
 
     time_interval_min = all_data.index.freq.n
     time_interval_h = time_interval_min / 60
     battery_model = BatteryModel(capacity_Ah=600, time_interval_h=time_interval_h)
 
-    decider = Decider(supplier)
+    # TODO this is super unfortunate:
+    # Consumption_fees travels via all_data_with_predictions,
+    # peak_demand and surcharge_per_kwh travels via precalculated_supplier of decider.
+    decider = Decider(precalculated_supplier)
 
     t = time.perf_counter()
-    results = simulator(battery_model, supplier, all_data_with_predictions, decider)
+    results = simulator(battery_model, all_data_with_predictions, decider)
     print("Simulation runtime", time.perf_counter() - t, "seconds.")
 
     if DO_VIS:

v2/supplier.py

@@ -3,6 +3,7 @@
 import numpy as np
 import pandas as pd
 import datetime
+from dataclasses import dataclass
 import unittest
 
 
@@ -16,19 +17,19 @@ class Supplier:
         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):
+    def set_price_for_weekly_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)
+            self.set_price_for_weekly_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)
+            self.set_price_for_weekly_interval(h + start, h + end, price)
 
     def set_demand_charge(self, peak_demand, surcharge_per_kwh):
         self.peak_demand = peak_demand # [kWh]
@@ -81,6 +82,26 @@ class Supplier:
             return total_charge
 
 
+@dataclass
+class PrecalculatedSupplier:
+    peak_demand: float # [kWh]
+    surcharge_per_kwh: float # [HUF / kWh surplus over 15 min interval]
+    consumption_fees: np.ndarray
+    time_index: pd.DatetimeIndex
+
+
+def precalculate_supplier(supplier, time_index):
+    ones = pd.Series(1, index=time_index)
+    total_charge, consumption_charge_series, demand_charges = supplier.fee(ones, provide_detail=True)
+
+    p = PrecalculatedSupplier(
+        peak_demand=supplier.peak_demand,
+        surcharge_per_kwh=supplier.surcharge_per_kwh,
+        consumption_fees=consumption_charge_series.to_numpy(),
+        time_index=time_index)
+    return p
+
+
 class TestSupplier(unittest.TestCase):
 
     def setUp(self):
@@ -92,14 +113,14 @@ class TestSupplier(unittest.TestCase):
         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)
+        self.supplier.set_price_for_weekly_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)
+        self.supplier.set_price_for_weekly_interval(0, 24, increased_price)
 
         date = datetime.datetime(2023, 4, 30, 12, 0, 0)  # Sunday noon
         expected_price = self.constant_price