rtc-tools 2.5.2rc4__py3-none-any.whl → 2.6.0__py3-none-any.whl

rtctools/optimization/homotopy_mixin.py

@@ -30,16 +30,18 @@ class HomotopyMixin(OptimizationProblem):
         # Overwrite the seed only when the results of the latest run are
         # stored within this class. That is, when the GoalProgrammingMixin
         # class is not used or at the first run of the goal programming loop.
-        if self.__theta > options['theta_start'] and getattr(self, '_gp_first_run', True):
+        if self.__theta > options["theta_start"] and getattr(self, "_gp_first_run", True):
             for key, result in self.__results[ensemble_member].items():
                 times = self.times(key)
-                if ((result.ndim == 1 and len(result) == len(times))
-                        or (result.ndim == 2 and result.shape[0] == len(times))):
+                if (result.ndim == 1 and len(result) == len(times)) or (
+                    result.ndim == 2 and result.shape[0] == len(times)
+                ):
                     # Only include seed timeseries which are consistent
                     # with the specified time stamps.
                     seed[key] = Timeseries(times, result)
-                elif ((result.ndim == 1 and len(result) == 1)
-                        or (result.ndim == 2 and result.shape[0] == 1)):
+                elif (result.ndim == 1 and len(result) == 1) or (
+                    result.ndim == 2 and result.shape[0] == 1
+                ):
                     seed[key] = result
         return seed
 
@@ -52,7 +54,7 @@ class HomotopyMixin(OptimizationProblem):
             # to avoid accidental usage of the parameter value in e.g. pre().
             # Note that we use a try-except here instead of hasattr, to avoid
             # explicit name mangling.
-            parameters[options['homotopy_parameter']] = self.__theta
+            parameters[options["homotopy_parameter"]] = self.__theta
         except AttributeError:
             pass
 
@@ -74,21 +76,23 @@ class HomotopyMixin(OptimizationProblem):
         | ``homotopy_parameter`` | ``string`` | ``theta``     |
         +------------------------+------------+---------------+
 
