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

rtctools/optimization/min_abs_goal_programming_mixin.py

@@ -3,12 +3,17 @@ import itertools
 from typing import List
 
 import casadi as ca
-
 import numpy as np
 
 from .goal_programming_mixin import GoalProgrammingMixin
-from .goal_programming_mixin_base import Goal, StateGoal, _GoalProgrammingMixinBase
-from .goal_programming_mixin_base import _EmptyEnsembleList, _EmptyEnsembleOrderedDict, _GoalConstraint
+from .goal_programming_mixin_base import (
+    Goal,
+    StateGoal,
+    _EmptyEnsembleList,
+    _EmptyEnsembleOrderedDict,
+    _GoalConstraint,
+    _GoalProgrammingMixinBase,
+)
 from .single_pass_goal_programming_mixin import SinglePassGoalProgrammingMixin
 from .timeseries import Timeseries
 
@@ -20,6 +25,7 @@ class MinAbsGoal(Goal):
     class, the default order is 1 as absolute minimization is typically
     desired for fully linear problems.
     """
+
     order = 1
 
 
@@ -28,7 +34,6 @@ class MinAbsStateGoal(StateGoal, MinAbsGoal):
 
 
 class _ConvertedMinAbsGoal(Goal):
-
     order = 1
 
     def __init__(self, abs_variable, is_path_goal, orig_goal):
@@ -83,7 +88,7 @@ class MinAbsGoalProgrammingMixin(_GoalProgrammingMixinBase):
 
     def bounds(self):
         bounds = super().bounds()
-        for abs_var in (self.__problem_vars + self.__problem_path_vars):
+        for abs_var in self.__problem_vars + self.__problem_path_vars:
             bounds[abs_var.name()] = (0.0, np.inf)
         return bounds
 
@@ -122,20 +127,29 @@ class MinAbsGoalProgrammingMixin(_GoalProgrammingMixinBase):
 
         for goal in goals:
             if not isinstance(goal, MinAbsGoal):
-                raise Exception("Absolute goal not an instance of MinAbsGoal for goal {}".format(goal))
+                raise Exception(
+                    "Absolute goal not an instance of MinAbsGoal for goal {}".format(goal)
+                )
 
             if goal.function_range != (np.nan, np.nan):
-                raise Exception("Absolute goal function is only allowed for minimization for goal {}".format(goal))
+                raise Exception(
+                    "Absolute goal function is only allowed for minimization for goal {}".format(
+                        goal
+                    )
+                )
 
             if goal.order != 1:
-                raise Exception("Absolute goal function is only allowed for order = 1 for goal {}".format(goal))
+                raise Exception(
+                    "Absolute goal function is only allowed for order = 1 for goal {}".format(goal)
+                )
 
             if goal.weight <= 0:
-                raise Exception("Absolute goal function is only allowed for weight > 0 for goal {}".format(goal))
+                raise Exception(
+                    "Absolute goal function is only allowed for weight > 0 for goal {}".format(goal)
+                )
 
     @staticmethod
     def __convert_goals(goals, sym_index, ensemble_size, is_path_goal):
-
         # Replace absolute minimization goals with a new goal, and some
         # additional hard constraints.
         constraints = [[] for ensemble_member in range(ensemble_size)]
@@ -160,15 +174,24 @@ class MinAbsGoalProgrammingMixin(_GoalProgrammingMixinBase):
             # original goal function, such that it corresponds to its absolute
             # value when minimizing.
             for ensemble_member in range(ensemble_size):
-                def _constraint_func(problem, sign, abs_variable=abs_variable,
-                                     ensemble_member=ensemble_member, goal=goal,
-                                     is_path_goal=is_path_goal):
+
+                def _constraint_func(
+                    problem,
+                    sign,
+                    abs_variable=abs_variable,
+                    ensemble_member=ensemble_member,
+                    goal=goal,
+                    is_path_goal=is_path_goal,
+                ):
                     if is_path_goal:
                         abs_variable = problem.variable(abs_variable.name())
                     else:
                         abs_variable = problem.extra_variable(abs_variable.name(), ensemble_member)
 
-                    return abs_variable + sign * goal.function(problem, ensemble_member) / goal.function_nominal
+                    return (
+                        abs_variable
+                        + sign * goal.function(problem, ensemble_member) / goal.function_nominal
+                    )
 
                 _pos = functools.partial(_constraint_func, sign=1)
                 _neg = functools.partial(_constraint_func, sign=-1)
@@ -188,16 +211,17 @@ class MinAbsGoalProgrammingMixin(_GoalProgrammingMixinBase):
         seed = [{} for ensemble_member in range(self.ensemble_size)]
 
         for goal in goals:
-
             assert isinstance(goal, _ConvertedMinAbsGoal)
 
             for ensemble_member in range(self.ensemble_size):
                 if is_path_goal:
-                    expr = self.map_path_expression(goal.orig_goal.function(self, ensemble_member), ensemble_member)
+                    expr = self.map_path_expression(
+                        goal.orig_goal.function(self, ensemble_member), ensemble_member
+                    )
                 else:
                     expr = goal.orig_goal.function(self, ensemble_member)
 
-                function = ca.Function('f', [self.solver_input], [expr])
+                function = ca.Function("f", [self.solver_input], [expr])
                 value = np.array(function(self.solver_output))
 
                 assert value.ndim == 2
@@ -244,32 +268,49 @@ class MinAbsGoalProgrammingMixin(_GoalProgrammingMixinBase):
         # We want to have consistent naming with GPMixin for our auxiliary
         # variables. We therefore need to loop over all priorities, regardless
         # of whether there are any MinAbsGoals in it or not.
-        priorities = {int(goal.priority) for goal in itertools.chain(
-            goals, path_goals, self.goals(), self.path_goals()) if not goal.is_empty}
+        priorities = {
+            int(goal.priority)
+            for goal in itertools.chain(goals, path_goals, self.goals(), self.path_goals())
+            if not goal.is_empty
+        }
 
         subproblems = []
         for priority in sorted(priorities):
-            subproblems.append((
-                priority,
-                [goal for goal in goals if int(goal.priority) == priority and not goal.is_empty],
-                [goal for goal in path_goals if int(goal.priority) == priority and not goal.is_empty]))
+            subproblems.append(
+                (
+                    priority,
+                    [
+                        goal
+                        for goal in goals
+                        if int(goal.priority) == priority and not goal.is_empty
+                    ],
+                    [
+                        goal
+                        for goal in path_goals
+                        if int(goal.priority) == priority and not goal.is_empty
+                    ],
+                )
+            )
 
         # Rewrite absolute minimization goals.
         self.__converted_goals = []
         self.__converted_path_goals = []
 
         for i, (priority, goals, path_goals) in enumerate(subproblems):
-
-            (goals,
+            (
+                goals,
                 self.__subproblem_constraints[priority],
-                self.__subproblem_vars[priority]) = self.__convert_goals(goals, i, self.ensemble_size, False)
+                self.__subproblem_vars[priority],
+            ) = self.__convert_goals(goals, i, self.ensemble_size, False)
 
             self.__converted_goals.extend(goals)
             self.__subproblem_abs_goals[priority] = goals
 
-            (path_goals,
+            (
+                path_goals,
                 self.__subproblem_path_constraints[priority],
-                self.__subproblem_path_vars[priority]) = self.__convert_goals(path_goals, i, self.ensemble_size, True)
+                self.__subproblem_path_vars[priority],
+            ) = self.__convert_goals(path_goals, i, self.ensemble_size, True)
 
             self.__converted_path_goals.extend(path_goals)
             self.__subproblem_path_abs_goals[priority] = path_goals
@@ -307,7 +348,9 @@ class MinAbsGoalProgrammingMixin(_GoalProgrammingMixinBase):
         # priority.
         if not self.__first_run and isinstance(self, GoalProgrammingMixin):
             self.__seeds = self.__calculate_seed(self.__subproblem_abs_goals[priority], False)
-            self.__path_seeds = self.__calculate_seed(self.__subproblem_path_abs_goals[priority], True)
+            self.__path_seeds = self.__calculate_seed(
+                self.__subproblem_path_abs_goals[priority], True
+            )
 
         self.__first_run = False
 

rtctools/optimization/modelica_mixin.py

@@ -3,11 +3,8 @@ import logging
 from typing import Dict, Union
 
 import casadi as ca
-
 import numpy as np
-
 import pkg_resources
-
 import pymoca
 import pymoca.backends.casadi.api
 
@@ -28,7 +25,8 @@ class ModelicaMixin(OptimizationProblem):
     During preprocessing, the Modelica files located inside the ``model`` subfolder are loaded.
 
     :cvar modelica_library_folders:
-        Folders in which any referenced Modelica libraries are to be found. Default is an empty list.
+        Folders in which any referenced Modelica libraries are to be found.
+        Default is an empty list.
     """
 
     # Folders in which the referenced Modelica libraries are found
