pybounds 0.0.1__py3-none-any.whl

pybounds/__init__.py

@@ -0,0 +1,11 @@
+
+from .simulator import Simulator
+
+from .observability import EmpiricalObservabilityMatrix
+from .observability import SlidingEmpiricalObservabilityMatrix
+from .observability import FisherObservability
+from .observability import SlidingFisherObservability
+from .observability import ObservabilityMatrixImage
+
+from .util import colorline
+

pybounds/observability.py

@@ -0,0 +1,579 @@
+
+import numpy as np
+import pandas as pd
+from multiprocessing import Pool
+import warnings
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+import sympy as sp
+from util import LatexStates
+
+
+class EmpiricalObservabilityMatrix:
+    def __init__(self, simulator, x0, t_sim, u_sim, eps=1e-5, parallel=False):
+        """ Construct an empirical observability matrix O.
+
+        Inputs
+            simulator:          simulator object: y = simulator(x0, t_sim, u_sim)
+            x0:                 initial state
+            t_sim:              simulation time
+            u_sim:              simulation inputs
+            eps:                amount to perturb initial states
+        """
+
+        # Store inputs
+        self.simulator = simulator
+        self.t_sim = t_sim.copy()
+        self.eps = eps
+        self.parallel = parallel
+
+        if isinstance(x0, dict):
+            self.x0 = np.array(list(x0.values()))
+        else:
+            self.x0 = np.array(x0).squeeze()
+
+        if isinstance(u_sim, dict):
+            self.u_sim = np.vstack(list(u_sim.values())).T
+        else:
+            self.u_sim = np.array(u_sim)
+
+        # Simulate once for nominal trajectory
+        self.y_nominal = self.simulator.simulate(self.x0, self.u_sim)
+        self.x_nominal = self.simulator.x.copy()
+        self.u_nominal = self.simulator.u.copy()
+        # self.sim_data_nominal = self.simulator.sim_data.copy()
+
+        # Perturbation amounts
+        self.w = len(t_sim)  # of points in time window
+        self.delta_x = eps * np.eye(self.simulator.n)  # perturbation amount for each state
+        self.delta_y = np.zeros((self.simulator.p, self.simulator.n, self.w))  # preallocate delta_y
+        self.y_plus = np.zeros((self.w, self.simulator.n, self.simulator.p))
+        self.y_minus = np.zeros((self.w, self.simulator.n, self.simulator.p))
+
+        # Observability matrix
+        self.O = np.nan * np.zeros((self.simulator.p * self.w, self.simulator.n))
+        self.O_df = pd.DataFrame(self.O)
+
+        # Set measurement names
+        self.measurement_labels = []
+        self.time_labels = []
+        for w in range(self.w):
+            tl = (w * np.ones(self.simulator.p)).astype(int)
+            self.time_labels.append(tl)
+            self.measurement_labels = self.measurement_labels + list(self.simulator.output_mode)
+
+        self.time_labels = np.hstack(self.time_labels)
+
+        # Run
+        self.run()
+
+    def run(self, parallel=None):
+        """ Construct empirical observability matrix.
+        """
+
+        if parallel is not None:
+            self.parallel = parallel
+
+        # Run simulations for perturbed initial conditions
+        state_index = np.arange(0, self.simulator.n).tolist()
+        if self.parallel:  # multiprocessing
+            with Pool(4) as pool:
+                results = pool.map(self.simulate, state_index)
+
+            for n, r in enumerate(results):
+                delta_y, y_plus, y_minus = r
+                self.delta_y[:, n, :] = delta_y
+                self.y_plus[:, n, :] = y_plus
+                self.y_minus[:, n, :] = y_minus
+
+        else:  # sequential
+            for n in state_index:
+                delta_y, y_plus, y_minus = self.simulate(n)
+                self.delta_y[:, n, :] = delta_y
+                self.y_plus[:, n, :] = y_plus
+                self.y_minus[:, n, :] = y_minus
+
+        # Construct O by stacking the 3rd dimension of delta_y along the 1st dimension, O is a (p*w x n) matrix
+        self.O = np.zeros((self.simulator.p * self.w, self.simulator.n))
+        for w in range(self.w):
+            if w == 0:
+                start_index = 0
+            else:
+                start_index = int(w * self.simulator.p)
+
+            end_index = start_index + self.simulator.p
+            self.O[start_index:end_index] = self.delta_y[:, :, w]
+
+        # Make O into a data-frame for interpretability
+        self.O_df = pd.DataFrame(self.O, columns=self.simulator.state_names, index=self.measurement_labels)
+        self.O_df['time_step'] = self.time_labels
+        self.O_df = self.O_df.set_index('time_step', append=True)
+        self.O_df.index.names = ['sensor', 'time_step']
+
+    def simulate(self, n):
+        """ Run the simulator for specified state index (n).
+        """
+
+        # Perturb initial condition in both directions
+        x0_plus = self.x0 + self.delta_x[:, n]
+        x0_minus = self.x0 - self.delta_x[:, n]
+
+        # Simulate measurements from perturbed initial conditions
+        y_plus = self.simulator.simulate(x0=x0_plus, u=self.u_sim)
+        y_minus = self.simulator.simulate(x0=x0_minus, u=self.u_sim)
+
+        # Calculate the numerical Jacobian & normalize by 2x the perturbation amount
+        delta_y = np.array(y_plus - y_minus).T / (2 * self.eps)
+
+        return delta_y, y_plus, y_minus
+
+
+class SlidingEmpiricalObservabilityMatrix:
+    def __init__(self, simulator, t_sim, x_sim, u_sim, w=None, eps=1e-5, parallel=False):
+        """ Construct an empirical observability matrix O in sliding windows along a trajectory.
+
+            Inputs
+                simulator:          simulator object
+                t_sim:              simulation time along trajectory
+                u_sim:              simulation inputs along trajectory
+                x_sim:              state trajectory
+                w:                  simulation window size for each calculation of O
+                eps:                amount to perturb initial state
+        """
+
+        self.simulator = simulator
+        self.t_sim = t_sim.copy()
+        self.eps = eps
+        self.parallel = parallel
+
+        if isinstance(x_sim, dict):
+            self.x_sim = np.vstack((list(x_sim.values()))).T
+        else:
+            self.x_sim = np.array(x_sim).squeeze()
+
+        if isinstance(u_sim, dict):
+            self.u_sim = np.vstack(list(u_sim.values())).T
+        else:
+            self.u_sim = np.array(u_sim).squeeze()
+
+        # self.dt = np.round(np.mean(np.diff(self.t_sim)), 6)
+        self.N = self.t_sim.shape[0]
+
+        if w is None:  # set window size to full time-series size
+            self.w = self.N
+        else:
+            self.w = w
+
+        if self.w > self.N:
+            raise ValueError('Window size must be smaller than trajectory length')
+
+        # All the indices to calculate O
+        self.O_index = np.arange(0, self.N - self.w + 1,  step=1)  # indices to compute O
+        self.O_time = self.t_sim[self.O_index]  # times to compute O
+        self.n_point = len(self.O_index)  # # of times to calculate O
+
+        # Where to store sliding window trajectory data & O's
+        self.window_data = {'t': [], 'u': [], 'x': [], 'y': [], 'y_plus': [], 'y_minus': []}
+        self.O_sliding = []
+        self.O_df_sliding = []
+
+        # Run
+        self.EOM = None
+        self.run()
+
+    def run(self, parallel=None):
+        """ Run.
+        """
+
+        if parallel is not None:
+            self.parallel = parallel
+
+        # Where to store sliding window trajectory data & O's
+        self.window_data = {'t': [], 'u': [], 'x': [], 'y': [], 'y_plus': [], 'y_minus': []}
+        self.O_sliding = []
+        self.O_df_sliding = []
+
+        # Construct O's
+        n_point_range = np.arange(0, self.n_point).astype(int)
+        if self.parallel:  # multiprocessing
+            with Pool(4) as pool:
+                results = pool.map(self.construct, n_point_range)
+                for r in results:
+                    self.O_sliding.append(r[0])
+                    self.O_df_sliding.append(r[1])
+                    for k in self.window_data.keys():
+                        self.window_data[k].append(r[2][k])
+
+        else:
+            for n in n_point_range:  # each point on trajectory
+                O_sliding, O_df_sliding, window_data = self.construct(n)
+                self.O_sliding.append(O_sliding)
+                self.O_df_sliding.append(O_df_sliding)
+                for k in self.window_data.keys():
+                    self.window_data[k].append(window_data[k])
+
+    def construct(self, n):
+        # Start simulation at point along nominal trajectory
+        x0 = np.squeeze(self.x_sim[self.O_index[n], :])  # get state on trajectory & set it as the initial condition
+
+        # Get the range to pull out time & input data for simulation
+        win = np.arange(self.O_index[n], self.O_index[n] + self.w, step=1)  # index range
+
+        # Remove part of window if it is past the end of the nominal trajectory
+        within_win = win < self.N
+        win = win[within_win]
+
+        # Pull out time & control inputs in window
+        t_win = self.t_sim[win]  # time in window
+        t_win0 = t_win - t_win[0]  # start at 0
+        u_win = self.u_sim[win, :]  # inputs in window
+
+        # Calculate O for window
+        EOM = EmpiricalObservabilityMatrix(self.simulator, x0, t_win0, u_win, eps=self.eps, parallel=False)
+        self.EOM = EOM
+
+        # Store data
+        O_sliding = EOM.O.copy()
+        O_df_sliding = EOM.O_df.copy()
+
+        window_data = {'t': t_win.copy(),
+                       'u': u_win.copy(),
+                       'x': EOM.x_nominal.copy(),
+                       'y': EOM.y_nominal.copy(),
+                       'y_plus': EOM.y_plus.copy(),
+                       'y_minus': EOM.y_minus.copy()}
+
+        return O_sliding, O_df_sliding, window_data
+
+
+class FisherObservability:
+    def __init__(self, O, R=None, sensor_noise_dict=None, sigma=None):
+        """ Evaluate the observability of a state variable(s) using the Fisher Information Matrix.
+
+            Inputs
+                O: observability matrix. Can be numpy array or pandas data-frame (pxw x n)
+                R: measurement noise covariance matrix (p x p)
+                beta: reconstruction error bound for binary observability
+                epsilon: F = F + epsilon*I if not None
+        """
+
+        # Make O a data-frame
+        self.pw = O.shape[0]  # number of sensors * time-steps
+        self.n = O.shape[1]  # number of states
+        if isinstance(O, pd.DataFrame):  # data-frame given
+            self.O = O.copy()
+            self.sensor_names = tuple(O.index.get_level_values('sensor'))
+            self.state_names = tuple(O.columns)
+        elif isinstance(O, np.ndarray):  # array given
+            self.sensor_names = tuple(['y' for n in range(self.pw)])
+            self.state_names = tuple(['x_' + str(n) for n in range(self.n)])
+            self.O = pd.DataFrame(O, index=self.sensor_names, columns=self.state_names)
+        else:
+            raise TypeError('O is not a pandas data-frame or numpy array')
+
+        # Set measurement noise covariance matrix
+        self.R = pd.DataFrame(np.eye(self.pw), index=self.O.index, columns=self.O.index)
+        self.R_inv = pd.DataFrame(np.eye(self.pw), index=self.O.index, columns=self.O.index)
+        self.set_noise_covariance(R=R, sensor_noise_dict=sensor_noise_dict)
+
+        # Calculate Fisher Information Matrix
+        self.F = self.O.values.T @ self.R_inv.values @ self.O.values
+        self.F = pd.DataFrame(self.F, index=O.columns, columns=O.columns)
+
+        # Set sigma
+        if sigma is None:
+            # np.linalg.eig(self.F)
+            self.sigma = 0.0
+        else:
+            self.sigma = sigma
+
+        # Invert F
+        if self.sigma == 'limit':  # calculate limit with symbolic sigma
+            sigma_sym = sp.symbols('sigma')
+            F_hat = self.F.values + sp.Matrix(sigma_sym * np.eye(self.n))
+            F_hat_inv = F_hat.inv()
+            F_hat_inv_limit = F_hat_inv.applyfunc(lambda elem: sp.limit(elem, sigma_sym, 0))
+            self.F_inv = np.array(F_hat_inv_limit, dtype=np.float64)
+        else:  # numeric sigma
+            F_epsilon = self.F.values + (self.sigma * np.eye(self.n))
+            self.F_inv = np.linalg.inv(F_epsilon)
+
+        self.F_inv = pd.DataFrame(self.F_inv, index=O.columns, columns=O.columns)
+
+        # Pull out diagonal elements
+        self.error_variance = pd.DataFrame(np.diag(self.F_inv), index=self.O.columns).T
+
+    def set_noise_covariance(self, R=None, sensor_noise_dict=None):
+        """ Set the measurement noise covariance matrix.
+        """
+
+        # Preallocate the noise covariance matrix R
+        self.R = pd.DataFrame(np.eye(self.pw), index=self.O.index, columns=self.O.index)
+
+        # Set R based on values in dict
+        if sensor_noise_dict is not None:  # set each distinct sensor's noise level
+            if R is not None:
+                raise Exception('R can not be set directly if sensor_noise_dict is set')
+            else:
+                # for s in self.R.index.levels[0]:
+                for s in pd.unique(self.R.index.get_level_values('sensor')):
+                    R_sensor = self.R.loc[[s], [s]]
+                    for r in range(R_sensor.shape[0]):
+                        R_sensor.iloc[r, r] = sensor_noise_dict[s]
+
+                    self.R.loc[[s], [s]] = R_sensor.values
+        else:
+            if R is None:
+                warnings.warn('R not set, defaulting to identity matrix')
+            else:  # set R directly
+                if np.atleast_1d(R).shape[0] == 1:  # given scalar
+                    self.R = R * self.R
+                elif isinstance(R, pd.DataFrame):  # matrix R in data-frame
+                    self.R = R.copy()
+                elif isinstance(R, np.ndarray):  # matrix in array
+                    self.R = pd.DataFrame(R, index=self.R.index, columns=self.R.columns)
+                else:
+                    raise Exception('R must be a numpy array, pandas data-frame, or scalar value')
+
+        # Inverse of R
+        R_diagonal = np.diag(self.R.values)
+        is_diagonal = np.all(self.R.values == np.diag(R_diagonal))
+        if is_diagonal:
+            self.R_inv = np.diag(1 / R_diagonal)
+        else:
+            self.R_inv = np.linalg.inv(self.R.values)
+
+        self.R_inv = pd.DataFrame(self.R_inv, index=self.R.index, columns=self.R.index)
+
+
+class SlidingFisherObservability:
+    def __init__(self, O_list, time=None, sigma=1e6, R=None, sensor_noise_dict=None,
+                 states=None, sensors=None, time_steps=None, w=None):
+
+        """ Compute the Fisher information matrix & inverse in sliding windows and pull put the minimum error variance.
+        :param O_list: list of observability matrices O
+        :param time: time vector the same size as O_list
+        :param states: list of states to use from O's
+        :param sensors: list of sensors to use from O's
+        :param time_steps: list of time steps to use from O's
+        """
+
+        self.O_list = O_list
+        self.n_window = len(O_list)
+
+        # Set time & time-step
+        if time is None:
+            self.time = np.arange(0, self.n_window, step=1)
+        else:
+            self.time = time
+
+        self.dt = np.mean(np.diff(self.time))
+
+        # Get single O
+        O = O_list[0]
+
+        # Set window size
+        if w is None:  # set automatically
+            self.w = np.max(np.array(O.index.get_level_values('time_step'))) + 1
+        else:
+            self.w = w
+
+        # Set the states to use
+        if states is None:
+            self.states = O.columns
+        else:
+            self.states = states
+
+        # Set the sensors to use
+        if sensors is None:
+            self.sensors = O.index.get_level_values('sensor')
+        else:
+            self.sensors = sensors
+
+        # Set the time-steps to use
+        if time_steps is None:
+            self.time_steps = O.index.get_level_values('time_step')
+        else:
+            self.time_steps = time_steps
+
+        # Compute Fisher information matrix & inverse for each sliding window
+        self.EV = []  # collect error variance data for each state over time
+        self.FO = []
+        self.shift_index = int(np.round((1 / 2) * self.w))
+        self.shift_time = self.shift_index * self.dt  # shift the time forward by half the window size
+        for k in range(self.n_window):  # each window
+            # Get full O
+            O = self.O_list[k]
+
+            # Get subset of O
+            O_subset = O.loc[(self.sensors, self.time_steps), self.states].sort_values(['time_step', 'sensor'])
+
+            # Compute Fisher information & inverse
+            FO = FisherObservability(O_subset, sensor_noise_dict=sensor_noise_dict, R=R, sigma=sigma)
+            self.FO.append(FO)
+
+            # Collect error variance data
+            ev = FO.error_variance.copy()
+            ev.insert(0, 'time_initial', self.time[k])
+            self.EV.append(ev)
+
+        # Concatenate error variance & make same size as simulation data
+        self.EV = pd.concat(self.EV, axis=0, ignore_index=True)
+        self.EV.index = np.arange(self.shift_index, self.EV.shape[0] + self.shift_index, step=1, dtype=int)
+        time_df = pd.DataFrame(np.atleast_2d(self.time).T, columns=['time'])
+        self.EV_aligned = pd.concat((time_df, self.EV), axis=1)
+
+
+class ObservabilityMatrixImage:
+    def __init__(self, O, state_names=None, sensor_names=None, vmax_percentile=100, vmin_ratio=1.0, cmap='bwr'):
+        """ Display an image of an observability matrix.
+        """
+
+        # Plotting parameters
+        self.vmax_percentile = vmax_percentile
+        self.vmin_ratio = vmin_ratio
+        self.cmap = cmap
+        self.crange = None
+        self.fig = None
+        self.ax = None
+        self.cbar = None
+
+        # Get O
+        self.pw, self.n = O.shape
+        if isinstance(O, pd.DataFrame):  # data-frame
+            self.O = O.copy()  # O in matrix form
+
+            # Default state names based on data-frame columns
+            self.state_names_default = list(O.columns)
+
+            # Default sensor names based on data-frame 'sensor' index
+            sensor_names_all = list(np.unique(O.index.get_level_values('sensor')))
+            self.sensor_names_default = list(O.index.get_level_values('sensor')[0:len(sensor_names_all)])
+
+        else:  # numpy matrix
+            raise TypeError('n-sensor must be an integer value when O is given as a numpy matrix')
+
+        self.n_sensor = len(self.sensor_names_default)  # number of sensors
+        self.n_time_step = int(self.pw / self.n_sensor)  # number of time-steps
+
+        # Set state names
+        if state_names is not None:
+            if len(state_names) == self.n:
+                self.state_names = state_names.copy()
+            elif len(state_names) == 1:
+                self.state_names = ['$' + state_names[0] + '_{' + str(n) + '}$' for n in range(1, self.n + 1)]
+            else:
+                raise TypeError('state_names must be of length n or length 1')
+        else:
+            self.state_names = self.state_names_default.copy()
+
+        # Convert to Latex
+        LatexConverter = LatexStates()
+        self.state_names = LatexConverter.convert_to_latex(self.state_names)
+
+        # Set sensor & measurement names
+        if sensor_names is not None:
+            if len(sensor_names) == self.n_sensor:
+                self.sensor_names = sensor_names.copy()
+                self.sensor_names = LatexConverter.convert_to_latex(self.sensor_names, remove_dollar_signs=True)
+                self.measurement_names = []
+                for w in range(self.n_time_step):
+                    for p in range(self.n_sensor):
+                        m = '$' + self.sensor_names[p] + ',_{' + 'k=' + str(w) + '}$'
+                        self.measurement_names.append(m)
+
+            elif len(sensor_names) == 1:
+                self.sensor_names = [sensor_names[0] + '_{' + str(n) + '}$' for n in range(1, self.n_sensor + 1)]
+                self.sensor_names = LatexConverter.convert_to_latex(self.sensor_names, remove_dollar_signs=True)
+                self.measurement_names = []
+                for w in range(self.n_time_step):
+                    for p in range(self.n_sensor):
+                        m = '$' + sensor_names[0] + '_{' + str(p) + ',k=' + str(w) + '}$'
+                        self.measurement_names.append(m)
+            else:
+                raise TypeError('sensor_names must be of length p or length 1')
+
+        else:
+            self.sensor_names = self.sensor_names_default.copy()
+            self.sensor_names = LatexConverter.convert_to_latex(self.sensor_names, remove_dollar_signs=True)
+            self.measurement_names = []
+            for w in range(self.n_time_step):
+                for p in range(self.n_sensor):
+                    m = '$' + self.sensor_names[p] + '_{' + ',k=' + str(w) + '}$'
+                    self.measurement_names.append(m)
+
+    def plot(self, vmax_percentile=100, vmin_ratio=0.0, vmax_override=None, cmap='bwr', grid=True, scale=1.0, dpi=150,
+             ax=None):
+        """ Plot the observability matrix.
+        """
+
+        # Plot properties
+        self.vmax_percentile = vmax_percentile
+        self.vmin_ratio = vmin_ratio
+        self.cmap = cmap
+
+        if vmax_override is None:
+            self.crange = np.percentile(np.abs(self.O), self.vmax_percentile)
+        else:
+            self.crange = vmax_override
+
+        # Display O
+        O_disp = self.O.values
+        # O_disp = np.nan_to_num(np.sign(O_disp) * np.log(np.abs(O_disp)), nan=0.0)
+        for n in range(self.n):
+            for m in range(self.pw):
+                oval = O_disp[m, n]
+                if (np.abs(oval) < (self.vmin_ratio * self.crange)) and (np.abs(oval) > 1e-6):
+                    O_disp[m, n] = self.vmin_ratio * self.crange * np.sign(oval)
+
+        # Plot
+        if ax is None:
+            fig, ax = plt.subplots(1, 1, figsize=(0.3 * self.n * scale, 0.3 * self.pw * scale),
+                                   dpi=dpi)
+        else:
+            fig = None
+
+        O_data = ax.imshow(O_disp, vmin=-self.crange, vmax=self.crange, cmap=self.cmap)
+        ax.grid(visible=False)
+
+        ax.set_xlim(-0.5, self.n - 0.5)
+        ax.set_ylim(self.pw - 0.5, -0.5)
+
+        ax.set_xticks(np.arange(0, self.n))
+        ax.set_yticks(np.arange(0, self.pw))
+
+        ax.set_xlabel('States', fontsize=10, fontweight='bold')
+        ax.set_ylabel('Measurements', fontsize=10, fontweight='bold')
+
+        ax.set_xticklabels(self.state_names)
+        ax.set_yticklabels(self.measurement_names)
+
+        ax.tick_params(axis='x', which='major', labelsize=7, pad=-1.0)
+        ax.tick_params(axis='y', which='major', labelsize=7, pad=-0.0, left=False)
+        ax.tick_params(axis='x', which='both', top=False, labeltop=True, bottom=False, labelbottom=False)
+        ax.xaxis.set_label_position('top')
+        plt.setp(ax.xaxis.get_majorticklabels(), rotation=0, ha='center')
+
+        # Draw grid
+        if grid:
+            grid_color = [0.8, 0.8, 0.8, 1.0]
+            grid_lw = 1.0
+            for n in np.arange(-0.5, self.pw + 1.5):
+                ax.axhline(y=n, color=grid_color, linewidth=grid_lw)
+            for n in np.arange(-0.5, self.n + 1.5):
+                ax.axvline(x=n, color=grid_color, linewidth=grid_lw)
+
+        # Make colorbar
+        axins = inset_axes(ax, width='100%', height=0.1, loc='lower left',
+                           bbox_to_anchor=(0.0, -1.0 * (1.0 / self.pw), 1, 1), bbox_transform=ax.transAxes,
+                           borderpad=0)
+
+        cbar = plt.colorbar(O_data, cax=axins, orientation='horizontal')
+        cbar.ax.tick_params(labelsize=8)
+        cbar.set_label('matrix values', fontsize=9, fontweight='bold', rotation=0)
+
+        # Store figure & axis
+        self.fig = fig
+        self.ax = ax
+        self.cbar = cbar