-        The homotopy process is controlled by the homotopy parameter in the model, specified
-        by the option ``homotopy_parameter``.  The homotopy parameter is initialized to ``theta_start``,
-        and increases to a value of ``1.0`` with a dynamically changing step size.  This step
-        size is initialized with the value of the option ``delta_theta_0``.  If this step
-        size is too large, i.e., if the problem with the increased homotopy parameter fails to
-        converge, the step size is halved.  The process of halving terminates when the step size falls
-        below the minimum value specified by the option ``delta_theta_min``.
+        The homotopy process is controlled by the homotopy parameter in the model, specified by the
+        option ``homotopy_parameter``.  The homotopy parameter is initialized to ``theta_start``,
+        and increases to a value of ``1.0`` with a dynamically changing step size.  This step size
+        is initialized with the value of the option ``delta_theta_0``.  If this step size is too
+        large, i.e., if the problem with the increased homotopy parameter fails to converge, the
+        step size is halved.  The process of halving terminates when the step size falls below the
+        minimum value specified by the option ``delta_theta_min``.
 
         :returns: A dictionary of homotopy options.
         """
 
-        return {'theta_start': 0.0,
-                'delta_theta_0': 1.0,
-                'delta_theta_min': 0.01,
-                'homotopy_parameter': 'theta'}
+        return {
+            "theta_start": 0.0,
+            "delta_theta_0": 1.0,
+            "delta_theta_min": 0.01,
+            "homotopy_parameter": "theta",
+        }
 
     def dynamic_parameters(self):
         dynamic_parameters = super().dynamic_parameters()
@@ -97,7 +101,7 @@ class HomotopyMixin(OptimizationProblem):
             # For theta = 0, we don't mark the homotopy parameter as being dynamic,
             # so that the correct sparsity structure is obtained for the linear model.
             options = self.homotopy_options()
-            dynamic_parameters.append(self.variable(options['homotopy_parameter']))
+            dynamic_parameters.append(self.variable(options["homotopy_parameter"]))
 
         return dynamic_parameters
 
@@ -107,18 +111,22 @@ class HomotopyMixin(OptimizationProblem):
             self.pre()
 
         options = self.homotopy_options()
-        delta_theta = options['delta_theta_0']
+        delta_theta = options["delta_theta_0"]
 
         # Homotopy loop
-        self.__theta = options['theta_start']
+        self.__theta = options["theta_start"]
 
         while self.__theta <= 1.0:
             logger.info("Solving with homotopy parameter theta = {}.".format(self.__theta))
 
-            success = super().optimize(preprocessing=False, postprocessing=False, log_solver_failure_as_error=False)
+            success = super().optimize(
+                preprocessing=False, postprocessing=False, log_solver_failure_as_error=False
+            )
             if success:
                 self.__results = [
-                    self.extract_results(ensemble_member) for ensemble_member in range(self.ensemble_size)]
+                    self.extract_results(ensemble_member)
+                    for ensemble_member in range(self.ensemble_size)
+                ]
 
                 if self.__theta == 0.0:
                     self.check_collocation_linearity = False
@@ -128,17 +136,18 @@ class HomotopyMixin(OptimizationProblem):
                     self.clear_transcription_cache()
 
             else:
-                if self.__theta == options['theta_start']:
+                if self.__theta == options["theta_start"]:
                     break
 
                 self.__theta -= delta_theta
                 delta_theta /= 2
 
-                if delta_theta < options['delta_theta_min']:
+                if delta_theta < options["delta_theta_min"]:
                     failure_message = (
-                        'Solver failed with homotopy parameter theta = {}. Theta cannot '
-                        'be decreased further, as that would violate the minimum delta '
-                        'theta of {}.'.format(self.__theta, options['delta_theta_min']))
+                        "Solver failed with homotopy parameter theta = {}. Theta cannot "
+                        "be decreased further, as that would violate the minimum delta "
+                        "theta of {}.".format(self.__theta, options["delta_theta_min"])
+                    )
                     if log_solver_failure_as_error:
                         logger.error(failure_message)
                     else:

rtctools/optimization/initial_state_estimation_mixin.py

@@ -12,9 +12,9 @@ class _MeasurementGoal(Goal):
 
     def function(self, optimization_problem, ensemble_member):
         op = optimization_problem
-        return (
-            op.state_at(self.__state, op.initial_time, ensemble_member) -
-            op.timeseries_at(self.__measurement_id, op.initial_time, ensemble_member))
+        return op.state_at(self.__state, op.initial_time, ensemble_member) - op.timeseries_at(
+            self.__measurement_id, op.initial_time, ensemble_member
+        )
 
     order = 2
     priority = -2
@@ -29,9 +29,9 @@ class _SmoothingGoal(Goal):
 
     def function(self, optimization_problem, ensemble_member):
         op = optimization_problem
-        return (
-            op.state_at(self.__state1, op.initial_time, ensemble_member) -
-            op.state_at(self.__state2, op.initial_time, ensemble_member))
+        return op.state_at(self.__state1, op.initial_time, ensemble_member) - op.state_at(
+            self.__state2, op.initial_time, ensemble_member
+        )
 
     order = 2
     priority = -1
@@ -61,8 +61,8 @@ class InitialStateEstimationMixin(GoalProgrammingMixin):
 
     def initial_state_measurements(self) -> List[Union[Tuple[str, str], Tuple[str, str, float]]]:
         """
-        List of pairs ``(state, measurement_id)`` or triples ``(state, measurement_id, max_deviation)``,
-        relating states to measurement time series IDs.
+        List of pairs ``(state, measurement_id)`` or triples ``(state, measurement_id,
+        max_deviation)``, relating states to measurement time series IDs.
 
         The default maximum deviation is ``1.0``.
         """

rtctools/optimization/io_mixin.py

@@ -4,7 +4,6 @@ import warnings
 from abc import ABCMeta, abstractmethod
 
 import casadi as ca
-
 import numpy as np
 
 from rtctools._internal.caching import cached
@@ -54,7 +53,7 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
 
     @abstractmethod
     def write(self) -> None:
-        """"
+        """
         Writes output data to files
         """
         pass