@@ -36,35 +34,38 @@ class ModelicaMixin(OptimizationProblem):
 
     def __init__(self, **kwargs):
         # Check arguments
-        assert ('model_folder' in kwargs)
+        assert "model_folder" in kwargs
 
         # Log pymoca version
         logger.debug("Using pymoca {}.".format(pymoca.__version__))
 
         # Transfer model from the Modelica .mo file to CasADi using pymoca
-        if 'model_name' in kwargs:
-            model_name = kwargs['model_name']
+        if "model_name" in kwargs:
+            model_name = kwargs["model_name"]
         else:
-            if hasattr(self, 'model_name'):
+            if hasattr(self, "model_name"):
                 model_name = self.model_name
             else:
                 model_name = self.__class__.__name__
 
         self.__pymoca_model = pymoca.backends.casadi.api.transfer_model(
-            kwargs['model_folder'], model_name, self.compiler_options())
+            kwargs["model_folder"], model_name, self.compiler_options()
+        )
 
         # Extract the CasADi MX variables used in the model
         self.__mx = {}
-        self.__mx['time'] = [self.__pymoca_model.time]
-        self.__mx['states'] = [v.symbol for v in self.__pymoca_model.states]
-        self.__mx['derivatives'] = [v.symbol for v in self.__pymoca_model.der_states]
-        self.__mx['algebraics'] = [v.symbol for v in self.__pymoca_model.alg_states]
-        self.__mx['parameters'] = [v.symbol for v in self.__pymoca_model.parameters]
-        self.__mx['string_parameters'] = [v.name for v in (*self.__pymoca_model.string_parameters,
-                                                           *self.__pymoca_model.string_constants)]
-        self.__mx['control_inputs'] = []
-        self.__mx['constant_inputs'] = []
-        self.__mx['lookup_tables'] = []
+        self.__mx["time"] = [self.__pymoca_model.time]
+        self.__mx["states"] = [v.symbol for v in self.__pymoca_model.states]
+        self.__mx["derivatives"] = [v.symbol for v in self.__pymoca_model.der_states]
+        self.__mx["algebraics"] = [v.symbol for v in self.__pymoca_model.alg_states]
+        self.__mx["parameters"] = [v.symbol for v in self.__pymoca_model.parameters]
+        self.__mx["string_parameters"] = [
+            v.name
+            for v in (*self.__pymoca_model.string_parameters, *self.__pymoca_model.string_constants)
+        ]
+        self.__mx["control_inputs"] = []
+        self.__mx["constant_inputs"] = []
+        self.__mx["lookup_tables"] = []
 
         # Merge with user-specified delayed feedback
         for v in self.__pymoca_model.inputs:
