rtc-tools-interface 0.10.2a2__tar.gz → 0.10.2a4__tar.gz

rtc_tools_interface-0.10.2a4/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: rtc_tools_interface
+Version: 0.10.2a4
+Summary: Toolbox for user interfaces for RTC-Tools
+Author: Deltares
+Maintainer: Deltares
+Requires-Python: >=3.9
+License-File: COPYING.LESSER
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: plotly
+Requires-Dist: pydantic
+Requires-Dist: casadi!=3.6.6
+Requires-Dist: rtc-tools>=2.7.0a3
+Dynamic: author
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a4}/README.md

@@ -11,8 +11,9 @@ pip install rtc-tools-interface
 ## Table of Contents
 1. [Goal generator](#goal-generator)
 2. [Goal performance metrics](#goal-performance-metrics)
-3. [Automatic plotting of results](#automatic-plotting-of-results)
-4. [Closed loop runner](#closed-loop-runner)
+3. [Active constraint diagnostics](#active-constraint-diagnostics)
+4. [Automatic plotting of results](#automatic-plotting-of-results)
+5. [Closed loop runner](#closed-loop-runner)
 
 ## Goal generator
 The `goal generator` can be used to automatically add goals based on a csv file. Currently, the following goal types are supported:
@@ -91,18 +92,19 @@ by minimizing, if any, the sum of exceedances for the timesteps. For more detail
 
 
 #### range_rate_of_change
-The range_rate_of_change goal can be used to set a target range on ramp rate. Like the range goal, one needs to set the `target_min` and `target_max` for that. **Importantly** for the range_rate_of_change goal, the supplied values are relative to the nominal of the function. So supplying a `target_max` of `10` corresponds to the aim of having a maximum increase per timestep of 10% * `nominal`, where the nominal automatically set to `maximum rate of change`/2 or specified manually. To formulate the target of having a maximum increase and decrease by of 10% per timestep, one would set the `target_min` to `-10` and the `target_max` to `10`.
+The range_rate_of_change goal can be used to set a target range on ramp rate for a model state. Like the range goal, one needs to set the `target_min` and `target_max` for that. **Importantly** for the range_rate_of_change goal, the supplied values are relative to the nominal of the function. So supplying a `target_max` of `10` corresponds to the aim of having a maximum increase per timestep of 10% * `nominal`, where the nominal automatically set to `maximum rate of change`/2 or specified manually. To formulate the target of having a maximum increase and decrease by of 10% per timestep, one would set the `target_min` to `-10` and the `target_max` to `10`.
 
-The equations for the range_rate_of_change goal are almost the same as for the range goal, which can be found above. The only difference is that $x_t$ is replaced by the derivative of $x$ with respect to $t$, calculated as $\frac{x_t - x_{t-1}}{\Delta t}$.  
+The equations for the range_rate_of_change goal are almost the same as for the range goal, which can be found above. The only difference is that $x_t$ is replaced by the derivative of $x$ with respect to $t$, calculated as $\frac{x_t - x_{t-1}}{\Delta t}$. RTC-Tools computes the derivative (the ramp rate) internally for the state variable specified in the goal table. 
 
 ### Example goal table
 See the table below for an example content of the `goal_table.csv`.
 
 | id     | state | active | goal_type    | function_min | function_max | function_nominal | target_data_type | target_min | target_max | priority | weight | order |
 |--------|-------|--------|--------------|--------------|--------------|------------------|------------------|------------|------------|----------|--------|-------|
-| goal_1 | reservoir_1_waterlevel     | 1      | range        | 0            | 15           | 10               | value            | 5.0        | 10.0       | 5       |        |       |
-| goal_2 | reservoir_2_waterlevel     | 1      | range        | 0            | 15           | 10               | timeseries            | "target_series"        | "target_series"       | 10       |        |       |
-| goal_3 | electricity_cost     | 1      | minimization_path |              |              |                  |                  |            |            | 20       |        |       |
+| goal_1 | reservoir_1_waterlevel     | 1      | range        | 0            | 15           | 10               | value            | 5.0        | 10.0       | 5       |    1    |    1   |
+| goal_2 | reservoir_2_waterlevel     | 1      | range        | 0            | 15           | 10               | timeseries            | "target_series"        | "target_series"       | 10       |    1    |   1    |
+| goal_3 | electricity_cost     | 1      | minimization_path |              |              |                  |                  |            |            | 20       |   1     |   1    |
+| goal_4 | reservoir_2_volume | 1 | range_rate_of_change | -100 | 100 | 10 | value | -10 | 10 | 30 | 1 | 1 |  
 
 ## Goal performance metrics
 For all goals defined with the goal generator this rtc-tools-interface module will also calculate performance metrics. By default, these performance metrics are saved to a .csv in the folder `output/perfomance_metrics`, with one csv file per goal. With the class variable `calculate_performance_metrics` this functionality can be disabled (by default it is enabled).
@@ -116,6 +118,23 @@ The calculated metrics are:
 - `mean_absolute_percentual_difference`: The mean of the absolute percentual difference per timestep over all timesteps (only for range goals).
 - `mean_absolute_difference`: The mean absolute difference per timestep of the state variable over all timesteps (only for range goals).
 
+## Active constraint diagnostics
+The `ActiveConstraintMixin` writes diagnostics about active constraints after each RTC-Tools goal-programming priority. A constraint is considered active when its evaluated value hits either its lower or upper bound within `active_constraint_tolerance` (default `1e-6`).
+
+To enable the diagnostics, import the mixin and add it before `BaseOptimizationProblem` or before RTC-Tools' `GoalProgrammingMixin` in the class inheritance order:
+
+```python
+from rtctools_interface.optimization.active_constraint_mixin import ActiveConstraintMixin
+from rtctools_interface.optimization.base_optimization_problem import BaseOptimizationProblem
+
+
+class MyOptimizationProblem(ActiveConstraintMixin, BaseOptimizationProblem):
+    pass
+```
+
+After optimization, the mixin creates `output/active_constraints/active_constraints_of_previous_goals.csv`.
+This file contains detailed rows for active constraints that RTC-Tools created from goals optimized in previous priorities. For each priority with active previous-goal constraints, it reports the total number of previous-goal constraints, how many are active, which bound (`lower`, `upper`, or `both`) was hit, and the corresponding bound value. Path-goal constraints are reported in one row per active path goal; the `active_times` column lists the timesteps at which that path-goal constraint is active.
+
 
 ## Automatic plotting of results
 With the `PlotMixin` one can easily make plots of the results of rtc-tools. This functionality can be used both for optimization and simulation problems. For optimization problems, use:
@@ -255,3 +274,11 @@ Note that this happens for:
 - Currently, only the initial values of the first time step in a given time range are set.
 - The closed_loop runner only works in combination with the CSVMixin or the PIMixin.
     The CDFMixin is not supported.
+
+### Matplotlib in Headless Environments
+
+For CI or servers without a display, set `MPLBACKEND=Agg` to ensure Matplotlib uses a non-interactive backend:
+
+```bash
+export MPLBACKEND=Agg
+```

rtc_tools_interface-0.10.2a4/rtc_tools_interface.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: rtc_tools_interface
+Version: 0.10.2a4
+Summary: Toolbox for user interfaces for RTC-Tools
+Author: Deltares
+Maintainer: Deltares
+Requires-Python: >=3.9
+License-File: COPYING.LESSER
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: plotly
+Requires-Dist: pydantic
+Requires-Dist: casadi!=3.6.6
+Requires-Dist: rtc-tools>=2.7.0a3
+Dynamic: author
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a4}/rtc_tools_interface.egg-info/SOURCES.txt

@@ -17,6 +17,8 @@ rtctools_interface/closed_loop/results_construction.py
 rtctools_interface/closed_loop/runner.py
 rtctools_interface/closed_loop/time_series_handler.py
 rtctools_interface/optimization/__init__.py
+rtctools_interface/optimization/active_constraint_helpers.py
+rtctools_interface/optimization/active_constraint_mixin.py
 rtctools_interface/optimization/base_goal.py
 rtctools_interface/optimization/base_optimization_problem.py
 rtctools_interface/optimization/goal_generator_mixin.py
@@ -42,10 +44,14 @@ rtctools_interface/utils/serialization.py
 rtctools_interface/utils/type_definitions.py
 tests/__init__.py
 tests/closed_loop/__init__.py
+tests/closed_loop/test_combine_xml_exports.py
 tests/closed_loop/test_optimization_ranges.py
 tests/closed_loop/test_read_xml.py
 tests/closed_loop/test_run_optization_problem_closed_loop.py
+tests/closed_loop/test_set_initial_values_from_previous_run.py
 tests/optimization/__init__.py
+tests/optimization/test_active_constraint_helpers.py
+tests/optimization/test_active_constraint_mixin.py
 tests/optimization/test_base_optimization_problem.py
 tests/optimization/test_passing_goals_directly.py
 tests/optimization/test_plot_goals_mixin.py

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a4}/rtctools_interface/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-10-30T09:45:54+0100",
+ "date": "2026-09-17T07:52:27+0200",
  "dirty": false,
  "error": null,
- "full-revisionid": "dcc43a518f9d2672d43280e14083500fb85225cb",
- "version": "0.10.2a2"
+ "full-revisionid": "8d59f3b94a76dba915ac4488e060b927d4820acc",
+ "version": "0.10.2a4"
 }
 '''  # END VERSION_JSON
 

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a4}/rtctools_interface/closed_loop/config.py

@@ -1,10 +1,10 @@
 """Module for configuring a closed-loop optimization problem."""
+
 from datetime import timedelta
 from pathlib import Path
-from typing import Optional
 
 
-class ClosedLoopConfig():
+class ClosedLoopConfig:
     """Configuration of a closed-loop optimization problem."""
 
     def __init__(
@@ -30,8 +30,8 @@ class ClosedLoopConfig():
         if file is not None:
             file = Path(file).resolve()
         self._file = file
-        self._forecast_timestep: Optional[timedelta] = None
-        self._optimization_period: Optional[timedelta] = None
+        self._forecast_timestep: timedelta | None = None
+        self._optimization_period: timedelta | None = None
         self.round_to_dates = round_to_dates
 
     @classmethod

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a4}/rtctools_interface/closed_loop/optimization_ranges.py

@@ -1,4 +1,5 @@
 """Module for calculating optimization periods."""
+
 import bisect
 import datetime
 from pathlib import Path
@@ -12,30 +13,40 @@ def get_optimization_ranges_from_file(
     """Read horizon config from a csv file"""
     if not file_path.exists():
         raise FileNotFoundError(
-            f"The closed_loop_dates csv does not exist. Please create a horizon config file in {file_path}."
+            "The closed_loop_dates csv does not exist. Please create a horizon "
+            f"config file in {file_path}."
         )
     try:
         closed_loop_dates = pd.read_csv(file_path)
     except pd.errors.EmptyDataError:
         raise ValueError(
-            "The closed_loop_dates csv is empty. Please provide a valid file with start_date and end_date column."
+            "The closed_loop_dates csv is empty. Please provide a valid file with "
+            "start_date and end_date column."
         )
     closed_loop_dates.columns = closed_loop_dates.columns.str.replace(" ", "")
-    if not all([col in closed_loop_dates.columns for col in ["start_date", "end_date"]]):
-        raise ValueError("The closed_loop_dates csv should have both 'start_date' and 'end_date' columns.")
+    if not all(col in closed_loop_dates.columns for col in ["start_date", "end_date"]):
+        raise ValueError(
+            "The closed_loop_dates csv should have both 'start_date' and 'end_date' columns."
+        )
     closed_loop_dates["start_date"] = pd.to_datetime(closed_loop_dates["start_date"])
     closed_loop_dates["end_date"] = pd.to_datetime(closed_loop_dates["end_date"])
     for i in range(1, len(closed_loop_dates)):
         if closed_loop_dates["start_date"].iloc[i] > closed_loop_dates["end_date"].iloc[i - 1]:
-            raise ValueError(f"Closed loop date table: Start date at row {i} is later than the previous end date. ")
+            raise ValueError(
+                f"Closed loop date table: Start date at row {i} is later than previous end date."
+            )
     if any(closed_loop_dates["start_date"] < closed_loop_dates["start_date"].shift(1)):
         raise ValueError("Closed loop date table: The start dates are not in ascending order.")
     if any(closed_loop_dates["end_date"] < closed_loop_dates["end_date"].shift(1)):
         raise ValueError("Closed loop date table: The end dates are not in ascending order.")
     if any(closed_loop_dates["end_date"] < closed_loop_dates["start_date"]):
-        raise ValueError("Closed loop date table: For one or more rows the end date is before the start date.")
+        raise ValueError(
+            "Closed loop date table: For one or more rows the end date is before the start date."
+        )
     if any(closed_loop_dates["start_date"] > closed_loop_dates["end_date"]):
-        raise ValueError("Closed loop date table: For one or more rows the start date is after the end date.")
+        raise ValueError(
+            "Closed loop date table: For one or more rows the start date is after the end date."
+        )
     if (
         any(closed_loop_dates["start_date"].dt.hour != 0)
         or any(closed_loop_dates["start_date"].dt.minute != 0)
@@ -43,17 +54,14 @@ def get_optimization_ranges_from_file(
         or any(closed_loop_dates["end_date"].dt.minute != 0)
     ):
         raise ValueError(
-            "Closed loop date table: Currently, the date ranges can only be specific up to the level of days."
+            "Closed loop date table: Currently, the date ranges can only be specific "
+            "up to the level of days."
         )
-    assert (
-        min(closed_loop_dates["start_date"]).date() == model_time_range[0].date()
-    ), (
+    assert min(closed_loop_dates["start_date"]).date() == model_time_range[0].date(), (
         "The start day of the first optimization run is not equal"
         " to the start day of the forecast date (or first timestep)."
     )
-    assert (
-        max(closed_loop_dates["end_date"]).date() <= model_time_range[1].date()
-    ), (
+    assert max(closed_loop_dates["end_date"]).date() <= model_time_range[1].date(), (
         "The end date of one or more optimization runs is later"
         " than the end date of the timeseries import."
     )
@@ -65,9 +73,7 @@ def get_optimization_ranges_from_file(
 
 
 def _get_next_time_index(
-    times: list[datetime.date],
-    i_current: int,
-    timestep_size: datetime.timedelta
+    times: list[datetime.date], i_current: int, timestep_size: datetime.timedelta
 ) -> int:
     """
     Get the next timestep index.
@@ -91,7 +97,7 @@ def get_optimization_ranges(
     model_times: list[datetime.date],
     start_time: datetime.datetime,
     forecast_timestep: datetime.timedelta,
-    optimization_period: datetime.timedelta
+    optimization_period: datetime.timedelta,
 ) -> list[tuple[datetime.datetime, datetime.datetime]]:
     """Calculate a list of optimization periods."""
     if forecast_timestep > optimization_period:
@@ -114,7 +120,7 @@ def get_optimization_ranges(
 
 
 def round_datetime_ranges_to_days(
-    datetime_ranges: list[tuple[datetime.datetime, datetime.datetime]]
+    datetime_ranges: list[tuple[datetime.datetime, datetime.datetime]],
 ) -> list[tuple[datetime.datetime, datetime.datetime]]:
     """Round datetimes to dats in datetime ranges.
 

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a4}/rtctools_interface/closed_loop/results_construction.py

@@ -2,10 +2,9 @@ import copy
 import logging
 import os
 from pathlib import Path
-from typing import List
+
 import pandas as pd
-from rtctools.data import rtc
-from rtctools.data import pi
+from rtctools.data import pi, rtc
 
 logger = logging.getLogger("rtctools")
 
@@ -22,7 +21,9 @@ def _get_variables_from_pi(data_config: rtc.DataConfig, timeseries: pi.Timeserie
     return variables
 
 
-def combine_xml_exports(output_base_path: Path, original_input_timeseries_path: Path, write_csv_out: bool = False):
+def combine_xml_exports(
+    output_base_path: Path, original_input_timeseries_path: Path, write_csv_out: bool = False
+):
     """Combine the xml exports of multiple periods into a single xml file."""
     logger.info("Combining XML exports.")
     dataconfig = rtc.DataConfig(folder=original_input_timeseries_path)
@@ -34,14 +35,22 @@ def combine_xml_exports(output_base_path: Path, original_input_timeseries_path:
         binary=False,
     )
     if ts_import_orig.forecast_datetime > ts_import_orig.start_datetime:
-        logger.info("Timeseries export will start at original forecast date, disregarding data before forecast date.")
+        logger.info(
+            "Timeseries export will start at original forecast date, disregarding data before"
+            " forecast date."
+        )
         ts_import_orig.resize(ts_import_orig.forecast_datetime, ts_import_orig.end_datetime)
-        ts_import_orig.times = ts_import_orig.times[ts_import_orig.times.index(ts_import_orig.forecast_datetime):]
+        ts_import_orig.times = ts_import_orig.times[
+            ts_import_orig.times.index(ts_import_orig.forecast_datetime) :
+        ]
     orig_start_datetime = ts_import_orig.start_datetime
     orig_end_datetime = ts_import_orig.end_datetime
 
     ts_export = pi.Timeseries(
-        data_config=dataconfig, folder=output_base_path / "period_0", basename="timeseries_export", binary=False
+        data_config=dataconfig,
+        folder=output_base_path / "period_0",
+        basename="timeseries_export",
+        binary=False,
     )  # Use the first timeseries export as a starting point for the combined timeseries export.
     ts_export.resize(orig_start_datetime, orig_end_datetime)
 
@@ -58,26 +67,32 @@ def combine_xml_exports(output_base_path: Path, original_input_timeseries_path:
         all_times = ts_import_orig.times  # Workaround to map indices to times, as ts_export does
         # not contain all times. TODO Check whether the assumption that these times map to
         # the correct indices for ts_export always holds.
+        new_times = ts_export_step.times
+        if len(new_times) <= 1:
+            logger.debug(f"Skipping model horizon {i}: only a single timestep was exported.")
+            i += 1
+            continue
+        try:
+            start_new_data_index = all_times.index(new_times[1])
+        except ValueError:
+            if all_times[-1] + ts_export.dt == new_times[0]:
+                start_new_data_index = len(all_times)
+            else:
+                raise ValueError(
+                    "Could not match the start data of the timeseries export file "
+                    + "with the end of the previous."
+                )
         for loc_par in variables:
             try:
                 current_values = ts_export.get(loc_par)
                 new_values = ts_export_step.get(loc_par)
             except KeyError:
-                logger.debug("Variable {} not found in output of model horizon: {}".format(loc_par, i))
+                logger.debug(f"Variable {loc_par} not found in output of model horizon: {i}")
                 continue
-            new_times = ts_export_step.times
-            try:
-                start_new_data_index = all_times.index(new_times[0])
-            except ValueError:
-                if all_times[-1] + ts_export.dt == new_times[0]:
-                    start_new_data_index = len(all_times)
-                else:
-                    raise ValueError(
-                        "Could not match the start data of the timeseries export file "
-                        + "with the end of the previous."
-                    )
             combined_values = copy.deepcopy(current_values)
-            combined_values[start_new_data_index : start_new_data_index + len(new_values)] = new_values  # noqa
+            combined_values[start_new_data_index : start_new_data_index + len(new_values[1:])] = (
+                new_values[1:]
+            )  # noqa
             ts_export.set(loc_par, combined_values)
         i += 1
     ts_export.write(output_folder=output_base_path.parent, output_filename="timeseries_export")
@@ -90,16 +105,16 @@ def combine_xml_exports(output_base_path: Path, original_input_timeseries_path:
                 values = ts_export.get(timeseries_id)
                 new_columns.append(pd.Series(values, name=timeseries_id))
             except KeyError:
-                logger.debug("Variable {} not found in output of model horizon: {}".format(timeseries_id, i))
+                logger.debug(f"Variable {timeseries_id} not found in output of model horizon: {i}")
                 continue
         data = pd.concat([data] + new_columns, axis=1)
         data.round(6).to_csv(output_base_path.parent / "timeseries_export.csv", index=False)
 
 
-def combine_dataframes(dfs: List[pd.DataFrame], index_col: str = "time"):
+def combine_dataframes(dfs: list[pd.DataFrame], index_col: str = "time"):
     """Combine multiple dataframes with the same index column.
-    The dataframes are combined in the order they are passed, with the last dataframe taking precedence
-    in case of overlapping indices."""
+    The dataframes are combined in the order they are passed, with the last dataframe taking
+    precedence in case of overlapping indices."""
     combined_df = pd.DataFrame()
     for df in dfs:
         df.set_index(index_col, inplace=True)
@@ -125,5 +140,7 @@ if __name__ == "__main__":
     output_base_path = closed_loop_test_folder / Path(
         r"test_models\goal_programming_xml\output\output_modelling_periods_reference"
     )
-    original_input_timeseries_path = closed_loop_test_folder / Path(r"test_models\goal_programming_xml\input")
+    original_input_timeseries_path = closed_loop_test_folder / Path(
+        r"test_models\goal_programming_xml\input"
+    )
     combine_xml_exports(output_base_path, original_input_timeseries_path, True)

{rtc_tools_interface-0.10.2a2 → rtc_tools_interface-0.10.2a4}/rtctools_interface/closed_loop/runner.py

@@ -6,28 +6,38 @@ import os
 import shutil
 import sys
 from pathlib import Path
-from typing import List, Optional
 
 from rtctools.data.pi import DiagHandler
-from rtctools.optimization.pi_mixin import PIMixin
 from rtctools.optimization.csv_mixin import CSVMixin
-from rtctools.util import run_optimization_problem, _resolve_folder
-from rtctools_interface.closed_loop.config import ClosedLoopConfig
+from rtctools.optimization.pi_mixin import PIMixin
+from rtctools.util import _resolve_folder, run_optimization_problem
+
 import rtctools_interface.closed_loop.optimization_ranges as opt_ranges
-from rtctools_interface.closed_loop.results_construction import combine_csv_exports, combine_xml_exports
-from rtctools_interface.closed_loop.time_series_handler import XMLTimeSeriesFile, CSVTimeSeriesFile, TimeSeriesHandler
+from rtctools_interface.closed_loop.config import ClosedLoopConfig
+from rtctools_interface.closed_loop.results_construction import (
+    combine_csv_exports,
+    combine_xml_exports,
+)
+from rtctools_interface.closed_loop.time_series_handler import (
+    CSVTimeSeriesFile,
+    TimeSeriesHandler,
+    XMLTimeSeriesFile,
+)
 
 logger = logging.getLogger("rtctools")
 
 
 def set_initial_values_from_previous_run(
-    results_previous_run: Optional[dict],
+    results_previous_run: dict | None,
     timeseries: TimeSeriesHandler,
-    previous_run_datetimes: List[datetime.datetime],
+    previous_run_datetimes: list[datetime.datetime],
 ) -> None:
-    """Modifies the initial values of `timeseries` based on the results of the previous run (if any)"""
+    """Modifies the initial values of `timeseries` based on the results of the previous run
+    (if any)"""
     if results_previous_run is not None:
-        variables_to_set = {key: value for key, value in results_previous_run.items() if not timeseries.is_set(key)}
+        variables_to_set = {
+            key: value for key, value in results_previous_run.items() if not timeseries.is_set(key)
+        }
         if timeseries.forecast_date:
             index_of_initial_value = previous_run_datetimes.index(timeseries.forecast_date)
         else:
@@ -63,7 +73,9 @@ def _get_optimization_ranges(
     """Return a list of optimization periods."""
     if config.file is not None:
         datetime_range = input_timeseries.get_datetime_range()
-        optimization_ranges = opt_ranges.get_optimization_ranges_from_file(config.file, datetime_range)
+        optimization_ranges = opt_ranges.get_optimization_ranges_from_file(
+            config.file, datetime_range
+        )
     elif config.optimization_period is not None:
         datetimes = input_timeseries.get_datetimes()
         optimization_ranges = opt_ranges.get_optimization_ranges(
@@ -73,7 +85,9 @@ def _get_optimization_ranges(
             optimization_period=config.optimization_period,
         )
     else:
-        raise ValueError("The closed-loop configuration should have either a file or optimization_period set.")
+        raise ValueError(
+            "The closed-loop configuration should have either a file or optimization_period set."
+        )
     if config.round_to_dates:
         optimization_ranges = opt_ranges.round_datetime_ranges_to_days(optimization_ranges)
     return optimization_ranges
@@ -84,8 +98,8 @@ def run_optimization_problem_closed_loop(
     base_folder="..",
     log_level=logging.INFO,
     profile=False,
-    config: Optional[ClosedLoopConfig] = None,
-    modelling_period_input_folder: Optional[str] = None,
+    config: ClosedLoopConfig | None = None,
+    modelling_period_input_folder: str | None = None,
     **kwargs,
 ) -> dict:
     """
@@ -111,7 +125,7 @@ def run_optimization_problem_closed_loop(
         handler.setFormatter(formatter)
         logger.addHandler(handler)
     if issubclass(optimization_problem_class, PIMixin):
-        if not any((isinstance(h, DiagHandler) for h in logger.handlers)):
+        if not any(isinstance(h, DiagHandler) for h in logger.handlers):
             diag_handler = DiagHandler(original_output_folder)
             logger.addHandler(diag_handler)
     logger.setLevel(log_level)
@@ -129,11 +143,14 @@ def run_optimization_problem_closed_loop(
     if not fixed_input_config_file.exists():
         raise FileNotFoundError(
             f"Could not find fixed inputs configuration file: {fixed_input_config_file}"
-            "Create a file with a list of strings that represent the fixed inputs (can be an empty list)."
+            "Create a file with a list of strings that represent the fixed inputs"
+            " (can be an empty list)."
         )
-    with open(fixed_input_config_file, "r") as file:
+    with open(fixed_input_config_file) as file:
         fixed_input_series = json.load(file)
-    if not isinstance(fixed_input_series, list) and all(isinstance(item, str) for item in fixed_input_series):
+    if not isinstance(fixed_input_series, list) and all(
+        isinstance(item, str) for item in fixed_input_series
+    ):
         raise ValueError("Fixed input config file should be a list of strings (or an empty list).")
 
     if modelling_period_input_folder is None:
@@ -157,44 +174,78 @@ def run_optimization_problem_closed_loop(
 
         timeseries_import.select_time_range(start_date=start_time, end_date=end_time)
 
-        set_initial_values_from_previous_run(results_previous_run, timeseries_import, previous_run_datetimes)
+        set_initial_values_from_previous_run(
+            results_previous_run, timeseries_import, previous_run_datetimes
+        )
 
         modelling_period_name = f"period_{i}"
         modelling_period_output_folder_i = modelling_periods_output_folder / modelling_period_name
         modelling_period_output_folder_i.mkdir(exist_ok=True)
         modelling_period_input_folder_i = modelling_period_input_folder / modelling_period_name
-        write_input_folder(modelling_period_input_folder_i, original_input_folder, timeseries_import)
+        write_input_folder(
+            modelling_period_input_folder_i, original_input_folder, timeseries_import
+        )
 
         logger.info(f"Running optimization for period {i}: {(str(start_time), str(end_time))}.")
-        result = run_optimization_problem(
-            optimization_problem_class,
-            base_folder,
-            log_level,
-            profile,
-            input_folder=modelling_period_input_folder_i,
-            output_folder=modelling_period_output_folder_i,
-            **kwargs,
-        )
+        run_number_in_fallback_list = 1
+        # Fallback mechanism: allows optimization class to request a retry
+        # run_number_in_fallback_list: 1=first attempt, 2=retry with fallback, 3=done
+        for _k in range(2):
+            if run_number_in_fallback_list < 3:
+                result = run_optimization_problem(
+                    optimization_problem_class,
+                    base_folder,
+                    log_level,
+                    profile,
+                    input_folder=modelling_period_input_folder_i,
+                    output_folder=modelling_period_output_folder_i,
+                    run_number_in_fallback_list=run_number_in_fallback_list,
+                    **kwargs,
+                )
+                if hasattr(result, "run_number_in_fallback_list"):
+                    run_number_in_fallback_list = result.run_number_in_fallback_list
+                else:
+                    run_number_in_fallback_list = 3
+                if run_number_in_fallback_list == 2:
+                    logger.info("The model failed, it will run it again with a fallback option")
         period = f"period {i} {(str(start_time), str(end_time))}"
         if result.solver_stats["success"]:
             logger.info(f"Successful optimization for {period}.")
         else:
-            message = f"Failed optimization for {period} with status '{result.solver_stats['return_status']}'."
+            message = (
+                f"Failed optimization for {period} with status"
+                + f"{result.solver_stats['return_status']}'."
+            )
             logger.error(message)
             raise Exception(message)
 
-        results_previous_run = {
-            key: result.extract_results().get(key) for key in variables_in_import if key not in fixed_input_series
-        }
+        extracted_results = result.extract_results() or {}
+        results_previous_run = {}
+        for key in variables_in_import:
+            if key not in fixed_input_series:
+                extracted_value = extracted_results.get(key)
+                if extracted_value is not None:
+                    results_previous_run[key] = extracted_value
+                else:
+                    try:
+                        fallback_value = result.get_timeseries(key)
+                    except KeyError:
+                        fallback_value = None
+                    results_previous_run[key] = (
+                        fallback_value.values if fallback_value is not None else None
+                    )
         previous_run_datetimes = result.io.datetimes
 
     logger.info("Finished all optimization runs.")
     if issubclass(optimization_problem_class, PIMixin):
-        combine_xml_exports(modelling_periods_output_folder, original_input_folder, write_csv_out=True)
+        combine_xml_exports(
+            modelling_periods_output_folder, original_input_folder, write_csv_out=True
+        )
     elif issubclass(optimization_problem_class, CSVMixin):
         combine_csv_exports(modelling_periods_output_folder)
     else:
         logger.warning(
-            "Could not combine exports because the optimization problem class is not derived from PIMixin or CSVMixin."
+            "Could not combine exports because the optimization problem class is not "
+            "derived from PIMixin or CSVMixin."
         )
     return result.solver_stats