v2

v2/architecture.py

@@ -0,0 +1,116 @@
+import numpy as np
+import pandas as pd
+import copy
+from enum import IntEnum
+
+# it's really just a network pricing model
+from supplier import Supplier
+from data_processing import read_datasets, add_production_field, interpolate_and_join, Parameters
+
+
+STEPS_PER_HOUR = 4
+
+
+# mock model
+class BatteryModel:
+    def __init__(self, capacity, efficiency=0.95):
+        self.soc = 0
+        self.capacity = capacity # kWh
+        self.efficiency = efficiency
+
+    def discharge(self, target):
+        assert 0 <= self.soc <= 1
+        if self.soc >= target:
+            self.soc -= target
+            amount = target
+        else:
+            amount = self.soc
+            self.soc = 0
+        assert 0 <= self.soc <= 1
+        return amount
+
+    # not very refined, whatevs.
+    def charge(self, target):
+        assert 0 <= self.soc <= 1
+        target_to_add = target * self.efficiency
+        if self.soc <= 1 - target_to_add:
+            self.soc += target_to_add
+            could_take = target
+        else:
+            could_take = (1 - self.soc) / self.efficiency
+            self.soc = 1
+        assert 0 <= self.soc <= 1
+        return could_take
+
+
+class Decision(IntEnum):
+    # use solar to satisfy consumption,
+    # and if it is not enough, use network.
+    # BESS is not discharged in this mode,
+    # but might be charged if solar has surplus.
+    PASSIVE = 0
+
+    # use the battery if possible and necessary.
+    # the possible part means that there's charge in it,
+    # and the necessary part means that the consumption
+    # is not already covered by solar.
+    DISCHARGE = 1
+
+    # use the network to charge the battery
+    # this is similar to PASSIVE, but forces the
+    # BESS to be charged, even if solar does not cover
+    # the whole of consumption plus BESS.
+    NETWORK_CHARGE = 2
+
+
+# mock class as usual
+class Decider:
+    def __init__(self):
+        self.parameters = None
+        self.input_window_size = STEPS_PER_HOUR * 24 # day long window.
+        self.output_window_size = STEPS_PER_HOUR # only output 4 decisions for the next hour
+
+    # 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_cons_pred, battery_model):
+        assert len(prod_cons_pred) == self.input_window_size
+        # dummy decider always says DISCHARGE:
+        return pd.Series([Decision.DISCHARGE] * STEPS_PER_HOUR, dtype=int)
+
+
+# this function does not mutate its inputs.
+# it makes a clone of battery_model and modifies that.
+# it returns 
+def simulator(battery_model, supplier, prod_cons, decider):
+    battery_model = copy.copy(battery_model)
+    for indx, date in enumerate(prod_cons.index):
+        if indx + decider.input_window_size > len(prod_cons):
+            break
+        # not really a prediction obviously
+        prod_cons_pred = prod_cons.iloc[indx: indx + decider.input_window_size]
+        decisions = decider.decide(prod_cons_pred, battery_model)
+    return None
+
+
+def main():
+    battery_model = BatteryModel(capacity=200, efficiency=0.95)
+
+    supplier = Supplier(price=100) # Ft/kWh
+    supplier.set_price_for_interval(9, 17, 150) # nine-to-five increased price.
+
+    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)
+
+    decider = Decider()
+
+    results = simulator(battery_model, supplier, all_2021_data, decider)
+
+
+if __name__ == '__main__':
+    main()

v2/data_processing.py

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

v2/supplier.py

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