Feat: Support shared storage (multi‑feed stock)

flexmeasures/data/models/planning/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections import defaultdict
 from collections.abc import Iterable
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
@@ -52,6 +53,7 @@ class Scheduler:
 
     flex_model: list[dict] | dict | None = None
     flex_context: dict | None = None
+    stock_groups: dict | None = None
 
     fallback_scheduler_class: "Type[Scheduler] | None" = None
     info: dict | None = None
@@ -64,6 +66,41 @@ class Scheduler:
 
     return_multiple: bool = False
 
+    @staticmethod
+    def _build_stock_groups(flex_model: list[dict]) -> dict:
+        """
+        Build stock groups where devices sharing the same state-of-charge sensor are grouped together.
+        """
+        groups = defaultdict(list)
+        soc_usage = defaultdict(list)
+
+        for d, fm in enumerate(flex_model):
+            if fm.get("sensor") is None:
+                continue
+
+            soc = fm.get("state_of_charge")
+            if soc is not None:
+                if hasattr(soc, "id"):
+                    soc_id = soc.id
+                elif isinstance(soc, dict) and "sensor" in soc:
+                    sensor = soc["sensor"]
+                    soc_id = sensor.id if hasattr(sensor, "id") else sensor
+                else:
+                    soc_id = soc
+
+                soc_usage[soc_id].append(d)
+
+        for soc_id, device_list in soc_usage.items():
+            groups[soc_id] = device_list
+
+        missing_soc_sensor_i = -len(flex_model)
+        for d, fm in enumerate(flex_model):
+            if fm.get("sensor") is not None and fm.get("state_of_charge") is None:
+                groups[missing_soc_sensor_i].append(d)
+                missing_soc_sensor_i += 1
+
+        return dict(groups)
+
     def __init__(
         self,
         sensor: Sensor | None = None,  # deprecated
@@ -202,12 +239,19 @@ def collect_flex_config(self):
             # Listify the flex-model for the next code block, which actually does the merging with the db_flex_model
             flex_model = [flex_model]
 
+        # Find which asset is relevant for a given device model in the flex-model from the trigger message
         for flex_model_d in flex_model:
             asset_id = flex_model_d.get("asset")
             if asset_id is None:
-                sensor_id = flex_model_d["sensor"]
-                sensor = db.session.get(Sensor, sensor_id)
-                asset_id = sensor.asset_id
+                sensor_id = flex_model_d.get("sensor")
+                if sensor_id is not None:
+                    sensor = db.session.get(Sensor, sensor_id)
+                    asset_id = sensor.asset_id
+                else:
+                    soc_sensor_ref = flex_model_d.get("state-of-charge")
+                    if soc_sensor_ref is not None:
+                        soc_sensor = db.session.get(Sensor, soc_sensor_ref["sensor"])
+                        asset_id = soc_sensor.asset_id
             if asset_id in db_flex_model:
                 flex_model_d = {**db_flex_model[asset_id], **flex_model_d}
             amended_flex_model.append(flex_model_d)

flexmeasures/data/models/planning/linear_optimization.py

@@ -41,6 +41,7 @@ def device_scheduler(  # noqa C901
     commitment_upwards_deviation_price: list[pd.Series] | list[float] | None = None,
     commitments: list[pd.DataFrame] | list[Commitment] | None = None,
     initial_stock: float | list[float] = 0,
+    stock_groups: dict[int, list[int]] | None = None,
 ) -> tuple[list[pd.Series], float, SolverResults, ConcreteModel]:
     """This generic device scheduler is able to handle an EMS with multiple devices,
     with various types of constraints on the EMS level and on the device level,
@@ -100,6 +101,22 @@ def device_scheduler(  # noqa C901
     resolution = pd.to_timedelta(device_constraints[0].index.freq).to_pytimedelta()
     end = device_constraints[0].index.to_pydatetime()[-1] + resolution
 
+    # map device → stock group
+    device_to_group = {}
+
+    if stock_groups:
+        for g, devices in stock_groups.items():
+            for d in devices:
+                device_to_group[d] = g
+        # For devices not in any stock group (e.g., inflexible devices),
+        # map them to themselves so they're treated as individual groups
+        for d in range(len(device_constraints)):
+            if d not in device_to_group:
+                device_to_group[d] = d
+    else:
+        for d in range(len(device_constraints)):
+            device_to_group[d] = d
+
     # Move commitments from old structure to new
     if commitments is None:
         commitments = []
@@ -484,33 +501,77 @@ def grouped_commitment_equalities(m, c, j, g):
     )
     model.commitment_sign = Var(model.c, domain=Binary, initialize=0)
 
+    # def _get_stock_change(m, d, j):
+    #     """Determine final stock change of device d until time j.
+    #
+    #     Apply conversion efficiencies to conversion from flow to stock change and vice versa,
+    #     and apply storage efficiencies to stock levels from one datetime to the next.
+    #     """
+    #     if isinstance(initial_stock, list):
+    #         # No initial stock defined for inflexible device
+    #         initial_stock_d = initial_stock[d] if d < len(initial_stock) else 0
+    #     else:
+    #         initial_stock_d = initial_stock
+    #
+    #     stock_changes = [
+    #         (
+    #             m.device_power_down[d, k] / m.device_derivative_down_efficiency[d, k]
+    #             + m.device_power_up[d, k] * m.device_derivative_up_efficiency[d, k]
+    #             + m.stock_delta[d, k]
+    #         )
+    #         for k in range(0, j + 1)
+    #     ]
+    #     efficiencies = [m.device_efficiency[d, k] for k in range(0, j + 1)]
+    #     final_stock_change = [
+    #         stock - initial_stock_d
+    #         for stock in apply_stock_changes_and_losses(
+    #             initial_stock_d, stock_changes, efficiencies
+    #         )
+    #     ][-1]
+    #     return final_stock_change
+
     def _get_stock_change(m, d, j):
-        """Determine final stock change of device d until time j.
 
-        Apply conversion efficiencies to conversion from flow to stock change and vice versa,
-        and apply storage efficiencies to stock levels from one datetime to the next.
-        """
+        # determine the stock group of this device
+        group = device_to_group[d]
+
+        # all devices belonging to this stock
+        devices = [dev for dev, g in device_to_group.items() if g == group]
+
+        # initial stock
         if isinstance(initial_stock, list):
-            # No initial stock defined for inflexible device
-            initial_stock_d = initial_stock[d] if d < len(initial_stock) else 0
+            initial_stock_g = initial_stock[d] if d < len(initial_stock) else 0
         else:
-            initial_stock_d = initial_stock
+            initial_stock_g = initial_stock
+
+        stock_changes = []
+
+        for k in range(0, j + 1):
+
+            change = 0
+
+            for dev in devices:
+                change += (
+                    m.device_power_down[dev, k]
+                    / m.device_derivative_down_efficiency[dev, k]
+                    + m.device_power_up[dev, k]
+                    * m.device_derivative_up_efficiency[dev, k]
+                    + m.stock_delta[dev, k]
+                )
+
+            stock_changes.append(change)
 
-        stock_changes = [
-            (
-                m.device_power_down[d, k] / m.device_derivative_down_efficiency[d, k]
-                + m.device_power_up[d, k] * m.device_derivative_up_efficiency[d, k]
-                + m.stock_delta[d, k]
-            )
-            for k in range(0, j + 1)
-        ]
         efficiencies = [m.device_efficiency[d, k] for k in range(0, j + 1)]
+
         final_stock_change = [
-            stock - initial_stock_d
+            stock - initial_stock_g
             for stock in apply_stock_changes_and_losses(
-                initial_stock_d, stock_changes, efficiencies
+                initial_stock_g,
+                stock_changes,
+                efficiencies,
             )
         ][-1]
+
         return final_stock_change
 
     # Add constraints as a tuple of (lower bound, value, upper bound)