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

rtctools/optimization/pi_mixin.py

@@ -14,11 +14,13 @@ class PIMixin(IOMixin):
     <https://publicwiki.deltares.nl/display/FEWSDOC/The+Delft-Fews+Published+Interface>`_
     I/O to your optimization problem.
 
-    During preprocessing, files named ``rtcDataConfig.xml``, ``timeseries_import.xml``, ``rtcParameterConfig.xml``,
-    and ``rtcParameterConfig_Numerical.xml`` are read from the ``input`` subfolder.  ``rtcDataConfig.xml`` maps
-    tuples of FEWS identifiers, including location and parameter ID, to RTC-Tools time series identifiers.
+    During preprocessing, files named ``rtcDataConfig.xml``, ``timeseries_import.xml``,
+    ``rtcParameterConfig.xml``, and ``rtcParameterConfig_Numerical.xml`` are read from the
+    ``input`` subfolder.  ``rtcDataConfig.xml`` maps tuples of FEWS identifiers, including
+    location and parameter ID, to RTC-Tools time series identifiers.
 
-    During postprocessing, a file named ``timeseries_export.xml`` is written to the ``output`` subfolder.
+    During postprocessing, a file named ``timeseries_export.xml`` is written to the ``output``
+    subfolder.
 
     :cvar pi_binary_timeseries:
         Whether to use PI binary timeseries format. Default is ``False``.
@@ -36,8 +38,8 @@ class PIMixin(IOMixin):
     pi_binary_timeseries = False
 
     #: Location of rtcParameterConfig files
-    pi_parameter_config_basenames = ['rtcParameterConfig']
-    pi_parameter_config_numerical_basename = 'rtcParameterConfig_Numerical'
+    pi_parameter_config_basenames = ["rtcParameterConfig"]
+    pi_parameter_config_numerical_basename = "rtcParameterConfig_Numerical"
 
     #: Check consistency of timeseries
     pi_validate_timeseries = True
@@ -61,29 +63,46 @@ class PIMixin(IOMixin):
         self.__parameter_config = []
         try:
             for pi_parameter_config_basename in self.pi_parameter_config_basenames:
-                self.__parameter_config.append(pi.ParameterConfig(
-                    self._input_folder, pi_parameter_config_basename))
+                self.__parameter_config.append(
+                    pi.ParameterConfig(self._input_folder, pi_parameter_config_basename)
+                )
         except IOError:
             raise Exception(
-                "PIMixin: {}.xml not found in {}.".format(pi_parameter_config_basename, self._input_folder))
+                "PIMixin: {}.xml not found in {}.".format(
+                    pi_parameter_config_basename, self._input_folder
+                )
+            )
 
         try:
             self.__parameter_config_numerical = pi.ParameterConfig(
-                self._input_folder, self.pi_parameter_config_numerical_basename)
+                self._input_folder, self.pi_parameter_config_numerical_basename
+            )
         except IOError:
             self.__parameter_config_numerical = None
 
         try:
             self.__timeseries_import = pi.Timeseries(
-                self.__data_config, self._input_folder, self.timeseries_import_basename,
-                binary=self.pi_binary_timeseries, pi_validate_times=self.pi_validate_timeseries)
+                self.__data_config,
+                self._input_folder,
+                self.timeseries_import_basename,
+                binary=self.pi_binary_timeseries,
+                pi_validate_times=self.pi_validate_timeseries,
+            )
         except IOError:
-            raise Exception("PIMixin: {}.xml not found in {}.".format(
-                self.timeseries_import_basename, self._input_folder))
+            raise Exception(
+                "PIMixin: {}.xml not found in {}.".format(
+                    self.timeseries_import_basename, self._input_folder
+                )
+            )
 
         self.__timeseries_export = pi.Timeseries(
-            self.__data_config, self._output_folder, self.timeseries_export_basename,
-            binary=self.pi_binary_timeseries, pi_validate_times=False, make_new_file=True)
+            self.__data_config,
+            self._output_folder,
+            self.timeseries_export_basename,
+            binary=self.pi_binary_timeseries,
+            pi_validate_times=False,
+            make_new_file=True,
+        )
 
         # Convert timeseries timestamps to seconds since t0 for internal use
         timeseries_import_times = self.__timeseries_import.times
@@ -92,8 +111,7 @@ class PIMixin(IOMixin):
         if self.pi_validate_timeseries:
             for i in range(len(timeseries_import_times) - 1):
                 if timeseries_import_times[i] >= timeseries_import_times[i + 1]:
-                    raise Exception(
-                        'PIMixin: Time stamps must be strictly increasing.')
+                    raise Exception("PIMixin: Time stamps must be strictly increasing.")
 
         if self.__timeseries_import.dt:
             # Check if the timeseries are truly equidistant