@@ -81,17 +80,17 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
         return Timeseries(*self.io.get_timeseries_sec(variable, ensemble_member))
 
     def set_timeseries(
-            self,
-            variable: str,
-            timeseries: Timeseries,
-            ensemble_member: int = 0,
-            output: bool = True,
-            check_consistency: bool = True):
-
+        self,
+        variable: str,
+        timeseries: Timeseries,
+        ensemble_member: int = 0,
+        output: bool = True,
+        check_consistency: bool = True,
+    ):
         def stretch_values(values, t_pos):
             # Construct a values range with preceding and possibly following nans
             new_values = np.full(self.io.times_sec.shape, np.nan)
-            new_values[t_pos:t_pos + len(values)] = values
+            new_values[t_pos : t_pos + len(values)] = values
             return new_values
 
         if output:
@@ -99,9 +98,12 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
 
         if isinstance(timeseries, Timeseries):
             if len(timeseries.values) != len(timeseries.times):
-                raise ValueError('IOMixin: Trying to set timeseries {} with times and values that are of '
-                                 'different length (lengths of {} and {}, respectively).'
-                                 .format(variable, len(timeseries.times), len(timeseries.values)))
+                raise ValueError(
+                    "IOMixin: Trying to set timeseries {} with times and values that are of "
+                    "different length (lengths of {} and {}, respectively).".format(
+                        variable, len(timeseries.times), len(timeseries.values)
+                    )
+                )
 
             timeseries_times_sec = self.io.times_sec
 
@@ -109,10 +111,10 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
                 if check_consistency:
                     if not set(timeseries_times_sec).issuperset(timeseries.times):
                         raise ValueError(
-                            'IOMixin: Trying to set timeseries {} with different times '
-                            '(in seconds) than the imported timeseries. Please make sure the '
-                            'timeseries covers all timesteps of the longest '
-                            'imported timeseries.'.format(variable)
+                            "IOMixin: Trying to set timeseries {} with different times "
+                            "(in seconds) than the imported timeseries. Please make sure the "
+                            "timeseries covers all timesteps of the longest "
+                            "imported timeseries.".format(variable)
                         )
 
                 # Determine position of first times of added timeseries within the
@@ -131,15 +133,18 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
 
             if check_consistency:
                 if len(self.times()) != len(timeseries):
-                    raise ValueError('IOMixin: Trying to set values for {} with a different '
-                                     'length ({}) than the forecast length ({}).'
-                                     .format(variable, len(timeseries), len(self.times())))
+                    raise ValueError(
+                        "IOMixin: Trying to set values for {} with a different "
+                        "length ({}) than the forecast length ({}).".format(
+                            variable, len(timeseries), len(self.times())
+                        )
+                    )
                 elif not set(timeseries_times_sec).issuperset(self.times()):
                     raise ValueError(
-                        'IOMixin: Trying to set timeseries {} with different times '
-                        '(in seconds) than the imported timeseries. Please make sure the '
-                        'timeseries covers all timesteps of the longest '
-                        'imported timeseries.'.format(variable)
+                        "IOMixin: Trying to set timeseries {} with different times "
+                        "(in seconds) than the imported timeseries. Please make sure the "
+                        "timeseries covers all timesteps of the longest "
+                        "imported timeseries.".format(variable)
                     )
 
             # If times is not supplied with the timeseries, we add the
@@ -158,7 +163,7 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
 
         :param variable: Variable name.
         """
-        return '_'.join((variable, 'Min'))
+        return "_".join((variable, "Min"))
 
     def max_timeseries_id(self, variable: str) -> str:
         """
