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

rtctools/optimization/csv_mixin.py

@@ -20,7 +20,8 @@ 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.
 
     In ensemble mode, a file named ``ensemble.csv`` is read from the ``input`` folder.  This file
     contains two columns. The first column gives the name of the ensemble member, and the second
@@ -44,16 +45,16 @@ class CSVMixin(IOMixin):
     """
 
     #: Initial state file basename
-    csv_initial_state_basename = 'initial_state'
+    csv_initial_state_basename = "initial_state"
 
     #: Parameters file basename
-    csv_parameters_basename = 'parameters'
+    csv_parameters_basename = "parameters"
 
     #: Ensemble file basename
-    csv_ensemble_basename = 'ensemble'
+    csv_ensemble_basename = "ensemble"
 
     #: Column delimiter used in CSV files
-    csv_delimiter = ','
+    csv_delimiter = ","
 
     #: Whether or not the timeseries data is equidistant
     csv_equidistant = True
@@ -80,20 +81,27 @@ 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, self.csv_initial_state_basename + '.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, self.csv_initial_state_basename + ".csv")
+                    )
+                )
 
         # Read CSV files
         self.__initial_state = []
         if self.csv_ensemble_mode:
             self.__ensemble = np.genfromtxt(
-                os.path.join(self._input_folder, self.csv_ensemble_basename + '.csv'),
-                delimiter=",", deletechars='', dtype=None, names=True, encoding=None)
+                os.path.join(self._input_folder, self.csv_ensemble_basename + ".csv"),
+                delimiter=",",
+                deletechars="",
+                dtype=None,
+                names=True,
+                encoding=None,
+            )
 
             logger.debug("CSVMixin: Read ensemble description")
 
-            for ensemble_member_index, ensemble_member_name in enumerate(self.__ensemble['name']):
+            for ensemble_member_index, ensemble_member_name in enumerate(self.__ensemble["name"]):
                 _timeseries = csv.load(
                     os.path.join(
                         self._input_folder,
@@ -112,37 +120,47 @@ class CSVMixin(IOMixin):
                         key,
                         self.__timeseries_times,
                         np.asarray(_timeseries[key], dtype=np.float64),
-                        ensemble_member_index
+                        ensemble_member_index,
                     )
             logger.debug("CSVMixin: Read timeseries")
 
-            for ensemble_member_index, ensemble_member_name in enumerate(self.__ensemble['name']):
+            for ensemble_member_index, ensemble_member_name in enumerate(self.__ensemble["name"]):
                 try:
-                    _parameters = csv.load(os.path.join(
-                        self._input_folder, ensemble_member_name, self.csv_parameters_basename + '.csv'),
-                        delimiter=self.csv_delimiter)
+                    _parameters = csv.load(
+                        os.path.join(
+                            self._input_folder,
+                            ensemble_member_name,
+                            self.csv_parameters_basename + ".csv",
+                        ),
+                        delimiter=self.csv_delimiter,
+                    )
                     for key in _parameters.dtype.names:
                         self.io.set_parameter(key, float(_parameters[key]), ensemble_member_index)
                 except IOError:
                     pass
             logger.debug("CSVMixin: Read parameters.")
 
-            for ensemble_member_name in self.__ensemble['name']:
+            for ensemble_member_name in self.__ensemble["name"]:
                 try:
-                    _initial_state = csv.load(os.path.join(
-                        self._input_folder, ensemble_member_name, self.csv_initial_state_basename + '.csv'),
-                        delimiter=self.csv_delimiter)
+                    _initial_state = csv.load(
+                        os.path.join(
+                            self._input_folder,
+                            ensemble_member_name,
+                            self.csv_initial_state_basename + ".csv",
+                        ),
+                        delimiter=self.csv_delimiter,
+                    )
                     check_initial_state_array(_initial_state)
-                    _initial_state = {key: float(_initial_state[key]) for key in _initial_state.dtype.names}
+                    _initial_state = {
+                        key: float(_initial_state[key]) for key in _initial_state.dtype.names
+                    }
                 except IOError:
                     _initial_state = {}
                 self.__initial_state.append(AliasDict(self.alias_relation, _initial_state))
             logger.debug("CSVMixin: Read initial state.")
         else:
             _timeseries = csv.load(
-                os.path.join(
-                    self._input_folder, self.timeseries_import_basename + ".csv"
-                ),
+                os.path.join(self._input_folder, self.timeseries_import_basename + ".csv"),
                 delimiter=self.csv_delimiter,
                 with_time=True,
             )
@@ -151,12 +169,16 @@ class CSVMixin(IOMixin):
             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))
+                self.io.set_timeseries(
+                    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, self.csv_parameters_basename + '.csv'), delimiter=self.csv_delimiter)
+                _parameters = csv.load(
+                    os.path.join(self._input_folder, self.csv_parameters_basename + ".csv"),
+                    delimiter=self.csv_delimiter,
+                )
                 logger.debug("CSVMixin: Read parameters.")
                 for key in _parameters.dtype.names:
                     self.io.set_parameter(key, float(_parameters[key]))
@@ -164,11 +186,15 @@ class CSVMixin(IOMixin):
                 pass
 
             try:
-                _initial_state = csv.load(os.path.join(
-                    self._input_folder, self.csv_initial_state_basename + '.csv'), delimiter=self.csv_delimiter)
+                _initial_state = csv.load(
+                    os.path.join(self._input_folder, self.csv_initial_state_basename + ".csv"),
+                    delimiter=self.csv_delimiter,
+                )
                 logger.debug("CSVMixin: Read initial state.")
                 check_initial_state_array(_initial_state)
-                _initial_state = {key: float(_initial_state[key]) for key in _initial_state.dtype.names}
+                _initial_state = {
+                    key: float(_initial_state[key]) for key in _initial_state.dtype.names
+                }
             except IOError:
                 _initial_state = {}
             self.__initial_state.append(AliasDict(self.alias_relation, _initial_state))
@@ -178,8 +204,7 @@ class CSVMixin(IOMixin):
             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.")
 
         if self.csv_equidistant:
             # Check if the timeseries are truly equidistant
@@ -189,13 +214,14 @@ 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 csv_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 csv_equidistant = False if this is intended.".format(times[i + 1])
+                        )
 
     def ensemble_member_probability(self, ensemble_member):
         if self.csv_ensemble_mode:
-            return self.__ensemble['probability'][ensemble_member]
+            return self.__ensemble["probability"][ensemble_member]
         else:
             return 1.0
 
@@ -207,11 +233,12 @@ class CSVMixin(IOMixin):
         initial_time = np.array([self.initial_time])
 
         # Load parameters from parameter config
-        for variable in self.dae_variables['free_variables']:
+        for variable in self.dae_variables["free_variables"]:
             variable = variable.name()
             try:
-                history[variable] = Timeseries(initial_time,
-                                               self.__initial_state[ensemble_member][variable])
+                history[variable] = Timeseries(
+                    initial_time, self.__initial_state[ensemble_member][variable]
+                )
             except (KeyError, ValueError):
                 pass
             else:
@@ -228,30 +255,33 @@ class CSVMixin(IOMixin):
 
         def write_output(ensemble_member, folder):
             results = self.extract_results(ensemble_member)
-            names = ['time'] + sorted({sym.name() for sym in self.output_variables})
-            formats = ['O'] + (len(names) - 1) * ['f8']
-            dtype = {'names': names, 'formats': formats}
+            names = ["time"] + sorted({sym.name() for sym in self.output_variables})
+            formats = ["O"] + (len(names) - 1) * ["f8"]
+            dtype = {"names": names, "formats": formats}
             data = np.zeros(len(times), dtype=dtype)
-            data['time'] = [self.io.reference_datetime + timedelta(seconds=s) for s in times]
+            data["time"] = [self.io.reference_datetime + timedelta(seconds=s) for s in times]
             for output_variable in self.output_variables:
                 output_variable = output_variable.name()
                 try:
                     values = results[output_variable]
                     if len(values) != len(times):
                         values = self.interpolate(
-                            times, self.times(output_variable), values, self.interpolation_method(output_variable))
+                            times,
+                            self.times(output_variable),
+                            values,
+                            self.interpolation_method(output_variable),
+                        )
                 except KeyError:
                     try:
-                        ts = self.get_timeseries(
-                            output_variable, ensemble_member)
+                        ts = self.get_timeseries(output_variable, 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(
-                            "Output requested for non-existent variable {}".format(output_variable))
+                            "Output requested for non-existent variable {}".format(output_variable)
+                        )
                         continue
                 data[output_variable] = values
 
@@ -259,8 +289,9 @@ class CSVMixin(IOMixin):
             csv.save(fname, data, delimiter=self.csv_delimiter, with_time=True)
 
         if self.csv_ensemble_mode:
-            for ensemble_member, ensemble_member_name in enumerate(self.__ensemble['name']):
-                write_output(ensemble_member, os.path.join(
-                    self._output_folder, ensemble_member_name))
+            for ensemble_member, ensemble_member_name in enumerate(self.__ensemble["name"]):
+                write_output(
+                    ensemble_member, os.path.join(self._output_folder, ensemble_member_name)
+                )
         else:
             write_output(0, self._output_folder)