rtc-tools 2.6.0b2__py3-none-any.whl → 2.7.0__py3-none-any.whl

rtctools/simulation/simulation_problem.py

@@ -1,13 +1,21 @@
 import copy
+import importlib.resources
 import itertools
 import logging
 import math
+import sys
 from collections import OrderedDict
 from typing import List, Union
 
+# Python 3.9's importlib.metadata does not support the "group" parameter to
+# entry_points yet.
+if sys.version_info < (3, 10):
+    import importlib_metadata
+else:
+    from importlib import metadata as importlib_metadata
+
 import casadi as ca
 import numpy as np
-import pkg_resources
 import pymoca
 import pymoca.backends.casadi.api
 
@@ -82,9 +90,21 @@ class SimulationProblem(DataStoreAccessor):
                 model_name = self.__class__.__name__
 
         # Load model from pymoca backend
-        self.__pymoca_model = pymoca.backends.casadi.api.transfer_model(
-            kwargs["model_folder"], model_name, self.compiler_options()
-        )
+        compiler_options = self.compiler_options()
+        logger.info(f"Loading/compiling model {model_name}.")
+        try:
+            self.__pymoca_model = pymoca.backends.casadi.api.transfer_model(
+                kwargs["model_folder"], model_name, compiler_options
+            )
+        except RuntimeError as error:
+            if compiler_options.get("cache", False):
+                raise error
+            compiler_options["cache"] = False
+            logger.warning(f"Loading model {model_name} using a cache file failed: {error}.")
+            logger.info(f"Compiling model {model_name}.")
+            self.__pymoca_model = pymoca.backends.casadi.api.transfer_model(
+                kwargs["model_folder"], model_name, compiler_options
+            )
 
         # Extract the CasADi MX variables used in the model
         self.__mx = {}
@@ -319,6 +339,17 @@ class SimulationProblem(DataStoreAccessor):
         """
         Initialize state vector with default values
 
+        Initial values are first read from the given Modelica files.
+        If an initial value equals zero or is not provided by a Modelica file,
+        and the variable is not marked as fixed,
+        then the initial value is tried to be set with the initial_state method.
+        When using CSVMixin, this method by default looks for initial values
+        in an initial_state.csv file.
+        Furthermore, if a variable is not marked as fixed
+        and no initial value is given by the initial_state method,
+        the initial value can be overwritten using the seed method.
+        When a variable is marked as fixed, the initial value is only read from the Modelica file.
+
         :param config_file: Path to an initialization file.
         """
         if config_file:
@@ -393,29 +424,33 @@ class SimulationProblem(DataStoreAccessor):
         for var in itertools.chain(self.__pymoca_model.states, self.__pymoca_model.alg_states):
             var_name = var.symbol.name()
             var_nominal = self.get_variable_nominal(var_name)
+            start_values = {}
 
             # Attempt to cast var.start to python type
             mx_start = ca.MX(var.start)
             if mx_start.is_constant():
                 # cast var.start to python type
-                start_val = var.python_type(mx_start.to_DM())
+                start_value_pymoca = var.python_type(mx_start.to_DM())
+                if start_value_pymoca is not None and start_value_pymoca != 0:
+                    start_values["modelica"] = start_value_pymoca
             else:
-                # var.start is a symbolic expression with unknown value
-                start_val = None
+                start_values["modelica"] = mx_start
 
-            if start_val == 0.0 and not var.fixed:
+            if not var.fixed:
                 # To make initialization easier, we allow setting initial states by providing
                 # timeseries with names that match a symbol in the model. We only check for this
                 # matching if the start and fixed attributes were left as default
                 try:
-                    start_val = self.initial_state()[var_name]
+                    start_values["initial_state"] = self.initial_state()[var_name]
                 except KeyError:
                     pass
                 else:
                     # An initial state was found- add it to the constrained residuals
                     logger.debug(
                         "Initialize: Added {} = {} to initial equations "
-                        "(found matching timeseries).".format(var_name, start_val)
+                        "(found matching timeseries).".format(
+                            var_name, start_values["initial_state"]
+                        )
                     )
                     # Set var to be fixed
                     var.fixed = True
@@ -425,36 +460,82 @@ class SimulationProblem(DataStoreAccessor):
                 # timeseries with names that match a symbol in the model. We only check for this
                 # matching if the start and fixed attributes were left as default
                 try:
-                    start_val = self.seed()[var_name]
+                    start_values["seed"] = self.seed()[var_name]
                 except KeyError:
                     pass
                 else:
                     # An initial state was found- add it to the constrained residuals
                     logger.debug(
                         "Initialize: Added {} = {} as initial guess "
-                        "(found matching timeseries).".format(var_name, start_val)
+                        "(found matching timeseries).".format(var_name, start_values["seed"])
+                    )
+
+            # Set the start value based on the different inputs.
+            if "seed" in start_values:
+                input_source = "seed"
+                source_description = "seed method"
+            elif "modelica" in start_values:
+                input_source = "modelica"
+                source_description = "modelica file"
+            elif "initial_state" in start_values:
+                input_source = "initial_state"
+                source_description = "initial_state method (typically reads initial_state.csv)"
+            else:
+                start_values["modelica"] = start_value_pymoca
+                input_source = "modelica"
+                source_description = "modelica file or default value"
+            start_val = start_values.get(input_source, None)
+            start_is_numeric = start_val is not None and not isinstance(start_val, ca.MX)
+            numeric_start_val = start_val if start_is_numeric else 0.0
+            if len(start_values) > 1:
+                logger.warning(
+                    "Initialize: Multiple initial values for {} are provided: {}.".format(
+                        var_name, start_values
                     )
+                    + " Value from {} will be used to continue.".format(source_description)
+                )
 
             # Attempt to set start_val in the state vector. Default to zero if unknown.
             try:
-                self.set_var(var_name, start_val if start_val is not None else 0.0)
+                self.set_var(var_name, numeric_start_val)
             except KeyError:
                 logger.warning(
-                    "Initialize: {} not found in state vector. "
-                    "Initial value of {} not set.".format(var_name, start_val)
+                    "Initialize: {} not found in state vector. Initial value of {} not set.".format(
+                        var_name, numeric_start_val
+                    )
                 )
 
             # Add a residual for the difference between the state and its starting expression
-            start_expr = start_val if start_val is not None else var.start
+            start_expr = start_val
+            min_is_symbolic = isinstance(var.min, ca.MX)
+            max_is_symbolic = isinstance(var.max, ca.MX)
             if var.fixed:
                 # Set bounds to be equal to each other, such that IPOPT can
                 # turn the decision variable into a parameter.
+                if min_is_symbolic or max_is_symbolic or var.min != -np.inf or var.max != np.inf:
+                    logger.info(
+                        "Initialize: bounds of {} will be overwritten".format(var_name)
+                        + " by the start value given by {}.".format(source_description)
+                    )
                 var.min = start_expr
                 var.max = start_expr
             else:
                 # minimize residual
                 minimized_residuals.append((var.symbol - start_expr) / var_nominal)
 
+            # Check that the start_value is in between the variable bounds.
+            if start_is_numeric and not min_is_symbolic and not max_is_symbolic:
+                if not (var.min <= start_val and start_val <= var.max):
+                    logger.log(
+                        (
+                            logging.WARNING
+                            if source_description != "modelica file or default value"
+                            else logging.DEBUG
+                        ),
+                        f"Initialize: start value {var_name} = {start_val} "
+                        f"is not in between bounds {var.min} and {var.max} and will be adjusted.",
+                    )
+
         # Default start var for ders is zero
         for der_var in self.__mx["derivatives"]:
             self.set_var(der_var.name(), 0.0)
@@ -610,7 +691,15 @@ class SimulationProblem(DataStoreAccessor):
         # If unsuccessful, stop.
         return_status = solver.stats()["return_status"]
         if return_status not in {"Solve_Succeeded", "Solved_To_Acceptable_Level"}:
-            raise Exception('Initialization Failed with return status "{}"'.format(return_status))
+            if return_status == "Infeasible_Problem_Detected":
+                message = (
+                    "Initialization Failed with return status: {}. ".format(return_status)
+                    + "This means no initial state could be found "
+                    + "that satisfies all equations and constraints."
+                )
+            else:
+                message = "Initialization Failed with return status: {}. ".format(return_status)
+            raise Exception(message)
 
         # Update state vector with initial conditions
         self.__state_vector[: self.__n_states] = initial_state["x"][: self.__n_states].T
@@ -762,6 +851,8 @@ class SimulationProblem(DataStoreAccessor):
         self.set_var("time", self.get_current_time() + dt)
 
         # take a step
+        if np.isnan(self.__state_vector).any():
+            logger.error("Found a nan in the state vector (before making the step)")
         guess = self.__state_vector[: self.__n_states]
         if len(self.__mx["parameters"]) > 0:
             next_state = self.__do_step(
@@ -769,6 +860,23 @@ class SimulationProblem(DataStoreAccessor):
             )
         else:
             next_state = self.__do_step(guess, dt, self.__state_vector)