@@ -166,7 +171,7 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
 
         :param variable: Variable name.
         """
-        return '_'.join((variable, 'Max'))
+        return "_".join((variable, "Max"))
 
     @cached
     def bounds(self):
@@ -177,7 +182,7 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
         t_pos = bisect.bisect_left(io_times, self.initial_time)
 
         # Load bounds from timeseries
-        for variable in self.dae_variables['free_variables']:
+        for variable in self.dae_variables["free_variables"]:
             variable_name = variable.name()
 
             m, M = None, None
@@ -222,17 +227,18 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
 
         end_index = bisect.bisect_left(self.io.times_sec, self.initial_time) + 1
 
-        variable_list = self.dae_variables['states'] + self.dae_variables['algebraics'] + \
-            self.dae_variables['control_inputs'] + self.dae_variables['constant_inputs']
+        variable_list = (
+            self.dae_variables["states"]
+            + self.dae_variables["algebraics"]
+            + self.dae_variables["control_inputs"]
+            + self.dae_variables["constant_inputs"]
+        )
 
         for variable in variable_list:
             variable = variable.name()
             try:
                 times, values = self.io.get_timeseries_sec(variable, ensemble_member)
-                history[variable] = Timeseries(
-                    times[:end_index],
-                    values[:end_index]
-                )
+                history[variable] = Timeseries(times[:end_index], values[:end_index])
             except KeyError:
                 pass
             else:
@@ -246,12 +252,10 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
         seed = super().seed(ensemble_member)
 
         # Load seeds
-        for variable in self.dae_variables['free_variables']:
+        for variable in self.dae_variables["free_variables"]:
             variable = variable.name()
             try:
-                s = Timeseries(
-                    *self.io.get_timeseries_sec(variable, ensemble_member)
-                )
+                s = Timeseries(*self.io.get_timeseries_sec(variable, ensemble_member))
             except KeyError:
                 pass
             else:
@@ -279,12 +283,10 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
         constant_inputs = super().constant_inputs(ensemble_member)
 
         # Load inputs from timeseries
-        for variable in self.dae_variables['constant_inputs']:
+        for variable in self.dae_variables["constant_inputs"]:
             variable = variable.name()
             try:
-                timeseries = Timeseries(
-                    *self.io.get_timeseries_sec(variable, ensemble_member)
-                )
+                timeseries = Timeseries(*self.io.get_timeseries_sec(variable, ensemble_member))
             except KeyError:
                 pass
             else:
@@ -310,6 +312,9 @@ class IOMixin(OptimizationProblem, metaclass=ABCMeta):
         Deprecated, use `io.reference_datetime` and `io.datetimes`, or override behavior using
         :py:meth:`OptimizationProblem.times` and/or :py:attr:`OptimizationProblem.initial_time`.
         """
-        warnings.warn('get_forecast_index() is deprecated and will be removed in the future',
-                      FutureWarning, stacklevel=1)
+        warnings.warn(
+            "get_forecast_index() is deprecated and will be removed in the future",
+            FutureWarning,
+            stacklevel=1,
+        )
         return bisect.bisect_left(self.io.datetimes, self.io.reference_datetime)

rtctools/optimization/linearization_mixin.py

@@ -19,7 +19,9 @@ class LinearizationMixin(OptimizationProblem):
         parameters = super().parameters(ensemble_member)
 
         for parameter, timeseries_id in self.linearization_parameters().items():
-            parameters[parameter] = self.timeseries_at(timeseries_id, self.initial_time, ensemble_member)
+            parameters[parameter] = self.timeseries_at(
+                timeseries_id, self.initial_time, ensemble_member
+            )
 
         return parameters
 

rtctools/optimization/linearized_order_goal_programming_mixin.py

@@ -1,14 +1,18 @@
 import casadi as ca
-
 import numpy as np
 
-from rtctools.optimization.goal_programming_mixin_base import Goal, StateGoal, _GoalProgrammingMixinBase
-from rtctools.optimization.goal_programming_mixin_base import _GoalConstraint
+from rtctools.optimization.goal_programming_mixin_base import (
+    Goal,
+    StateGoal,
+    _GoalConstraint,
+    _GoalProgrammingMixinBase,
+)
 
 
 class LinearizedOrderGoal(Goal):
     #: Override linearization of goal order. Related global goal programming
