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

rtctools/simulation/csv_mixin.py

@@ -17,14 +17,15 @@ class CSVMixin(IOMixin):
     During preprocessing, files named ``timeseries_import.csv``, ``initial_state.csv``,
     and ``parameters.csv`` are read from the ``input`` subfolder.
 
-    During postprocessing, a file named ``timeseries_export.csv`` is written to the ``output`` subfolder.
+    During postprocessing, a file named ``timeseries_export.csv`` is written to the ``output``
+    subfolder.
 
     :cvar csv_delimiter:           Column delimiter used in CSV files.  Default is ``,``.
     :cvar csv_validate_timeseries: Check consistency of timeseries.  Default is ``True``.
     """
 
     #: Column delimiter used in CSV files
-    csv_delimiter = ','
+    csv_delimiter = ","
 
     #: Check consistency of timeseries
     csv_validate_timeseries = True
@@ -45,30 +46,32 @@ class CSVMixin(IOMixin):
             """
             if initial_state.shape:
                 raise Exception(
-                    'CSVMixin: Initial state file {} contains more than one row of data. '
-                    'Please remove the data row(s) that do not describe the initial '
-                    'state.'.format(os.path.join(self._input_folder, 'initial_state.csv')))
+                    "CSVMixin: Initial state file {} contains more than one row of data. "
+                    "Please remove the data row(s) that do not describe the initial "
+                    "state.".format(os.path.join(self._input_folder, "initial_state.csv"))
+                )
 
         # Read CSV files
         _timeseries = csv.load(
-            os.path.join(self._input_folder, self.timeseries_import_basename + '.csv'),
-            delimiter=self.csv_delimiter, with_time=True)
+            os.path.join(self._input_folder, self.timeseries_import_basename + ".csv"),
+            delimiter=self.csv_delimiter,
+            with_time=True,
+        )
         self.__timeseries_times = _timeseries[_timeseries.dtype.names[0]]
 
         self.io.reference_datetime = self.__timeseries_times[0]
 
         for key in _timeseries.dtype.names[1:]:
             self.io.set_timeseries(
-                key,
-                self.__timeseries_times,
-                np.asarray(_timeseries[key], dtype=np.float64))
+                key, self.__timeseries_times, np.asarray(_timeseries[key], dtype=np.float64)
+            )
 
         logger.debug("CSVMixin: Read timeseries.")
 
         try:
             _parameters = csv.load(
-                os.path.join(self._input_folder, 'parameters.csv'),
-                delimiter=self.csv_delimiter)
+                os.path.join(self._input_folder, "parameters.csv"), delimiter=self.csv_delimiter
+            )
             for key in _parameters.dtype.names:
                 self.io.set_parameter(key, float(_parameters[key]))
             logger.debug("CSVMixin: Read parameters.")
@@ -77,12 +80,13 @@ class CSVMixin(IOMixin):
 
         try:
             _initial_state = csv.load(
-                os.path.join(self._input_folder, 'initial_state.csv'),
-                delimiter=self.csv_delimiter)
+                os.path.join(self._input_folder, "initial_state.csv"), delimiter=self.csv_delimiter
+            )
             logger.debug("CSVMixin: Read initial state.")
             check_initial_state_array(_initial_state)
             self.__initial_state = {
-                key: float(_initial_state[key]) for key in _initial_state.dtype.names}
+                key: float(_initial_state[key]) for key in _initial_state.dtype.names
+            }
         except IOError:
             self.__initial_state = {}
 
@@ -92,16 +96,16 @@ class CSVMixin(IOMixin):
                 continue
             else:
                 logger.warning(
-                    'CSVMixin: Entry {} in initial_state.csv conflicts with '
-                    'timeseries_import.csv'.format(collision))
+                    "CSVMixin: Entry {} in initial_state.csv conflicts with "
+                    "timeseries_import.csv".format(collision)
+                )
 
         # Timestamp check
         if self.csv_validate_timeseries:
             times = self.__timeseries_times
             for i in range(len(times) - 1):
                 if times[i] >= times[i + 1]:
-                    raise Exception(
-                        'CSVMixin: Time stamps must be strictly increasing.')
+                    raise Exception("CSVMixin: Time stamps must be strictly increasing.")
 
         times = self.__timeseries_times
         dt = times[1] - times[0]
