rtc-tools 2.7.3__py3-none-any.whl

rtctools/optimization/timeseries.py

@@ -0,0 +1,56 @@
+from typing import Union
+
+import casadi as ca
+import numpy as np
+
+
+class Timeseries:
+    """
+    Time series object, bundling time stamps with values.
+    """
+
+    def __init__(self, times: np.ndarray, values: Union[float, np.ndarray, list, ca.DM]):
+        """
+        Create a new time series object.
+
+        :param times:  Iterable of time stamps.
+        :param values: Iterable of values.
+        """
+        self.__times = times
+
+        if isinstance(values, ca.DM):
+            # Note that a ca.DM object has no __iter__ attribute, which we
+            # want it to have. We also want it to store it as a _flat_ array,
+            # not a 2-D column vector.
+            assert values.shape[0] == 1 or values.shape[1] == 1, "Only 1D ca.DM objects supported"
+            values = values.toarray().ravel()
+        elif isinstance(values, (np.ndarray, list)) and len(values) == 1:
+            values = values[0]
+
+        if hasattr(values, "__iter__"):
+            self.__values = np.array(values, dtype=np.float64, copy=True)
+        else:
+            self.__values = np.full_like(times, values, dtype=np.float64)
+
+    @property
+    def times(self) -> np.ndarray:
+        """
+        Array of time stamps.
+        """
+        return self.__times
+
+    @property
+    def values(self) -> np.ndarray:
+        """
+        Array of values.
+        """
+        return self.__values
+
+    def __neg__(self) -> "Timeseries":
+        return self.__class__(self.times, -self.values)
+
+    def __repr__(self) -> str:
+        return "Timeseries({}, {})".format(self.__times, self.__values)
+
+    def __eq__(self, other: "Timeseries") -> bool:
+        return np.array_equal(self.times, other.times) and np.array_equal(self.values, other.values)

rtctools/rtctoolsapp.py

