feature: add command flexmeasures add schedule for-process

documentation/api/notation.rst

@@ -202,13 +202,13 @@ Here are the three types of flexibility models you can expect to be built-in:
 
    For some examples, see the `[POST] /sensors/(id)/schedules/trigger <../api/v3_0.html#post--api-v3_0-sensors-(id)-schedules-trigger>`_ endpoint docs.
 
-2) For **shiftable processes**
+2) For **processes**
 
     - ``power``: nominal power of the load.
     - ``duration``: time that the load last.
     - ``optimization_sense``: objective of the scheduler, to maximize or minimize.
     - ``time_restrictions``: time periods in which the load cannot be schedule to.
-    - ``load_type``: Inflexible, Breakable or Shiftable.
+    - ``process_type``: INFLEXIBLE, BREAKABLE or SHIFTABLE.
 
 
 3) For **buffer devices** (e.g. thermal energy storage systems connected to heat pumps), use the same flexibility parameters described above for storage devices. Here are some tips to model a buffer with these parameters:

documentation/changelog.rst

@@ -17,7 +17,7 @@ New features
 * DataSource table now allows storing arbitrary attributes as a JSON (without content validation), similar to the Sensor and GenericAsset tables [see `PR #750 <https://www.github.com/FlexMeasures/flexmeasures/pull/750>`_]
 * Added API endpoint `/sensor/<id>` for fetching a single sensor. [see `PR #759 <https://www.github.com/FlexMeasures/flexmeasures/pull/759>`_]
 * The CLI now allows to set lists and dicts as asset & sensor attributes (formerly only single values) [see `PR #762 <https://www.github.com/FlexMeasures/flexmeasures/pull/762>`_]
-* Add `ProcessScheduler` class and CLI command `flexmeasures add schedule for-process` to optimize the starting time of processes one of the following policies: inflexible, shiftable and breakable [see `PR #729 <https://www.github.com/FlexMeasures/flexmeasures/pull/729>`_ and `PR #768 <https://www.github.com/FlexMeasures/flexmeasures/pull/768>`_]
+* Add `ProcessScheduler` class to optimize the starting time of processes one of the policies developed (INFLEXIBLE, SHIFTABLE and BREAKABLE), accessible via the CLI command `flexmeasures add schedule for-process`  [see `PR #729 <https://www.github.com/FlexMeasures/flexmeasures/pull/729>`_ and `PR #768 <https://www.github.com/FlexMeasures/flexmeasures/pull/768>`_]
 
 Bugfixes
 -----------

flexmeasures/cli/data_add.py

@@ -1271,11 +1271,13 @@ def add_schedule_process(
             "power": process_power,
             "time-restrictions": [TimeIntervalSchema().dump(f) for f in forbid],
         },
-        flex_context={
-            "consumption-price-sensor": consumption_price_sensor.id,
-        },
     )
 
+    if consumption_price_sensor is not None:
+        scheduling_kwargs["flex_context"] = {
+            "consumption-price-sensor": consumption_price_sensor.id,
+        }
+
     if as_job:
         job = create_scheduling_job(sensor=power_sensor, **scheduling_kwargs)
         if job:

flexmeasures/cli/tests/conftest.py

@@ -2,11 +2,14 @@
 
 from datetime import datetime, timedelta
 from pytz import utc
+import pandas as pd
 
 from flexmeasures.data.models.data_sources import DataSource
 from flexmeasures.data.models.generic_assets import GenericAsset, GenericAssetType
 from flexmeasures.data.models.time_series import Sensor, TimedBelief
 
+from flexmeasures.data.models.planning.utils import initialize_index
+
 
 @pytest.fixture(scope="module")
 @pytest.mark.skip_github
@@ -100,32 +103,50 @@ def reporter_config_raw(app, db, setup_dummy_data):
 
 @pytest.mark.skip_github
 @pytest.fixture(scope="module")
-def process_power_sensor(db, app):
+def process_power_sensor(db, app, setup_markets, setup_sources):
     """
-    Create an asset of type "ProcessType" and a power sensor to hold the result of
-    the scheduler.
+    Create an asset of type "process", power sensor to hold the result of
+    the scheduler and price data consisting of 8 expensive hours, 8 cheap hours, and again 8 expensive hours-
 
     """
 
     process_asset_type = GenericAssetType(name="process")
 
     db.session.add(process_asset_type)
 