pybounds/simulator.py

@@ -0,0 +1,241 @@
+
+import numpy as np
+import do_mpc
+from util import FixedKeysDict, SetDict
+
+# from typing import Callable
+
+
+class Simulator(object):
+    def __init__(self, f, h, x0, u0, dt=0.01,
+                 state_names=None, input_names=None, measurement_names=None,
+                 params_simulator=None):
+        """ Simulator.
+        :param float f: callable dynamics function f(X, U, t)
+        :param float h: callable measurement function h(X, U, t)
+        :param float dt: sampling time in seconds
+        """
+
+        self.f = f
+        self.h = h
+        self.dt = dt
+
+        # Set state & input sizes
+        self.n = len(x0)  # number of states
+        self.m = len(u0)  # number of inputs
+
+        # Run measurement function to get measurement size
+        y = self.h(x0, u0, 0)
+        self.p = len(y)  # number of measurements
+
+        # Set state names
+        if state_names is None:  # default state names
+            self.state_names = ['x_' + str(n) for n in range(self.n)]
+        else:
+            self.state_names = state_names
+            if len(self.state_names) != self.n:
+                raise ValueError('state_names must have length equal to x0')
+
+        # Set input names
+        if input_names is None:  # default measurement names
+            self.input_names = ['u_' + str(m) for m in range(self.m)]
+        else:
+            self.input_names = input_names
+            if len(self.input_names) != self.m:
+                raise ValueError('input_names must have length equal to u0')
+
+        # Set measurement names
+        if measurement_names is None:  # default measurement names
+            self.measurement_names = ['y_' + str(p) for p in range(self.p)]
+        else:
+            self.measurement_names = measurement_names
+            if len(self.measurement_names) != self.p:
+                raise ValueError('measurement_names must have length equal to y')
+
+        self.output_mode = self.measurement_names
+
+        # Initialize time vector
+        w = 10  # initialize for w time-steps, but this can change later
+        self.time = np.arange(0, w * self.dt + self.dt / 2, step=self.dt)  # time vector
+
+        # Define initial states & initialize state time-series
+        self.x0 = {}
+        self.x = {}
+        for n, state_name in enumerate(self.state_names):
+            self.x0[state_name] = x0[n]
+            self.x[state_name] = x0[n] * np.ones(w)
+
+        self.x0 = FixedKeysDict(self.x0)
+
+        # Initialize input time-series
+        self.u = {}
+        for m, input_name in enumerate(self.input_names):
+            self.u[input_name] = u0[m] * np.ones(w)
+
+        self.u = FixedKeysDict(self.u)
+
+        # Initialize measurement time-series
+        self.y = {}
+        for p, measurement_name in enumerate(self.measurement_names):
+            self.y[measurement_name] = 0.0 * np.ones(w)
+
+        self.y = FixedKeysDict(self.y)
+
+        # Define continuous-time MPC model
+        self.model = do_mpc.model.Model('continuous')
+
+        # Define state variables
+        X = []
+        for n, state_name in enumerate(self.state_names):
+            x = self.model.set_variable(var_type='_x', var_name=state_name, shape=(1, 1))
+            X.append(x)
+
+        # Define input variables
+        U = []
+        for m, input_name in enumerate(self.input_names):
+            u = self.model.set_variable(var_type='_u', var_name=input_name, shape=(1, 1))
+            U.append(u)
+
+        # Define dynamics
+        Xdot = self.f(X, U, 0)
+        for n, state_name in enumerate(self.state_names):
+            self.model.set_rhs(state_name, Xdot[n])
+
+        # Build model
+        self.model.setup()
+
+        # Define simulator & simulator parameters
+        self.simulator = do_mpc.simulator.Simulator(self.model)
+
+        # Set simulation parameters
+        if params_simulator is None:
+            self.params_simulator = {
+                'integration_tool': 'idas',  # cvodes, idas
+                'abstol': 1e-8,
+                'reltol': 1e-8,
+                't_step': self.dt
+            }
+        else:
+            self.params_simulator = params_simulator
+
+        self.simulator.set_param(**self.params_simulator)
+        self.simulator.setup()
+
+    def set_initial_state(self, x0):
+        """ Update the initial state.
+        """
+
+        if x0 is not None:  # initial state given
+            if isinstance(x0, dict):  # in dict format
+                SetDict().set_dict_with_overwrite(self.x0, x0)  # update only the states in the dict given
+            elif isinstance(x0, list) or isinstance(x0, tuple) or (
+            x0, np.ndarray):  # list, tuple,  or numpy array format
+                x0 = np.array(x0).squeeze()
+                for n, key in enumerate(self.x0.keys()):  # each state
+                    self.x0[key] = x0[n]
+            else:
+                raise Exception('x0 must be either a dict, tuple, list, or numpy array')
+
+    def set_inputs(self, u):
+        """ Update the inputs.
+        """
+
+        if u is not None:  # inputs given
+            if isinstance(u, dict):  # in dict format
+                SetDict().set_dict_with_overwrite(self.u, u)  # update only the inputs in the dict given
+            elif isinstance(u, list) or isinstance(u, tuple):  # list or tuple format, each input vector in each element
+                for n, k in enumerate(self.u.keys()):  # each input
+                    self.u[k] = u[n]
+            elif isinstance(u, np.ndarray):  # numpy array format given as matrix where columns are the different inputs
+                if len(u.shape) <= 1:  # given as 1d array, so convert to column vector
+                    u = np.atleast_2d(u).T
+
+                for m, key in enumerate(self.u.keys()):  # each input
+                    self.u[key] = u[:, m]
+
+            else:
+                raise Exception('u must be either a dict, tuple, list, or numpy array')
+
+        # Make sure inputs are the same size
+        points = np.array([self.u[key].shape[0] for key in self.u.keys()])
+        points_check = points == points[0]
+        if not np.all(points_check):
+            raise Exception('inputs are not the same size')
+
+    def simulate(self, x0=None, u=None, return_full_output=False):
+        """
+        Simulate the system.
+
+        :params x0: initial state dict or array
+        :params u: input dict or array
+        :params output_mode: array of strings containing variable names of outputs
+        :params run_mpc: boolean to run MPC controller
+        """
+
+        # Update the initial state
+        self.set_initial_state(x0=x0.copy())
+
+        # Update the inputs
+        self.set_inputs(u=u)
+
+        # Concatenate the inputs, where rows are individual inputs and columns are time-steps
+        u_sim = np.vstack(list(self.u.values())).T
+        n_point = u_sim.shape[0]
+
+        # Update time vector
+        T = (n_point - 1) * self.dt
+        self.time = np.linspace(0, T, num=n_point)
+
+        # Set array to store simulated states, where rows are individual states and columns are time-steps
+        x_step = np.array(list(self.x0.values()))  # initialize state
+        x_sim = np.nan * np.zeros((n_point, self.n))
+        x_sim[0, :] = x_step.copy()
+
+        # Initialize the simulator
+        self.simulator.t0 = self.time[0]
+        self.simulator.x0 = x_step.copy()
+        self.simulator.set_initial_guess()
+
+        # Run simulation
+        for k in range(1, n_point):
+            # Set input
+            u_step = u_sim[k - 1:k, :].T
+
+            # Store inputs
+            u_sim[k - 1, :] = u_step.squeeze()
+
+            # Simulate one time step given current inputs
+            x_step = self.simulator.make_step(u_step)
+
+            # Store new states
+            x_sim[k, :] = x_step.squeeze()
+
+        # Update the inputs
+        self.set_inputs(u=u_sim)
+
+        # Update state trajectory
+        for n, key in enumerate(self.x.keys()):
+            self.x[key] = x_sim[:, n]
+
+        # Calculate measurements
+        x_list = list(self.x.values())
+        u_list = list(self.u.values())
+        y = self.h(x_list, u_list, 0)
+
+        # Set outputs
+        self.y = {}
+        for p, measurement_name in enumerate(self.measurement_names):
+            self.y[measurement_name] = y[p]
+
+        # Return the outputs in array format
+        y_array = np.vstack(list(self.y.values())).T
+
+        if return_full_output:
+            return self.time.copy(), self.x.copy(), self.u.copy(), self.u.copy()
+        else:
+            return y_array
+
+    def get_time_states_input_measurements(self):
+        return self.time.copy(), self.x.copy(), self.u.copy(), self.u.copy()
+
+

