rtc-tools 2.5.1rc1__tar.gz → 2.5.2a2__tar.gz

{rtc-tools-2.5.1rc1/src/rtc_tools.egg-info → rtc-tools-2.5.2a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rtc-tools
-Version: 2.5.1rc1
+Version: 2.5.2a2
 Summary: Toolbox for control and optimization of water systems.
 Home-page: https://oss.deltares.nl/web/rtc-tools/home
 Author: Deltares

{rtc-tools-2.5.1rc1 → rtc-tools-2.5.2a2}/setup.py

@@ -42,8 +42,8 @@ setup(
     packages = find_packages("src"),
     package_dir = {"": "src"},
     install_requires = ["casadi == 3.5.*",
-                        "numpy >= 1.16.0",
-                        "scipy >= 1.0.0",
+                        "numpy >= 1.16.0, <1.23",
+                        "scipy >= 1.0.0, <1.11",
                         "pymoca == 0.9.*",
                         "rtc-tools-channel-flow >= 1.1.0"],
     tests_require = ['pytest', 'pytest-runner'],

{rtc-tools-2.5.1rc1 → rtc-tools-2.5.2a2/src/rtc_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rtc-tools
-Version: 2.5.1rc1
+Version: 2.5.2a2
 Summary: Toolbox for control and optimization of water systems.
 Home-page: https://oss.deltares.nl/web/rtc-tools/home
 Author: Deltares

{rtc-tools-2.5.1rc1 → rtc-tools-2.5.2a2}/src/rtc_tools.egg-info/requires.txt

@@ -1,6 +1,6 @@
 casadi==3.5.*
-numpy>=1.16.0
-scipy>=1.0.0
+numpy<1.23,>=1.16.0
+scipy<1.11,>=1.0.0
 pymoca==0.9.*
 rtc-tools-channel-flow>=1.1.0
 

{rtc-tools-2.5.1rc1 → rtc-tools-2.5.2a2}/src/rtctools/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2022-12-08T16:06:43+0000",
+ "date": "2023-03-21T15:45:07+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "3f949d10da42fb1aa8b9888f742771dd50947494",
- "version": "2.5.1rc1"
+ "full-revisionid": "51c2d6cf97df52e8a6790dc74aa9ec0866fc5a5c",
+ "version": "2.5.2a2"
 }
 '''  # END VERSION_JSON
 

{rtc-tools-2.5.1rc1 → rtc-tools-2.5.2a2}/src/rtctools/data/pi.py

@@ -732,14 +732,6 @@ class Timeseries:
         if self.__binary:
             f = io.open(self.binary_path, 'wb')
 
-        if self.timezone is not None:
-            timezone = self.__xml_root.find('pi:timeZone', ns)
-            if timezone is None:
-                timezone = ET.Element('{%s}' % (ns['pi'], ) + 'timeZone')
-                # timeZone has to be the first element according to the schema
-                self.__xml_root.insert(0, timezone)
-            timezone.text = str(self.timezone)
-
         if self.make_new_file:
             # Force reinitialization in case write() is called more than once
             self.__reset_xml_tree()
@@ -753,6 +745,14 @@ class Timeseries:
                         ensemble_member=ensemble_member, miss_val=-999, unit=unit)
 
         for ensemble_member in range(len(self.__values)):
+            if self.timezone is not None:
+                timezone = self.__xml_root.find('pi:timeZone', ns)
+                if timezone is None:
+                    timezone = ET.Element('{%s}' % (ns['pi'],) + 'timeZone')
+                    # timeZone has to be the first element according to the schema
+                    self.__xml_root.insert(0, timezone)
+                timezone.text = str(self.timezone)
+
             for series in self.__xml_root.findall('pi:series', ns):
                 header = series.find('pi:header', ns)
 

{rtc-tools-2.5.1rc1 → rtc-tools-2.5.2a2}/src/rtctools/optimization/collocated_integrated_optimization_problem.py

@@ -227,7 +227,7 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
 
         if self.integrated_states:
             warnings.warn("Integrated states are deprecated and support will be removed in a future version.",
-                          FutureWarning)
+                          FutureWarning, stacklevel=1)
 
         # Variables that are integrated states are not yet allowed to have size > 1
         for variable in self.integrated_states:
@@ -442,7 +442,8 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
         # Establish integrator theta
         theta = self.theta
         if theta < 1:
-            warnings.warn("Explicit collocation is deprecated and will be removed in a future version.", FutureWarning)
+            warnings.warn("Explicit collocation is deprecated and will be removed in a future version.",
+                          FutureWarning, stacklevel=1)
 
         # Set CasADi function options
         options = self.solver_options()
@@ -1326,7 +1327,8 @@ class CollocatedIntegratedOptimizationProblem(OptimizationProblem, metaclass=ABC
                             ca.repmat(np.nan, len(self.path_variables)),
                             ca.repmat(np.nan, len(self.__extra_constant_inputs))),
                          ca.repmat(np.nan, len(self.extra_variables))])
-                    delayed_feedback_history[i, :] = history_delayed_feedback_res
+                    delayed_feedback_history[i, :] = [
+                        float(val) for val in history_delayed_feedback_res]
 
                 initial_delayed_feedback = delayed_feedback_function.call(
                     self.__func_initial_inputs[ensemble_member], False, True)

{rtc-tools-2.5.1rc1 → rtc-tools-2.5.2a2}/src/rtctools/optimization/csv_lookup_table_mixin.py

@@ -293,6 +293,11 @@ class CSVLookupTableMixin(OptimizationProblem):
                 curve_name, *curvefit_options))
             return tuple(curvefit_options)
 
+        def check_lookup_table(lookup_table):
+            if lookup_table in self.__lookup_tables:
+                raise Exception(
+                    "Cannot add lookup table {},"
+                    "since there is already one with this name.".format(lookup_table))
         # Read CSV files
         logger.info(
             "CSVLookupTableMixin: Generating Splines from lookup table data.")
@@ -365,6 +370,7 @@ class CSVLookupTableMixin(OptimizationProblem):
                 symbols = [ca.SX.sym(inputs[0])]
                 if not valid_cache:
                     function = ca.Function('f', symbols, [BSpline1D(*tck)(symbols[0])])
+                check_lookup_table(output)
                 self.__lookup_tables[output] = LookupTable(symbols, function, tck)
 
             elif len(csvinput.dtype.names) == 3:
@@ -400,6 +406,7 @@ class CSVLookupTableMixin(OptimizationProblem):
                 symbols = [ca.SX.sym(inputs[0]), ca.SX.sym(inputs[1])]
                 if not valid_cache:
                     function = ca.Function('f', symbols, [BSpline2D(*tck)(symbols[0], symbols[1])])
+                check_lookup_table(output)
                 self.__lookup_tables[output] = LookupTable(symbols, function, tck)
 
             else:

{rtc-tools-2.5.1rc1 → rtc-tools-2.5.2a2}/src/rtctools/optimization/goal_programming_mixin.py

@@ -563,7 +563,7 @@ class GoalProgrammingMixin(_GoalProgrammingMixinBase):
             self.pre()
 
         # Group goals into subproblems
-        subproblems = []
+        self.subproblems = []
         goals = self.goals()
         path_goals = self.path_goals()
 
@@ -580,7 +580,7 @@ class GoalProgrammingMixin(_GoalProgrammingMixinBase):
         priorities = {int(goal.priority) for goal in itertools.chain(goals, path_goals) if not goal.is_empty}
 
         for priority in sorted(priorities):
-            subproblems.append((
+            self.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]))
@@ -605,7 +605,7 @@ class GoalProgrammingMixin(_GoalProgrammingMixinBase):
         self.__results_are_current = False
         self.__original_constant_input_keys = {}
         self.__original_parameter_keys = {}
-        for i, (priority, goals, path_goals) in enumerate(subproblems):
+        for i, (priority, goals, path_goals) in enumerate(self.subproblems):
             logger.info("Solving goals at priority {}".format(priority))
 
             # Call the pre priority hook

{rtc-tools-2.5.1rc1 → rtc-tools-2.5.2a2}/src/rtctools/optimization/io_mixin.py

@@ -310,5 +310,6 @@ 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)
+        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)

{rtc-tools-2.5.1rc1 → rtc-tools-2.5.2a2}/src/rtctools/optimization/optimization_problem.py

@@ -155,12 +155,34 @@ class OptimizationProblem(DataStoreAccessor, metaclass=ABCMeta):
 
         success, log_level = self.solver_success(self.__solver_stats, log_solver_failure_as_error)
 
+        return_status = self.__solver_stats['return_status']
+        if 'secondary_return_status' in self.__solver_stats:
+            return_status = "{}: {}".format(return_status, self.__solver_stats['secondary_return_status'])
+        wall_clock_time = "elapsed time not read"
+        if 't_wall_total' in self.__solver_stats:
+            wall_clock_time = "{} seconds".format(self.__solver_stats['t_wall_total'])
+        elif 't_wall_solver' in self.__solver_stats:
+            wall_clock_time = "{} seconds".format(self.__solver_stats['t_wall_solver'])
+
         if success:
-            logger.log(log_level, "Solver succeeded with status {}".format(
-                self.__solver_stats['return_status']))
+            logger.log(log_level, "Solver succeeded with status {} ({}).".format(
+                return_status, wall_clock_time))
         else:
-            logger.log(log_level, "Solver failed with status {}".format(
-                self.__solver_stats['return_status']))
+            try:
+                ii = [y[0] for y in self.loop_over_error].index(self.priority)
+                loop_error_indicator = self.loop_over_error[ii][1]
+                try:
+                    loop_error = self.loop_over_error[ii][2]
+                    if loop_error_indicator and loop_error in return_status:
+                        log_level = logging.INFO
+                except IndexError:
+                    if loop_error_indicator:
+                        log_level = logging.INFO
+                logger.log(log_level, "Solver succeeded with status {} ({}).".format(
+                        return_status, wall_clock_time))
+            except (AttributeError, ValueError):
+                logger.log(log_level, "Solver succeeded with status {} ({}).".format(
+                    return_status, wall_clock_time))
 
         # Do any postprocessing
         if postprocessing: