pybounds 0.0.11__py3-none-any.whl → 0.0.12__py3-none-any.whl

pybounds/observability.py

@@ -11,7 +11,7 @@ from .jacobian import SymbolicJacobian
 
 
 class EmpiricalObservabilityMatrix:
-    def __init__(self, simulator, x0, u, eps=1e-5, parallel=False,
+    def __init__(self, simulator, x0, u, aux=None, eps=1e-5, parallel=False,
                  z_function=None, z_state_names=None):
         """ Construct an empirical observability matrix O.
 
@@ -19,18 +19,20 @@ class EmpiricalObservabilityMatrix:
             y is (w x p) array. w is the number of time-steps and p is the number of measurements
         :param dict/list/np.array x0: initial state for Simulator
         :param dict/np.array u: inputs array
+        :param aux: auxiliary input that can be passed to Simulator class
         :param float eps: epsilon value for perturbations to construct O, should be small number
         :param bool parallel: if True, run the perturbations in parallel
         :param callable z_function: function that transforms coordinates from original to new states
             must be of the form z = z_function(x), where x & z are the same size
             should use sympy functions wherever possible
             leave as None to maintain original coordinates
-        :param list | tuple z_state_names: (optional) names of states in new coordinates.
+        :param list | tuple | None z_state_names: (optional) names of states in new coordinates.
             will only have an effect if O is a data-frame & z_function is not None
         """
 
         # Store inputs
         self.simulator = simulator
+        self.aux = aux
         self.eps = eps
         self.parallel = parallel
 
@@ -48,7 +50,7 @@ class EmpiricalObservabilityMatrix:
         self.n = self.x0.shape[0]
 
         # Simulate once for nominal trajectory
-        self.y_nominal = self.simulator.simulate(self.x0, self.u)
+        self.y_nominal = self.simulator.simulate(x0=self.x0, u=self.u, aux=self.aux)
 
         # Number of outputs
         self.p = self.y_nominal.shape[1]
@@ -158,8 +160,8 @@ class EmpiricalObservabilityMatrix:
         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)
-        y_minus = self.simulator.simulate(x0=x0_minus, u=self.u)
+        y_plus = self.simulator.simulate(x0=x0_plus, u=self.u, aux=self.aux)
+        y_minus = self.simulator.simulate(x0=x0_minus, u=self.u, aux=self.aux)
 
         # Calculate the numerical Jacobian & normalize by 2x the perturbation amount
         delta_y = np.array(y_plus - y_minus).T / (2 * self.eps)
@@ -168,7 +170,7 @@ class EmpiricalObservabilityMatrix:
 
 
 class SlidingEmpiricalObservabilityMatrix:
-    def __init__(self, simulator, t_sim, x_sim, u_sim, w=None, eps=1e-5,
+    def __init__(self, simulator, t_sim, x_sim, u_sim, aux_list=None, w=None, eps=1e-5,
                  parallel_sliding=False, parallel_perturbation=False,
                  z_function=None, z_state_names=None):
         """ Construct empirical observability matrix O in sliding windows along a trajectory.
@@ -178,6 +180,7 @@ class SlidingEmpiricalObservabilityMatrix:
         :param np.array t_sim: time values along state trajectory array (N, 1)
         :param np.array x_sim: state trajectory array (N, n), can also be dict
         :param np.array u_sim: input array (N, m), can also be dict
+        :param aux_list: auxiliary input that can be passed to Simulator class
         :param np.array w: window size for O calculations, will automatically set how many windows to compute
         :params float eps: tolerance for sliding windows
         :param float eps: epsilon value for perturbations to construct O's, should be small number
@@ -207,7 +210,7 @@ class SlidingEmpiricalObservabilityMatrix:
         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.u_sim = np.array(u_sim)
 
         # Check sizes
         if self.N != self.x_sim.shape[0]:
@@ -217,6 +220,15 @@ class SlidingEmpiricalObservabilityMatrix:
         elif self.x_sim.shape[0] != self.u_sim.shape[0]:
             raise ValueError('x_sim & u_sim must have same number of rows')
 
+        # Set aux inputs
+        if aux_list is None:
+            self.aux_list = [None for k in range(self.N)]
+        else:
+            self.aux_list = aux_list
+
+        if len(self.aux_list) != self.N:
+            raise ValueError('aux_list must have same number of elements as t_sim')
+
         # Set time-window to calculate O's
         if w is None:  # set window size to full time-series size
             self.w = self.N
@@ -292,7 +304,9 @@ class SlidingEmpiricalObservabilityMatrix:
         u_win = self.u_sim[win, :]  # inputs in window
 
         # Calculate O for window
-        EOM = EmpiricalObservabilityMatrix(self.simulator, x0, u_win, eps=self.eps,
+        EOM = EmpiricalObservabilityMatrix(self.simulator, x0, u_win,
+                                           aux=self.aux_list[n],
+                                           eps=self.eps,
                                            parallel=self.parallel_perturbation,
                                            z_function=self.z_function,
                                            z_state_names=self.z_state_names)
@@ -315,7 +329,8 @@ class SlidingEmpiricalObservabilityMatrix:
 
 
 class FisherObservability:
-    def __init__(self, O, R=None, lam=None):
+    def __init__(self, O, R=None, lam=None,
+                 states=None, sensors=None, time_steps=None, w=None):
         """ Evaluate the observability of a state variable(s) using the Fisher Information Matrix.
 
         :param np.array O: observability matrix (w*p, n)
@@ -328,7 +343,11 @@ class FisherObservability:
             can also be dict where keys must correspond to the 'sensor' index in O data-frame
             if None, then R = I_(nxn)
         :param float lam: lamda parameter, if lam='limit' compute F^-1 symbolically, otherwise use Chernoff inverse
-        """
+        :param None | tuple | list states: list of states to use from O's. ex: ['g', 'd']
+        :param None | tuple | list sensors: list of sensors to use from O's, ex: ['r']
+        :param None | tuple | list | np.array time_steps: array of time steps to use from O's, ex: np.array([0, 1, 2])
+        :param None | tuple | list | np.array w: window size to use from O's,
+            if None then just grab it from O as the maximum window size        """
 
         # Make O a data-frame
         self.pw = O.shape[0]  # number of sensors * time-steps
@@ -344,6 +363,37 @@ class FisherObservability:
         else:
             raise TypeError('O is not a pandas data-frame or numpy array')
 
+        # Set window size
+        if w is None:  # set automatically
+            self.w = np.max(np.array(self.O.index.get_level_values('time_step'))) + 1
+        else:
+            self.w = w
+
+        # Set the states to use
+        if states is None:
+            self.states = self.O.columns
+        else:
+            self.states = states
+
+        # Set the sensors to use
+        if sensors is None:
+            self.sensors = self.O.index.get_level_values('sensor')
+        else:
+            self.sensors = sensors
+
+        # Set the time-steps to use
+        if time_steps is None:
+            self.time_steps = self.O.index.get_level_values('time_step')
+        else:
+            self.time_steps = np.array(time_steps)
+
+        # Get subset of O
+        self.O = O.loc[(self.sensors, self.time_steps), self.states].sort_values(['time_step', 'sensor'])
+
+        # Reset the size of O
+        self.pw = self.O.shape[0]  # number of sensors * time-steps
+        self.n = self.O.shape[1]  # number of states
+
         # 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)
@@ -351,7 +401,7 @@ class FisherObservability:
 
         # 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)
+        self.F = pd.DataFrame(self.F, index=self.O.columns, columns=self.O.columns)
 
         # Set sigma
         if lam is None:
@@ -371,7 +421,7 @@ class FisherObservability:
             F_epsilon = self.F.values + (self.lam * 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)
+        self.F_inv = pd.DataFrame(self.F_inv, index=self.O.columns, columns=self.O.columns)
 
         # Pull out diagonal elements
         self.error_variance = pd.DataFrame(np.diag(self.F_inv), index=self.O.columns).T
@@ -421,18 +471,19 @@ class FisherObservability:
 
 
 class SlidingFisherObservability:
-    def __init__(self, O_list, time=None, lam=1e6, R=None,
+    def __init__(self, O_list, R=None, lam=1e6, time=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 list O_list: list of observability matrices O (stored as pd.DataFrame)
-        :param None | np.array time: time vector the same size as O_list
-        :param float | np.array lam: lamda parameter, if lam='limit' compute F^-1 symbolically, otherwise use Chernoff inverse
         :param None | np.array | float| dict  R: measurement noise covariance matrix (w*p x w*p)
             can also be set as pd.DataFrame where R.index = R.columns = O.index
             can also be a scaler where R = R * I_(nxn)
             can also be dict where keys must correspond to the 'sensor' index in O data-frame
             if None, then R = I_(nxn)
+        :param float | np.array lam: lamda parameter, if lam='limit' compute F^-1 symbolically, otherwise use Chernoff inverse
+        :param None | np.array time: time vector the same size as O_list
         :param None | tuple | list states: list of states to use from O's. ex: ['g', 'd']
         :param None | tuple | list sensors: list of sensors to use from O's, ex: ['r']
         :param None | tuple | list | np.array time_steps: array of time steps to use from O's, ex: np.array([0, 1, 2])
@@ -458,33 +509,6 @@ class SlidingFisherObservability:
         else:  # default is time-step of 1
             self.dt = 1
 
-        # 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 = np.array(time_steps)
-
         # Compute Fisher information matrix & inverse for each sliding window
         self.EV = []  # collect error variance data for each state over windows
         self.FO = []  # collect FisherObservability objects over windows
@@ -492,11 +516,8 @@ class SlidingFisherObservability:
             # 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, R=R, lam=lam)
+            FO = FisherObservability(O, R=R, lam=lam, states=states, sensors=sensors, time_steps=time_steps, w=w)
             self.FO.append(FO)
 
             # Collect error variance data
@@ -505,7 +526,7 @@ class SlidingFisherObservability:
             self.EV.append(ev)
 
         # Concatenate error variance & make same size as simulation data
-        self.shift_index = int(np.round((1 / 2) * self.w))
+        self.shift_index = int(np.round((1 / 2) * float(FO.w)))
         self.shift_time = self.shift_index * self.dt  # shift the time forward by half the window size
         self.EV = pd.concat(self.EV, axis=0, ignore_index=True)
         if self.n_window > 1:  # more than 1 window

pybounds/simulator.py

@@ -2,6 +2,7 @@
 import warnings
 import numpy as np
 import matplotlib.pyplot as plt
+import casadi
 import do_mpc
 from .util import FixedKeysDict, SetDict
 
@@ -129,7 +130,7 @@ class Simulator(object):
         # Define dynamics
         Xdot = self.f(X, U)
         for n, state_name in enumerate(self.state_names):
-            self.model.set_rhs(state_name, Xdot[n])
+            self.model.set_rhs(state_name, casadi.SX(Xdot[n]))
 
         # Add time-varying set-point variables for later use with MPC
         for n, state_name in enumerate(self.state_names):
@@ -271,12 +272,14 @@ class Simulator(object):
         if not np.all(points_check):
             raise Exception(name + ' not the same size')
 
-    def simulate(self, x0=None, u=None, mpc=False, return_full_output=False):
+    def simulate(self, x0=None, u=None, aux=None, mpc=False, return_full_output=False):
         """
         Simulate the system.
 
         :params x0: initial state dict or array
-        :params u: input dict or array
+        :params u: input dict or array, if True then mpc must be None
+        :params aux: auxiliary input
+        :params mpc: boolean to run MPC, if True then u must be None
         :params return_full_output: boolean to run (time, x, u, y) instead of y
         """
 
@@ -420,14 +423,16 @@ class Simulator(object):
                 ax[n].legend(fontsize=6)
 
                 y = self.x[key]
-                y_min = np.min(y)
-                y_max = np.max(y)
-                delta = y_max - y_min
-                if np.abs(delta) < 0.01:
-                    margin = 0.1
-                    ax[n].set_ylim(y_min - margin, y_max + margin)
-                else:
-                    margin = 0.0
+            else:
+                y = plot_dict[key]
+
+            # Set y-axis limits
+            y_min = np.min(y)
+            y_max = np.max(y)
+            delta = y_max - y_min
+            if np.abs(delta) < 0.01:
+                margin = 0.1
+                ax[n].set_ylim(y_min - margin, y_max + margin)
 
         ax[-1].set_xlabel('time', fontsize=7)
         ax[0].set_title(name, fontsize=8, fontweight='bold')

{pybounds-0.0.11.dist-info → pybounds-0.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pybounds
-Version: 0.0.11
+Version: 0.0.12
 Summary: Bounding Observability for Uncertain Nonlinear Dynamics Systems (BOUNDS)
 Home-page: https://pypi.org/project/pybounds/
 Author: Ben Cellini, Burak Boyacioglu, Floris van Breugel
@@ -41,6 +41,9 @@ For a simple system
 For a more complex system
 *  Fly-wind: [fly_wind_example.ipynb](examples%2Ffly_wind_example.ipynb)
 
+## Guides
+* Creating a custom simulator: 
+
 ## Citation
 
 If you use the code or methods from this package, please cite the following paper:

pybounds-0.0.12.dist-info/RECORD

@@ -0,0 +1,10 @@
+pybounds/__init__.py,sha256=e4SQdDBQzqr7_x5lcQsuSoWqfBg258i7CDrhhvnmCe4,433
+pybounds/jacobian.py,sha256=hqDOwwqZMdnlTECz0Rx6txCd4VuZ4iZHPaj62PTkKvA,2057
+pybounds/observability.py,sha256=AZgUHk781C0C81aibNAaQSanbhY_0WMbmuCiHT82Onk,32926
+pybounds/simulator.py,sha256=Qx9QGFYuuFnyuq1z5dcub5T_Lz8ISWcKLLrHup9UY0A,16702
+pybounds/util.py,sha256=Gs0UgqgLXTJI9FZww90iJhqU02iJ31bXBURjGiq3YzM,7401
+pybounds-0.0.12.dist-info/LICENSE,sha256=kqeyRXtRGgBVZdXYeIX4zR9l2KZ2rqIBVEiPMTjxjcI,1093
+pybounds-0.0.12.dist-info/METADATA,sha256=9u0pmrau2uJorcTcjznL56LxkOTshpA-uQ7GNTwUqJU,2202
+pybounds-0.0.12.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+pybounds-0.0.12.dist-info/top_level.txt,sha256=V-ofnWE3m_UkXTXJwNRD07n14m5R6sc6l4NadaCCP_A,9
+pybounds-0.0.12.dist-info/RECORD,,

pybounds/observability_transform.py

@@ -1,11 +0,0 @@
-
-# from .observability import EmpiricalObservabilityMatrix
-#
-#
-# class DroneSimulator(EmpiricalObservabilityMatrix):
-#     def __init__(self, dt=0.1, mpc_horizon=10, r_u=1e-2, input_mode='direct', control_mode='velocity_body_level'):
-#         self.dynamics = DroneModel()
-#         super().__init__(self.dynamics.f, self.dynamics.h, dt=dt, mpc_horizon=mpc_horizon,
-#                          state_names=self.dynamics.state_names,
-#                          input_names=self.dynamics.input_names,
-#                          measurement_names=self.dynamics.measurement_names)

pybounds-0.0.11.dist-info/RECORD

@@ -1,11 +0,0 @@
-pybounds/__init__.py,sha256=e4SQdDBQzqr7_x5lcQsuSoWqfBg258i7CDrhhvnmCe4,433
-pybounds/jacobian.py,sha256=hqDOwwqZMdnlTECz0Rx6txCd4VuZ4iZHPaj62PTkKvA,2057
-pybounds/observability.py,sha256=GmWrPADr-vCbBJIv0Cjk3Gj9JJoCuOizKrF8lzX3ncs,31553
-pybounds/observability_transform.py,sha256=YibApe7OzwrZT44BmlZwetJ1JLHOIgMkpVYggWz5Myo,585
-pybounds/simulator.py,sha256=nKLtMQs_HgNYKIJ1YIg63lW2v-r7sT7WxLyouOV07wA,16518
-pybounds/util.py,sha256=Gs0UgqgLXTJI9FZww90iJhqU02iJ31bXBURjGiq3YzM,7401
-pybounds-0.0.11.dist-info/LICENSE,sha256=kqeyRXtRGgBVZdXYeIX4zR9l2KZ2rqIBVEiPMTjxjcI,1093
-pybounds-0.0.11.dist-info/METADATA,sha256=Evpk9-4sk6w_czjxjX-CYC1Y9eFuRGuYRcYrNlMQqjg,2156
-pybounds-0.0.11.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-pybounds-0.0.11.dist-info/top_level.txt,sha256=V-ofnWE3m_UkXTXJwNRD07n14m5R6sc6l4NadaCCP_A,9
-pybounds-0.0.11.dist-info/RECORD,,