{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "velvet-romance", "metadata": {}, "outputs": [], "source": [ "\"\"\"\n", "@author: Enrico Regolin\n", "\"\"\"\n", "# observability / controllability example\n", "import numpy as np" ] }, { "cell_type": "code", "execution_count": 2, "id": "geological-lewis", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1 0 0]\n", " [0 1 0]\n", " [0 0 1]]\n", "observability matrix rank = 3\n", "[[0 0 1]\n", " [0 1 2]\n", " [1 2 3]]\n", "controllability matrix rank = 3\n" ] } ], "source": [ "#A = np.array([[0,1,0] , [1,1,0], [0,0,1]])\n", "A = np.array([[0,1,0] , [0,0,1], [1,-1,2]])\n", "C = np.array([[1,0,0]])\n", "B = np.array( [ [0],[0],[1]])\n", "\n", "# build obs and ctb matrices\n", "m = C\n", "n = B\n", "Om = C\n", "Cm = B\n", "for i in range(A.shape[0]-1):\n", " m = np.matmul(m,A)\n", " n = np.matmul(A,n)\n", " Om = np.append(Om,m, axis = 0)\n", " Cm = np.append(Cm,n, axis = 1)\n", " \n", "# calculate rank \n", "print(Om)\n", "print(f'observability matrix rank = {np.linalg.matrix_rank(Om)}')\n", "print(Cm)\n", "print(f'controllability matrix rank = {np.linalg.matrix_rank(Cm)}')" ] }, { "cell_type": "code", "execution_count": 3, "id": "rural-million", "metadata": {}, "outputs": [], "source": [ "# pole placement / Luenberger observer\n", "from scipy.signal import place_poles\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 4, "id": "pleased-swaziland", "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "\u001b[0;31mSignature:\u001b[0m \u001b[0mplace_poles\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mB\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpoles\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'YT'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrtol\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.001\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmaxiter\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m30\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mDocstring:\u001b[0m\n", "Compute K such that eigenvalues (A - dot(B, K))=poles.\n", "\n", "K is the gain matrix such as the plant described by the linear system\n", "``AX+BU`` will have its closed-loop poles, i.e the eigenvalues ``A - B*K``,\n", "as close as possible to those asked for in poles.\n", "\n", "SISO, MISO and MIMO systems are supported.\n", "\n", "Parameters\n", "----------\n", "A, B : ndarray\n", " State-space representation of linear system ``AX + BU``.\n", "poles : array_like\n", " Desired real poles and/or complex conjugates poles.\n", " Complex poles are only supported with ``method=\"YT\"`` (default).\n", "method: {'YT', 'KNV0'}, optional\n", " Which method to choose to find the gain matrix K. One of:\n", "\n", " - 'YT': Yang Tits\n", " - 'KNV0': Kautsky, Nichols, Van Dooren update method 0\n", "\n", " See References and Notes for details on the algorithms.\n", "rtol: float, optional\n", " After each iteration the determinant of the eigenvectors of\n", " ``A - B*K`` is compared to its previous value, when the relative\n", " error between these two values becomes lower than `rtol` the algorithm\n", " stops. Default is 1e-3.\n", "maxiter: int, optional\n", " Maximum number of iterations to compute the gain matrix.\n", " Default is 30.\n", "\n", "Returns\n", "-------\n", "full_state_feedback : Bunch object\n", " full_state_feedback is composed of:\n", " gain_matrix : 1-D ndarray\n", " The closed loop matrix K such as the eigenvalues of ``A-BK``\n", " are as close as possible to the requested poles.\n", " computed_poles : 1-D ndarray\n", " The poles corresponding to ``A-BK`` sorted as first the real\n", " poles in increasing order, then the complex congugates in\n", " lexicographic order.\n", " requested_poles : 1-D ndarray\n", " The poles the algorithm was asked to place sorted as above,\n", " they may differ from what was achieved.\n", " X : 2-D ndarray\n", " The transfer matrix such as ``X * diag(poles) = (A - B*K)*X``\n", " (see Notes)\n", " rtol : float\n", " The relative tolerance achieved on ``det(X)`` (see Notes).\n", " `rtol` will be NaN if it is possible to solve the system\n", " ``diag(poles) = (A - B*K)``, or 0 when the optimization\n", " algorithms can't do anything i.e when ``B.shape[1] == 1``.\n", " nb_iter : int\n", " The number of iterations performed before converging.\n", " `nb_iter` will be NaN if it is possible to solve the system\n", " ``diag(poles) = (A - B*K)``, or 0 when the optimization\n", " algorithms can't do anything i.e when ``B.shape[1] == 1``.\n", "\n", "Notes\n", "-----\n", "The Tits and Yang (YT), [2]_ paper is an update of the original Kautsky et\n", "al. (KNV) paper [1]_. KNV relies on rank-1 updates to find the transfer\n", "matrix X such that ``X * diag(poles) = (A - B*K)*X``, whereas YT uses\n", "rank-2 updates. This yields on average more robust solutions (see [2]_\n", "pp 21-22), furthermore the YT algorithm supports complex poles whereas KNV\n", "does not in its original version. Only update method 0 proposed by KNV has\n", "been implemented here, hence the name ``'KNV0'``.\n", "\n", "KNV extended to complex poles is used in Matlab's ``place`` function, YT is\n", "distributed under a non-free licence by Slicot under the name ``robpole``.\n", "It is unclear and undocumented how KNV0 has been extended to complex poles\n", "(Tits and Yang claim on page 14 of their paper that their method can not be\n", "used to extend KNV to complex poles), therefore only YT supports them in\n", "this implementation.\n", "\n", "As the solution to the problem of pole placement is not unique for MIMO\n", "systems, both methods start with a tentative transfer matrix which is\n", "altered in various way to increase its determinant. Both methods have been\n", "proven to converge to a stable solution, however depending on the way the\n", "initial transfer matrix is chosen they will converge to different\n", "solutions and therefore there is absolutely no guarantee that using\n", "``'KNV0'`` will yield results similar to Matlab's or any other\n", "implementation of these algorithms.\n", "\n", "Using the default method ``'YT'`` should be fine in most cases; ``'KNV0'``\n", "is only provided because it is needed by ``'YT'`` in some specific cases.\n", "Furthermore ``'YT'`` gives on average more robust results than ``'KNV0'``\n", "when ``abs(det(X))`` is used as a robustness indicator.\n", "\n", "[2]_ is available as a technical report on the following URL:\n", "https://hdl.handle.net/1903/5598\n", "\n", "References\n", "----------\n", ".. [1] J. Kautsky, N.K. Nichols and P. van Dooren, \"Robust pole assignment\n", " in linear state feedback\", International Journal of Control, Vol. 41\n", " pp. 1129-1155, 1985.\n", ".. [2] A.L. Tits and Y. Yang, \"Globally convergent algorithms for robust\n", " pole assignment by state feedback\", IEEE Transactions on Automatic\n", " Control, Vol. 41, pp. 1432-1452, 1996.\n", "\n", "Examples\n", "--------\n", "A simple example demonstrating real pole placement using both KNV and YT\n", "algorithms. This is example number 1 from section 4 of the reference KNV\n", "publication ([1]_):\n", "\n", ">>> from scipy import signal\n", ">>> import matplotlib.pyplot as plt\n", "\n", ">>> A = np.array([[ 1.380, -0.2077, 6.715, -5.676 ],\n", "... [-0.5814, -4.290, 0, 0.6750 ],\n", "... [ 1.067, 4.273, -6.654, 5.893 ],\n", "... [ 0.0480, 4.273, 1.343, -2.104 ]])\n", ">>> B = np.array([[ 0, 5.679 ],\n", "... [ 1.136, 1.136 ],\n", "... [ 0, 0, ],\n", "... [-3.146, 0 ]])\n", ">>> P = np.array([-0.2, -0.5, -5.0566, -8.6659])\n", "\n", "Now compute K with KNV method 0, with the default YT method and with the YT\n", "method while forcing 100 iterations of the algorithm and print some results\n", "after each call.\n", "\n", ">>> fsf1 = signal.place_poles(A, B, P, method='KNV0')\n", ">>> fsf1.gain_matrix\n", "array([[ 0.20071427, -0.96665799, 0.24066128, -0.10279785],\n", " [ 0.50587268, 0.57779091, 0.51795763, -0.41991442]])\n", "\n", ">>> fsf2 = signal.place_poles(A, B, P) # uses YT method\n", ">>> fsf2.computed_poles\n", "array([-8.6659, -5.0566, -0.5 , -0.2 ])\n", "\n", ">>> fsf3 = signal.place_poles(A, B, P, rtol=-1, maxiter=100)\n", ">>> fsf3.X\n", "array([[ 0.52072442+0.j, -0.08409372+0.j, -0.56847937+0.j, 0.74823657+0.j],\n", " [-0.04977751+0.j, -0.80872954+0.j, 0.13566234+0.j, -0.29322906+0.j],\n", " [-0.82266932+0.j, -0.19168026+0.j, -0.56348322+0.j, -0.43815060+0.j],\n", " [ 0.22267347+0.j, 0.54967577+0.j, -0.58387806+0.j, -0.40271926+0.j]])\n", "\n", "The absolute value of the determinant of X is a good indicator to check the\n", "robustness of the results, both ``'KNV0'`` and ``'YT'`` aim at maximizing\n", "it. Below a comparison of the robustness of the results above:\n", "\n", ">>> abs(np.linalg.det(fsf1.X)) < abs(np.linalg.det(fsf2.X))\n", "True\n", ">>> abs(np.linalg.det(fsf2.X)) < abs(np.linalg.det(fsf3.X))\n", "True\n", "\n", "Now a simple example for complex poles:\n", "\n", ">>> A = np.array([[ 0, 7/3., 0, 0 ],\n", "... [ 0, 0, 0, 7/9. ],\n", "... [ 0, 0, 0, 0 ],\n", "... [ 0, 0, 0, 0 ]])\n", ">>> B = np.array([[ 0, 0 ],\n", "... [ 0, 0 ],\n", "... [ 1, 0 ],\n", "... [ 0, 1 ]])\n", ">>> P = np.array([-3, -1, -2-1j, -2+1j]) / 3.\n", ">>> fsf = signal.place_poles(A, B, P, method='YT')\n", "\n", "We can plot the desired and computed poles in the complex plane:\n", "\n", ">>> t = np.linspace(0, 2*np.pi, 401)\n", ">>> plt.plot(np.cos(t), np.sin(t), 'k--') # unit circle\n", ">>> plt.plot(fsf.requested_poles.real, fsf.requested_poles.imag,\n", "... 'wo', label='Desired')\n", ">>> plt.plot(fsf.computed_poles.real, fsf.computed_poles.imag, 'bx',\n", "... label='Placed')\n", ">>> plt.grid()\n", ">>> plt.axis('image')\n", ">>> plt.axis([-1.1, 1.1, -1.1, 1.1])\n", ">>> plt.legend(bbox_to_anchor=(1.05, 1), loc=2, numpoints=1)\n", "\u001b[0;31mFile:\u001b[0m ~/miniconda3/lib/python3.7/site-packages/scipy/signal/ltisys.py\n", "\u001b[0;31mType:\u001b[0m function\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "?place_poles" ] }, { "cell_type": "code", "execution_count": 5, "id": "stuffed-optimization", "metadata": { "tags": [] }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# desired eigenvalues of closed loop controlled system and observer\n", "ctrl_poles = 1*np.array([-10,-5,-4])\n", "obsrv_poles = 1*np.array([-5,-20,-10])\n", "\n", "# gains for pole placement\n", "K_placement = place_poles(A, B, ctrl_poles)\n", "L_placement = place_poles(A.T, C.T, obsrv_poles)\n", "K = K_placement.gain_matrix\n", "L = L_placement.gain_matrix.T\n", "\n", "# initialize arrays and logs\n", "x = np.array([1,0,-2],dtype = np.float64).T\n", "x_hat = np.zeros(x.shape)\n", "err_x = np.zeros(x.shape)\n", "u = 0\n", "y = 0\n", "y_hat = 0\n", "\n", "x_hist = x[np.newaxis,:]\n", "x_hat_hist = x_hat[np.newaxis]\n", "u_hist = np.array([0])\n", "x_ref_hist = np.array([0])\n", "\n", "\n", "t = 0\n", "dt = 0.001\n", "\n", "for _ in range(int(10/dt)):\n", " \n", " t+= dt\n", " x_ref = np.sin(t)\n", " \n", " # control action\n", " #err_x = x_ref*np.array([1,0,0]) - x_hat\n", " err_x = x_ref*np.array([1,0,0]) - x\n", " u = np.matmul(K,err_x)\n", " u = np.clip(u,-100,100)\n", "\n", " # observer\n", " err = y - y_hat\n", " x_hat_dot = np.matmul(A,x_hat) + np.matmul(B,u) + L[:,0]*err\n", " x_hat += x_hat_dot*dt\n", " y_hat = np.matmul(C,x_hat)\n", " \n", " # plant\n", " x_dot = np.matmul(A,x) + np.matmul(B,u)\n", " x += x_dot*dt\n", " y = np.matmul(C,x)\n", "\n", " # log history \n", " x_hist = np.append(x_hist, x[np.newaxis,:], axis = 0)\n", " x_hat_hist = np.append(x_hat_hist, x_hat[np.newaxis,:], axis = 0)\n", " u_hist = np.append(u_hist, u)\n", " x_ref_hist = np.append(x_ref_hist, x_ref)\n", " \n", "\n", "plt.rcParams[\"figure.figsize\"] = (10,10) \n", "t = dt*np.arange(u_hist.shape[0])\n", "fig,ax = plt.subplots(5,1)\n", "ax[0].plot(t,x_hist[:,0],t,x_hat_hist[:,0])\n", "ax[0].legend(['actual','estimated'], loc = 5)\n", "ax[1].plot(t,x_hist[:,1],t,x_hat_hist[:,1])\n", "ax[1].legend(['actual','estimated'], loc = 5)\n", "ax[2].plot(t,x_hist[:,2],t,x_hat_hist[:,2])\n", "ax[2].legend(['actual','estimated'], loc = 5)\n", "\n", "ax[3].plot(t,x_ref_hist,t,x_hat_hist[:,0])\n", "ax[3].legend(['reference','actual'], loc = 5)\n", "ax[4].plot(t,u_hist)\n", "ax[4].legend(['control'], loc = 5)" ] }, { "cell_type": "code", "execution_count": null, "id": "equipped-pastor", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.7.9" } }, "nbformat": 4, "nbformat_minor": 5 }