-    #: option is ``linearize_goal_order`` (see :py:meth:`LinearizedOrderGoalProgrammingMixin.goal_programming_options`).
+    #: option is ``linearize_goal_order``
+    #: (see :py:meth:`LinearizedOrderGoalProgrammingMixin.goal_programming_options`).
     #: The default value of None defers to the global option, but the user can
     #: explicitly override it per goal by setting this value to True or False.
     linearize_order = None
@@ -17,7 +21,7 @@ class LinearizedOrderGoal(Goal):
     _linear_coefficients = {}
 
     @classmethod
-    def _get_linear_coefficients(cls, order, eps=0.1, kind='balanced'):
+    def _get_linear_coefficients(cls, order, eps=0.1, kind="balanced"):
         assert order > 1, "Order should be strictly larger than one"
 
         try:
@@ -25,15 +29,15 @@ class LinearizedOrderGoal(Goal):
         except KeyError:
             pass
 
-        x = ca.SX.sym('x')
-        a = ca.SX.sym('a')
-        b = ca.SX.sym('b')
+        x = ca.SX.sym("x")
+        a = ca.SX.sym("a")
+        b = ca.SX.sym("b")
 
         # Strike a balance between "absolute error < eps" and "relative error < eps" by
         # multiplying eps with x**(order-1)
-        if kind == 'balanced':
-            f = x**order - eps * x**(order-1) - (a * x + b)
-        elif kind == 'abs':
+        if kind == "balanced":
+            f = x**order - eps * x ** (order - 1) - (a * x + b)
+        elif kind == "abs":
             f = x**order - eps - (a * x + b)
         else:
             raise Exception("Unknown error approximation strategy '{}'".format(kind))
@@ -61,7 +65,7 @@ class LinearizedOrderGoal(Goal):
         xs = np.array(xs)
         ys = xs**order
 
-        a = (ys[1:] - ys[:-1])/(xs[1:] - xs[:-1])
+        a = (ys[1:] - ys[:-1]) / (xs[1:] - xs[:-1])
         b = ys[1:] - a * xs[1:]
         lines = list(zip(a, b))
 
@@ -76,6 +80,7 @@ class LinearizedOrderStateGoal(LinearizedOrderGoal, StateGoal):
     it is possible to just inherit from :py:class:`.LinearizedOrderGoal` to get the needed
     functionality for control of the linearization at goal level.
     """
+
     pass
 
 
@@ -98,7 +103,7 @@ class LinearizedOrderGoalProgrammingMixin(_GoalProgrammingMixinBase):
         :py:attr:`LinearizedOrderGoal.linearize_order`).
         """
         options = super().goal_programming_options()
-        options['linearize_goal_order'] = True
+        options["linearize_goal_order"] = True
         return options
 
     def _gp_validate_goals(self, goals, is_path_goal):
@@ -109,10 +114,12 @@ class LinearizedOrderGoalProgrammingMixin(_GoalProgrammingMixinBase):
             if isinstance(goal, LinearizedOrderGoal):
                 goal_linearize = goal.linearize_order
 
-            if goal_linearize or (options['linearize_goal_order'] and goal_linearize is not False):
+            if goal_linearize or (options["linearize_goal_order"] and goal_linearize is not False):
                 if not goal.has_target_bounds and goal.order > 1:
-                    raise Exception("Higher order minimization goals not allowed with "
-                                    "`linearize_goal_order` for goal {}".format(goal))
+                    raise Exception(
+                        "Higher order minimization goals not allowed with "
+                        "`linearize_goal_order` for goal {}".format(goal)
+                    )
 
         super()._gp_validate_goals(goals, is_path_goal)
 