pybounds/util.py

@@ -0,0 +1,162 @@
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.collections as mcoll
+import matplotlib.patheffects as path_effects
+
+class FixedKeysDict(dict):
+    def __init__(self, *args, **kwargs):
+        super(FixedKeysDict, self).__init__(*args, **kwargs)
+        self._frozen_keys = set(self.keys())  # Capture initial keys
+
+    def __setitem__(self, key, value):
+        if key not in self._frozen_keys:
+            raise KeyError(f"Key '{key}' cannot be added.")
+        super(FixedKeysDict, self).__setitem__(key, value)
+
+    def __delitem__(self, key):
+        raise KeyError(f"Key '{key}' cannot be deleted.")
+
+    def pop(self, key, default=None):
+        raise KeyError(f"Key '{key}' cannot be popped.")
+
+    def popitem(self):
+        raise KeyError("Cannot pop item from FixedKeysDict.")
+
+    def clear(self):
+        raise KeyError("Cannot clear FixedKeysDict.")
+
+    def update(self, *args, **kwargs):
+        for key in dict(*args, **kwargs):
+            if key not in self._frozen_keys:
+                raise KeyError(f"Key '{key}' cannot be added.")
+        super(FixedKeysDict, self).update(*args, **kwargs)
+
+
+class SetDict(object):
+    # set_dict(self, dTarget, dSource, bPreserve)
+    # Takes a target dictionary, and enters values from the source dictionary, overwriting or not, as asked.
+    # For example,
+    #    dT={'a':1, 'b':2}
+    #    dS={'a':0, 'c':0}
+    #    Set(dT, dS, True)
+    #    dT is {'a':1, 'b':2, 'c':0}
+    #
+    #    dT={'a':1, 'b':2}
+    #    dS={'a':0, 'c':0}
+    #    Set(dT, dS, False)
+    #    dT is {'a':0, 'b':2, 'c':0}
+    #
+    def set_dict(self, dTarget, dSource, bPreserve):
+        for k, v in dSource.items():
+            bKeyExists = (k in dTarget)
+            if (not bKeyExists) and type(v) == type({}):
+                dTarget[k] = {}
+            if ((not bKeyExists) or not bPreserve) and (type(v) != type({})):
+                dTarget[k] = v
+
+            if type(v) == type({}):
+                self.set_dict(dTarget[k], v, bPreserve)
+
+    def set_dict_with_preserve(self, dTarget, dSource):
+        self.set_dict(dTarget, dSource, True)
+
+    def set_dict_with_overwrite(self, dTarget, dSource):
+        self.set_dict(dTarget, dSource, False)
+
+
+class LatexStates:
+    """ Holds LaTex format corresponding to set symbolic variables.
+    """
+
+    def __init__(self, dict=None):
+        self.dict = {'v_para': r'$v_{\parallel}$',
+                     'v_perp': r'$v_{\perp}$',
+                     'phi': r'$\phi$',
+                     'phidot': r'$\dot{\phi}$',
+                     'phiddot': r'$\ddot{\phi}$',
+                     'w': r'$w$',
+                     'zeta': r'$\zeta$',
+                     'I': r'$I$',
+                     'm': r'$m$',
+                     'C_para': r'$C_{\parallel}$',
+                     'C_perp': r'$C_{\perp}$',
+                     'C_phi': r'$C_{\phi}$',
+                     'km1': r'$k_{m_1}$',
+                     'km2': r'$k_{m_2}$',
+                     'km3': r'$k_{m_3}$',
+                     'km4': r'$k_{m_4}$',
+                     'd': r'$d$',
+                     'psi': r'$\psi$',
+                     'gamma': r'$\gamma$',
+                     'alpha': r'$\alpha$',
+                     'of': r'$\frac{g}{d}$',
+                     'gdot': r'$\dot{g}$',
+                     'v_para_dot': r'$\dot{v_{\parallel}}$',
+                     'v_perp_dot': r'$\dot{v_{\perp}}$',
+                     'v_para_dot_ratio': r'$\frac{\Delta v_{\parallel}}{v_{\parallel}}$',
+                     'sigma': r'$\sigma$',
+                     'rho': r'$\rho$',
+                     'beta': r'$\beta$'
+                     }
+
+        if dict is not None:
+            SetDict().set_dict_with_overwrite(self.dict, dict)
+
+    def convert_to_latex(self, list_of_strings, remove_dollar_signs=False):
+        """ Loop through list of strings and if any match the dict, then swap in LaTex symbol.
+        """
+
+        if isinstance(list_of_strings, str):  # if single string is given instead of list
+            list_of_strings = [list_of_strings]
+            string_flag = True
+        else:
+            string_flag = False
+
+        list_of_strings = list_of_strings.copy()
+        for n, s in enumerate(list_of_strings):  # each string in list
+            for k in self.dict.keys():  # check each key in Latex dict
+                if s == k:  # string contains key
+                    # print(s, ',', self.dict[k])
+                    list_of_strings[n] = self.dict[k]  # replace string with LaTex
+                    if remove_dollar_signs:
+                        list_of_strings[n] = list_of_strings[n].replace('$', '')
+
+        if string_flag:
+            list_of_strings = list_of_strings[0]
+
+        return list_of_strings
+
+
+def make_segments(x, y):
+    points = np.array([x, y]).T.reshape(-1, 1, 2)
+    segments = np.concatenate([points[:-1], points[1:]], axis=1)
+    return segments
+
+
+def colorline(x, y, z, ax=None, cmap=plt.get_cmap('copper'), norm=None, linewidth=1.5, alpha=1.0):
+    # Special case if a single number:
+    if not hasattr(z, "__iter__"):  # to check for numerical input -- this is a hack
+        z = np.array([z])
+
+    z = np.asarray(z)
+
+    # Set normalization
+    if norm is None:
+        norm = plt.Normalize(np.min(z), np.max(z))
+
+    print(norm)
+
+    # Make segments
+    segments = make_segments(x, y)
+    lc = mcoll.LineCollection(segments, array=z, cmap=cmap, norm=norm,
+                              linewidth=linewidth, alpha=alpha,
+                              path_effects=[path_effects.Stroke(capstyle="round")])
+
+    # Plot
+    if ax is None:
+        ax = plt.gca()
+
+    ax.add_collection(lc)
+
+    return lc

