diff --git a/notebooks/1.1-symbolic-system-equations.ipynb b/notebooks/1.1-symbolic-system-equations.ipynb
index 7cb4feb..80239e8 100644
--- a/notebooks/1.1-symbolic-system-equations.ipynb
+++ b/notebooks/1.1-symbolic-system-equations.ipynb
@@ -151,14 +151,49 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Ackermann"
+    "## Ackermann Kinematics model\n",
+    "\n",
+    "### Jacobians"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle \\left[\\begin{matrix}0 & 0 & \\cos{\\left(\\theta \\right)} & - v \\sin{\\left(\\theta \\right)}\\\\0 & 0 & \\sin{\\left(\\theta \\right)} & v \\cos{\\left(\\theta \\right)}\\\\0 & 0 & 0 & 0\\\\0 & 0 & \\frac{\\tan{\\left(\\delta \\right)}}{L} & 0\\end{matrix}\\right]$"
+      ],
+      "text/plain": [
+       "Matrix([\n",
+       "[0, 0,   cos(theta), -v*sin(theta)],\n",
+       "[0, 0,   sin(theta),  v*cos(theta)],\n",
+       "[0, 0,            0,             0],\n",
+       "[0, 0, tan(delta)/L,             0]])"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/latex": [
+       "$\\displaystyle \\left[\\begin{matrix}0 & 0\\\\0 & 0\\\\1 & 0\\\\0 & \\frac{v \\left(\\tan^{2}{\\left(\\delta \\right)} + 1\\right)}{L}\\end{matrix}\\right]$"
+      ],
+      "text/plain": [
+       "Matrix([\n",
+       "[0,                       0],\n",
+       "[0,                       0],\n",
+       "[1,                       0],\n",
+       "[0, v*(tan(delta)**2 + 1)/L]])"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "x,y,theta,v,delta,L,a = sp.symbols(\"x y theta v delta L a\")\n",
     "\n",
@@ -175,39 +210,21 @@
     "U = sp.Matrix([a,delta])\n",
     "\n",
     "#B\n",
-    "B=gs.jacobian(U)#.subs({x:0,y:0,theta:0})B="
+    "B=gs.jacobian(U)\n",
+    "display(A)\n",
+    "display(B)"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 6,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "$\\displaystyle \\left[\\begin{matrix}0 & 0\\\\0 & 0\\\\1 & 0\\\\0 & \\frac{v \\left(\\tan^{2}{\\left(\\delta \\right)} + 1\\right)}{L}\\end{matrix}\\right]$"
-      ],
-      "text/plain": [
-       "Matrix([\n",
-       "[0,                       0],\n",
-       "[0,                       0],\n",
-       "[1,                       0],\n",
-       "[0, v*(tan(delta)**2 + 1)/L]])"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
    "source": [
-    "B"
+    "### Discretized and Linearized model"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -223,22 +240,9 @@
        "[0, 0, dt*tan(delta)/L,                1]])"
       ]
      },
-     "execution_count": 7,
      "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "#A LIN\n",
