Dynamical_system_control_synthesis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from numpy import linalg as LA\n",
    "\n",
    "import itertools\n",
    "\n",
    "import cvxpy\n",
    "import optim_tools #own file with helper functions\n",
    "import loadtools #own file with helper for loading stored data\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%pylab inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solvers are ready!\n"
     ]
    }
   ],
   "source": [
    "used_solvers = ['MOSEK', 'CVXOPT', 'SCS']\n",
    "\n",
    "solvers = cvxpy.installed_solvers()\n",
    "if set(used_solvers).issubset(solvers):\n",
    "    print \"Solvers are ready!\"\n",
    "else:\n",
    "    print \"Please ensure that used solvers are present ({}):\".format(used_solvers)\n",
    "    print solvers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_position_state(A0, B0, C0):\n",
    "    A = np.vstack((C0, A0))\n",
    "    A = np.hstack((np.zeros((A.shape[0],1)), A))\n",
    "    \n",
    "    B = np.vstack((np.zeros((1, B0.shape[1])), B0))\n",
    "    \n",
    "    C = np.matrix(np.zeros(B.shape).T)\n",
    "    C[0,0] = 1\n",
    "    return A, B, C\n",
    "\n",
    "def getX00(x0):\n",
    "    arrays = []\n",
    "    X00 = []\n",
    "    for x in x0:\n",
    "        arrays.append((x, -x))\n",
    "    for per in list(itertools.product(*arrays)):\n",
    "        X00.append(np.matrix(per).T)\n",
    "    return X00"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f91b5121390>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fnames = [\"ss5_20180724-082628_poles2_ident_nodelay.npy\",\n",
    "          \"ss5_20180724-082628_poles3_ident_pade1_0:032.npy\"]\n",
    "\n",
    "res, _ = loadtools.loadNPY(fnames[1])\n",
    "\n",
    "pylab.rcParams['figure.figsize'] = (15, 9)\n",
    "\n",
    "plt.title('Model approximation')\n",
    "plt.plot(res['plot_model_step'][0], np.ones(len(res['plot_model_step'][0])), label=\"desired value\")\n",
    "plt.plot(*res['plot_model_step'], label=\"step data\")\n",
    "plt.plot(*res['plot_input_step'], label=\"best-fit second-order+delay model\")\n",
    "\n",
    "plt.ylabel('y in m/s')\n",
    "plt.xlabel('time in s')\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Limits on canonical state space variables: [1.0, 2.0, 0.5, 0.025]\n"
     ]
    }
   ],
   "source": [
    "_Ax, _Bx, _Cx, D = loadtools.getModel(fnames[1])\n",
    "A, B, C = add_position_state(_Ax, _Bx, _Cx)\n",
    "\n",
    "\n",
    "_A0x, _B0x, _C0x, D0, delay = loadtools.getDelayModel(fnames[0])\n",
    "A0, B0, C0 = add_position_state(_A0x, _B0x, _C0x)\n",
    "\n",
    "U_max = [2.0]\n",
    "\n",
    "xx0 = [1.0, 2.0,   0.5,  0.025, 0.01]\n",
    "print 'Limits on canonical state space variables:', xx0[0:len(B)]\n",
    "\n",
    "X00 = getX00(xx0[0:len(B)])\n",
    "\n",
    "# Transform boundaries into reachable form (to allow useful specification of boundaries)\n",
    "(A1, B1, C1, D1), T1, Q1 = optim_tools.get_Steuerungsnormalform(A, B, C.T, D)\n",
    "X0 = [T1.dot(x0) for x0 in X00]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Helper functions for optimization problem\n",
    "\n",
    "def Tri(i, n_u):\n",
    "    if n_u>1:\n",
    "        print \"Please implement: All Permutations with ones on main diagonal!\"\n",
    "        raise NotImplementedError()\n",
    "        \n",
    "    if i==1:\n",
    "        return np.eye(n_u)\n",
    "    else:\n",
    "        # only true for n_u == 1\n",
    "        return np.zeros((n_u, n_u))\n",
    "\n",
    "def negTri(i, n_u):\n",
    "    return np.eye(n_u) - Tri(i, n_u)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing upper bound: 1.0\n",
      "processing upper bound: 2.0\n",
      "processing upper bound: 4.0\n",
      "processing upper bound: 8.0\n",
      "processing upper bound: 16.0\n",
      "processing upper bound: 32.0\n",
      " -----> Exception by CVXOPT: Solver 'CVXOPT' failed. Try another solver.\n",
      " -----> Exception by MOSEK: Solver 'MOSEK' failed. Try another solver.\n",
      "found bounds: [16.0-32.0]\n",
      " -----> Exception by CVXOPT: Solver 'CVXOPT' failed. Try another solver.\n",
      " -----> Exception by MOSEK: Solver 'MOSEK' failed. Try another solver.\n",
      "Range: 16.0-32.0; parameter 24.0 -> optimal\n",
      "Range: 24.0-32.0; parameter 28.0 -> optimal\n",
      " -----> Exception by CVXOPT: Solver 'CVXOPT' failed. Try another solver.\n",
      " -----> Exception by MOSEK: Solver 'MOSEK' failed. Try another solver.\n",
      "Range: 28.0-32.0; parameter 30.0 -> unknown\n",
      " -----> Exception by CVXOPT: Solver 'CVXOPT' failed. Try another solver.\n",
      " -----> Exception by MOSEK: Solver 'MOSEK' failed. Try another solver.\n",
      "Range: 28.0-30.0; parameter 29.0 -> unknown\n",
      " -----> Exception by CVXOPT: Solver 'CVXOPT' failed. Try another solver.\n",
      " -----> Exception by MOSEK: Solver 'MOSEK' failed. Try another solver.\n",
      "Range: 28.0-29.0; parameter 28.5 -> unknown\n",
      "Range: 28.0-28.5; parameter 28.25 -> optimal\n",
      " -----> Exception by CVXOPT: Solver 'CVXOPT' failed. Try another solver.\n",
      " -----> Exception by MOSEK: Solver 'MOSEK' failed. Try another solver.\n",
      "Range: 28.25-28.5; parameter 28.375 -> unknown\n",
      " -----> Exception by CVXOPT: Solver 'CVXOPT' failed. Try another solver.\n",
      " -----> Exception by MOSEK: Solver 'MOSEK' failed. Try another solver.\n",
      "Range: 28.25-28.375; parameter 28.3125 -> unknown\n",
      " -----> Exception by CVXOPT: Solver 'CVXOPT' failed. Try another solver.\n",
      " -----> Exception by MOSEK: Solver 'MOSEK' failed. Try another solver.\n",
      "Range: 28.25-28.3125; parameter 28.28125 -> unknown\n",
      " -----> Exception by CVXOPT: Solver 'CVXOPT' failed. Try another solver.\n",
      " -----> Exception by MOSEK: Solver 'MOSEK' failed. Try another solver.\n",
      "Range: 28.25-28.28125; parameter 28.265625 -> unknown\n",
      "Range: 28.25-28.265625; parameter 28.2578125 -> optimal\n",
      "g: 28.2578125\n",
      "\n",
      "-----------------------\n",
      "CPU times: user 1min 18s, sys: 1min 48s, total: 3min 6s\n",
      "Wall time: 25 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# Init\n",
    "n = B.shape[0] # get dimension of system\n",
    "n_u = B.shape[1] # get dimension of output\n",
    "\n",
    "# Variables\n",
    "X = cvxpy.Semidef(n)\n",
    "Y = cvxpy.Semidef(n)\n",
    "W = cvxpy.Variable(n_u)\n",
    "\n",
    "Ak_h = cvxpy.Semidef(*A.shape)\n",
    "Bk_h = cvxpy.Variable(*B.shape)\n",
    "Ck_h = cvxpy.Variable(*C.shape)\n",
    "Dk_h = cvxpy.Variable(*D.shape)\n",
    "\n",
    "Ch = cvxpy.Variable(*C.shape)\n",
    "Dh = cvxpy.Variable(*D.shape)\n",
    "\n",
    "# Substitutionen\n",
    "C_hat = lambda i: Tri(i, n_u)*Ck_h + negTri(i, n_u)*Ch\n",
    "D_hat = lambda i: Tri(i, n_u)*Dk_h + negTri(i, n_u)*Dh\n",
    "\n",
    "Xi = cvxpy.bmat([[ A*X + B*Ck_h, A + B*Dk_h*C ],\n",
    "                 [ Ak_h,         Y*A + Bk_h*C ]])\n",
    "\n",
    "I = np.eye(n)\n",
    "\n",
    "# Bisection parameter\n",
    "g = cvxpy.Parameter(sign='positive')\n",
    "\n",
    "# Pole restriction\n",
    "ro = cvxpy.Parameter(sign='positive') # Real <=-ro\n",
    "ni = cvxpy.Parameter(sign='positive') # |Imag| <= ni*Real\n",
    "\n",
    "ro.value = 100\n",
    "ni.value = 10\n",
    "\n",
    "# Define Constraints\n",
    "\n",
    "# (7a)\n",
    "const_7a = cvxpy.bmat([[X, I],\n",
    "                         #[I, Y]]) >> 0\n",
    "                         [I, Y]]) == cvxpy.Semidef(2*n)\n",
    "\n",
    "\n",
    "\n",
    "# (7b)\n",
    "const_7b = cvxpy.bmat([[ X*A.T + A*X + B*Ck_h + (B*Ck_h).T, Ak_h.T + A + B*Dk_h*C            ],\n",
    "                         [ cvxpy.Variable(n, n),          A.T*Y + Y*A + Bk_h*C + (Bk_h*C).T]]) + \\\n",
    "             2*g*cvxpy.bmat([[X, I],\n",
    "                             #[I, Y]]) << 0\n",
    "                             [I, Y]]) == -cvxpy.Semidef(2*n)\n",
    "    \n",
    "# (7c)\n",
    "const_7c = [cvxpy.bmat([[ X*A.T + A*X + B*C_hat(i) + (B*C_hat(i)).T, Ak_h.T + A + B*D_hat(i)*C            ],\n",
    "                          #[ cvxpy.Variable(n, n),                      A.T*Y + Y*A + Bk_h*C + (Bk_h*C).T]]) << 0 for i in range(2, (2**n_u)+1)]\n",
    "                          [ cvxpy.Variable(n, n),                      A.T*Y + Y*A + Bk_h*C + (Bk_h*C).T]]) == -cvxpy.Semidef(2*n) for i in range(2, (2**n_u)+1)]\n",
    "    \n",
    "    \n",
    "# (7d)\n",
    "const_7d = cvxpy.bmat([[ X,  I,    Ch.T     ],\n",
    "                         [ I,  Y,    (Dh*C).T ],\n",
    "                         #[ Ch, Dh*C, W        ]]) >> 0\n",
    "                         [ Ch, Dh*C, W        ]]) == cvxpy.Semidef(2*n+n_u)\n",
    "\n",
    "# (7e)\n",
    "const_7e = [W[j,j] <= U_max[j]**2 for j in range(0, n_u)]\n",
    "\n",
    "# (7f)\n",
    "const_7f = [ X0[k].T*Y*X0[k] <= 1.0\n",
    "                            for k in range(0, len(X0))]\n",
    "\n",
    "# (7g)\n",
    "const_7g = Xi.T + Xi + ro*cvxpy.bmat([[X, I],\n",
    "                                        #[I, Y]]) >> 0\n",
    "                                        [I, Y]]) == cvxpy.Semidef(2*n)\n",
    "\n",
    "# (7h)\n",
    "const_7h = cvxpy.bmat([[ ni*(Xi.T + Xi), Xi.T - Xi ],\n",
    "                         #[ -Xi.T + Xi,     ni*(Xi.T + Xi) ]]) << 0\n",
    "                         [ -Xi.T + Xi,     ni*(Xi.T + Xi) ]]) == -cvxpy.Semidef(4*n)\n",
    "\n",
    "\n",
    "# Collect all constraints\n",
    "constraints_7 = []\n",
    "constraints_7.append(const_7a)\n",
    "constraints_7.append(const_7b)\n",
    "constraints_7.extend(const_7c)\n",
    "constraints_7.append(const_7d)\n",
    "constraints_7.extend(const_7e)\n",
    "constraints_7.extend(const_7f)\n",
    "\n",
    "constraints_7.append(const_7g)\n",
    "constraints_7.append(const_7h)\n",
    "\n",
    "\n",
    "# Form feasibility problem.\n",
    "prob_7 = cvxpy.Problem(cvxpy.Minimize(0), constraints_7)\n",
    "\n",
    "# bisection alternative with list of multiple solvers\n",
    "[[X_o, Y_o, W_o,\n",
    "  Ak_h_o, Bk_h_o, Ck_h_o, Dk_h_o,\n",
    "  Ch_o, Dh_o], g_o] = optim_tools.bisect_max2(0, None, prob_7, g, [X, Y, W, Ak_h, Bk_h, Ck_h, Dk_h, Ch, Dh],\n",
    "                                                      bisect_verbose=True,\n",
    "                                                      bisection_tol=0.01,\n",
    "                                                      solvers=[\n",
    "                                                               (cvxpy.CVXOPT, {'verbose':False}),\n",
    "                                                               (cvxpy.MOSEK, {'verbose':False}),\n",
    "                                                               #(cvxpy.SCS, {'max_iters':5000, 'warm_start':True, 'verbose':True})\n",
    "                                                              ])\n",
    "print \"g:\", g_o\n",
    "\n",
    "print\n",
    "print '-----------------------'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# (8)\n",
    "# QR Decomposition for M and N\n",
    "M, NT = LA.qr(I - X_o.dot(Y_o))\n",
    "N = NT.T\n",
    "# Check\n",
    "assert(np.allclose(I - X_o.dot(Y_o), M.dot(N.T)))\n",
    "\n",
    "# Reconstruction\n",
    "# (9a)\n",
    "Ek = -LA.solve(N, Y_o.dot(B))\n",
    "# (9b)\n",
    "Dk = np.matrix(Dk_h_o)\n",
    "\n",
    "# (9c)\n",
    "Ck = LA.solve(M, (Ck_h_o - Dk.dot(C).dot(X_o)).T).T\n",
    "# Check\n",
    "Ck_1 = (Ck_h_o - Dk.dot(C).dot(X_o)).dot(LA.inv(M).T) #Check\n",
    "assert(np.allclose(Ck_1, Ck))\n",
    "\n",
    "# (9d)\n",
    "Bk = LA.solve(N, Bk_h_o)\n",
    "\n",
    "# (9e)\n",
    "temp_alpha = LA.solve(N, (Ak_h_o-Y_o.dot(A).dot(X_o)))\n",
    "temp_beta = Bk.dot(C).dot(X_o)\n",
    "Ak = (LA.solve(M, temp_alpha.T) - LA.solve(M, temp_beta.T)).T\n",
    "# Check\n",
    "Ak_1 = LA.solve(N, (Ak_h_o-Y_o.dot(A).dot(X_o))).dot(LA.inv(M).T) - Bk.dot(C).dot(X_o).dot(LA.inv(M).T) #Check\n",
    "assert(np.allclose(Ak_1, Ak))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model:\n",
      "\n",
      "A:\n",
      "[[       0.000        0.000        0.000       -1.000]\n",
      " [       0.000        0.000       -0.000       35.000]\n",
      " [       0.000       10.000        0.000       32.877]\n",
      " [       0.000        0.000     -100.000     -106.143]] \n",
      "\n",
      "B:\n",
      "[[       0.000]\n",
      " [      34.921]\n",
      " [      -5.587]\n",
      " [       0.000]] \n",
      "\n",
      "C:\n",
      "[[       1.000        0.000        0.000        0.000]] \n",
      "\n",
      "D:\n",
      "[[       0.000]] \n",
      "\n",
      "u_max:\n",
      "[2.0] \n",
      "\n",
      "\n",
      "Control System:\n",
      "\n",
      "Ak:\n",
      "[[     -48.162       -1.108       -0.097        0.001]\n",
      " [     267.319      -21.440        0.908       -0.006]\n",
      " [   -4262.269       27.229      -80.439        0.272]\n",
      " [-1632995.792    37688.552    -7662.291        3.482]] \n",
      "\n",
      "Bk:\n",
      "[[      -0.372]\n",
      " [       3.607]\n",
      " [     -71.784]\n",
      " [  -29386.828]] \n",
      "\n",
      "Ck:\n",
      "[[   -8047.488      188.940      -32.945        0.213]] \n",
      "\n",
      "Dk:\n",
      "[[    -145.091]] \n",
      "\n",
      "Ek:\n",
      "[[      -0.019]\n",
      " [      -0.359]\n",
      " [       2.404]\n",
      " [    -193.735]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "np.set_printoptions(suppress=True,\n",
    "   formatter={'float_kind':'{:12.3f}'.format}, linewidth=130)\n",
    "\n",
    "print \"Model:\\n\"\n",
    "print \"A:\\n\",A,\"\\n\"\n",
    "print \"B:\\n\",B,\"\\n\"\n",
    "print \"C:\\n\",C,\"\\n\"\n",
    "print \"D:\\n\",D,\"\\n\"\n",
    "print \"u_max:\\n\",U_max,\"\\n\"\n",
    "print\n",
    "\n",
    "print \"Control System:\\n\"\n",
    "print \"Ak:\\n\",Ak,\"\\n\"\n",
    "print \"Bk:\\n\",Bk,\"\\n\"\n",
    "print \"Ck:\\n\",Ck,\"\\n\"\n",
    "print \"Dk:\\n\",Dk,\"\\n\"\n",
    "print \"Ek:\\n\",Ek,\"\\n\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class control_func_dyn_out():\n",
    "    def __init__(self, Ak, Bk, Ck, Dk, Ek, A, B, C, D, umax=None, dT=1e-3):\n",
    "        self.Ak = Ak\n",
    "        self.Bk = Bk\n",
    "        self.Ck = Ck\n",
    "        self.Dk = Dk\n",
    "        self.Ek = Ek\n",
    "        self.umax = umax\n",
    "        self.dT = dT\n",
    "\n",
    "        self.z = np.zeros(B.shape)\n",
    "                \n",
    "        # Construct Prefilter\n",
    "        C2 = np.hstack((-C, np.zeros(Ck.shape)))\n",
    "\n",
    "        A2_u = np.hstack(((A+B.dot(Dk).dot(C)), B.dot(Ck)))\n",
    "        A2_d = np.hstack((Bk.dot(C), Ak))\n",
    "\n",
    "        A2 = np.vstack((A2_u, A2_d))\n",
    "        B2 = np.vstack((B, np.zeros(Bk.shape)))\n",
    "\n",
    "        self.N = LA.inv(C2.dot(LA.inv(A2)).dot(B2))\n",
    "        \n",
    "    def estimate(self, y, u):\n",
    "        # already saturated\n",
    "        if self.umax is not None:\n",
    "            u = optim_tools.sat(u, self.umax)\n",
    "        \n",
    "        z_dot = self.Ak.dot(self.z) + self.Bk.dot(y) + self.Ek.dot(u)\n",
    "        return self.z + z_dot*self.dT\n",
    "        \n",
    "    def regulate(self, y, s, x):\n",
    "        u = self.N.dot(s)+self.Ck.dot(self.z) + self.Dk.dot(y)\n",
    "\n",
    "        # Saturate \n",
    "        if self.umax is not None:\n",
    "            u = optim_tools.sat(u, self.umax)\n",
    "            \n",
    "        self.z = self.estimate(y, u)\n",
    "        return u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Timeline\n",
    "T = np.arange(0, 1, 1e-3) \n",
    "\n",
    "#s: input, e.g., step function with amplitude of 1\n",
    "s = np.ones(len(T));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from functools import partial\n",
    "\n",
    "y0, u0, u0_sat = optim_tools.simulate(A, B, C, D, \n",
    "                                   partial(optim_tools.openLoop),\n",
    "                                   s, T, delay=None, umax=U_max[0], x0=np.zeros(B.shape))\n",
    "\n",
    "y1, u1, u1_sat = optim_tools.simulate(A, B, C, D, \n",
    "                                   control_func_dyn_out(Ak, Bk, Ck, Dk, Ek,\n",
    "                                                        A, B, C, D,\n",
    "                                                        umax=U_max[0]).regulate,\n",
    "                                   s, T, delay=None, umax=U_max[0], x0=np.zeros(B.shape))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "y2, u2, u2_sat = optim_tools.simulate(A0, B0, C0, D0, \n",
    "                                   control_func_dyn_out(Ak, Bk, Ck, Dk, Ek,\n",
    "                                                        A, B, C, D,\n",
    "                                                        umax=U_max[0]).regulate,\n",
    "                                   s, T, delay=delay, umax=U_max[0], x0=np.zeros(B0.shape))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f91b5114890>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pylab.rcParams['figure.figsize'] = (15, 15)\n",
    "\n",
    "ax = plt.subplot(111)\n",
    "plt.title('Closed Loop Step Response')\n",
    "\n",
    "ax1 = plt.subplot(2, 1, 1)\n",
    "plt.plot(T[:], s, 'b', label='desired value')\n",
    "plt.plot(T[:], np.array(y1[0,:].T), 'r', label='step response (original plant)')\n",
    "plt.plot(T[:], np.array(y2[0,:].T), 'g--', label='step response (delayed plant)')\n",
    "\n",
    "ax1.set_ylabel('y in m')\n",
    "plt.xlim(0, 1)\n",
    "legend()\n",
    "\n",
    "ax2 = plt.subplot(2, 1, 2)\n",
    "plt.plot(T, u1, 'r', label='output (original plant)')\n",
    "plt.plot(T, u2, 'g--', label='output (delayed plant)')\n",
    "\n",
    "ax2.set_ylabel('u in m/s')\n",
    "ax2.set_xlabel('time in s')\n",
    "plt.xlim(0, 1)\n",
    "legend()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}