@@ -72,29 +73,31 @@ class ModelicaMixin(OptimizationProblem):
                 # Delayed feedback variables are local to each ensemble, and
                 # therefore belong to the collection of algebraic variables,
                 # rather than to the control inputs.
-                self.__mx['algebraics'].append(v.symbol)
+                self.__mx["algebraics"].append(v.symbol)
             else:
-                if v.symbol.name() in kwargs.get('lookup_tables', []):
-                    self.__mx['lookup_tables'].append(v.symbol)
+                if v.symbol.name() in kwargs.get("lookup_tables", []):
+                    self.__mx["lookup_tables"].append(v.symbol)
                 elif v.fixed:
-                    self.__mx['constant_inputs'].append(v.symbol)
+                    self.__mx["constant_inputs"].append(v.symbol)
                 else:
-                    self.__mx['control_inputs'].append(v.symbol)
+                    self.__mx["control_inputs"].append(v.symbol)
 
         # Initialize nominals and types
         # These are not in @cached dictionary properties for backwards compatibility.
         self.__python_types = AliasDict(self.alias_relation)
         for v in itertools.chain(
-                self.__pymoca_model.states, self.__pymoca_model.alg_states, self.__pymoca_model.inputs):
+            self.__pymoca_model.states, self.__pymoca_model.alg_states, self.__pymoca_model.inputs
+        ):
             self.__python_types[v.symbol.name()] = v.python_type
 
         # Initialize dae, initial residuals, as well as delay arguments
         # These are not in @cached dictionary properties so that we need to create the list
         # of function arguments only once.