-    "DT = sp.symbols(\"dt\")\n",
-    "sp.eye(4)+A*DT"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
+     "output_type": "display_data"
+    },
     {
      "data": {
       "text/latex": [
@@ -252,20 +256,9 @@
        "[ 0, dt*v*(tan(delta)**2 + 1)/L]])"
       ]
      },
-     "execution_count": 8,
      "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "B*DT"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
+     "output_type": "display_data"
+    },
     {
      "data": {
       "text/latex": [
@@ -279,13 +272,16 @@
        "[-delta*dt*v*(tan(delta)**2 + 1)/L]])"
       ]
      },
-     "execution_count": 9,
      "metadata": {},
-     "output_type": "execute_result"
+     "output_type": "display_data"
     }
    ],
    "source": [
-    "DT*(gs - A*X - B*U)"
+    "DT = sp.symbols(\"dt\")\n",
+    "\n",
+    "display(sp.eye(4)+A*DT)\n",
+    "display(B*DT)\n",
+    "display(DT*(gs - A*X - B*U))"
    ]
   },
   {
diff --git a/notebooks/2.3-MPC-simplified.ipynb b/notebooks/2.3-MPC-simplified.ipynb
new file mode 100644
index 0000000..386ecf3
--- /dev/null
+++ b/notebooks/2.3-MPC-simplified.ipynb
@@ -0,0 +1,497 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Simplified MPC\n",
+    "\n",
+    "Checking the implementation from [Reuben Ferrante](https://github.com/arex18/rocket-lander) \n",
+    "\n",
+    "Here the system dynamics matrices are evaluated only once given the current state, input -> So no more need to keep track of **x_bar** and **u_bar**.\n",
+    "\n",
+    "This should give less precise results but the computation time should be gratly reduced and the overall code is slimmer, worth checking out!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import cvxpy as opt\n",
+    "import time\n",
+    "from scipy.integrate import odeint\n",
+    "from scipy.interpolate import interp1d\n",
+    "import matplotlib.pyplot as plt\n",
+    "plt.style.use(\"ggplot\")\n",
+    "\n",
+    "N = 4 #number of state variables\n",
+    "M = 2 #number of control variables\n",
+    "T = 10 #Prediction Horizon\n",
+    "DT = 0.2 #discretization step\n",
+    "\n",
+    "L = 0.3 #vehicle wheelbase\n",
+    "MAX_SPEED = 1.5 #m/s\n",
+    "MAX_ACC = 1.0 #m/ss\n",
+    "MAX_D_ACC = 1.0 #m/sss\n",
+    "MAX_STEER = np.radians(30) #rad\n",
+    "MAX_D_STEER = np.radians(30) #rad/s\n",
+    "\n",
+    "def get_linear_model_matrices(x_bar,u_bar):\n",
+    "    \"\"\"\n",
+    "    Computes the LTI approximated state space model x' = Ax + Bu + C\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    x = x_bar[0]\n",
+    "    y = x_bar[1]\n",
+    "    v = x_bar[2]\n",
+    "    theta = x_bar[3]\n",
+    "    \n",
+    "    a = u_bar[0]\n",
+    "    delta = u_bar[1]\n",
+    "    \n",
+    "    ct = np.cos(theta)\n",
+    "    st = np.sin(theta)\n",
+    "    cd = np.cos(delta)\n",
+    "    td = np.tan(delta)\n",
+    "    \n",
+    "    A = np.zeros((N,N))\n",
+    "    A[0,2] = ct\n",
+    "    A[0,3] = -v*st\n",
+    "    A[1,2] = st\n",
+    "    A[1,3] = v*ct\n",
+    "    A[3,2] = v*td/L\n",
+    "    A_lin = np.eye(N)+DT*A\n",
+    "    \n",
+    "    B = np.zeros((N,M))\n",
+    "    B[2,0]=1\n",
+    "    B[3,1]=v/(L*cd**2)\n",
+    "    B_lin=DT*B\n",
+    "    \n",
+    "    f_xu=np.array([v*ct, v*st, a, v*td/L]).reshape(N,1)\n",
+    "    C_lin = DT*(f_xu - np.dot(A, x_bar.reshape(N,1)) - np.dot(B, u_bar.reshape(M,1)))#.flatten()\n",
+    "    \n",
+    "    #return np.round(A_lin,6), np.round(B_lin,6), np.round(C_lin,6)\n",
+    "    return A_lin, B_lin, C_lin\n",
+    "\n",
+    "class MPC():\n",
+    "    \n",
+    "    def __init__(self):\n",
+    "        \"\"\"\n",
+    "        \"\"\"\n",
+    "        self.state_len = N\n",
+    "        self.action_len = M\n",
+    "        \n",
+    "    def optimize_linearized_model(self, A, B, C, initial_state, Q, R, target, time_horizon=10, verbose=False):\n",
+    "        \"\"\"\n",
+    "        Optimisation problem defined for the linearised model,\n",
+    "        :param A: \n",
+    "        :param B:\n",
+    "        :param C: \n",
+    "        :param initial_state:\n",
+    "        :param Q:\n",
+    "        :param R:\n",
+    "        :param target:\n",
+    "        :param time_horizon:\n",
+    "        :param verbose:\n",
+    "        :return:\n",
+    "        \"\"\"\n",
+    "        \n",
+    "        assert len(initial_state) == self.state_len\n",
+    "        # Create variables\n",
+    "        x = opt.Variable((self.state_len, time_horizon + 1), name='states')\n",
+    "        u = opt.Variable((self.action_len, time_horizon), name='actions')\n",
+    "\n",
+    "        # Loop through the entire time_horizon and append costs\n",
+    "        cost_function = []\n",
+    "\n",
+    "        for t in range(time_horizon):\n",
+    "\n",
+    "            _cost = opt.quad_form(target[:, t + 1] - x[:, t + 1], Q) +\\\n",
+    "                    opt.quad_form(u[:, t], R) +\\\n",
+    "                    opt.quad_form(u[:, t] - u[:, t - 1], R * 0.1)\n",
+    "            \n",
+    "            \n",
+    "            _constraints = [x[:, t + 1] == A @ x[:, t] + B @ u[:, t] + C,\n",
+    "                            u[0, t] >= -MAX_ACC, u[0, t] <= MAX_ACC,\n",
+    "                            u[1, t] >= -MAX_STEER, u[1, t] <= MAX_STEER]\n",
+    "                            #opt.norm(target[:, t + 1] - x[:, t + 1], 1) <= 0.1]\n",
+    "            \n",
+    "            # Actuation rate of change\n",
+    "            if t < (time_horizon - 1):\n",
+    "                _cost += opt.quad_form(u[:,t+1] - u[:,t], R_)\n",
+    "                _constraints += [opt.abs(u[0, t + 1] - u[0, t])/DT <= MAX_D_ACC]\n",
+    "                _constraints += [opt.abs(u[1, t + 1] - u[1, t])/DT <= MAX_D_STEER] #max steer rate of change\n",
+    "\n",
+    "            if t == 0:\n",
+    "                #_constraints += [opt.norm(target[:, time_horizon] - x[:, time_horizon], 1) <= 0.01,\n",
+    "                #                x[:, 0] == initial_state]\n",
+    "                _constraints += [x[:, 0] == initial_state]\n",
+    "            \n",
+    "            cost_function.append(opt.Problem(opt.Minimize(_cost), constraints=_constraints))\n",
+    "\n",
+    "        # Add final cost\n",
+    "        problem = sum(cost_function)\n",
+    "        \n",
+    "        # Minimize Problem\n",
+    "        problem.solve(verbose=verbose, solver=opt.OSQP)\n",
+    "        return x, u"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "jupyter": {
+     "source_hidden": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "\"\"\"\n",
+    "the ODE is used to update the simulation given the mpc results\n",
+    "I use this insted of using the LTI twice\n",
+    "\"\"\"\n",
+    "def kinematics_model(x,t,u):\n",
+    "    \"\"\"\n",
+    "    Returns the set of ODE of the vehicle model.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    L=0.3 #vehicle wheelbase\n",
+    "    dxdt = x[2]*np.cos(x[3])\n",
+    "    dydt = x[2]*np.sin(x[3])\n",
+    "    dvdt = u[0]\n",
+    "    dthetadt = x[2]*np.tan(u[1])/L\n",
+    "\n",
+    "    dqdt = [dxdt,\n",
+    "            dydt,\n",
+    "            dvdt,\n",
+    "            dthetadt]\n",
+    "\n",
+    "    return dqdt\n",
+    "\n",
+    "def predict(x0,u):\n",
+    "    \"\"\"\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    x_ = np.zeros((N,T+1))\n",
+    "    \n",
+    "    x_[:,0] = x0\n",
+    "    \n",
+    "    # solve ODE\n",
+    "    for t in range(1,T+1):\n",
+    "\n",
+    "        tspan = [0,DT]\n",
+    "        x_next = odeint(kinematics_model,\n",
+    "                         x0,\n",
+    "                         tspan,\n",
+    "                         args=(u[:,t-1],))\n",
+    "\n",
+    "        x0 = x_next[1]\n",
+    "        x_[:,t]=x_next[1]\n",
+    "        \n",
+    "    return x_\n",
+    "\n",
+    "\n",
+    "\"\"\"\n",
+    "MODIFIED TO INCLUDE FRAME TRANSFORMATION\n",
+    "\"\"\"\n",
+    "def compute_path_from_wp(start_xp, start_yp, step = 0.1):\n",
+    "    \"\"\"\n",
+    "    Computes a reference path given a set of waypoints\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    final_xp=[]\n",
+    "    final_yp=[]\n",
+    "    delta = step #[m]\n",
+    "\n",
+    "    for idx in range(len(start_xp)-1):\n",
+    "        section_len = np.sum(np.sqrt(np.power(np.diff(start_xp[idx:idx+2]),2)+np.power(np.diff(start_yp[idx:idx+2]),2)))\n",
+    "\n",
+    "        interp_range = np.linspace(0,1,np.floor(section_len/delta).astype(int))\n",
+    "        \n",
+    "        fx=interp1d(np.linspace(0,1,2),start_xp[idx:idx+2],kind=1)\n",
+    "        fy=interp1d(np.linspace(0,1,2),start_yp[idx:idx+2],kind=1)\n",
+    "        \n",
+    "        # watch out to duplicate points!\n",
+    "        final_xp=np.append(final_xp,fx(interp_range)[1:])\n",
+    "        final_yp=np.append(final_yp,fy(interp_range)[1:])\n",
+    "    \n",
+    "    dx = np.append(0, np.diff(final_xp))\n",
+    "    dy = np.append(0, np.diff(final_yp))\n",
+    "    theta = np.arctan2(dy, dx)\n",
+    "\n",
+    "    return np.vstack((final_xp,final_yp,theta))\n",
+    "\n",
+    "\n",
+    "def get_nn_idx(state,path):\n",
+    "    \"\"\"\n",
+    "    Computes the index of the waypoint closest to vehicle\n",
+    "    \"\"\"\n",
+    "\n",
+    "    dx = state[0]-path[0,:]\n",
+    "    dy = state[1]-path[1,:]\n",
+    "    dist = np.hypot(dx,dy)\n",
+    "    nn_idx = np.argmin(dist)\n",
+    "\n",
+    "    try:\n",
+    "        v = [path[0,nn_idx+1] - path[0,nn_idx],\n",
+    "             path[1,nn_idx+1] - path[1,nn_idx]]   \n",
+    "        v /= np.linalg.norm(v)\n",
+    "\n",
+    "        d = [path[0,nn_idx] - state[0],\n",
+    "             path[1,nn_idx] - state[1]]\n",
+    "\n",
+    "        if np.dot(d,v) > 0:\n",
+    "            target_idx = nn_idx\n",
+    "        else:\n",
+    "            target_idx = nn_idx+1\n",
+    "\n",
+    "    except IndexError as e:\n",
+    "        target_idx = nn_idx\n",
+    "\n",
+    "    return target_idx\n",
+    "\n",
+    "def normalize_angle(angle):\n",
+    "    \"\"\"\n",
+    "    Normalize an angle to [-pi, pi]\n",
+    "    \"\"\"\n",
+    "    while angle > np.pi:\n",
+    "        angle -= 2.0 * np.pi\n",
+    "\n",
+    "    while angle < -np.pi:\n",
+    "        angle += 2.0 * np.pi\n",
+    "\n",
+    "    return angle\n",
+    "\n",
+    "def get_ref_trajectory(state, path, target_v):\n",
+    "    \"\"\"\n",
+    "    modified reference in robot frame\n",
+    "    \"\"\"\n",
+    "    xref = np.zeros((N, T + 1))\n",
+    "    dref = np.zeros((1, T + 1))\n",
+    "    \n",
+    "    #sp = np.ones((1,T +1))*target_v #speed profile\n",
+    "    \n",
+    "    ncourse = path.shape[1]\n",
+    "\n",
+    "    ind = get_nn_idx(state, path)\n",
+    "    dx=path[0,ind] - state[0]\n",
+    "    dy=path[1,ind] - state[1]\n",
+    "    \n",
+    "    xref[0, 0] = dx * np.cos(-state[3]) - dy * np.sin(-state[3]) #X\n",
+    "    xref[1, 0] = dy * np.cos(-state[3]) + dx * np.sin(-state[3]) #Y\n",
+    "    xref[2, 0] = target_v                                        #V\n",
+    "    xref[3, 0] = normalize_angle(path[2,ind]- state[3])          #Theta\n",
+    "    dref[0, 0] = 0.0                                             # steer operational point should be 0\n",
+    "    \n",
+    "    dl = 0.05 # Waypoints spacing [m]\n",
+    "    travel = 0.0\n",
+    "    \n",
+    "    for i in range(T + 1):\n",
+    "        travel += abs(target_v) * DT #current V or target V?\n",
+    "        dind = int(round(travel / dl))\n",
+    "        \n",
+    "        if (ind + dind) < ncourse:\n",
+    "            dx=path[0,ind + dind] - state[0]\n",
+    "            dy=path[1,ind + dind] - state[1]\n",
+    "            \n",
+    "            xref[0, i] = dx * np.cos(-state[3]) - dy * np.sin(-state[3])\n",
+    "            xref[1, i] = dy * np.cos(-state[3]) + dx * np.sin(-state[3])\n",
+    "            xref[2, i] = target_v #sp[ind + dind]\n",
+    "            xref[3, i] = normalize_angle(path[2,ind + dind] - state[3])\n",
+    "            dref[0, i] = 0.0\n",
+    "        else:\n",
+    "            dx=path[0,ncourse - 1] - state[0]\n",
+    "            dy=path[1,ncourse - 1] - state[1]\n",
+    "            \n",
+    "            xref[0, i] = dx * np.cos(-state[3]) - dy * np.sin(-state[3])\n",
+    "            xref[1, i] = dy * np.cos(-state[3]) + dx * np.sin(-state[3])\n",
+    "            xref[2, i] = 0.0 #stop? #sp[ncourse - 1]\n",
+    "            xref[3, i] = normalize_angle(path[2,ncourse - 1] - state[3])\n",
+    "            dref[0, i] = 0.0\n",
+    "\n",
+    "    return xref, dref"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CVXPY Optimization Time: Avrg: 0.1026s Max: 0.1282s Min: 0.0958s\n"
+     ]
+    }
+   ],
+   "source": [
+    "track = compute_path_from_wp([0,3,4,6,10,12,14,6,1,0],\n",
+    "                             [0,0,2,4,3,3,-2,-6,-2,-2],0.05)\n",
+    "\n",
+    "# track = compute_path_from_wp([0,10,10,0],\n",
+    "#                              [0,0,1,1],0.05)\n",
+    "\n",
+    "sim_duration = 200 #time steps\n",
+    "opt_time=[]\n",
+    "x_sim = np.zeros((N,sim_duration))\n",
+    "u_sim = np.zeros((M,sim_duration-1))\n",
+    "\n",
+    "# Starting Condition\n",
+    "x0 = np.zeros(N)\n",
+    "x0[0] = 0               #x\n",
+    "x0[1] = -0.25           #y\n",
+    "x0[2] = 0.0             #v\n",
+    "x0[3] = np.radians(-0)  #yaw\n",
+    "x_sim[:,0] = x0         #simulation_starting conditions\n",
+    "\n",
+    "#starting guess\n",
+    "action = np.zeros(M)\n",
+    "action[0] = MAX_ACC/2 #a\n",
+    "action[1] = 0.0      #delta\n",
+    "u_sim[:,0] = action\n",
+    "\n",
+    "mpc = MPC()\n",
+    "REF_VEL = 1.0\n",
+    "\n",
+    "for sim_time in range(sim_duration-1):\n",
+    "    \n",
+    "    iter_start = time.time()\n",
+    "    \n",
+    "    # dynamics starting state w.r.t. robot are always null except vel \n",
+    "    start_state = np.array([0, 0, x_sim[2,sim_time], 0])\n",
+    "    action = np.array([u_sim[0,sim_time], u_sim[1,sim_time]])\n",
+    "    \n",
+    "    # State Matrices\n",
+    "    A,B,C = get_linear_model_matrices(start_state, action)\n",
+    "\n",
+    "    # Cost Matrices\n",
+    "    Q = np.diag([20,20,10,20]) #state error cost\n",
+    "    Qf = np.diag([30,30,30,30]) #state final error cost\n",
+    "    R = np.diag([10,10])       #input cost\n",
+    "    R_ = np.diag([10,10])      #input rate of change cost\n",
+    "\n",
+    "    #Get Reference_traj\n",
+    "    target, _ = get_ref_trajectory(x_sim[:,sim_time] ,track, REF_VEL)\n",
+    "    \n",
+    "    x_mpc, u_mpc = mpc.optimize_linearized_model(A, B, C, start_state, Q, R, target, time_horizon=T, verbose=False)\n",
+    "    \n",
+    "    #retrieved optimized U and assign to u_bar to linearize in next step\n",
+    "    u_bar = np.vstack((np.array(u_mpc.value[0,:]).flatten(),\n",
+    "                      (np.array(u_mpc.value[1,:]).flatten())))\n",
+    "    \n",
+    "    u_sim[:,sim_time] = u_bar[:,0]\n",
+    "    \n",
+    "    # Measure elpased time to get results from cvxpy\n",
+    "    opt_time.append(time.time()-iter_start)\n",
+    "    \n",
+    "    # move simulation to t+1\n",
+    "    tspan = [0,DT]\n",
+    "    x_sim[:,sim_time+1] = odeint(kinematics_model,\n",
+    "                                 x_sim[:,sim_time],\n",
+    "                                 tspan,\n",
+    "                                 args=(u_bar[:,0],))[1]\n",
+    "    \n",
+    "print(\"CVXPY Optimization Time: Avrg: {:.4f}s Max: {:.4f}s Min: {:.4f}s\".format(np.mean(opt_time),\n",
+    "                                                                                np.max(opt_time),\n",
+    "                                                                                np.min(opt_time)))   "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### RESUTS\n",
+    "\n",
+    "SCS -> Optimization Time: Avrg: 0.2139s Max: 0.3517s Min: 0.1913s\n",
+    "\n",
+    "OSQP -> Optimization Time: Avrg: 0.1035s Max: 0.1311s Min: 0.0959s\n",
+    "\n",
+    "ECOS -> Avrg: 0.2024s Max: 0.2313s Min: 0.1904s\n",
+    "\n",
+    "**Qualitative result** aka \"it drives?\" seems the same..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x720 with 5 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#plot trajectory\n",
+    "grid = plt.GridSpec(4, 5)\n",
+    "\n",
+    "plt.figure(figsize=(15,10))\n",
+    "\n",
+    "plt.subplot(grid[0:4, 0:4])\n",
+    "plt.plot(track[0,:],track[1,:],\"b+\")\n",
+    "plt.plot(x_sim[0,:],x_sim[1,:])\n",
+    "plt.axis(\"equal\")\n",
+    "plt.ylabel('y')\n",
+    "plt.xlabel('x')\n",
+    "\n",
+    "plt.subplot(grid[0, 4])\n",
+    "plt.plot(u_sim[0,:])\n",
+    "plt.ylabel('a(t) [m/ss]')\n",
+    "\n",
+    "plt.subplot(grid[1, 4])\n",
+    "plt.plot(x_sim[2,:])\n",
+    "plt.ylabel('v(t) [m/s]')\n",
+    "\n",
+    "plt.subplot(grid[2, 4])\n",
+    "plt.plot(np.degrees(u_sim[1,:]))\n",
+    "plt.ylabel('delta(t) [rad]')\n",
+    "\n",
+    "plt.subplot(grid[3, 4])\n",
+    "plt.plot(x_sim[3,:])\n",
+    "plt.ylabel('theta(t) [rad]')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:.conda-jupyter] *",
+   "language": "python",
+   "name": "conda-env-.conda-jupyter-py"
+  },
+  "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.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}