@@ -0,0 +1,131 @@
+import importlib.resources
+import logging
+import os
+import shutil
+import sys
+from pathlib import Path
+
+# 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 rtctools
+
+logging.basicConfig(format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger("rtctools")
+logger.setLevel(logging.INFO)
+
+
+def copy_libraries(*args):
+    if not args:
+        args = sys.argv[1:]
+
+    if not args:
+        path = input("Folder to put the Modelica libraries: [.] ") or "."
+    else:
+        path = args[0]
+
+    if not os.path.exists(path):
+        sys.exit("Folder '{}' does not exist".format(path))
+
+    def _copytree(src, dst, symlinks=False, ignore=None):
+        if not os.path.exists(dst):
+            os.makedirs(dst)
+        for item in os.listdir(src):
+            s = os.path.join(src, item)
+            d = os.path.join(dst, item)
+            if os.path.isdir(s):
+                _copytree(s, d, symlinks, ignore)
+            else:
+                if not os.path.exists(d):
+                    shutil.copy2(s, d)
+                elif Path(s).name.lower() == "package.mo":
+                    # Pick the largest one, assuming that all plugin packages
+                    # to not provide a meaningful package.mo
+                    if os.stat(s).st_size > os.stat(d).st_size:
+                        logger.warning(
+                            "Overwriting '{}' with '{}' as the latter is larger.".format(d, s)
+                        )
+                        os.remove(d)
+                        shutil.copy2(s, d)
+                    else:
+                        logger.warning(
+                            "Not copying '{}' to '{}' as the latter is larger.".format(s, d)
+                        )
+                else:
+                    raise OSError("Could not combine two folders")
+
+    dst = Path(path)
+
+    library_folders = []
+
+    for ep in importlib_metadata.entry_points(group="rtctools.libraries.modelica"):
+        if ep.name == "library_folder":
+            library_folders.append(Path(importlib.resources.files(ep.module).joinpath(ep.attr)))
+
+    tlds = {}
+    for lf in library_folders:
+        for x in lf.iterdir():
+            if x.is_dir():
+                tlds.setdefault(x.name, []).append(x)
+
+    for tld, paths in tlds.items():
+        if Path(tld).exists():
+            sys.exit("Library with name '{}'' already exists".format(tld))
+
+        try:
+            for p in paths:
+                _copytree(p, dst / p.name)
+        except OSError:
+            sys.exit("Failed merging the libraries in package '{}'".format(tld))
+
+    sys.exit("Succesfully copied all library folders to '{}'".format(dst.resolve()))
+
+
+def download_examples(*args):
+    if not args:
+        args = sys.argv[1:]
+
+    if not args:
+        path = input("Folder to download the examples to: [.] ") or "."
+    else:
+        path = args[0]
+
+    if not os.path.exists(path):
+        sys.exit("Folder '{}' does not exist".format(path))
+
+    path = Path(path)
+
+    import urllib.request
+    from urllib.error import HTTPError
+    from zipfile import ZipFile
+
+    version = rtctools.__version__
+    try:
+        url = "https://github.com/rtc-tools/rtc-tools/zipball/{}".format(version)
+
+        opener = urllib.request.build_opener()
+        urllib.request.install_opener(opener)
+        # The security warning can be dismissed as the url variable is hardcoded to a remote.
+        local_filename, _ = urllib.request.urlretrieve(url)  # nosec
+    except HTTPError:
+        sys.exit("Could not found examples for RTC-Tools version {}.".format(version))
+
+    with ZipFile(local_filename, "r") as z:
+        target = path / "rtc-tools-examples"
+        zip_folder_name = next(x for x in z.namelist() if x.startswith("Deltares-rtc-tools-"))
+        prefix = "{}/examples/".format(zip_folder_name.rstrip("/"))
+        members = [x for x in z.namelist() if x.startswith(prefix)]
+        z.extractall(members=members)
+        shutil.move(prefix, target)
+        shutil.rmtree(zip_folder_name)
+
+        sys.exit("Succesfully downloaded the RTC-Tools examples to '{}'".format(target.resolve()))
+
+    try:
+        os.remove(local_filename)
+    except OSError:
+        pass

rtctools/simulation/csv_mixin.py

@@ -0,0 +1,171 @@
+import logging
+import os
+
+import numpy as np
+
+import rtctools.data.csv as csv
+from rtctools._internal.caching import cached
+from rtctools.simulation.io_mixin import IOMixin
+
+logger = logging.getLogger("rtctools")
+
+
+class CSVMixin(IOMixin):
+    """
+    Adds reading and writing of CSV timeseries and parameters to your simulation problem.
+
+    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.
+
+    :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 = ","
+
+    #: Check consistency of timeseries
+    csv_validate_timeseries = True
+
+    def __init__(self, **kwargs):
+        # Call parent class first for default behaviour.
+        super().__init__(**kwargs)
+
+    def read(self):
+        # Call parent class first for default behaviour.
+        super().read()
+
+        # Helper function to check if initial state array actually defines
+        # only the initial state
+        def check_initial_state_array(initial_state):
+            """
+            Check length of initial state array, throw exception when larger than 1.
+            """
+            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"))
+                )
+
+        # Read CSV files
+        _timeseries = csv.load(
+            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)
+            )
+
+        logger.debug("CSVMixin: Read timeseries.")
+
+        try:
+            _parameters = csv.load(
+                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.")
+        except IOError:
+            pass
+
+        try:
+            _initial_state = csv.load(
+                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
+            }
+        except IOError:
+            self.__initial_state = {}
+
+        # Check for collisions in __initial_state and timeseries import (CSV)
+        for collision in set(self.__initial_state) & set(_timeseries.dtype.names[1:]):
+            if self.__initial_state[collision] == _timeseries[collision][0]:
+                continue
+            else:
+                logger.warning(
+                    "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.")
+
+        times = self.__timeseries_times
+        dt = times[1] - times[0]
+
+        # Check if the timeseries are truly equidistant
+        if self.csv_validate_timeseries:
+            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])
+                    )
+
+    def write(self):
+        # Call parent class first for default behaviour.
+        super().write()
+
+        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}
+        data = np.zeros(len(times), dtype=dtype)
+        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")
+        csv.save(fname, data, delimiter=self.csv_delimiter, with_time=True)
+
+    @cached
+    def initial_state(self):
+        """
+        The initial state. Includes entries from parent classes and initial_state.csv
+
+        :returns: A dictionary of variable names and initial state (t0) values.
+        """
+        # Call parent class first for default values.
+        initial_state = super().initial_state()
+
+        # Set of model vars that are allowed to have an initial state
+        valid_model_vars = set(self.get_state_variables()) | set(self.get_input_variables())
+
+        # 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)
+
+            # Only store variables that are allowed to have an initial state
+            if canonical_var in valid_model_vars:
+                initial_state[canonical_var] = value * sign
+
+                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
+                    )
+                )
+        return initial_state

rtctools/simulation/io_mixin.py

@@ -0,0 +1,195 @@
+import bisect
+import logging
+from abc import ABCMeta, abstractmethod
+from math import isfinite
+
+import numpy as np
+
+from rtctools._internal.alias_tools import AliasDict
+from rtctools._internal.caching import cached
+from rtctools.simulation.simulation_problem import SimulationProblem
+
+logger = logging.getLogger("rtctools")
+
+
+class IOMixin(SimulationProblem, metaclass=ABCMeta):
+    """
+    Base class for all IO methods of optimization problems.
+    """
+
+    def __init__(self, **kwargs):
+        # Call parent class first for default behaviour.
+        super().__init__(**kwargs)
+
+        self._simulation_times = []
+
+        self.__first_update_call = True
+
+    def pre(self) -> None:
+        # Call read method to read all input
+        self.read()
+
+        self._simulation_times = []
+
+    @abstractmethod
+    def read(self) -> None:
+        """
+        Reads input data from files, storing it in the internal data store through the various set
+        or add methods
+        """
+        pass
+
+    def post(self) -> None:
+        # Call write method to write all output
+        self.write()
+
+    @abstractmethod
+    def write(self) -> None:
+        """
+        Writes output data to files, getting the data from the data store through the various get
+        methods
+        """
+        pass
+
+    def initialize(self, config_file=None):
+        # Set up experiment
+        timeseries_import_times = self.io.times_sec
+        self.__dt = timeseries_import_times[1] - timeseries_import_times[0]
+        self.setup_experiment(0, timeseries_import_times[-1], self.__dt)
+
+        parameter_variables = set(self.get_parameter_variables())
+
+        logger.debug("Model parameters are {}".format(parameter_variables))
+
+        for parameter, value in self.io.parameters().items():
+            if parameter in parameter_variables:
+                logger.debug("IOMixin: Setting parameter {} = {}".format(parameter, value))
+                self.set_var(parameter, value)
+
+        # Load input variable names
+        self.__input_variables = set(self.get_input_variables().keys())
+
+        # Set input values
+        t_idx = bisect.bisect_left(timeseries_import_times, 0.0)
+        self.__set_input_variables(t_idx)
+
+        logger.debug("Model inputs are {}".format(self.__input_variables))
+
+        # Set first timestep
+        self._simulation_times.append(self.get_current_time())
+
+        # Empty output
+        self._io_output_variables = self.get_output_variables()
+        self._io_output = AliasDict(self.alias_relation)
+
+        # Call super, which will also initialize the model itself
+        super().initialize(config_file)
+
+        # Extract consistent t0 values
+        for variable in self._io_output_variables:
+            self._io_output[variable] = [self.get_var(variable)]
+
+    def __set_input_variables(self, t_idx, use_cache=False):
+        if not use_cache:
+            self.__cache_loop_timeseries = {}
+
+            timeseries_names = set(self.io.get_timeseries_names(0))
+            for v in self.get_input_variables():
+                if v in timeseries_names:
+                    _, values = self.io.get_timeseries_sec(v)
+                    self.__cache_loop_timeseries[v] = values
+
+        for variable, values in self.__cache_loop_timeseries.items():
+            value = values[t_idx]
+            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)
+                )
+
+    def update(self, dt):
+        # Time step
+        if dt < 0:
+            dt = self.__dt
+
+        # Current time stamp
+        t = self.get_current_time()
+        self._simulation_times.append(t + dt)
+
+        # Get current time index
+        t_idx = bisect.bisect_left(self.io.times_sec, t + dt)
+
+        # Set input values
+        self.__set_input_variables(t_idx, not self.__first_update_call)
+
+        # Call super
+        super().update(dt)
+
+        # Extract results
+        for variable, values in self._io_output.items():
+            values.append(self.get_var(variable))
+
+        self.__first_update_call = False
+
+    def extract_results(self):
+        """
+        Extracts the results of output
+
+        :returns: An AliasDict of output variables and results array format.
+        """
+        io_outputs_arrays = self._io_output.copy()
+        for k in io_outputs_arrays.keys():
+            io_outputs_arrays[k] = np.array(io_outputs_arrays[k])
+
+        return io_outputs_arrays
+
+    @cached
+    def parameters(self):
+        """
+        Return a dictionary of parameters, including parameters in the input files files.
+
+        :returns: Dictionary of parameters
+        """
+        # Call parent class first for default values.
+        parameters = super().parameters()
+
+        # Load parameters from input files (stored in internal data store)
+        for parameter_name, value in self.io.parameters().items():
+            parameters[parameter_name] = value
+
+        if logger.getEffectiveLevel() == logging.DEBUG:
+            for parameter_name in self.io.parameters().keys():
+                logger.debug("IOMixin: Read parameter {}".format(parameter_name))
+
+        return parameters
+
+    def times(self, variable=None):
+        """
+        Return a list of all the timesteps in seconds.
+
+        :param variable: Variable name.
+
+        :returns: List of all the timesteps in seconds.
+        """
+        idx = bisect.bisect_left(self.io.datetimes, self.io.reference_datetime)
+        return self.io.times_sec[idx:]
+
+    def timeseries_at(self, variable, t):
+        """
+        Return the value of a time series at the given time.
+
+        :param variable: Variable name.
+        :param t: Time.
+
+        :returns: The interpolated value of the time series.
+
+        :raises: KeyError
+        """
+        timeseries_times_sec, values = self.io.get_timeseries_sec(variable)
+        t_idx = bisect.bisect_left(timeseries_times_sec, t)
+        if timeseries_times_sec[t_idx] == t:
+            return values[t_idx]
+        else:
+            return np.interp(t, timeseries_times_sec, values)