@@ -111,10 +115,10 @@ class CSVMixin(IOMixin):
             for i in range(len(times) - 1):
                 if times[i + 1] - times[i] != dt:
                     raise Exception(
-                        'CSVMixin: Expecting equidistant timeseries, the time step '
-                        'towards {} is not the same as the time step(s) before. '
-                        'Set equidistant=False if this is intended.'.format(
-                            times[i + 1]))
+                        "CSVMixin: Expecting equidistant timeseries, the time step "
+                        "towards {} is not the same as the time step(s) before. "
+                        "Set equidistant=False if this is intended.".format(times[i + 1])
+                    )
 
     def write(self):
         # Call parent class first for default behaviour.
@@ -123,15 +127,15 @@ class CSVMixin(IOMixin):
         times = self._simulation_times
 
         # Write output
-        names = ['time'] + sorted(set(self._io_output_variables))
-        formats = ['O'] + (len(names) - 1) * ['f8']
-        dtype = {'names': names, 'formats': formats}
+        names = ["time"] + sorted(set(self._io_output_variables))
+        formats = ["O"] + (len(names) - 1) * ["f8"]
+        dtype = {"names": names, "formats": formats}
         data = np.zeros(len(times), dtype=dtype)
-        data['time'] = self.io.sec_to_datetime(times, self.io.reference_datetime)
+        data["time"] = self.io.sec_to_datetime(times, self.io.reference_datetime)
         for variable in self._io_output_variables:
             data[variable] = np.array(self._io_output[variable])
 
-        fname = os.path.join(self._output_folder, self.timeseries_export_basename + '.csv')
+        fname = os.path.join(self._output_folder, self.timeseries_export_basename + ".csv")
         csv.save(fname, data, delimiter=self.csv_delimiter, with_time=True)
 
     @cached
@@ -149,7 +153,6 @@ class CSVMixin(IOMixin):
 
         # Load initial states from __initial_state
         for variable, value in self.__initial_state.items():
-
             # Get the cannonical vars and signs
             canonical_var, sign = self.alias_relation.canonical_signed(variable)
 
@@ -160,5 +163,9 @@ class CSVMixin(IOMixin):
                 if logger.getEffectiveLevel() == logging.DEBUG:
                     logger.debug("CSVMixin: Read initial state {} = {}".format(variable, value))
             else:
-                logger.warning("CSVMixin: In initial_state.csv, {} is not an input or state variable.".format(variable))
+                logger.warning(
+                    "CSVMixin: In initial_state.csv, {} is not an input or state variable.".format(
+                        variable
+                    )
+                )
         return initial_state

rtctools/simulation/io_mixin.py

@@ -34,7 +34,8 @@ class IOMixin(SimulationProblem, metaclass=ABCMeta):
     @abstractmethod
     def read(self) -> None:
         """
-        Reads input data from files, storing it in the internal data store through the various set or add methods
+        Reads input data from files, storing it in the internal data store through the various set
+        or add methods
         """
         pass
 
@@ -44,8 +45,9 @@ class IOMixin(SimulationProblem, metaclass=ABCMeta):
 
     @abstractmethod
     def write(self) -> None:
-        """"
-        Writes output data to files, getting the data from the data store through the various get methods
+        """
+        Writes output data to files, getting the data from the data store through the various get
+        methods
         """
         pass
 
@@ -102,8 +104,10 @@ class IOMixin(SimulationProblem, metaclass=ABCMeta):
             if isfinite(value):
                 self.set_var(variable, value)
             else:
-                logger.debug("IOMixin: Found bad value {} at index [{}] in timeseries aliased to input {}"
-                             .format(value, t_idx, variable))
+                logger.debug(
+                    "IOMixin: Found bad value {} at index [{}] "
+                    "in timeseries aliased to input {}".format(value, t_idx, variable)
+                )
 
     def update(self, dt):
         # Time step

rtctools/simulation/pi_mixin.py

@@ -16,16 +16,19 @@ class PIMixin(IOMixin):
     <https://publicwiki.deltares.nl/display/FEWSDOC/The+Delft-Fews+Published+Interface>`_
     I/O to your simulation problem.
 
-    During preprocessing, files named ``rtcDataConfig.xml``, ``timeseries_import.xml``,  and``rtcParameterConfig.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``,
+    and``rtcParameterConfig.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``.
     :cvar pi_parameter_config_basenames:
         List of parameter config file basenames to read. Default is [``rtcParameterConfig``].
-    :cvar pi_check_for_duplicate_parameters: Check if duplicate parameters are read. Default is ``True``.
+    :cvar pi_check_for_duplicate_parameters:
+        Check if duplicate parameters are read. Default is ``True``.
     :cvar pi_validate_timeseries: Check consistency of timeseries.  Default is ``True``.
     """
 