pybounds-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 van Breugel lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pybounds-0.0.1.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: pybounds
+Version: 0.0.1
+Summary: Bounding Observability for Uncertain Nonlinear Dynamics Systems (BOUNDS)
+Home-page: https://github.com/vanbreugel-lab/pybounds
+Author: Ben Cellini, Burak Boyacioglu, Floris van Breugel
+Author-email: bcellini00@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# pybounds

pybounds-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+pybounds/__init__.py,sha256=so9LuRNw2V8MGsDs-RPstGGgJtBFp2YGolQbS0rVfhw,348
+pybounds/observability.py,sha256=tiJdR5tS72SGn1df8Vnz303nDPzhOFaQWSYJoY1o8Qg,24055
+pybounds/simulator.py,sha256=-XpPKQUcwNubw40wNfoqSfqmohbGpBjSQSNWctyfRkQ,8837
+pybounds/util.py,sha256=xxmXmpLR3yK923X6wAPKp_5w814cO3m9OqF1XIt9S8c,5818
+pybounds-0.0.1.dist-info/LICENSE,sha256=kqeyRXtRGgBVZdXYeIX4zR9l2KZ2rqIBVEiPMTjxjcI,1093
+pybounds-0.0.1.dist-info/METADATA,sha256=Il4j0WbOUWga2nq69YD-fjh3OtElrZ-XA4TBSKMUUMs,539
+pybounds-0.0.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+pybounds-0.0.1.dist-info/top_level.txt,sha256=V-ofnWE3m_UkXTXJwNRD07n14m5R6sc6l4NadaCCP_A,9
+pybounds-0.0.1.dist-info/RECORD,,

pybounds-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pybounds-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pybounds