-        variable_lists = ['states', 'der_states', 'alg_states', 'inputs', 'constants', 'parameters']
+        variable_lists = ["states", "der_states", "alg_states", "inputs", "constants", "parameters"]
         function_arguments = [self.__pymoca_model.time] + [
             ca.veccat(*[v.symbol for v in getattr(self.__pymoca_model, variable_list)])
-            for variable_list in variable_lists]
+            for variable_list in variable_lists
+        ]
 
         self.__dae_residual = self.__pymoca_model.dae_residual_function(*function_arguments)
         if self.__dae_residual is None:
@@ -106,18 +109,36 @@ class ModelicaMixin(OptimizationProblem):
 
         # Log variables in debug mode
         if logger.getEffectiveLevel() == logging.DEBUG:
-            logger.debug("ModelicaMixin: Found states {}".format(
-                ', '.join([var.name() for var in self.__mx['states']])))
-            logger.debug("ModelicaMixin: Found derivatives {}".format(
-                ', '.join([var.name() for var in self.__mx['derivatives']])))
-            logger.debug("ModelicaMixin: Found algebraics {}".format(
-                ', '.join([var.name() for var in self.__mx['algebraics']])))
-            logger.debug("ModelicaMixin: Found control inputs {}".format(
-                ', '.join([var.name() for var in self.__mx['control_inputs']])))
-            logger.debug("ModelicaMixin: Found constant inputs {}".format(
-                ', '.join([var.name() for var in self.__mx['constant_inputs']])))
-            logger.debug("ModelicaMixin: Found parameters {}".format(
-                ', '.join([var.name() for var in self.__mx['parameters']])))
+            logger.debug(
+                "ModelicaMixin: Found states {}".format(
+                    ", ".join([var.name() for var in self.__mx["states"]])
+                )
+            )
+            logger.debug(
+                "ModelicaMixin: Found derivatives {}".format(
+                    ", ".join([var.name() for var in self.__mx["derivatives"]])
+                )
+            )
+            logger.debug(
+                "ModelicaMixin: Found algebraics {}".format(
+                    ", ".join([var.name() for var in self.__mx["algebraics"]])
+                )
+            )
+            logger.debug(
+                "ModelicaMixin: Found control inputs {}".format(
+                    ", ".join([var.name() for var in self.__mx["control_inputs"]])
+                )
+            )
+            logger.debug(
+                "ModelicaMixin: Found constant inputs {}".format(
+                    ", ".join([var.name() for var in self.__mx["constant_inputs"]])
+                )
+            )
+            logger.debug(
+                "ModelicaMixin: Found parameters {}".format(
+                    ", ".join([var.name() for var in self.__mx["parameters"]])
+                )
+            )
 
         # Call parent class first for default behaviour.
         super().__init__(**kwargs)
