diff --git a/control/freqplot.py b/control/freqplot.py index 961f499b3..f7bf60fba 100644 --- a/control/freqplot.py +++ b/control/freqplot.py @@ -1919,7 +1919,7 @@ def _parse_linestyle(style_name, allow_false=False): # Internal function to add arrows to a curve def _add_arrows_to_line2D( axes, line, arrow_locs=[0.2, 0.4, 0.6, 0.8], - arrowstyle='-|>', arrowsize=1, dir=1, transform=None): + arrowstyle='-|>', arrowsize=1, dir=1): """ Add arrows to a matplotlib.lines.Line2D at selected locations. @@ -1930,7 +1930,6 @@ def _add_arrows_to_line2D( arrow_locs: list of locations where to insert arrows, % of total length arrowstyle: style of the arrow arrowsize: size of the arrow - transform: a matplotlib transform instance, default to data coordinates Returns: -------- @@ -1939,13 +1938,13 @@ def _add_arrows_to_line2D( Based on https://stackoverflow.com/questions/26911898/ """ + # Get the coordinates of the line, in plot coordinates if not isinstance(line, mpl.lines.Line2D): raise ValueError("expected a matplotlib.lines.Line2D object") x, y = line.get_xdata(), line.get_ydata() - arrow_kw = { - "arrowstyle": arrowstyle, - } + # Determine the arrow properties + arrow_kw = {"arrowstyle": arrowstyle} color = line.get_color() use_multicolor_lines = isinstance(color, np.ndarray) @@ -1960,36 +1959,43 @@ def _add_arrows_to_line2D( else: arrow_kw['linewidth'] = linewidth - if transform is None: - transform = axes.transData + # Figure out the size of the axes (length of diagonal) + xlim, ylim = axes.get_xlim(), axes.get_ylim() + ul, lr = np.array([xlim[0], ylim[0]]), np.array([xlim[1], ylim[1]]) + diag = np.linalg.norm(ul - lr) # Compute the arc length along the curve s = np.cumsum(np.sqrt(np.diff(x) ** 2 + np.diff(y) ** 2)) + # Truncate the number of arrows if the curve is short + # TODO: figure out a smarter way to do this + frac = min(s[-1] / diag, 1) + if len(arrow_locs) and frac < 0.05: + arrow_locs = [] # too short; no arrows at all + elif len(arrow_locs) and frac < 0.2: + arrow_locs = [0.5] # single arrow in the middle + + # Plot the arrows (and return list if patches) arrows = [] for loc in arrow_locs: n = np.searchsorted(s, s[-1] * loc) - # Figure out what direction to paint the arrow - if dir == 1: - arrow_tail = (x[n], y[n]) - arrow_head = (np.mean(x[n:n + 2]), np.mean(y[n:n + 2])) - elif dir == -1: - # Orient the arrow in the other direction on the segment - arrow_tail = (x[n + 1], y[n + 1]) - arrow_head = (np.mean(x[n:n + 2]), np.mean(y[n:n + 2])) - else: - raise ValueError("unknown value for keyword 'dir'") + if dir == 1 and n == 0: + # Move the arrow forward by one if it is at start of a segment + n = 1 + + # Place the head of the arrow at the desired location + arrow_head = [x[n], y[n]] + arrow_tail = [x[n - dir], y[n - dir]] p = mpl.patches.FancyArrowPatch( - arrow_tail, arrow_head, transform=transform, lw=0, + arrow_tail, arrow_head, transform=axes.transData, lw=0, **arrow_kw) axes.add_patch(p) arrows.append(p) return arrows - # # Function to compute Nyquist curve offsets # diff --git a/control/nlsys.py b/control/nlsys.py index 38efea355..358c4b125 100644 --- a/control/nlsys.py +++ b/control/nlsys.py @@ -18,16 +18,17 @@ """ -import numpy as np -import scipy as sp import copy from warnings import warn +import numpy as np +import scipy as sp + from . import config -from .iosys import InputOutputSystem, _process_signal_list, \ - _process_iosys_keywords, isctime, isdtime, common_timebase, _parse_spec -from .timeresp import _check_convert_array, _process_time_response, \ - TimeResponseData +from .iosys import InputOutputSystem, _parse_spec, _process_iosys_keywords, \ + _process_signal_list, common_timebase, isctime, isdtime +from .timeresp import TimeResponseData, _check_convert_array, \ + _process_time_response __all__ = ['NonlinearIOSystem', 'InterconnectedSystem', 'nlsys', 'input_output_response', 'find_eqpt', 'linearize', @@ -132,13 +133,15 @@ def __init__(self, updfcn, outfcn=None, params=None, **kwargs): if updfcn is None: if self.nstates is None: self.nstates = 0 + self.updfcn = lambda t, x, u, params: np.zeros(0) else: raise ValueError( "states specified but no update function given.") if outfcn is None: - # No output function specified => outputs = states - if self.noutputs is None and self.nstates is not None: + if self.noutputs == 0: + self.outfcn = lambda t, x, u, params: np.zeros(0) + elif self.noutputs is None and self.nstates is not None: self.noutputs = self.nstates elif self.noutputs is not None and self.noutputs == self.nstates: # Number of outputs = number of states => all is OK @@ -364,9 +367,8 @@ def _rhs(self, t, x, u): user-friendly interface you may want to use :meth:`dynamics`. """ - xdot = self.updfcn(t, x, u, self._current_params) \ - if self.updfcn is not None else [] - return np.array(xdot).reshape((-1,)) + return np.asarray( + self.updfcn(t, x, u, self._current_params)).reshape(-1) def dynamics(self, t, x, u, params=None): """Compute the dynamics of a differential or difference equation. @@ -403,7 +405,8 @@ def dynamics(self, t, x, u, params=None): dx/dt or x[t+dt] : ndarray """ self._update_params(params) - return self._rhs(t, x, u) + return self._rhs( + t, np.asarray(x).reshape(-1), np.asarray(u).reshape(-1)) def _out(self, t, x, u): """Evaluate the output of a system at a given state, input, and time @@ -414,9 +417,17 @@ def _out(self, t, x, u): :meth:`output`. """ - y = self.outfcn(t, x, u, self._current_params) \ - if self.outfcn is not None else x - return np.array(y).reshape((-1,)) + # + # To allow lazy evaluation of the system size, we allow for the + # possibility that noutputs is left unspecified when the system + # is created => we have to check for that case here (and return + # the system state or a portion of it). + # + if self.outfcn is None: + return x if self.noutputs is None else x[:self.noutputs] + else: + return np.asarray( + self.outfcn(t, x, u, self._current_params)).reshape(-1) def output(self, t, x, u, params=None): """Compute the output of the system @@ -444,7 +455,8 @@ def output(self, t, x, u, params=None): y : ndarray """ self._update_params(params) - return self._out(t, x, u) + return self._out( + t, np.asarray(x).reshape(-1), np.asarray(u).reshape(-1)) def feedback(self, other=1, sign=-1, params=None): """Feedback interconnection between two input/output systems @@ -517,14 +529,13 @@ def linearize(self, x0, u0, t=0, params=None, eps=1e-6, # numerical linearization use the `_rhs()` and `_out()` member # functions. # - # If x0 and u0 are specified as lists, concatenate the elements x0 = _concatenate_list_elements(x0, 'x0') u0 = _concatenate_list_elements(u0, 'u0') # Figure out dimensions if they were not specified. - nstates = _find_size(self.nstates, x0) - ninputs = _find_size(self.ninputs, u0) + nstates = _find_size(self.nstates, x0, "states") + ninputs = _find_size(self.ninputs, u0, "inputs") # Convert x0, u0 to arrays, if needed if np.isscalar(x0): @@ -533,7 +544,7 @@ def linearize(self, x0, u0, t=0, params=None, eps=1e-6, u0 = np.ones((ninputs,)) * u0 # Compute number of outputs by evaluating the output function - noutputs = _find_size(self.noutputs, self._out(t, x0, u0)) + noutputs = _find_size(self.noutputs, self._out(t, x0, u0), "outputs") # Update the current parameters self._update_params(params) @@ -1306,7 +1317,7 @@ def nlsys( def input_output_response( - sys, T, U=0., X0=0, params=None, + sys, T, U=0., X0=0, params=None, ignore_errors=False, transpose=False, return_x=False, squeeze=None, solve_ivp_kwargs=None, t_eval='T', **kwargs): """Compute the output response of a system to a given input. @@ -1382,6 +1393,11 @@ def input_output_response( to 'RK45'. solve_ivp_kwargs : dict, optional Pass additional keywords to :func:`scipy.integrate.solve_ivp`. + ignore_errors : bool, optional + If ``False`` (default), errors during computation of the trajectory + will raise a ``RuntimeError`` exception. If ``True``, do not raise + an exception and instead set ``results.success`` to ``False`` and + place an error message in ``results.message``. Raises ------ @@ -1516,7 +1532,7 @@ def input_output_response( X0 = np.hstack([X0, np.zeros(sys.nstates - X0.size)]) # Compute the number of states - nstates = _find_size(sys.nstates, X0) + nstates = _find_size(sys.nstates, X0, "states") # create X0 if not given, test if X0 has correct shape X0 = _check_convert_array(X0, [(nstates,), (nstates, 1)], @@ -1583,7 +1599,11 @@ def ivp_rhs(t, x): ivp_rhs, (T0, Tf), X0, t_eval=t_eval, vectorized=False, **solve_ivp_kwargs) if not soln.success: - raise RuntimeError("solve_ivp failed: " + soln.message) + message = "solve_ivp failed: " + soln.message + if not ignore_errors: + raise RuntimeError(message) + else: + message = None # Compute inputs and outputs for each time point u = np.zeros((ninputs, len(soln.t))) @@ -1639,7 +1659,7 @@ def ivp_rhs(t, x): u = np.transpose(np.array(u)) # Mark solution as successful - soln.success = True # No way to fail + soln.success, message = True, None # No way to fail else: # Neither ctime or dtime?? raise TypeError("Can't determine system type") @@ -1649,7 +1669,8 @@ def ivp_rhs(t, x): output_labels=sys.output_labels, input_labels=sys.input_labels, state_labels=sys.state_labels, sysname=sys.name, title="Input/output response for " + sys.name, - transpose=transpose, return_x=return_x, squeeze=squeeze) + transpose=transpose, return_x=return_x, squeeze=squeeze, + success=soln.success, message=message) def find_eqpt(sys, x0, u0=None, y0=None, t=0, params=None, @@ -1732,9 +1753,9 @@ def find_eqpt(sys, x0, u0=None, y0=None, t=0, params=None, from scipy.optimize import root # Figure out the number of states, inputs, and outputs - nstates = _find_size(sys.nstates, x0) - ninputs = _find_size(sys.ninputs, u0) - noutputs = _find_size(sys.noutputs, y0) + nstates = _find_size(sys.nstates, x0, "states") + ninputs = _find_size(sys.ninputs, u0, "inputs") + noutputs = _find_size(sys.noutputs, y0, "outputs") # Convert x0, u0, y0 to arrays, if needed if np.isscalar(x0): @@ -1977,15 +1998,15 @@ def linearize(sys, xeq, ueq=None, t=0, params=None, **kw): return sys.linearize(xeq, ueq, t=t, params=params, **kw) -def _find_size(sysval, vecval): +def _find_size(sysval, vecval, label): """Utility function to find the size of a system parameter If both parameters are not None, they must be consistent. """ if hasattr(vecval, '__len__'): if sysval is not None and sysval != len(vecval): - raise ValueError("Inconsistent information to determine size " - "of system component") + raise ValueError( + f"inconsistent information for number of {label}") return len(vecval) # None or 0, which is a valid value for "a (sysval, ) vector of zeros". if not vecval: @@ -1993,7 +2014,7 @@ def _find_size(sysval, vecval): elif sysval == 1: # (1, scalar) is also a valid combination from legacy code return 1 - raise ValueError("can't determine size of system component") + raise ValueError(f"can't determine number of {label}") # Function to create an interconnected system @@ -2241,7 +2262,7 @@ def interconnect( `outputs`, for more natural naming of SISO systems. """ - from .statesp import StateSpace, LinearICSystem, _convert_to_statespace + from .statesp import LinearICSystem, StateSpace, _convert_to_statespace from .xferfcn import TransferFunction dt = kwargs.pop('dt', None) # bypass normal 'dt' processing @@ -2551,7 +2572,7 @@ def interconnect( return newsys -# Utility function to allow lists states, inputs +# Utility function to allow lists of states, inputs def _concatenate_list_elements(X, name='X'): # If we were passed a list, concatenate the elements together if isinstance(X, (tuple, list)): @@ -2574,13 +2595,14 @@ def _convert_static_iosystem(sys): # Convert sys1 to an I/O system if needed if isinstance(sys, (int, float, np.number)): return NonlinearIOSystem( - None, lambda t, x, u, params: sys * u, inputs=1, outputs=1) + None, lambda t, x, u, params: sys * u, + outputs=1, inputs=1, dt=None) elif isinstance(sys, np.ndarray): sys = np.atleast_2d(sys) return NonlinearIOSystem( None, lambda t, x, u, params: sys @ u, - outputs=sys.shape[0], inputs=sys.shape[1]) + outputs=sys.shape[0], inputs=sys.shape[1], dt=None) def connection_table(sys, show_names=False, column_width=32): """Print table of connections inside an interconnected system model. diff --git a/control/phaseplot.py b/control/phaseplot.py index d785a2221..a885f2d5c 100644 --- a/control/phaseplot.py +++ b/control/phaseplot.py @@ -52,7 +52,7 @@ def phase_plane_plot( sys, pointdata=None, timedata=None, gridtype=None, gridspec=None, plot_streamlines=True, plot_vectorfield=False, plot_equilpoints=True, - plot_separatrices=True, ax=None, **kwargs + plot_separatrices=True, ax=None, suppress_warnings=False, **kwargs ): """Plot phase plane diagram. @@ -88,22 +88,6 @@ def phase_plane_plot( Parameters to pass to system. For an I/O system, `params` should be a dict of parameters and values. For a callable, `params` should be dict with key 'args' and value given by a tuple (passed to callable). - plot_streamlines : bool or dict - If `True` (default) then plot streamlines based on the pointdata - and gridtype. If set to a dict, pass on the key-value pairs in - the dict as keywords to :func:`~control.phaseplot.streamlines`. - plot_vectorfield : bool or dict - If `True` (default) then plot the vector field based on the pointdata - and gridtype. If set to a dict, pass on the key-value pairs in - the dict as keywords to :func:`~control.phaseplot.vectorfield`. - plot_equilpoints : bool or dict - If `True` (default) then plot equilibrium points based in the phase - plot boundary. If set to a dict, pass on the key-value pairs in the - dict as keywords to :func:`~control.phaseplot.equilpoints`. - plot_separatrices : bool or dict - If `True` (default) then plot separatrices starting from each - equilibrium point. If set to a dict, pass on the key-value pairs - in the dict as keywords to :func:`~control.phaseplot.separatrices`. color : str Plot all elements in the given color (use `plot_={'color': c}` to set the color in one element of the phase plot. @@ -117,6 +101,27 @@ def phase_plane_plot( out[1] = Quiver object (vector field arrows) out[2] = list of Line2D objects (equilibrium points) + Other parameters + ---------------- + plot_streamlines : bool or dict, optional + If `True` (default) then plot streamlines based on the pointdata + and gridtype. If set to a dict, pass on the key-value pairs in + the dict as keywords to :func:`~control.phaseplot.streamlines`. + plot_vectorfield : bool or dict, optional + If `True` (default) then plot the vector field based on the pointdata + and gridtype. If set to a dict, pass on the key-value pairs in + the dict as keywords to :func:`~control.phaseplot.vectorfield`. + plot_equilpoints : bool or dict, optional + If `True` (default) then plot equilibrium points based in the phase + plot boundary. If set to a dict, pass on the key-value pairs in the + dict as keywords to :func:`~control.phaseplot.equilpoints`. + plot_separatrices : bool or dict, optional + If `True` (default) then plot separatrices starting from each + equilibrium point. If set to a dict, pass on the key-value pairs + in the dict as keywords to :func:`~control.phaseplot.separatrices`. + suppress_warnings : bool, optional + If set to `True`, suppress warning messages in generating trajectories. + """ # Process arguments params = kwargs.get('params', None) @@ -149,7 +154,8 @@ def _create_kwargs(global_kwargs, local_kwargs, **other_kwargs): kwargs, plot_streamlines, gridspec=gridspec, gridtype=gridtype, ax=ax) out[0] += streamlines( - sys, pointdata, timedata, check_kwargs=False, **kwargs_local) + sys, pointdata, timedata, check_kwargs=False, + suppress_warnings=suppress_warnings, **kwargs_local) # Get rid of keyword arguments handled by streamlines for kw in ['arrows', 'arrow_size', 'arrow_style', 'color', @@ -195,7 +201,7 @@ def _create_kwargs(global_kwargs, local_kwargs, **other_kwargs): raise TypeError("unrecognized keywords: ", str(initial_kwargs)) if fig is not None: - fig.suptitle(f"Phase portrait for {sys.name}") + ax.set_title(f"Phase portrait for {sys.name}") ax.set_xlabel(sys.state_labels[0]) ax.set_ylabel(sys.state_labels[1]) @@ -203,7 +209,8 @@ def _create_kwargs(global_kwargs, local_kwargs, **other_kwargs): def vectorfield( - sys, pointdata, gridspec=None, ax=None, check_kwargs=True, **kwargs): + sys, pointdata, gridspec=None, ax=None, suppress_warnings=False, + check_kwargs=True, **kwargs): """Plot a vector field in the phase plane. This function plots a vector field for a two-dimensional state @@ -244,6 +251,11 @@ def vectorfield( ------- out : Quiver + Other parameters + ---------------- + suppress_warnings : bool, optional + If set to `True`, suppress warning messages in generating trajectories. + """ # Get system parameters params = kwargs.pop('params', None) @@ -283,8 +295,8 @@ def vectorfield( def streamlines( - sys, pointdata, timedata=1, gridspec=None, gridtype=None, - dir=None, ax=None, check_kwargs=True, **kwargs): + sys, pointdata, timedata=1, gridspec=None, gridtype=None, dir=None, + ax=None, check_kwargs=True, suppress_warnings=False, **kwargs): """Plot stream lines in the phase plane. This function plots stream lines for a two-dimensional state space @@ -328,6 +340,11 @@ def streamlines( ------- out : list of Line2D objects + Other parameters + ---------------- + suppress_warnings : bool, optional + If set to `True`, suppress warning messages in generating trajectories. + """ # Get system parameters params = kwargs.pop('params', None) @@ -373,9 +390,10 @@ def streamlines( timepts = _make_timepts(timedata, i) traj = _create_trajectory( sys, revsys, timepts, X0, params, dir, - gridtype=gridtype, gridspec=gridspec, xlim=xlim, ylim=ylim) + gridtype=gridtype, gridspec=gridspec, xlim=xlim, ylim=ylim, + suppress_warnings=suppress_warnings) - # Plot the trajectory + # Plot the trajectory (if there is one) if traj.shape[1] > 1: out.append( ax.plot(traj[0], traj[1], color=color)) @@ -465,7 +483,7 @@ def equilpoints( def separatrices( sys, pointdata, timedata=None, gridspec=None, ax=None, - check_kwargs=True, **kwargs): + check_kwargs=True, suppress_warnings=False, **kwargs): """Plot separatrices in the phase plane. This function plots separatrices for a two-dimensional state space @@ -509,6 +527,11 @@ def separatrices( ------- out : list of Line2D objects + Other parameters + ---------------- + suppress_warnings : bool, optional + If set to `True`, suppress warning messages in generating trajectories. + """ # Get system parameters params = kwargs.pop('params', None) @@ -586,16 +609,19 @@ def separatrices( if evals[j].real < 0: traj = _create_trajectory( sys, revsys, timepts, x0, params, 'reverse', - gridtype='boxgrid', xlim=xlim, ylim=ylim) + gridtype='boxgrid', xlim=xlim, ylim=ylim, + suppress_warnings=suppress_warnings) color = stable_color linestyle = '--' elif evals[j].real > 0: traj = _create_trajectory( sys, revsys, timepts, x0, params, 'forward', - gridtype='boxgrid', xlim=xlim, ylim=ylim) + gridtype='boxgrid', xlim=xlim, ylim=ylim, + suppress_warnings=suppress_warnings) color = unstable_color linestyle = '-' + # Plot the trajectory (if there is one) if traj.shape[1] > 1: out.append(ax.plot( traj[0], traj[1], color=color, linestyle=linestyle)) @@ -879,16 +905,21 @@ def _get_color(kwargs, ax=None): def _create_trajectory( - sys, revsys, timepts, X0, params, dir, + sys, revsys, timepts, X0, params, dir, suppress_warnings=False, gridtype=None, gridspec=None, xlim=None, ylim=None): # Comput ethe forward trajectory if dir == 'forward' or dir == 'both': - fwdresp = input_output_response(sys, timepts, X0=X0, params=params) + fwdresp = input_output_response( + sys, timepts, X0=X0, params=params, ignore_errors=True) + if not fwdresp.success and not suppress_warnings: + warnings.warn(f"{X0=}, {fwdresp.message}") # Compute the reverse trajectory if dir == 'reverse' or dir == 'both': revresp = input_output_response( - revsys, timepts, X0=X0, params=params) + revsys, timepts, X0=X0, params=params, ignore_errors=True) + if not revresp.success and not suppress_warnings: + warnings.warn(f"{X0=}, {revresp.message}") # Create the trace to plot if dir == 'forward': @@ -898,7 +929,14 @@ def _create_trajectory( elif dir == 'both': traj = np.hstack([revresp.states[:, :1:-1], fwdresp.states]) - return traj + # Remove points outside the window (keep first point beyond boundary) + inrange = np.asarray( + (traj[0] >= xlim[0]) & (traj[0] <= xlim[1]) & + (traj[1] >= ylim[0]) & (traj[1] <= ylim[1])) + inrange[:-1] = inrange[:-1] | inrange[1:] # keep if next point in range + inrange[1:] = inrange[1:] | inrange[:-1] # keep if prev point in range + + return traj[:, inrange] def _make_timepts(timepts, i): @@ -1203,6 +1241,3 @@ def _find(condition): Private implementation of deprecated matplotlib.mlab.find """ return np.nonzero(np.ravel(condition))[0] - - - diff --git a/control/tests/nlsys_test.py b/control/tests/nlsys_test.py index 1c2976c56..80baa646f 100644 --- a/control/tests/nlsys_test.py +++ b/control/tests/nlsys_test.py @@ -9,6 +9,7 @@ import pytest import numpy as np +import math import control as ct # Basic test of nlsys() @@ -45,6 +46,7 @@ def kincar_output(t, x, u, params): ]) def test_lti_nlsys_response(nin, nout, input, output): sys_ss = ct.rss(4, nin, nout, strictly_proper=True) + sys_ss.A = np.diag([-1, -2, -3, -4]) # avoid random noise errors sys_nl = ct.nlsys( lambda t, x, u, params: sys_ss.A @ x + sys_ss.B @ u, lambda t, x, u, params: sys_ss.C @ x + sys_ss.D @ u, @@ -92,3 +94,63 @@ def test_nlsys_impulse(): # Impulse_response (not implemented) with pytest.raises(ValueError, match="system must be LTI"): resp_nl = ct.impulse_response(sys_nl, timepts) + + +# Test nonlinear systems that are missing inputs or outputs +def test_nlsys_empty_io(): + + # No inputs + sys_nl = ct.nlsys( + lambda t, x, u, params: -x, lambda t, x, u, params: x[0:2], + name="no inputs", states=3, inputs=0, outputs=2) + P = sys_nl.linearize(np.zeros(sys_nl.nstates), None) + assert P.A.shape == (3, 3) + assert P.B.shape == (3, 0) + assert P.C.shape == (2, 3) + assert P.D.shape == (2, 0) + + # Check that we can compute dynamics and outputs + x = np.array([1, 2, 3]) + np.testing.assert_equal(sys_nl.dynamics(0, x, None, {}), -x) + np.testing.assert_equal(P.dynamics(0, x, None), -x) + np.testing.assert_equal(sys_nl.output(0, x, None, {}), x[0:2]) + np.testing.assert_equal(P.output(0, x, None), x[0:2]) + + # Make sure initial response runs OK + resp = ct.initial_response(sys_nl, np.linspace(0, 1), x) + np.testing.assert_allclose( + resp.states[:, -1], x * math.exp(-1), atol=1e-3, rtol=1e-3) + + resp = ct.initial_response(P, np.linspace(0, 1), x) + np.testing.assert_allclose(resp.states[:, -1], x * math.exp(-1)) + + # No outputs + sys_nl = ct.nlsys( + lambda t, x, u, params: -x + np.array([1, 1, 1]) * u[0], None, + name="no outputs", states=3, inputs=1, outputs=0) + P = sys_nl.linearize(np.zeros(sys_nl.nstates), 0) + assert P.A.shape == (3, 3) + assert P.B.shape == (3, 1) + assert P.C.shape == (0, 3) + assert P.D.shape == (0, 1) + + # Check that we can compute dynamics + x = np.array([1, 2, 3]) + np.testing.assert_equal(sys_nl.dynamics(0, x, 1, {}), -x + 1) + np.testing.assert_equal(P.dynamics(0, x, 1), -x + 1) + + # Make sure initial response runs OK + resp = ct.initial_response(sys_nl, np.linspace(0, 1), x) + np.testing.assert_allclose( + resp.states[:, -1], x * math.exp(-1), atol=1e-3, rtol=1e-3) + + resp = ct.initial_response(P, np.linspace(0, 1), x) + np.testing.assert_allclose(resp.states[:, -1], x * math.exp(-1)) + + # Make sure forced response runs OK + resp = ct.forced_response(sys_nl, np.linspace(0, 1), 1) + np.testing.assert_allclose( + resp.states[:, -1], 1 - math.exp(-1), atol=1e-3, rtol=1e-3) + + resp = ct.forced_response(P, np.linspace(0, 1), 1) + np.testing.assert_allclose(resp.states[:, -1], 1 - math.exp(-1)) diff --git a/control/tests/phaseplot_test.py b/control/tests/phaseplot_test.py index a01ab2aea..18e06716f 100644 --- a/control/tests/phaseplot_test.py +++ b/control/tests/phaseplot_test.py @@ -9,14 +9,16 @@ the figures so that you can check them visually. """ +import warnings import matplotlib.pyplot as plt import numpy as np -from numpy import pi import pytest -from control import phase_plot +from math import pi + import control as ct import control.phaseplot as pp +from control import phase_plot # Legacy tests @@ -156,7 +158,22 @@ def invpend_ode(t, x, m=0, l=0, b=0, g=0): ct.phase_plane_plot( invpend_ode, [-5, 5, 2, 2], params={'stuff': (1, 1, 0.2, 1)}) - + # Warning messages for invalid solutions: nonlinear spring mass system + sys = ct.nlsys( + lambda t, x, u, params: np.array( + [x[1], -0.25 * (x[0] - 0.01 * x[0]**3) - 0.1 * x[1]]), + states=2, inputs=0) + with pytest.warns(UserWarning, match=r"X0=array\(.*\), solve_ivp failed"): + ct.phase_plane_plot( + sys, [-12, 12, -10, 10], 15, gridspec=[2, 9], + plot_separatrices=False) + + # Turn warnings off + with warnings.catch_warnings(): + warnings.simplefilter("error") + ct.phase_plane_plot( + sys, [-12, 12, -10, 10], 15, gridspec=[2, 9], + plot_separatrices=False, suppress_warnings=True) def test_basic_phase_plots(savefigs=False): diff --git a/control/tests/timebase_test.py b/control/tests/timebase_test.py index a391d2fe7..79b1492d7 100644 --- a/control/tests/timebase_test.py +++ b/control/tests/timebase_test.py @@ -3,18 +3,36 @@ import numpy as np import control as ct +# Utility function to convert state space system to nlsys +def ss2io(sys): + return ct.nlsys( + sys.updfcn, sys.outfcn, states=sys.nstates, + inputs=sys.ninputs, outputs=sys.noutputs, dt=sys.dt) + @pytest.mark.parametrize( "dt1, dt2, dt3", [ (0, 0, 0), (0, 0.1, ValueError), (0, None, 0), + (0, 'float', 0), + (0, 'array', 0), + (None, 'array', None), + (None, 'array', None), (0, True, ValueError), (0.1, 0, ValueError), (0.1, 0.1, 0.1), (0.1, None, 0.1), (0.1, True, 0.1), + (0.1, 'array', 0.1), + (0.1, 'float', 0.1), (None, 0, 0), + ('float', 0, 0), + ('array', 0, 0), + ('float', None, None), + ('array', None, None), (None, 0.1, 0.1), + ('array', 0.1, 0.1), + ('float', 0.1, 0.1), (None, None, None), (None, True, True), (True, 0, ValueError), @@ -25,16 +43,28 @@ (0.2, 0.1, ValueError), ]) @pytest.mark.parametrize("op", [ct.series, ct.parallel, ct.feedback]) -@pytest.mark.parametrize("type", [ct.StateSpace, ct.ss, ct.tf]) +@pytest.mark.parametrize("type", [ct.StateSpace, ct.ss, ct.tf, ss2io]) def test_composition(dt1, dt2, dt3, op, type): - # Define the system A, B, C, D = [[1, 1], [0, 1]], [[0], [1]], [[1, 0]], 0 - sys1 = ct.StateSpace(A, B, C, D, dt1) - sys2 = ct.StateSpace(A, B, C, D, dt2) + Karray = np.array([[1]]) + kfloat = 1 - # Convert to the desired form - sys1 = type(sys1) - sys2 = type(sys2) + # Define the system + if isinstance(dt1, (int, float)) or dt1 is None: + sys1 = ct.StateSpace(A, B, C, D, dt1) + sys1 = type(sys1) + elif dt1 == 'array': + sys1 = Karray + elif dt1 == 'float': + sys1 = kfloat + + if isinstance(dt2, (int, float)) or dt2 is None: + sys2 = ct.StateSpace(A, B, C, D, dt2) + sys2 = type(sys2) + elif dt2 == 'array': + sys2 = Karray + elif dt2 == 'float': + sys2 = kfloat if inspect.isclass(dt3) and issubclass(dt3, Exception): with pytest.raises(dt3, match="incompatible timebases"): diff --git a/control/tests/type_conversion_test.py b/control/tests/type_conversion_test.py index ad8dea911..efd1a66a8 100644 --- a/control/tests/type_conversion_test.py +++ b/control/tests/type_conversion_test.py @@ -57,7 +57,7 @@ def sys_dict(): ('add', 'ios', ['ios', 'ios', 'E', 'ios', 'ios', 'ios']), ('add', 'arr', ['ss', 'tf', 'frd', 'ios', 'arr', 'arr']), ('add', 'flt', ['ss', 'tf', 'frd', 'ios', 'arr', 'flt']), - + # op left ss tf frd ios arr flt ('sub', 'ss', ['ss', 'ss', 'frd', 'ios', 'ss', 'ss' ]), ('sub', 'tf', ['tf', 'tf', 'frd', 'ios', 'tf', 'tf' ]), @@ -65,7 +65,7 @@ def sys_dict(): ('sub', 'ios', ['ios', 'ios', 'E', 'ios', 'ios', 'ios']), ('sub', 'arr', ['ss', 'tf', 'frd', 'ios', 'arr', 'arr']), ('sub', 'flt', ['ss', 'tf', 'frd', 'ios', 'arr', 'flt']), - + # op left ss tf frd ios arr flt ('mul', 'ss', ['ss', 'ss', 'frd', 'ios', 'ss', 'ss' ]), ('mul', 'tf', ['tf', 'tf', 'frd', 'ios', 'tf', 'tf' ]), @@ -73,7 +73,7 @@ def sys_dict(): ('mul', 'ios', ['ios', 'ios', 'E', 'ios', 'ios', 'ios']), ('mul', 'arr', ['ss', 'tf', 'frd', 'ios', 'arr', 'arr']), ('mul', 'flt', ['ss', 'tf', 'frd', 'ios', 'arr', 'flt']), - + # op left ss tf frd ios arr flt ('truediv', 'ss', ['E', 'tf', 'frd', 'E', 'ss', 'ss' ]), ('truediv', 'tf', ['tf', 'tf', 'xrd', 'E', 'tf', 'tf' ]), @@ -88,7 +88,7 @@ def sys_dict(): for rtype, expected in zip(rtype_list, expected_list): # Add this to the list of tests to run test_matrix.append([opname, ltype, rtype, expected]) - + @pytest.mark.parametrize("opname, ltype, rtype, expected", test_matrix) def test_operator_type_conversion(opname, ltype, rtype, expected, sys_dict): op = getattr(operator, opname) @@ -98,7 +98,7 @@ def test_operator_type_conversion(opname, ltype, rtype, expected, sys_dict): # Get rid of warnings for NonlinearIOSystem objects by making a copy if isinstance(leftsys, ct.NonlinearIOSystem) and leftsys == rightsys: rightsys = leftsys.copy() - + # Make sure we get the right result if expected == 'E' or expected[0] == 'x': # Exception expected @@ -107,7 +107,7 @@ def test_operator_type_conversion(opname, ltype, rtype, expected, sys_dict): else: # Operation should work and return the given type result = op(leftsys, rightsys) - + # Print out what we are testing in case something goes wrong assert isinstance(result, type_dict[expected]) @@ -126,7 +126,7 @@ def test_operator_type_conversion(opname, ltype, rtype, expected, sys_dict): # # * For IOS/LTI, convert to IOS. In the case of a linear I/O system (LIO), # this will preserve the linear structure since the LTI system will -# be converted to state space. +# be converted to state space. # # * When combining state space or transfer with linear I/O systems, the # * output should be of type Linear IO system, since that maintains the diff --git a/control/timeresp.py b/control/timeresp.py index 428baf230..81b2030b3 100644 --- a/control/timeresp.py +++ b/control/timeresp.py @@ -71,19 +71,18 @@ """ import warnings +from copy import copy import numpy as np import scipy as sp from numpy import einsum, maximum, minimum from scipy.linalg import eig, eigvals, matrix_balance, norm -from copy import copy from . import config from .exception import pandas_check from .iosys import isctime, isdtime from .timeplot import time_response_plot - __all__ = ['forced_response', 'step_response', 'step_info', 'initial_response', 'impulse_response', 'TimeResponseData'] @@ -170,6 +169,13 @@ class TimeResponseData: input_labels, output_labels, state_labels : array of str Names for the input, output, and state variables. + success : bool, optional + If ``False``, result may not be valid (see + :func:`~control.input_output_response`). Defaults to ``True``. + + message : str, optional + Informational message if ``success`` is ``False``. + sysname : str, optional Name of the system that created the data. @@ -230,7 +236,8 @@ def __init__( output_labels=None, state_labels=None, input_labels=None, title=None, transpose=False, return_x=False, squeeze=None, multi_trace=False, trace_labels=None, trace_types=None, - plot_inputs=True, sysname=None, params=None + plot_inputs=True, sysname=None, params=None, success=True, + message=None ): """Create an input/output time response object. @@ -307,6 +314,13 @@ def __init__( a MIMO system, the ``input`` attribute should then be set to indicate which trace is being specified. Default is ``False``. + success : bool, optional + If ``False``, result may not be valid (see + :func:`~control.input_output_response`). + + message : str, optional + Informational message if ``success`` is ``False``. + """ # # Process and store the basic input/output elements @@ -460,6 +474,10 @@ def __init__( # Store legacy keyword values (only needed for legacy interface) self.return_x = return_x + # Information on the whether the simulation result may be incorrect + self.success = success + self.message = message + def __call__(self, **kwargs): """Change value of processing keywords. @@ -978,9 +996,9 @@ def forced_response(sys, T=None, U=0., X0=0., transpose=False, params=None, :ref:`package-configuration-parameters`. """ + from .nlsys import NonlinearIOSystem, input_output_response from .statesp import StateSpace, _convert_to_statespace from .xferfcn import TransferFunction - from .nlsys import NonlinearIOSystem, input_output_response if not isinstance(sys, (StateSpace, TransferFunction)): if isinstance(sys, NonlinearIOSystem): @@ -1370,8 +1388,8 @@ def step_response(sys, T=None, X0=0, input=None, output=None, T_num=None, """ from .lti import LTI - from .xferfcn import TransferFunction from .statesp import _convert_to_statespace + from .xferfcn import TransferFunction # Create the time and input vectors if T is None or np.asarray(T).size == 1: @@ -1543,9 +1561,9 @@ def step_info(sysdata, T=None, T_num=None, yfinal=None, params=None, PeakTime: 4.242 SteadyStateValue: -1.0 """ + from .nlsys import NonlinearIOSystem from .statesp import StateSpace from .xferfcn import TransferFunction - from .nlsys import NonlinearIOSystem if isinstance(sysdata, (StateSpace, TransferFunction, NonlinearIOSystem)): T, Yout = step_response(sysdata, T, squeeze=False, params=params) @@ -1875,8 +1893,8 @@ def impulse_response(sys, T=None, input=None, output=None, T_num=None, >>> T, yout = ct.impulse_response(G) """ - from .statesp import _convert_to_statespace from .lti import LTI + from .statesp import _convert_to_statespace # Make sure we have an LTI system if not isinstance(sys, LTI): diff --git a/examples/cds110_invpend-dynamics.ipynb b/examples/cds110_invpend-dynamics.ipynb new file mode 100644 index 000000000..0543452dd --- /dev/null +++ b/examples/cds110_invpend-dynamics.ipynb @@ -0,0 +1,610 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "t0JD8EbaVWg-" + }, + "source": [ + "# Inverted Pendulum Dynamics\n", + "\n", + "CDS 110, Winter 2024
\n", + "Richard M. Murray\n", + "\n", + "In this lecture we investigate the nonlinear dynamics of an inverted pendulum system. More information on this example can be found in [FBS2e](https://fbswiki.org/wiki/index.php?title=FBS), Examples 3.3 and 5.4.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Import the packages needed for the examples included in this notebook\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from math import pi\n", + "\n", + "import control as ct" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "P_ZMCccjvHY1" + }, + "source": [ + "## System model" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Msad1ficHjtc" + }, + "source": [ + "The dynamics for an inverted pendulum system can be written as:\n", + "\n", + "$$\n", + " \\dfrac{d}{dt} \\begin{bmatrix} \\theta \\\\ \\dot\\theta\\end{bmatrix} =\n", + " \\begin{bmatrix}\n", + " \\dot\\theta \\\\\n", + " \\dfrac{m g l}{J_\\text{t}} \\sin \\theta\n", + " - \\dfrac{b}{J_\\text{t}} \\dot\\theta\n", + " + \\dfrac{l}{J_\\text{t}} u \\cos\\theta\n", + " \\end{bmatrix}, \\qquad\n", + " y = \\theta,\n", + "$$\n", + "\n", + "where $m$ and $J_t = J + m l^2$ are the mass and (total) moment of inertia of the system to be balanced, $l$ is the distance from the base to the center of mass of the balanced body, $b$ is the coefficient of rotational friction, and $g$ is the acceleration due to gravity.\n", + "\n", + "We begin by creating a nonlinear model of the system:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": invpend\n", + "Inputs (1): ['tau']\n", + "Outputs (2): ['theta', 'thdot']\n", + "States (2): ['theta', 'thdot']\n", + "\n", + "Update: \n", + "Output: None\n" + ] + } + ], + "source": [ + "invpend_params = {'m': 1, 'l': 1, 'b': 0.5, 'g': 1}\n", + "def invpend_update(t, x, u, params):\n", + " m, l, b, g = params['m'], params['l'], params['b'], params['g']\n", + " umax = params.get('umax', 1)\n", + " usat = np.clip(u[0], -umax, umax)\n", + " return [x[1], -b/m * x[1] + (g * l / m) * np.sin(x[0] + usat/m)]\n", + "invpend = ct.nlsys(\n", + " invpend_update, states=['theta', 'thdot'],\n", + " inputs=['tau'], outputs=['theta', 'thdot'],\n", + " params=invpend_params, name='invpend')\n", + "print(invpend)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IAoQAORFvLj1" + }, + "source": [ + "## Open loop dynamics" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vOALp_IwjVxC" + }, + "source": [ + "The open loop dynamics of the system can be visualized using the `phase_plane_plot` command in python-control:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ct.phase_plane_plot(\n", + " invpend, [-2*pi - 1, 2*pi + 1, -2, 2], 8),\n", + "\n", + "# Draw lines at the downward equilibrium angles\n", + "plt.plot([-pi, -pi], [-2, 2], 'k--')\n", + "plt.plot([pi, pi], [-2, 2], 'k--')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WZuvqNzeJinm" + }, + "source": [ + "We see that the vertical ($\\theta = 0$) equilibrium point is unstable, but the downward equlibrium points ($\\theta = \\pm \\pi$) are stable.\n", + "\n", + "Note also the *separatrices* for the equilibrium point, which gives insights into the regions of attraction (the red dashed line separates the two regions of attraction)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2JibDTJBKHIF" + }, + "source": [ + "## Proportional feedback\n", + "\n", + "We now stabilize the system using a simple proportional feedback controller:\n", + "\n", + "$$u = -k_\\text{p} \\theta.$$\n", + "\n", + "This controller can be designed as an input/output system that has no state dynamics, just a mapping from the inputs to the outputs:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": p_ctrl\n", + "Inputs (2): ['theta', 'r']\n", + "Outputs (1): ['tau']\n", + "States (0): []\n", + "\n", + "Update: . at 0x13c3c37e0>\n", + "Output: \n" + ] + } + ], + "source": [ + "# Set up the controller\n", + "def propctrl_output(t, x, u, params):\n", + " kp = params.get('kp', 1)\n", + " return -kp * (u[0] - u[1])\n", + "propctrl = ct.nlsys(\n", + " None, propctrl_output, name=\"p_ctrl\",\n", + " inputs=['theta', 'r'], outputs='tau'\n", + ")\n", + "print(propctrl)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AvU35WoBMFjt" + }, + "source": [ + "Note that the input to the controller is the reference value $r$ (which we will always take to be zero), the measured output $y$, which is the angle $\\theta$ for our system. The output of the controller is the system input $u$, corresponding to the force applied to the wheels.\n", + "\n", + "To connect the controller to the system, we use the [`interconnect`](https://python-control.readthedocs.io/en/latest/generated/control.interconnect.html) function, which will connect all signals that have the same names:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": invpend w/ proportional feedback\n", + "Inputs (1): ['r']\n", + "Outputs (2): ['theta', 'tau']\n", + "States (2): ['invpend_theta', 'invpend_thdot']\n", + "\n", + "Update: .updfcn at 0x13dc72700>\n", + "Output: .outfcn at 0x13dc728e0>\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/murray/src/python-control/murrayrm/control/nlsys.py:1208: UserWarning: Unused output(s) in InterconnectedSystem: (0, 1) : invpend.thdot\n", + " warn(msg)\n" + ] + } + ], + "source": [ + "# Create the closed loop system\n", + "clsys = ct.interconnect(\n", + " [invpend, propctrl], name='invpend w/ proportional feedback',\n", + " inputs=['r'], outputs=['theta', 'tau'], params={'kp': 1})\n", + "print(clsys)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IIiSaHNuM1u_" + }, + "source": [ + "We can now linearize the closed loop system at different gains and compute the eigenvalues to check for stability:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "kp = 0 ; poles = [ 0.78077641+0.j -1.28077641+0.j]\n", + "kp = 1 ; poles = [ 0. +0.j -0.5+0.j]\n", + "kp = 10 ; poles = [-0.25+2.98956519j -0.25-2.98956519j]\n" + ] + } + ], + "source": [ + "# Solution\n", + "for kp in [0, 1, 10]:\n", + " print(\"kp = \", kp, \"; poles = \", clsys.linearize([0, 0], [0], params={'kp': kp}).poles())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iV4u31DsNWP9" + }, + "source": [ + "We see that at $k_\\text{p} = 10$ the eigenvalues (poles) of the closed loop system both have negative real part, and so the system is stabilized." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Jg87a3iZP-Qd" + }, + "source": [ + "### Phase portrait\n", + "\n", + "To study the resulting dynamics, we try plotting a phase plot using the same commands as before, but now for the closed loop system (with appropriate proportional gain):" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ct.phase_plane_plot(\n", + " clsys, [-2*pi, 2*pi, -2, 2], 8, params={'kp': 10});" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5nss-eU_vevc" + }, + "source": [ + "### Improved phase portrait" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jhU2gidqi-ri" + }, + "source": [ + "This plot is not very useful and has several errors. It shows the limitations of the default parameter values for the `phase_plane_plot` command.\n", + "\n", + "Some things to notice in this plot:\n", + "* The equilibrium point at $\\theta = 0$ is not showing up. This happens because the grid spacing is such that we don't find that point.\n", + "\n", + "To fix these issues, we can do a couple of things:\n", + "* Restrict the range of the plot from $-\\pi$ to $\\pi$, which means that grid used to calculate the equilibrium point is a bit finer.\n", + "* Reset the grid spacing, so that we have more initial conditions around the edge of the plot and a finer search for equilibrium points.\n", + "\n", + "Here's some improved code:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "kp_params = {'kp': 10}\n", + "ct.phase_plane_plot(\n", + " clsys, [-1.5 * pi, 1.5 * pi, -2, 2], 8,\n", + " gridspec=[13, 7], params=kp_params,\n", + " plot_separatrices={'timedata': 5})\n", + "plt.plot([-pi, -pi], [-2, 2], 'k--', [ pi, pi], [-2, 2], 'k--')\n", + "plt.plot([-pi/2, -pi/2], [-2, 2], 'k:', [ pi/2, pi/2], [-2, 2], 'k:')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Play around with some paramters to see what happens\n", + "fig, axs = plt.subplots(2, 2)\n", + "for i, kp in enumerate([3, 10]):\n", + " for j, umax in enumerate([0.2, 1]):\n", + " ct.phase_plane_plot(\n", + " clsys, [-1.5 * pi, 1.5 * pi, -2, 2], 8,\n", + " gridspec=[13, 7], plot_separatrices={'timedata': 5},\n", + " params={'kp': kp, 'umax': umax}, ax=axs[i, j])\n", + " axs[i, j].set_title(f\"{kp=}, {umax=}\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dYeVbfG4kU-9" + }, + "source": [ + "## State space controller\n", + "\n", + "For the proportional controller, we have limited control over the dynamics of the closed loop system. For example, we see that the solutions near the origin are highly oscillatory in both the $k_\\text{p} = 3$ and $k_\\text{p} = 10$ cases.\n", + "\n", + "An alternative is to use \"full state feedback\", in which we set\n", + "\n", + "$$\n", + "u = -K (x - x_\\text{d}) = -k_1 (\\theta - \\theta_d) - k_2 (\\dot\\theta - \\dot\\theta_d).\n", + "$$\n", + "\n", + "To compute the gains, we make use of the `place` command, applied to the linearized system:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K=array([[2.01, 1.5 ]])\n" + ] + } + ], + "source": [ + "# Linearize the system\n", + "P = invpend.linearize([0, 0], [0])\n", + "\n", + "# Place the closed loop eigenvalues (poles) at desired locations\n", + "K = ct.place(P.A, P.B, [-1 + 0.1j, -1 - 0.1j])\n", + "print(f\"{K=}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": k_ctrl\n", + "Inputs (4): ['theta', 'thdot', 'theta_d', 'thdot_d']\n", + "Outputs (1): ['tau']\n", + "States (0): []\n", + "\n", + "Update: . at 0x13dd50a40>\n", + "Output: \n" + ] + } + ], + "source": [ + "def statefbk_output(t, x, u, params):\n", + " K = params.get('K', np.array([0, 0]))\n", + " return -K @ (u[0:2] - u[2:])\n", + "statefbk = ct.nlsys(\n", + " None, statefbk_output, name=\"k_ctrl\",\n", + " inputs=['theta', 'thdot', 'theta_d', 'thdot_d'], outputs='tau'\n", + ")\n", + "print(statefbk)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ": invpend w/ state feedback\n", + "Inputs (2): ['theta_d', 'thdot_d']\n", + "Outputs (2): ['theta', 'tau']\n", + "States (2): ['invpend_theta', 'invpend_thdot']\n", + "\n", + "Update: .updfcn at 0x13dd507c0>\n", + "Output: .outfcn at 0x13dd50860>\n" + ] + } + ], + "source": [ + "clsys_sf = ct.interconnect(\n", + " [invpend, statefbk], name='invpend w/ state feedback',\n", + " inputs=['theta_d', 'thdot_d'], outputs=['theta', 'tau'], params={'kp': 1})\n", + "print(clsys_sf)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aGm3usQIvmqN" + }, + "source": [ + "### Phase portrait" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ct.phase_plane_plot(\n", + " clsys_sf, [-1.5 * pi, 1.5 * pi, -2, 2], 8,\n", + " gridspec=[13, 7], params={'K': K})\n", + "plt.plot([-pi, -pi], [-2, 2], 'k--', [ pi, pi], [-2, 2], 'k--')\n", + "plt.plot([-pi/2, -pi/2], [-2, 2], 'k:', [ pi/2, pi/2], [-2, 2], 'k:')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "A7UNUtfJwLWQ" + }, + "source": [ + "Note that the closed loop response around the upright equilibrium point is much less oscillatory (consistent with where we placed the closed loop eigenvalues of the system dynamics)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eVSa1Mvqycov" + }, + "source": [ + "## Things to try\n", + "\n", + "Here are some things to try with the above code:\n", + "* Try changing the locations of the closed loop eigenvalues in the `place` command\n", + "* Try resetting the limits of the control action (`umax`)\n", + "* Try leaving the state space controller fixed but changing the parameters of the system dynamics ($m$, $l$, $b$). Does the controller still stabilize the system?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/pvtol-nested.py b/examples/pvtol-nested.py index 040b4a1f4..eeb46d075 100644 --- a/examples/pvtol-nested.py +++ b/examples/pvtol-nested.py @@ -61,8 +61,6 @@ Hi = ct.parallel(ct.feedback(Ci, Pi), -m * g *ct.feedback(Ci * Pi, 1)) plt.figure(4) -plt.clf() -plt.subplot(221) ct.bode_plot(Hi) # Now design the lateral control system @@ -129,7 +127,7 @@ # plt.figure(7) plt.clf() -ct.nyquist_plot(L, (0.0001, 1000)) +ct.nyquist_plot(L) # Add a box in the region we are going to expand plt.plot([-2, -2, 1, 1, -2], [-4, 4, 4, -4, -4], 'r-')