@@ -124,7 +131,7 @@ class LinearizedOrderGoalProgrammingMixin(_GoalProgrammingMixinBase):
             if isinstance(goal, LinearizedOrderGoal):
                 goal_linearize = goal.linearize_order
 
-            if goal_linearize or (options['linearize_goal_order'] and goal_linearize is not False):
+            if goal_linearize or (options["linearize_goal_order"] and goal_linearize is not False):
                 if goal.order > 1 and not goal.critical:
                     return True
                 else:
@@ -147,7 +154,9 @@ class LinearizedOrderGoalProgrammingMixin(_GoalProgrammingMixinBase):
             # Make a linear epsilon, and constraints relating the linear
             # variable to the original objective function
             path_prefix = "path_" if is_path_goal else ""
-            linear_variable = ca.MX.sym(path_prefix + "lineps_{}_{}".format(sym_index, j), goal.size)
+            linear_variable = ca.MX.sym(
+                path_prefix + "lineps_{}_{}".format(sym_index, j), goal.size
+            )
 
             lo_epsilons.append(linear_variable)
 
@@ -163,9 +172,17 @@ class LinearizedOrderGoalProgrammingMixin(_GoalProgrammingMixinBase):
                 # having `keep_soft_constraints` = False. This is because the `epsilon` and
                 # the `linear_variable` no longer exist in the next priority.
                 for ensemble_member in range(self.ensemble_size):
-                    def _f(problem,
-                           goal=goal, epsilon_name=epsilon_name, linear_variable=linear_variable, a=a, b=b,
-                           ensemble_member=ensemble_member, is_path_constraint=is_path_goal):
+
+                    def _f(
+                        problem,
+                        goal=goal,
+                        epsilon_name=epsilon_name,
+                        linear_variable=linear_variable,
+                        a=a,
+                        b=b,
+                        ensemble_member=ensemble_member,
+                        is_path_constraint=is_path_goal,
+                    ):
                         if is_path_constraint:
                             eps = problem.variable(epsilon_name)
                             lin = problem.variable(linear_variable.name())
@@ -175,18 +192,25 @@ class LinearizedOrderGoalProgrammingMixin(_GoalProgrammingMixinBase):
 
                         return lin - a * eps - b
 
-                    lo_soft_constraints[ensemble_member].append(_GoalConstraint(goal, _f, 0.0, np.inf, False))
+                    lo_soft_constraints[ensemble_member].append(
+                        _GoalConstraint(goal, _f, 0.0, np.inf, False)
+                    )
 
-            if is_path_goal and options['scale_by_problem_size']:
+            if is_path_goal and options["scale_by_problem_size"]:
                 goal_m, goal_M = self._gp_min_max_arrays(goal, target_shape=len(self.times()))
                 goal_active = np.isfinite(goal_m) | np.isfinite(goal_M)
                 n_active = np.sum(goal_active.astype(int), axis=0)
             else:
                 n_active = 1
 
-            def _objective_func(problem, ensemble_member,
-                                goal=goal, linear_variable=linear_variable, is_path_goal=is_path_goal,
-                                n_active=n_active):
+            def _objective_func(
+                problem,
+                ensemble_member,
+                goal=goal,
+                linear_variable=linear_variable,
+                is_path_goal=is_path_goal,
+                n_active=n_active,
+            ):
                 if is_path_goal:
                     lin = problem.variable(linear_variable.name())
                 else:
@@ -196,8 +220,13 @@ class LinearizedOrderGoalProgrammingMixin(_GoalProgrammingMixinBase):
 
             goal._objective_func = _objective_func
 
-        epsilons, objectives, soft_constraints, hard_constraints, extra_constants = \
-            super()._gp_goal_constraints(goals, sym_index, options, is_path_goal)
+        (
+            epsilons,
+            objectives,
+            soft_constraints,
+            hard_constraints,
+            extra_constants,
+        ) = super()._gp_goal_constraints(goals, sym_index, options, is_path_goal)
 
         epsilons = epsilons + lo_epsilons
         for ensemble_member in range(self.ensemble_size):