@@ -125,55 +146,56 @@ class ModelicaMixin(OptimizationProblem):
     @cached
     def compiler_options(self) -> Dict[str, Union[str, bool]]:
         """
-        Subclasses can configure the `pymoca <http://github.com/pymoca/pymoca>`_ compiler options here.
+        Subclasses can configure the `pymoca <http://github.com/pymoca/pymoca>`_ compiler options
+        here.
 
-        :returns: A dictionary of pymoca compiler options.  See the pymoca documentation for details.
+        :returns:
+            A dictionary of pymoca compiler options.  See the pymoca documentation for details.
         """
 
         # Default options
         compiler_options = {}
 
         # Expand vector states to multiple scalar component states.
-        compiler_options['expand_vectors'] = True
+        compiler_options["expand_vectors"] = True
 
         # Where imported model libraries are located.
         library_folders = self.modelica_library_folders.copy()
 
-        for ep in pkg_resources.iter_entry_points(group='rtctools.libraries.modelica'):
+        for ep in pkg_resources.iter_entry_points(group="rtctools.libraries.modelica"):
             if ep.name == "library_folder":
-                library_folders.append(
-                    pkg_resources.resource_filename(ep.module_name, ep.attrs[0]))
+                library_folders.append(pkg_resources.resource_filename(ep.module_name, ep.attrs[0]))
 
-        compiler_options['library_folders'] = library_folders
+        compiler_options["library_folders"] = library_folders
 
         # Eliminate equations of the type 'var = const'.
-        compiler_options['eliminate_constant_assignments'] = True
+        compiler_options["eliminate_constant_assignments"] = True
 
         # Eliminate constant symbols from model, replacing them with the values
         # specified in the model.
-        compiler_options['replace_constant_values'] = True
+        compiler_options["replace_constant_values"] = True
 
         # Replace any constant expressions into the model.
-        compiler_options['replace_constant_expressions'] = True
+        compiler_options["replace_constant_expressions"] = True
 
         # Replace any parameter expressions into the model.
-        compiler_options['replace_parameter_expressions'] = True
+        compiler_options["replace_parameter_expressions"] = True
 
         # Eliminate variables starting with underscores.
-        compiler_options['eliminable_variable_expression'] = r'(.*[.]|^)_\w+(\[[\d,]+\])?\Z'
+        compiler_options["eliminable_variable_expression"] = r"(.*[.]|^)_\w+(\[[\d,]+\])?\Z"
 
         # Pymoca currently requires `expand_mx` to be set for
         # `eliminable_variable_expression` to work.
-        compiler_options['expand_mx'] = True
+        compiler_options["expand_mx"] = True
 
         # Automatically detect and eliminate alias variables.
-        compiler_options['detect_aliases'] = True
+        compiler_options["detect_aliases"] = True
 
         # Disallow aliasing to derivative states
-        compiler_options['allow_derivative_aliases'] = False
+        compiler_options["allow_derivative_aliases"] = False
 
         # Cache the model on disk
-        compiler_options['cache'] = True
+        compiler_options["cache"] = True
 
         # Done
         return compiler_options
@@ -182,9 +204,10 @@ class ModelicaMixin(OptimizationProblem):
         delayed_feedback = super().delayed_feedback()
 
         # Create delayed feedback