+
+        try:
+            if np.isnan(next_state).any():
+                index_to_name = {index[0]: name for name, index in self.__indices.items()}
+                named_next_state = {
+                    index_to_name[i]: float(next_state[i]) for i in range(0, next_state.shape[0])
+                }
+                variables_with_nan = [
+                    name for name, value in named_next_state.items() if np.isnan(value)
+                ]
+                if variables_with_nan:
+                    logger.error(
+                        f"Found nan(s) in the next_state vector for:\n\t {variables_with_nan}"
+                    )
+        except (KeyError, IndexError, TypeError):
+            logger.warning("Something went wrong while checking for nans in the next_state vector")
+
         # Check convergence of rootfinder
         rootfinder_stats = self.__do_step.stats()
 
@@ -964,9 +1072,9 @@ class SimulationProblem(DataStoreAccessor):
         :param dt: Timestep size of the simulation.
         """
         if self._dt_is_fixed:
-            assert math.isclose(
-                self.__dt, dt
-            ), "Timestep size dt is marked as constant and cannot be changed."
+            assert math.isclose(self.__dt, dt), (
+                "Timestep size dt is marked as constant and cannot be changed."
+            )
         else:
             self.__dt = dt
 
@@ -1149,9 +1257,9 @@ class SimulationProblem(DataStoreAccessor):
         # 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 importlib_metadata.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(str(importlib.resources.files(ep.module).joinpath(ep.attr)))
 
         compiler_options["library_folders"] = library_folders
 

rtctools/util.py

@@ -110,6 +110,7 @@ def run_optimization_problem(
             "GoalProgrammingMixin",
             "PIMixin",
             "CSVMixin",
+            "IOMixin",
             "ModelicaMixin",
             "PlanningMixin",
             "ControlTreeMixin",

rtc_tools-2.6.0b2.dist-info/RECORD

@@ -1,50 +0,0 @@
-rtctools/__init__.py,sha256=91hvS2-ryd2Pvw0COpsUzTwJwSnTZ035REiej-1hNI4,107
-rtctools/_version.py,sha256=dUPcNcf2xQ9Ynkv1d2c0aTxHuz_HBjht0yZ3i8NDzGc,499
-rtctools/rtctoolsapp.py,sha256=A6M0v6vymAZWdBPLzgRVyAUfahD0knC8B4IptJ7_sBM,4097
-rtctools/util.py,sha256=PaeKfDUA174ODZbY5fZjCTf-F-TdhW7yEuP189Ro190,9075
-rtctools/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rtctools/_internal/alias_tools.py,sha256=XuQSAhhFuVtwn0yrAObZWIKPsSF4j2axXRtEmitIFPs,5310
-rtctools/_internal/caching.py,sha256=p4gqSL7kCI7Hff-KjMEP7mhJCQSiU_lYm2MR7E18gBM,905
-rtctools/_internal/casadi_helpers.py,sha256=oAf5zyFkZbaMhvhgMnQkOi2A6dBOzj-VAUkYwBf-Jxk,1410
-rtctools/_internal/debug_check_helpers.py,sha256=UgQTEPw4PyR7MbYLewSSWQqTwQj7xr5yUBk820O9Kk4,1084
-rtctools/data/__init__.py,sha256=EllgSmCdrlvQZSd1VilvjPaeYJGhY9ErPiQtedmuFoA,157
-rtctools/data/csv.py,sha256=iYOEED3AaNxt4ews_aAkHfl9Tq9a-9vjxvYwjVR_lQE,5231
-rtctools/data/netcdf.py,sha256=xpk4Ggl7gItNG6lO7p3OJPR-elK8_CiCtxUI7cX0gwk,19109
-rtctools/data/pi.py,sha256=hBgK_dSLv_V9pWFGNzOEnG76ffLsjW3SBSWfgVJpXSA,45380
-rtctools/data/rtc.py,sha256=FBuUQ6aL4D3y6puKudyuLAeP_vmpDiliqzJg8f1kd7g,9043
-rtctools/data/storage.py,sha256=67J4BRTl0AMEzlKNZ8Xdpy_4cGtwx8Lo_tL2n0G4S9w,13206
-rtctools/data/interpolation/__init__.py,sha256=GBubCIT5mFoSTV-lOk7cpwvZekNMEe5bvqSQJ9HE34M,73
-rtctools/data/interpolation/bspline.py,sha256=qevB842XWCH3fWlWMBqKMy1mw37ust-0YtSnb9PKCEc,948
-rtctools/data/interpolation/bspline1d.py,sha256=hQrok4rrBcJV_HciuFjZYSwrSP8w_VufQRP6JLZhA7U,6106
-rtctools/data/interpolation/bspline2d.py,sha256=ScmX0fPDxbUVtj3pbUE0L7UJocqroD_6fUT-4cvdRMc,1693
-rtctools/optimization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rtctools/optimization/collocated_integrated_optimization_problem.py,sha256=Bv1a1O4QTAdIpe9SOA9_oEDDph-oj-9q5yfN4SFMdW8,131343
-rtctools/optimization/control_tree_mixin.py,sha256=CC6TWp3kFQgMokx6213pRLx9iY17Fd0VcwG4Wpwa0Uo,8974
-rtctools/optimization/csv_lookup_table_mixin.py,sha256=xiyOKpPT3kQ6yuxSJRorGYW_QwnlBzW6vvrtvQNhHsE,17264
-rtctools/optimization/csv_mixin.py,sha256=sRp5paHWfCw2bz-23Nw-HdFLS3CZTpVwaBdFo98DbvE,12252
-rtctools/optimization/goal_programming_mixin.py,sha256=GK25DrbAY_rMsra080pSCDZwzLQNN2Ppd-2d0_FEllg,32999
-rtctools/optimization/goal_programming_mixin_base.py,sha256=oh9CsEiyYTmthcfvRbX-9Z9bIo6SHv_DCiVt9kx0sjI,43781
-rtctools/optimization/homotopy_mixin.py,sha256=Kh0kMfxB-Fo1FBGW5tPOQk24Xx_Mmw_p0YuSQotdkMU,6905
-rtctools/optimization/initial_state_estimation_mixin.py,sha256=74QYfG-VYYTNVg-kAnCG6QoY3_sUmaID0ideF7bPkkY,3116
-rtctools/optimization/io_mixin.py,sha256=AsZQ7YOUcUbWoczmjTXaSje5MUEsPNbQyZBJ6qzSjzU,11821
-rtctools/optimization/linearization_mixin.py,sha256=mG5S7uwvwDydw-eBPyQKnLyKoy08EBjQh25vu97afhY,1049
-rtctools/optimization/linearized_order_goal_programming_mixin.py,sha256=LQ2qpYt0YGLpEoerif4FJ5wwzq16q--27bsRjcqIU5A,9087
-rtctools/optimization/min_abs_goal_programming_mixin.py,sha256=WMOv9EF8cfDJgTunzXfI_cUmBSQK26u1HJB_9EAarfM,14031
-rtctools/optimization/modelica_mixin.py,sha256=ysVMayNA4sSFoHkSdhjWOxT6UzOVbN0ZeM4v-RpvZXE,17161
-rtctools/optimization/netcdf_mixin.py,sha256=-zkXh3sMYE50c3kHsrmUVGWMSFm-0cXQpGrCm0yn-Tc,7563
-rtctools/optimization/optimization_problem.py,sha256=qzpc81NaZMeoXKuayFmBF15iXYuNAk5yxmaER_Gcz_A,44131
-rtctools/optimization/pi_mixin.py,sha256=63qda6i7hjtDuP3hL6RO29vCCP11aUpR9B4KoqlLFVI,11314
-rtctools/optimization/planning_mixin.py,sha256=O_Y74X8xZmaNZR4iYOe7BR06s9hnmcapbuHYHQTBPPQ,724
-rtctools/optimization/single_pass_goal_programming_mixin.py,sha256=Zb9szg3PGT2o6gkGsXluSfEaAswkw3TKfPQDzUrj_Y4,25784
-rtctools/optimization/timeseries.py,sha256=nCrsGCJThBMh9lvngEpbBDa834_QvklVvkxJqwX4a1M,1734
-rtctools/simulation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rtctools/simulation/csv_mixin.py,sha256=rGDUFPsqGHmF0_dWdXeWzWzMpkPmwCNweTBVrwSh31g,6704
-rtctools/simulation/io_mixin.py,sha256=SJasNGI--OQ9Y-Z61oeeaGCxSrNddYz4AOVfJYbmf74,6209
-rtctools/simulation/pi_mixin.py,sha256=uwl61LYjb8dmMz910EB2-bC0KSuhLzsrJzk0hxWYEhk,9359
-rtctools/simulation/simulation_problem.py,sha256=gTAimG2MLw_TTkeHLkIMxpYgAmR-voqzvje7pcFnw4U,44556
-rtc_tools-2.6.0b2.dist-info/COPYING.LESSER,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
-rtc_tools-2.6.0b2.dist-info/METADATA,sha256=J_s90hgXnSTTIZg76jopXRUeL0V3VUJfOyvorAaE_1s,1452
-rtc_tools-2.6.0b2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-rtc_tools-2.6.0b2.dist-info/entry_points.txt,sha256=-x622IB_l1duw2M6t6syfQ4yzOiQTp0IZxKGcYRgWgk,151
-rtc_tools-2.6.0b2.dist-info/top_level.txt,sha256=pnBrb58PFPd1kp1dqa-JHU7R55h3alDNJIJnF3Jf9Dw,9
-rtc_tools-2.6.0b2.dist-info/RECORD,,