@@ -33,7 +36,7 @@ class PIMixin(IOMixin):
     pi_binary_timeseries = False
 
     #: Location of rtcParameterConfig files
-    pi_parameter_config_basenames = ['rtcParameterConfig']
+    pi_parameter_config_basenames = ["rtcParameterConfig"]
 
     #: Check consistency of timeseries
     pi_validate_timeseries = True
@@ -60,11 +63,15 @@ 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 FileNotFoundError:
             raise FileNotFoundError(
-                "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
+                )
+            )
 
         # Make a parameters dict for later access
         for parameter_config in self.__parameter_config:
@@ -77,15 +84,27 @@ class PIMixin(IOMixin):
 
         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 FileNotFoundError:
-            raise FileNotFoundError('PIMixin: {}.xml not found in {}'.format(
-                self.timeseries_import_basename, self._input_folder))
+            raise FileNotFoundError(
+                "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
@@ -94,8 +113,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 ValueError(
-                        'PIMixin: Time stamps must be strictly increasing.')
+                    raise ValueError("PIMixin: Time stamps must be strictly increasing.")
 
         # Check if the timeseries are equidistant
         dt = timeseries_import_times[1] - timeseries_import_times[0]
@@ -103,10 +121,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 ValueError(
-                        '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]
+                        )
+                    )
 
         # Stick timeseries into an AliasDict
         self.io.reference_datetime = self.__timeseries_import.forecast_datetime
@@ -115,7 +135,9 @@ class PIMixin(IOMixin):
         for variable, values in self.__timeseries_import.items(self.pi_ensemble_member):
             self.io.set_timeseries(variable, timeseries_import_times, values)
             if debug and variable in self.get_variables():
-                logger.debug('PIMixin: Timeseries {} replaced another aliased timeseries.'.format(variable))
+                logger.debug(
+                    "PIMixin: Timeseries {} replaced another aliased timeseries.".format(variable)
+                )
 
     def write(self):
         # Call parent class first for default behaviour.
@@ -129,7 +151,9 @@ class PIMixin(IOMixin):
 
         # Start of write output
         # Write the time range for the export file.
-        self.__timeseries_export.times = [self.io.reference_datetime + timedelta(seconds=s) for s in times]
+        self.__timeseries_export.times = [
+            self.io.reference_datetime + timedelta(seconds=s) for s in times
+        ]
 
         # Write other time settings
         self.__timeseries_export.forecast_datetime = self.io.reference_datetime
@@ -149,12 +173,15 @@ class PIMixin(IOMixin):
                 self.__data_config.pi_variable_ids(variable)
             except KeyError:
                 logger.debug(
-                    'PIMixin: variable {} has no mapping defined in rtcDataConfig '
-                    'so cannot be added to the output file.'.format(variable))
+                    "PIMixin: variable {} has no mapping defined in rtcDataConfig "
+                    "so cannot be added to the output file.".format(variable)
+                )
                 continue
 
             # Add series to output file
-            self.__timeseries_export.set(variable, values, unit=self.__timeseries_import.get_unit(variable))
+            self.__timeseries_export.set(
+                variable, values, unit=self.__timeseries_import.get_unit(variable)
+            )
 
         # Write output file to disk
         self.__timeseries_export.write()
@@ -186,10 +213,12 @@ class PIMixin(IOMixin):
         if check_consistency:
             if len(self.times()) != len(values):
                 raise ValueError(
-                    'PIMixin: Trying to set/append values {} with a different '
-                    'length than the forecast length. Please make sure the '
-                    'values cover forecastDate through endDate with timestep {}.'.format(
-                        variable, self.__timeseries_import.dt))
+                    "PIMixin: Trying to set/append values {} with a different "
+                    "length than the forecast length. Please make sure the "
+                    "values cover forecastDate through endDate with timestep {}.".format(
+                        variable, self.__timeseries_import.dt
+                    )
+                )
 
         if unit is None:
             unit = self.__timeseries_import.get_unit(variable)
@@ -199,8 +228,9 @@ class PIMixin(IOMixin):
                 self.__data_config.pi_variable_ids(variable)
             except KeyError:
                 logger.debug(
-                    'PIMixin: variable {} has no mapping defined in rtcDataConfig '
-                    'so cannot be added to the output file.'.format(variable))
+                    "PIMixin: variable {} has no mapping defined in rtcDataConfig "
+                    "so cannot be added to the output file.".format(variable)
+                )
             else:
                 self.__timeseries_export.set(variable, values, unit=unit)