-        for delay_state, delay_argument in zip(self.__pymoca_model.delay_states, self.__pymoca_model.delay_arguments):
-            delayed_feedback.append(
-                (delay_argument.expr, delay_state, delay_argument.duration))
+        for delay_state, delay_argument in zip(
+            self.__pymoca_model.delay_states, self.__pymoca_model.delay_arguments
+        ):
+            delayed_feedback.append((delay_argument.expr, delay_state, delay_argument.duration))
         return delayed_feedback
 
     @property
@@ -198,9 +221,8 @@ class ModelicaMixin(OptimizationProblem):
     @property
     @cached
     def output_variables(self):
-        output_variables = [ca.MX.sym(variable)
-                            for variable in self.__pymoca_model.outputs]
-        output_variables.extend(self.__mx['control_inputs'])
+        output_variables = [ca.MX.sym(variable) for variable in self.__pymoca_model.outputs]
+        output_variables.extend(self.__mx["control_inputs"])
         return output_variables
 
     @cached
@@ -234,7 +256,9 @@ class ModelicaMixin(OptimizationProblem):
 
         # Parameter values
         parameters = self.parameters(ensemble_member)
-        parameter_values = [parameters.get(param.name(), param) for param in self.__mx['parameters']]
+        parameter_values = [
+            parameters.get(param.name(), param) for param in self.__mx["parameters"]
+        ]
 
         # Initial conditions obtained from start attributes.
         for v in self.__pymoca_model.states:
@@ -245,16 +269,24 @@ class ModelicaMixin(OptimizationProblem):
                 if isinstance(start, ca.MX):
                     # If start contains symbolics, try substituting parameter values
                     if isinstance(start, ca.MX) and not start.is_constant():
-                        [start] = substitute_in_external([start], self.__mx['parameters'], parameter_values)
+                        [start] = substitute_in_external(
+                            [start], self.__mx["parameters"], parameter_values
+                        )
                         if not start.is_constant() or np.isnan(float(start)):
-                            raise Exception('ModelicaMixin: Could not resolve initial value for {}'.format(sym_name))
+                            raise Exception(
+                                "ModelicaMixin: Could not resolve initial value for {}".format(
+                                    sym_name
+                                )
+                            )
 
                     start = v.python_type(start)
 
                 history[sym_name] = Timeseries(initial_time, start)
 
                 if logger.getEffectiveLevel() == logging.DEBUG:
-                    logger.debug("ModelicaMixin: Initial state variable {} = {}".format(sym_name, start))
+                    logger.debug(
+                        "ModelicaMixin: Initial state variable {} = {}".format(sym_name, start)
+                    )
 
         return history
 
@@ -269,11 +301,14 @@ class ModelicaMixin(OptimizationProblem):
 
         # Parameter values
         parameters = self.parameters(0)
-        parameter_values = [parameters.get(param.name(), param) for param in self.__mx['parameters']]
+        parameter_values = [
+            parameters.get(param.name(), param) for param in self.__mx["parameters"]
+        ]
 
         # Load additional bounds from model
         for v in itertools.chain(
-                self.__pymoca_model.states, self.__pymoca_model.alg_states, self.__pymoca_model.inputs):
+            self.__pymoca_model.states, self.__pymoca_model.alg_states, self.__pymoca_model.inputs
+        ):
             sym_name = v.symbol.name()
 
             try:
@@ -286,16 +321,20 @@ class ModelicaMixin(OptimizationProblem):
 
             m_ = v.min
             if isinstance(m_, ca.MX) and not m_.is_constant():
-                [m_] = substitute_in_external([m_], self.__mx['parameters'], parameter_values)
+                [m_] = substitute_in_external([m_], self.__mx["parameters"], parameter_values)
                 if not m_.is_constant() or np.isnan(float(m_)):
-                    raise Exception('Could not resolve lower bound for variable {}'.format(sym_name))
+                    raise Exception(
+                        "Could not resolve lower bound for variable {}".format(sym_name)
+                    )
             m_ = float(m_)
 
             M_ = v.max
             if isinstance(M_, ca.MX) and not M_.is_constant():