@@ -102,10 +120,12 @@ class PIMixin(IOMixin):
                 for i in range(len(timeseries_import_times) - 1):
                     if timeseries_import_times[i + 1] - timeseries_import_times[i] != dt:
                         raise Exception(
-                            'PIMixin: Expecting equidistant timeseries, the time step '
-                            'towards {} is not the same as the time step(s) before. Set '
-                            'unit to nonequidistant if this is intended.'.format(
-                                timeseries_import_times[i + 1]))
+                            "PIMixin: Expecting equidistant timeseries, the time step "
+                            "towards {} is not the same as the time step(s) before. Set "
+                            "unit to nonequidistant if this is intended.".format(
+                                timeseries_import_times[i + 1]
+                            )
+                        )
 
         # Offer input timeseries to IOMixin
         self.io.reference_datetime = self.__timeseries_import.forecast_datetime
@@ -120,12 +140,18 @@ class PIMixin(IOMixin):
             for parameter_config in self.__parameter_config:
                 for location_id, model_id, parameter_id, value in parameter_config:
                     try:
-                        parameter = self.__data_config.parameter(parameter_id, location_id, model_id)
+                        parameter = self.__data_config.parameter(
+                            parameter_id, location_id, model_id
+                        )
                     except KeyError:
                         parameter = parameter_id
 
-                    self.io.set_parameter(parameter, value, ensemble_member,
-                                          check_duplicates=self.pi_check_for_duplicate_parameters)
+                    self.io.set_parameter(
+                        parameter,
+                        value,
+                        ensemble_member,
+                        check_duplicates=self.pi_check_for_duplicate_parameters,
+                    )
 
     def solver_options(self):
         # Call parent
@@ -157,7 +183,9 @@ class PIMixin(IOMixin):
         # Write the time range for the export file.
         self.__timeseries_export.times = [
             self.__timeseries_import.times[self.__timeseries_import.forecast_index]
-            + timedelta(seconds=s) for s in times]
+            + timedelta(seconds=s)
+            for s in times
+        ]
 
         # Write other time settings
         self.__timeseries_export.forecast_datetime = self.__timeseries_import.forecast_datetime
@@ -168,7 +196,7 @@ class PIMixin(IOMixin):
         if self.ensemble_size > 1:
             self.__timeseries_export.contains_ensemble = True
         self.__timeseries_export.ensemble_size = self.ensemble_size
-        self.__timeseries_export.contains_ensemble = (self.ensemble_size > 1)
+        self.__timeseries_export.contains_ensemble = self.ensemble_size > 1
 
         # Start looping over the ensembles for extraction of the output values.
         for ensemble_member in range(self.ensemble_size):
@@ -182,19 +210,20 @@ class PIMixin(IOMixin):
                         values = results[alias]
                         if len(values) != len(times):
                             values = self.interpolate(
-                                times, self.times(alias), values, self.interpolation_method(alias))
+                                times, self.times(alias), values, self.interpolation_method(alias)
+                            )
                     except KeyError:
                         try:
                             ts = self.get_timeseries(alias, ensemble_member)
                             if len(ts.times) != len(times):
-                                values = self.interpolate(
-                                    times, ts.times, ts.values)
+                                values = self.interpolate(times, ts.times, ts.values)
                             else:
                                 values = ts.values
                         except KeyError:
                             logger.error(
-                                'PIMixin: Output requested for non-existent alias {}. '
-                                'Will not be in output file.'.format(alias))
+                                "PIMixin: Output requested for non-existent alias {}. "
+                                "Will not be in output file.".format(alias)
+                            )
                             continue
 
                     # Check if ID mapping is present
@@ -202,17 +231,20 @@ class PIMixin(IOMixin):
                         self.__data_config.pi_variable_ids(alias)
                     except KeyError:
                         logger.debug(
-                            'PIMixin: variable {} has no mapping defined in rtcDataConfig '
-                            'so cannot be added to the output file.'.format(alias))
+                            "PIMixin: variable {} has no mapping defined in rtcDataConfig "
+                            "so cannot be added to the output file.".format(alias)
+                        )
                         continue
 
                     # Add series to output file.
                     # NOTE: We use the unit of the zeroth ensemble member, as
                     # we might be outputting more ensembles than we read in.
                     self.__timeseries_export.set(
-                        alias, values,
+                        alias,
+                        values,
                         unit=self.__timeseries_import.get_unit(alias, ensemble_member=0),
-                        ensemble_member=ensemble_member)
+                        ensemble_member=ensemble_member,
+                    )
 
         # Write output file to disk
         self.__timeseries_export.write()

rtctools/optimization/planning_mixin.py

@@ -0,0 +1,19 @@
+from rtctools.optimization.optimization_problem import OptimizationProblem
+
+
+class PlanningMixin(OptimizationProblem):
+    """
+    Uses default discretization logic for planning variables, but uses
+    dedicated per-ensemble-member decision variables for other, non-planning control
+    variables.
+    """
+
+    # Planning variables
+    planning_variables = []
+
+    def discretize_control(self, variable, ensemble_member, times, offset):
+        if variable not in self.planning_variables:
+            # Non-planning variables are never shared between ensemble members
+            return slice(offset, offset + len(times))
+        else:
+            return super().discretize_control(variable, ensemble_member, times, offset)