simulator with dummy decider and dummy predictors does something

v2/architecture.py

@@ -64,40 +64,45 @@ class Decision(IntEnum):
 
 
 # mock class as usual
+# output_window_size is not yet used, always decides one timestep.
 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 decisions for the next hour
+        self.random_seed = 0
 
     # 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
+    def decide(self, prod_pred, cons_pred, battery_model):
+        # assert len(prod_pred) == len(cons_pred) == self.input_window_size
+        self.random_seed += 1
+        self.random_seed %= 3 # dummy rotates between 3 Decisions
+        return self.random_seed
         # dummy decider always says DISCHARGE:
-        return pd.Series([Decision.DISCHARGE] * STEPS_PER_HOUR, dtype=int)
+        # return pd.Series([Decision.DISCHARGE] * self.output_window_size, 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
+# even mock-er class than usual.
+# knows the future in advance, so it predicts it very well.
+# it's also unrealistic in that it takes row index instead of date.
+class DummyPredictor:
+    def __init__(self, series):
+        self.series = series
+
+    def predict(self, indx, window_size):
+        prediction = self.series.iloc[indx: indx + window_size]
+        return prediction
 
 
+# this function does not mutate its inputs.
+# it makes a clone of battery_model and modifies that.
 # TODO even in a first mockup version, parameters should come from a single
 # place, not some from the parameters dataclass and some from the battery_model.
-def simulator(battery_model, supplier, prod_cons, decider, parameters):
+def simulator(battery_model, supplier, prod_cons, prod_predictor, cons_predictor, decider, parameters):
     battery_model = copy.copy(battery_model)
 
     demand_np = prod_cons['Consumption'].to_numpy()
@@ -114,8 +119,9 @@ def simulator(battery_model, supplier, prod_cons, decider, parameters):
     # in our simple model, demand is always satisfied, hence demand=consumption.
     # BESS demand is called charge.
     consumption_from_solar_series = [] # demand satisfied by solar production
-    consumption_from_network_series = [] # demand satisfied by network
+    consumption_from_network_series = [] # full demand satisfied by network, also includes consumption_from_network_to_bess.
     consumption_from_bess_series = [] # demand satisfied by BESS
+    consumption_from_network_to_bess_series = [] # network used to charge BESS, also included in consumption_from_network.
     # the previous three must sum to demand_series.
 
     # power taken from solar by BESS.
@@ -132,37 +138,39 @@ def simulator(battery_model, supplier, prod_cons, decider, parameters):
     # and will use only maximal_depth_of_discharge percent of the real battery capacity
 
     max_cap_of_battery = parameters.bess_capacity * parameters.maximal_depth_of_discharge
-    cap_of_battery = soc * max_cap_of_battery
 
     time_interval = step_in_minutes / 60 # amount of time step in hours
     for i, (demand, production) in enumerate(zip(demand_np, production_np)):
-
+        cap_of_battery = battery_model.soc * max_cap_of_battery
         # these five are modified on the appropriate codepaths:
         consumption_from_solar = 0
         consumption_from_bess = 0
         consumption_from_network = 0
         discarded_production = 0
+        network_used_to_charge = 0
 
         unsatisfied_demand = demand
         remaining_production = production
         
-        if parameters.bess_present:
-            is_battery_charged_enough = battery_model.soc > 0
-            is_battery_chargeable = battery_model.soc < 1.0
-        else:
-            is_battery_charged_enough = battery_model.soc <= 0
-            is_battery_chargeable = battery_model.soc >= 1.0
+        assert parameters.bess_present
+        is_battery_charged_enough = battery_model.soc > 0
+        is_battery_chargeable = battery_model.soc < 1.0
+
+        prod_prediction = prod_predictor.predict(i, decider.input_window_size)
+        cons_prediction = cons_predictor.predict(i, decider.input_window_size)
+        decision = decider.decide(prod_prediction, cons_prediction, battery_model)
 
+        production_used_to_charge = 0
         if unsatisfied_demand >= remaining_production:
             # all goes to demand
             consumption_from_solar = remaining_production
             unsatisfied_demand -= consumption_from_solar
             remaining_production = 0
             # we try to cover the rest from BESS
-            if (unsatisfied_demand > 0 ) and parameters.bess_present:
-                if is_battery_charged_enough:
+            if unsatisfied_demand > 0:
+                if is_battery_charged_enough and decision == Decision.DISCHARGE:
                     # battery capacity is limited!
-                    if cap_of_battery >= unsatisfied_demand * time_interval :
+                    if cap_of_battery >= unsatisfied_demand * time_interval:
                         consumption_from_bess = unsatisfied_demand
                         unsatisfied_demand = 0
                         cap_of_battery -= consumption_from_bess * time_interval
@@ -185,14 +193,16 @@ def simulator(battery_model, supplier, prod_cons, decider, parameters):
             consumption_from_solar = unsatisfied_demand
             remaining_production -= unsatisfied_demand
             unsatisfied_demand = 0
-            if (remaining_production > 0) and parameters.bess_present:
+            if remaining_production > 0:
                 # exploitable production still remains:
                 if is_battery_chargeable:
                     # we try to specify the BESS modell
                     if parameters.bess_charge <= remaining_production :
                         energy = parameters.bess_charge * time_interval
                         remaining_production = remaining_production - parameters.bess_charge
+                        production_used_to_charge = parameters.bess_charge
                     else :
+                        production_used_to_charge = remaining_production
                         energy = remaining_production * time_interval
                         remaining_production = 0
                     cap_of_battery += energy
@@ -200,9 +210,30 @@ def simulator(battery_model, supplier, prod_cons, decider, parameters):
 
         discarded_production = remaining_production
 
+        if decision == Decision.NETWORK_CHARGE:
+            # there are two things that can limit charging at this point,
+            # one is a distance-like, the other is a velocity-like quantity.
+            # 1. the battery is fully charged
+            # 2. the battery is being charged from solar, no bandwidth left.
+            is_battery_chargeable = battery_model.soc < 1.0
+            remaining_network_charge = parameters.bess_charge - production_used_to_charge
+            if is_battery_chargeable:
+                # we try to specify the BESS modell
+                if parameters.bess_charge <= remaining_network_charge :
+                    energy = parameters.bess_charge * time_interval
+                    remaining_network_charge = remaining_network_charge - parameters.bess_charge
+                    network_used_to_charge = parameters.bess_charge
+                else :
+                    network_used_to_charge = remaining_production
+                    energy = remaining_production * time_interval
+                cap_of_battery += energy
+                soc = cap_of_battery / max_cap_of_battery
+            consumption_from_network += network_used_to_charge
+
         soc_series.append(battery_model.soc)
         consumption_from_solar_series.append(consumption_from_solar)
         consumption_from_network_series.append(consumption_from_network)
+        consumption_from_network_to_bess_series.append(network_used_to_charge)
         consumption_from_bess_series.append(consumption_from_bess)
         discarded_production_series.append(discarded_production)
 
@@ -215,11 +246,12 @@ def simulator(battery_model, supplier, prod_cons, decider, parameters):
     results = pd.DataFrame({'soc_series': soc_series, 'consumption_from_solar': consumption_from_solar_series,
                             'consumption_from_network': consumption_from_network_series,
                             'consumption_from_bess': consumption_from_bess_series,
+                            'consumption_from_network_to_bess_series': consumption_from_network_to_bess_series,
                             'discarded_production': discarded_production_series,
-                            'Consumption': all_data['Consumption'],
-                            'Production': all_data['Production']
+                            'Consumption': prod_cons['Consumption'],
+                            'Production': prod_cons['Production']
                             })
-    results = results.set_index(all_data.index)
+    results = results.set_index(prod_cons.index)
     return results
 
 
@@ -235,9 +267,12 @@ def main():
     add_production_field(met_2021_data, parameters)
     all_2021_data = interpolate_and_join(met_2021_data, cons_2021_data)
 
+    prod_predictor = DummyPredictor(pd.Series(all_2021_data['Production']))
+    cons_predictor = DummyPredictor(pd.Series(all_2021_data['Consumption']))
+
     decider = Decider()
 
-    results = simulator(battery_model, supplier, all_2021_data, decider, parameters)
+    results = simulator(battery_model, supplier, all_2021_data, prod_predictor, cons_predictor, decider, parameters)
 
 
 if __name__ == '__main__':