-    processasset = GenericAsset(
-        name="Test Asset", generic_asset_type=process_asset_type
+    process_asset = GenericAsset(
+        name="Test Process Asset", generic_asset_type=process_asset_type
     )
 
-    db.session.add(processasset)
+    db.session.add(process_asset)
 
     power_sensor = Sensor(
         "power",
-        generic_asset=processasset,
+        generic_asset=process_asset,
         event_resolution=timedelta(hours=1),
         unit="MW",
     )
 
     db.session.add(power_sensor)
 
+    time_slots = initialize_index(
+        start=pd.Timestamp("2015-01-02").tz_localize("Europe/Amsterdam"),
+        end=pd.Timestamp("2015-01-03").tz_localize("Europe/Amsterdam"),
+        resolution="1H",
+    )
+    values = [100] * 8 + [90] * 8 + [100] * 8
+    beliefs = [
+        TimedBelief(
+            event_start=dt,
+            belief_horizon=timedelta(hours=0),
+            event_value=val,
+            source=setup_sources["Seita"],
+            sensor=setup_markets["epex_da"].corresponding_sensor,
+        )
+        for dt, val in zip(time_slots, values)
+    ]
+    db.session.add_all(beliefs)
+
     db.session.commit()
 
     yield power_sensor.id

flexmeasures/cli/tests/test_data_add.py

@@ -215,10 +215,10 @@ def test_add_reporter(app, db, setup_dummy_data, reporter_config_raw):
 
 @pytest.mark.skip_github
 @pytest.mark.parametrize("process_type", [("INFLEXIBLE"), ("SHIFTABLE"), ("BREAKABLE")])
-def test_add_process(app, db, process_power_sensor, add_market_prices, process_type):
+def test_add_process(app, db, process_power_sensor, process_type):
     """
     Schedule a 4h of consumption block at a constant power of 400kW in a day using
-    the three process policies: inflexible, shiftable and breakable.
+    the three process policies: INFLEXIBLE, SHIFTABLE and BREAKABLE.
     """
 
     from flexmeasures.cli.data_add import add_schedule_process

flexmeasures/data/models/planning/process.py

@@ -24,16 +24,16 @@ class ProcessScheduler(Scheduler):
     __author__ = "Seita"
 
     def compute(self) -> pd.Series | None:
-        """Schedule a prrocess, defined as a `power` and a `duration`, within the specified time window.
+        """Schedule a process, defined as a `power` and a `duration`, within the specified time window.
         To schedule a battery, please, refer to the StorageScheduler.
 
-        For example, this scheduler can plan the start of a process of type `Shiftable` that lasts 5h and requires a power of 10kW.
+        For example, this scheduler can plan the start of a process of type `SHIFTABLE` that lasts 5h and requires a power of 10kW.
         In that case, the scheduler will find the best (as to minimize/maximize the cost) hour to start the process.
 
         This scheduler supports three types of `process_types`:
-            - Inflexible: this process needs to be scheduled as soon as possible.
-            - Breakable: this process can be divisible in smaller consumption periods.
-            - Shiftable: this process can start at any time within the specified time window.
+            - INFLEXIBLE: this process needs to be scheduled as soon as possible.
+            - BREAKABLE: this process can be divisible in smaller consumption periods.
+            - SHIFTABLE: this process can start at any time within the specified time window.
 
         The resulting schedule provides the power flow at each time period.
 
@@ -45,9 +45,9 @@ def compute(self) -> pd.Series | None:
         power: nominal power of the process.
         duration: time that the process last.
 
-        optimization_sense: objective of the scheduler, to maximize or minimize.
+        optimization_direction: objective of the scheduler, to maximize or minimize.
         time_restrictions: time periods in which the process cannot be schedule to.
-        process_type: Inflexible, Breakable or Shiftable.
+        process_type: INFLEXIBLE, BREAKABLE or SHIFTABLE.
 
         :returns:               The computed schedule.
         """
@@ -66,7 +66,7 @@ def compute(self) -> pd.Series | None:
         )
         duration: timedelta = self.flex_model.get("duration")
         power = self.flex_model.get("power")
-        optimization_sense = self.flex_model.get("optimization_sense")
+        optimization_direction = self.flex_model.get("optimization_direction")
         process_type: ProcessType = self.flex_model.get("process_type")
         time_restrictions = self.flex_model.get("time_restrictions")
 
@@ -125,7 +125,7 @@ def compute(self) -> pd.Series | None:
         elif process_type == ProcessType.BREAKABLE:
             self.compute_breakable(
                 schedule,
-                optimization_sense,
+                optimization_direction,
                 time_restrictions,
                 cost,
                 rows_to_fill,
@@ -134,7 +134,7 @@ def compute(self) -> pd.Series | None:
         elif process_type == ProcessType.SHIFTABLE:
             self.compute_shiftable(
                 schedule,
-                optimization_sense,
+                optimization_direction,
                 start_time_restrictions,
                 cost,
                 rows_to_fill,
@@ -207,16 +207,16 @@ def compute_inflexible(
     def compute_breakable(
         self,
         schedule: pd.Series,
-        optimization_sense: OptimizationSense,
+        optimization_direction: OptimizationSense,
         time_restrictions: pd.Series,
         cost: pd.DataFrame,
         rows_to_fill: int,
         energy: float,
     ) -> None:
-        """Break up schedule and divide it over the time slots with the largest utility (max/min cost depending on optimization_sense)."""
+        """Break up schedule and divide it over the time slots with the largest utility (max/min cost depending on optimization_direction)."""
         cost = cost[~time_restrictions].reset_index()
 
-        if optimization_sense == OptimizationSense.MIN:
+        if optimization_direction == OptimizationSense.MIN:
             cost_ranking = cost.sort_values(
                 by=["event_value", "event_start"], ascending=[True, True]
             )
@@ -230,7 +230,7 @@ def compute_breakable(
     def compute_shiftable(
         self,
         schedule: pd.Series,
-        optimization_sense: OptimizationSense,
+        optimization_direction: OptimizationSense,
         time_restrictions: pd.Series,
         cost: pd.DataFrame,
         rows_to_fill: int,
@@ -241,7 +241,7 @@ def compute_shiftable(
             cost.rolling(rows_to_fill).sum().shift(-rows_to_fill + 1)
         )
 
-        if optimization_sense == OptimizationSense.MIN:
+        if optimization_direction == OptimizationSense.MIN:
             start = block_cost[~time_restrictions].idxmin()
         else:
             start = block_cost[~time_restrictions].idxmax()

flexmeasures/data/models/planning/tests/test_process.py

@@ -16,7 +16,7 @@
     "process_type, optimal_start",
     [("INFLEXIBLE", datetime(2015, 1, 2, 0)), ("SHIFTABLE", datetime(2015, 1, 2, 8))],
 )
-def test_processscheduler(add_battery_assets, process, process_type, optimal_start):
+def test_process_scheduler(add_battery_assets, process, process_type, optimal_start):
     """
     Test scheduling a process of 4kW of power that last 4h using the ProcessScheduler
     without time restrictions.
@@ -94,7 +94,7 @@ def test_duration_exceeds_planning_window(
     assert (schedule == 4).all()
 
 
-def test_processscheduler_time_restrictions(add_battery_assets, process):
+def test_process_scheduler_time_restrictions(add_battery_assets, process):
     """
     Test ProcessScheduler with a time restrictions consisting of a block of 2h starting
     at 8am. The resulting schedules avoid the 8am-10am period and schedules for a valid period.
@@ -145,7 +145,7 @@ def test_processscheduler_time_restrictions(add_battery_assets, process):
 
 def test_breakable_scheduler_time_restrictions(add_battery_assets, process):
     """
-    Test breakable process_type of ProcessScheduler by introducing four 1-hour restrictions
+    Test BREAKABLE process_type of ProcessScheduler by introducing four 1-hour restrictions
     interspaced by 1 hour. The equivalent mask would be the following: [0,...,0,1,0,1,0,1,0,1,0, ...,0].
     Trying to get the best prices (between 9am and 4pm), his makes the schedule choose time periods between
     the time restrictions.

flexmeasures/data/schemas/scheduling/process.py

@@ -48,7 +48,7 @@ class ProcessSchedulerFlexModelSchema(Schema):
         load_default=[],
     )
     # objective of the scheduler, to maximize or minimize.
-    optimization_sense = fields.Enum(
+    optimization_direction = fields.Enum(
         OptimizationSense,
         load_default=OptimizationSense.MIN,
         data_key="optimization-sense",