-                [M_] = substitute_in_external([M_], self.__mx['parameters'], parameter_values)
+                [M_] = substitute_in_external([M_], self.__mx["parameters"], parameter_values)
                 if not M_.is_constant() or np.isnan(float(M_)):
-                    raise Exception('Could not resolve upper bound for variable {}'.format(sym_name))
+                    raise Exception(
+                        "Could not resolve upper bound for variable {}".format(sym_name)
+                    )
             M_ = float(M_)
 
             # We take the intersection of all provided bounds
@@ -313,7 +352,9 @@ class ModelicaMixin(OptimizationProblem):
 
         # Parameter values
         parameters = self.parameters(ensemble_member)
-        parameter_values = [parameters.get(param.name(), param) for param in self.__mx['parameters']]
+        parameter_values = [
+            parameters.get(param.name(), param) for param in self.__mx["parameters"]
+        ]
 
         # Load seeds
         for var in itertools.chain(self.__pymoca_model.states, self.__pymoca_model.alg_states):
@@ -328,9 +369,13 @@ class ModelicaMixin(OptimizationProblem):
 
                 # If start contains symbolics, try substituting parameter values
                 if isinstance(start, ca.MX) and not start.is_constant():
-                    [start] = substitute_in_external([start], self.__mx['parameters'], parameter_values)
+                    [start] = substitute_in_external(
+                        [start], self.__mx["parameters"], parameter_values
+                    )
                     if not start.is_constant() or np.isnan(float(start)):
-                        logger.error('ModelicaMixin: Could not resolve seed value for {}'.format(sym_name))
+                        logger.error(
+                            "ModelicaMixin: Could not resolve seed value for {}".format(sym_name)
+                        )
                         continue
 
                 times = self.times(sym_name)
@@ -353,25 +398,31 @@ class ModelicaMixin(OptimizationProblem):
     @property
     @cached
     def __nominals(self):
-
         # Make the dict
         nominal_dict = AliasDict(self.alias_relation)
 
         # Grab parameters and their values
         parameters = self.parameters(0)
-        parameter_values = [parameters.get(param.name(), param) for param in self.__mx['parameters']]
+        parameter_values = [
+            parameters.get(param.name(), param) for param in self.__mx["parameters"]
+        ]
 
         # Iterate over nominalizable states
         for v in itertools.chain(
-                self.__pymoca_model.states, self.__pymoca_model.alg_states, self.__pymoca_model.inputs):
+            self.__pymoca_model.states, self.__pymoca_model.alg_states, self.__pymoca_model.inputs
+        ):
             sym_name = v.symbol.name()
             nominal = v.nominal
 
             # If nominal contains parameter symbols, substitute them
             if isinstance(nominal, ca.MX) and not nominal.is_constant():
-                [nominal] = substitute_in_external([nominal], self.__mx['parameters'], parameter_values)
+                [nominal] = substitute_in_external(
+                    [nominal], self.__mx["parameters"], parameter_values
+                )
                 if not nominal.is_constant() or np.isnan(float(nominal)):
-                    logger.error('ModelicaMixin: Could not resolve nominal value for {}'.format(sym_name))
+                    logger.error(
+                        "ModelicaMixin: Could not resolve nominal value for {}".format(sym_name)
+                    )
                     continue
 
             nominal = float(nominal)
@@ -387,8 +438,11 @@ class ModelicaMixin(OptimizationProblem):
                 nominal_dict[sym_name] = nominal
 
                 if logger.getEffectiveLevel() == logging.DEBUG:
-                    logger.debug("ModelicaMixin: Set nominal value for variable {} to {}".format(
-                        sym_name, nominal))
+                    logger.debug(
+                        "ModelicaMixin: Set nominal value for variable {} to {}".format(
+                            sym_name, nominal
+                        )
+                    )
             else:
                 logger.warning("ModelicaMixin: Could not set nominal value for {}".format(sym_name))