diff --git a/exercise-session-3.ipynb b/exercise-session-3.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..bb5b845ed311375b155c870ff0b174caeed1b72a
--- /dev/null
+++ b/exercise-session-3.ipynb
@@ -0,0 +1,844 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7b4f552e-2590-44c2-ad81-13866058fb1e",
+   "metadata": {},
+   "source": [
+    "## <center> Target Tracking -- Exercise 3 </center>\n",
+    "### <center> Anton Kullberg </center>\n",
+    "\n",
+    "This report contains solutions for the third set of exercises in the Target Tracking course given at Linköping University during fall 2021."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "3e6fa80c-07ba-4112-a0d3-2b3aec744e1d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "sns.set()\n",
+    "rng = np.random.default_rng(13)\n",
+    "import tqdm.notebook as tqdm\n",
+    "from src.sim import generate_data\n",
+    "from src.trajectories import get_ex2_trajectories\n",
+    "import src.gaters as gaters\n",
+    "import src.filters as filters\n",
+    "import src.associators as associators\n",
+    "import src.trackers as trackers\n",
+    "import src.plotters as plotters\n",
+    "import src.models as models\n",
+    "import src.logic as logic\n",
+    "import murty as murty_\n",
+    "# Get the necessary trajectories\n",
+    "trajectories = get_ex2_trajectories()\n",
+    "trajs = ['T1', 'T3', 'T5', 'T6'] # Select the trajectories to use\n",
+    "filtered_trajs = {key: T for key, T in trajectories.items() if key in trajs}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1f7e085f-ebe1-4f9c-a38b-79917e802d32",
+   "metadata": {},
+   "source": [
+    "### Task 3.1 - HOMHT\n",
+    "\n",
+    "A HOMHT tracker was implemented, see src.trackers. The model setup is as follows\n",
+    "\n",
+    "##### **Sensor Model**\n",
+    "The sensor model is the standard distance and bearing radar with $\\mathbf{R}=\\mathrm{diag}[10, 0.001]^2$. The probability of detection is set to $P_D=0.9$.\n",
+    "\n",
+    "##### **Gating**\n",
+    "Mahalanobis gating is used with $\\gamma=9.2$.\n",
+    "\n",
+    "##### **Clutter Model**\n",
+    "The volume is rectangular with $0\\leq x\\leq 2500$ and $0\\leq y\\leq2000$. Further, $\\beta_{FA}V=2$.\n",
+    "\n",
+    "##### **Track Logic**\n",
+    "A score-based track logic was used with an exponential forgetting factor to avoid integrator wind-up. The forgetting factor was tuned to $\\lambda=0.6$. The new target rate $\\beta_{NT}=\\beta_{FA}$. Further, the probability of confirming false tracks $P_{FC}0.1\\%$ and the probability of rejecting true tracks is $P_{TM}=1\\%$.\n",
+    "\n",
+    "##### **Motion Model**\n",
+    "The motion model is chosen as a CV model with $\\mathbf{Q}=10\\mathbf{I}$ which yielded good tracking performance for both GNN and JPDA.\n",
+    "\n",
+    "##### **Filter**\n",
+    "The filter was chosen as an EKF for simplicity (and it seemed to work fine).\n",
+    "\n",
+    "##### **Initialization**\n",
+    "The tracks were initialized at the measurement (converted to the positional domain) with a $0$ velocity. The initial uncertainty was set to $\\mathbf{P}_0=\\mathsc{diag}[10, 10, 100, 100]$ to account for the unknown initial velocity. The track score is initially set to $L_t=0$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "ad8aeebb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "R = np.diag([10, 0.001])**2\n",
+    "# R = np.diag([0, 0])\n",
+    "PD = 0.9\n",
+    "lam = 2\n",
+    "volume = dict(xmin=0, xmax=2500, ymin=0, ymax=2000)\n",
+    "V = (volume['xmax']-volume['xmin'])*(volume['ymax']-volume['ymin'])\n",
+    "Bfa = lam/V\n",
+    "Bfa = 4e-7\n",
+    "sensor_model = models.radar_model(R=R, PD=PD)\n",
+    "clutter_model = dict(volume=volume, lam=lam, Bfa=Bfa)\n",
+    "Bnt = Bfa\n",
+    "\n",
+    "q = 10\n",
+    "motion_model = models.cv_model(Q=q*np.identity(2), D=2, T=1)\n",
+    "\n",
+    "# Setup Gater\n",
+    "gamma = 9.2\n",
+    "gater = gaters.MahalanobisGater(sensor_model, gamma)\n",
+    "\n",
+    "P0 = np.diag([10, 10, 100, 100])\n",
+    "Ptm = 0.01\n",
+    "Pfc = 0.001\n",
+    "lam = 0.6\n",
+    "logic_params = dict(PD=sensor_model['PD'], PG=1, lam=lam, Ptm=Ptm, Pfc=Pfc, Bfa=Bfa, Ldel=1*np.log(Ptm/(1-Pfc)), Bnt=Bnt)\n",
+    "\n",
+    "def init_track(y, k, identity, filt):\n",
+    "    track = dict(stage='tentative', Lt=0, x=[], P=[], t=[k], identity=identity, associations=[k], filt=filt)\n",
+    "    x0 = np.concatenate(plotters.radar_to_pos(y[:, None])).flatten()\n",
+    "    x0 = np.hstack([x0, np.zeros((2,))])\n",
+    "    track['x'] = [x0]\n",
+    "    track['P'] = [P0]\n",
+    "    return track\n",
+    "\n",
+    "filt = filters.EKF(motion_model, sensor_model)\n",
+    "Y = generate_data(filtered_trajs, sensor_model, clutter_model, rng)\n",
+    "\n",
+    "def murty(C):\n",
+    "    \"\"\"Algorithm due to Murty.\"\"\"\n",
+    "    mgen = murty_.Murty(C)\n",
+    "    while True:\n",
+    "        ok, cost, sol = mgen.draw()\n",
+    "        if not ok:\n",
+    "            return None\n",
+    "        yield cost, sol"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "bb81be9c-d47c-4dc2-8514-fa7727d67b4e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pdb\n",
+    "import copy\n",
+    "import scipy.stats as stats\n",
+    "\n",
+    "def get_association_cost(meas, tracks, logic_params, gater):\n",
+    "    ny = meas.shape[1]\n",
+    "    Nc = len(tracks) # Number of tracks to associate\n",
+    "    validation_matrix = np.zeros((ny, Nc), dtype=bool)\n",
+    "    association_matrix = -np.inf*np.ones((ny, Nc+ny))\n",
+    "    likelihood_matrix = np.zeros((ny, Nc+ny))\n",
+    "    # Entry for false alarms\n",
+    "    np.fill_diagonal(association_matrix[:, Nc:Nc+ny], np.log(logic_params['Bfa']))\n",
+    "    np.fill_diagonal(likelihood_matrix[:, Nc:Nc+ny], 1-logic_params['PD']*logic_params['PG'])\n",
+    "\n",
+    "    for ti, track in enumerate(tracks): # Iterate over confirmed tracks\n",
+    "        validation_matrix[:, ti] = gater.gate(track['x'][-1], track['P'][-1], meas)\n",
+    "        # Entry for validated tracks\n",
+    "        val_meas = meas[:, validation_matrix[:, ti]] # Get the validated measurements for this track\n",
+    "        yhat = track['filt'].sensor_model['h'](track['x'][-1]) # Calculate the predicted measurement for this track\n",
+    "        H = track['filt'].sensor_model['dhdx'](track['x'][-1])\n",
+    "        py = stats.multivariate_normal.pdf(val_meas.squeeze().T, mean=yhat.flatten(), cov=H@track['P'][-1]@H.T+track['filt'].sensor_model['R'])\n",
+    "        association_matrix[validation_matrix[:, ti], ti] = np.log(track['filt'].sensor_model['PD']*py/(1-track['filt'].sensor_model['PD'])) # PG assumed = 1\n",
+    "        likelihood_matrix[validation_matrix[:, ti], ti] = track['filt'].sensor_model['PD']*py\n",
+    "    return association_matrix, likelihood_matrix, validation_matrix\n",
+    "\n",
+    "class MHT():\n",
+    "    def __init__(self, logic, logic_params, init_track, filt, gater, clutter_model, pthresh):\n",
+    "        \"\"\"An implementation of a Hypothesis Oriented Multiple Hypothesis Tracker.\n",
+    "\n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        logic : logic\n",
+    "            See src.logic. Some sort of track logic.\n",
+    "        logic_params : dict\n",
+    "            Contains parameters to the track logic.\n",
+    "        init_track : callable\n",
+    "            A function that initiates a track. Should take a measurement, the\n",
+    "            time, an id and the filter to use for the track as input.\n",
+    "        filt : filter\n",
+    "            See src.filter. Some sort of filter to use for the tracks.\n",
+    "        gater : gater\n",
+    "            See src.gater. A gating function.\n",
+    "        clutter_model : dict\n",
+    "            A dict containing the clutter model.\n",
+    "        pthresh : float [0, 1\n",
+    "            Threshold for the amount of probability \"mass\" to keep each timestep. Prunes unlikely hypothesis until this threshold is reached\n",
+    "\n",
+    "        \"\"\"\n",
+    "        self.logic = logic\n",
+    "        self.logic_params = logic_params\n",
+    "        self.init_track = init_track\n",
+    "        self.filt = filt\n",
+    "        self.gater = gater\n",
+    "        self.clutter_model = clutter_model\n",
+    "        self.pthresh = pthresh\n",
+    "    \n",
+    "    def _update_track(self, meas, track):\n",
+    "        \"\"\"Handles the update of a certain track with the given measurement(s).\n",
+    "\n",
+    "        Modifies the track in-place!\n",
+    "\n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        meas : numpy.ndarray\n",
+    "            Contains measurement(s) to update a specific track with. ny by N,\n",
+    "            where N is the number of measurements to update the track with.\n",
+    "        track : dict\n",
+    "            A dict containing everything relevant to the track.\n",
+    "\n",
+    "        \"\"\"\n",
+    "        if meas.size == 0:\n",
+    "            track = self.logic(np.array([]), track['filt'], track, self.logic_params) # If no meas associated, still update logic of track\n",
+    "            return\n",
+    "        # Calculate prediction error of each measurement\n",
+    "        yhat = track['filt'].sensor_model['h'](track['x'][-1])\n",
+    "        \n",
+    "        eps = meas-yhat\n",
+    "        track = self.logic(meas, track['filt'], track, self.logic_params)\n",
+    "        \n",
+    "        # Update\n",
+    "        track['x'][-1], track['P'][-1] = track['filt'].update(track['x'][-1], track['P'][-1], eps)\n",
+    "\n",
+    "    def evaluate(self, Y):\n",
+    "        \"\"\" Evaluates the detections in Y.\n",
+    "\n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        Y : list\n",
+    "            List of detections at time k=0 to K where K is the length of Y.\n",
+    "            Each entry of Y is ny by N_k where N_k is time-varying as the number\n",
+    "            of detections vary.\n",
+    "\n",
+    "        Returns\n",
+    "        -------\n",
+    "        list, list\n",
+    "            First list contains all initiated tracks, both tentative, deleted\n",
+    "            and confirmed. The second list contains only the confirmed list,\n",
+    "            even if they have died. Hence, the lists contain duplicates (but\n",
+    "            point to the same object!).\n",
+    "\n",
+    "        \"\"\"\n",
+    "        rng = np.random.default_rng()\n",
+    "        hypothesis = dict() # This will contain hypothesis over time\n",
+    "        init_hypothesis = lambda probability: dict(tracks=[], probability=probability) # For more readable code in the end\n",
+    "        hypothesis[-1] = [init_hypothesis(1)]\n",
+    "\n",
+    "        ids = 0\n",
+    "        for k, meas_k in tqdm.tqdm(enumerate(Y), desc=\"HOMHT evaluating detections: \", total=len(Y)):\n",
+    "            hypothesis[k] = []\n",
+    "            # For each hypothesis from the last time step\n",
+    "            for hyp in hypothesis[k-1]:\n",
+    "                # Propagate each track to this time step\n",
+    "                for track in hyp['tracks']:\n",
+    "                    if track['stage'] != 'deleted':\n",
+    "                        x, P = track['filt'].propagate(track['x'][-1], track['P'][-1])\n",
+    "                        track['x'].append(x)\n",
+    "                        track['P'].append(P)\n",
+    "                        track['t'].append(k)\n",
+    "\n",
+    "                unused_meas = np.ones((meas_k.shape[1],), dtype=bool)\n",
+    "                # For all \"live\" tracks in hypothesis\n",
+    "                live_tracks = [track for track in hyp['tracks'] if track['stage'] in ['confirmed', 'tentative']]\n",
+    "                association_matrix, likelihood_matrix, _ = get_association_cost(meas_k, live_tracks, self.logic_params, self.gater)\n",
+    "                ny = meas_k.shape[1]\n",
+    "                nt = len(live_tracks)\n",
+    "                # The Murty alg. returns the cost of the association and the indices of the association\n",
+    "                for (cost, associations) in murty(-association_matrix):\n",
+    "                    unused_meas = np.ones((ny,), dtype=bool)\n",
+    "                    \n",
+    "                    # Initiate a new hypothesis and copy over all the tracks in the current hypothesis.\n",
+    "                    hypothesis[k].append(init_hypothesis(hyp['probability']))\n",
+    "                    for track in hyp['tracks']:\n",
+    "                        if track['stage'] != 'deleted':\n",
+    "                            tmp_track = init_track(np.ones((2, 1)), k, track['identity'], track['filt'])\n",
+    "                            tmp_track['x'][-1] = track['x'][-1]\n",
+    "                            tmp_track['P'][-1] = track['P'][-1]\n",
+    "                            tmp_track['t'] = track['t']\n",
+    "                            tmp_track['associations'] = copy.copy(track['associations'])\n",
+    "                            tmp_track['stage'] = track['stage']\n",
+    "                            tmp_track['Lt'] = track['Lt']\n",
+    "                            hypothesis[k][-1]['tracks'].append(tmp_track)\n",
+    "#                     hypothesis[k].append(copy.deepcopy(hyp)) # the easy but INCREDIBLY slow way to do it\n",
+    "\n",
+    "                    # Update the tracks with associated measurements\n",
+    "                    for j, association in enumerate(associations):\n",
+    "                        if association < nt: # i.e. associated to a track\n",
+    "                            self._update_track(meas_k[:, j], hypothesis[k][-1]['tracks'][association])\n",
+    "                            hypothesis[k][-1]['tracks'][association]['associations'].append(k)\n",
+    "                            unused_meas[j] = 0\n",
+    "                        # Update the proability of the hypothesis for this particular association\n",
+    "                        hypothesis[k][-1]['probability'] *= likelihood_matrix[j, association]\n",
+    "                    # Update tracks without an association in this particular hypothesis\n",
+    "                    for j in range(nt):\n",
+    "                        if j not in associations:\n",
+    "                            self._update_track(np.array([]), hypothesis[k][-1]['tracks'][j])\n",
+    "                    \n",
+    "                    # For any still unused measurements, possibly initiate a new track\n",
+    "                    while unused_meas.any():\n",
+    "                        # Select an unused measurement at random and initiate a track\n",
+    "                        ind = rng.choice(np.arange(unused_meas.size), p=unused_meas/unused_meas.sum())\n",
+    "                        track = init_track(meas_k[:, ind], k, ids, filt) # Initialize track\n",
+    "                        hypothesis[k][-1]['tracks'].append(track)\n",
+    "                        unused_meas[ind] = 0 # Remove measurement from association hypothesis\n",
+    "                        _, _, validation_matrix = get_association_cost(meas_k[:, unused_meas], \n",
+    "                                                                        [hypothesis[k][-1]['tracks'][-1]], \n",
+    "                                                                        self.logic_params, \n",
+    "                                                                        self.gater)\n",
+    "                        ids += 1\n",
+    "                        # Remove any gated measurements from further consideration\n",
+    "                        if validation_matrix.any():\n",
+    "                            unused_meas[(meas_k[:, unused_meas][:, validation_matrix.flatten()]==meas_k).all(axis=0)] = 0 \n",
+    "            \n",
+    "            # Normalize the hypothesis probabilities\n",
+    "            total_score = np.sum([hyp['probability'] for hyp in hypothesis[k]])\n",
+    "            for hyp in hypothesis[k]:\n",
+    "                hyp['probability'] /= total_score\n",
+    "            # Only keep the hypothesis which amount to pthresh probability \"mass\"\n",
+    "            hypothesis[k].sort(key=lambda x: x['probability'], reverse=True)\n",
+    "            prob = [hyp['probability'] for hyp in hypothesis[k]]\n",
+    "            ind = np.argmax(np.cumsum(prob)>self.pthresh)+1 # Find the index to keep\n",
+    "            hypothesis[k] = hypothesis[k][:ind]\n",
+    "            # Re-normalize the hypothesis probabilities\n",
+    "            total_score = np.sum([hyp['probability'] for hyp in hypothesis[k]])\n",
+    "            for hyp in hypothesis[k]:\n",
+    "                hyp['probability'] /= total_score\n",
+    "        return hypothesis\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "7bd04719-2e24-4f2f-bed4-9930fa8993d5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "db1215b8bd4442e197ee1e312daac863",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HOMHT evaluating detections:   0%|          | 0/50 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " \n",
+      "*** Profile printout saved to text file 'prun0'. \n"
+     ]
+    }
+   ],
+   "source": [
+    "%%prun -s cumulative -q -l 10 -T prun0\n",
+    "pthresh = 0.6\n",
+    "mht = MHT(logic.score_logic, logic_params, init_track, filt, gater, clutter_model, pthresh)\n",
+    "hypothesis = mht.evaluate(Y[:50])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "c1a720f1-b40f-42e5-81b7-bf7d809281e9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "         496471912 function calls (490681722 primitive calls) in 547.971 seconds\n",
+      "\n",
+      "   Ordered by: cumulative time\n",
+      "   List reduced from 836 to 10 due to restriction <10>\n",
+      "\n",
+      "   ncalls  tottime  percall  cumtime  percall filename:lineno(function)\n",
+      "        1    0.000    0.000  548.417  548.417 {built-in method builtins.exec}\n",
+      "        1    0.005    0.005  548.417  548.417 <string>:1(<module>)\n",
+      "        1    0.766    0.766  548.411  548.411 177206276.py:83(evaluate)\n",
+      "    27049    0.553    0.000  402.205    0.015 api.py:1092(jacfun)\n",
+      "     7615    0.910    0.000  378.889    0.050 177206276.py:5(get_association_cost)\n",
+      "    51380    3.226    0.000  367.744    0.007 models.py:32(h)\n",
+      "170170/40361    0.640    0.000  358.772    0.009 traceback_util.py:158(reraise_with_filtered_traceback)\n",
+      "    27049    0.415    0.000  356.330    0.013 api.py:1444(batched_fun)\n",
+      "54098/27049    1.299    0.000  353.689    0.013 linear_util.py:152(call_wrapped)\n",
+      "    27049    0.425    0.000  341.642    0.013 api.py:2082(_jvp)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(open('prun0', 'r').read())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "6921d06f-1d64-40e5-856a-e17bb0b1a339",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def recreate_trajectories(hypothesis, marginalize=True):\n",
+    "    confirmed_tracks = dict()\n",
+    "    tracks = dict()\n",
+    "    for t, hyp_t in hypothesis.items():\n",
+    "        t_tracks = dict()\n",
+    "        t_prob = []\n",
+    "        for hyp in hyp_t:\n",
+    "            t_prob.append(hyp['probability'])\n",
+    "            for track in hyp['tracks']:\n",
+    "                # Restructure the tracks to easily marginalize\n",
+    "                if track['identity'] not in t_tracks.keys():\n",
+    "                    t_tracks[track['identity']] = [track]\n",
+    "                else:# If a track exists in more than one hypothesis it exists in all of them\n",
+    "                    t_tracks[track['identity']].append(track)\n",
+    "        t_prob = np.array(t_prob)\n",
+    "        # Marginalization over the hypothesis\n",
+    "        for track_list in t_tracks.values():\n",
+    "            # Identify the track in the previous track list\n",
+    "            track_identity = track_list[0]['identity']\n",
+    "            associations = [association for track in track_list for association in track['associations']] # Get associations in the different hypothesis\n",
+    "            mult_hyp = len(track_list) == t_prob.size\n",
+    "            if mult_hyp:\n",
+    "                # Compute the track score\n",
+    "                Lt = np.array([track['Lt'] for track in track_list])\n",
+    "                x = np.vstack([track['x'][0] for track in track_list])\n",
+    "                P = [track['P'][0] for track in track_list]\n",
+    "                if marginalize:\n",
+    "                    xhat = t_prob@x\n",
+    "                    Lt = Lt@t_prob\n",
+    "                    # Compute the state error covariance\n",
+    "                    err = (x-xhat[None, :]).T\n",
+    "                    Pk = np.stack([col[:,None]@col[None,:] for col in err.T])\n",
+    "                    Phat = np.tensordot(np.stack(P)+Pk, t_prob, (0, 0)) # Dot product over axis 0\n",
+    "                else:\n",
+    "                    most_prob = np.argmax(t_prob)\n",
+    "                    xhat = x[most_prob, :]\n",
+    "                    Phat = P[most_prob]\n",
+    "                    Lt = Lt[most_prob]\n",
+    "            else:\n",
+    "                xhat = track_list[0]['x'][-1]\n",
+    "                Phat = track_list[0]['P'][-1]\n",
+    "                Lt = track_list[0]['Lt']\n",
+    "            \n",
+    "            if track_identity in tracks.keys():\n",
+    "                tracks[track_identity]['x'].append(xhat)\n",
+    "                tracks[track_identity]['P'].append(Phat)\n",
+    "                tracks[track_identity]['Lt'] = Lt\n",
+    "                if t in associations:\n",
+    "                    tracks[track_identity]['associations'].append(t)\n",
+    "                if mult_hyp:\n",
+    "                    stages = [track['stage'] for track in track_list]\n",
+    "                    # The stage is assumed to be the most probable hypothesis\n",
+    "                    tracks[track_identity]['stage'] = stages[np.argmax(t_prob)]\n",
+    "                else:\n",
+    "                    tracks[track_identity]['stage'] = track_list[0]['stage']\n",
+    "            else:\n",
+    "                track = copy.deepcopy(track_list[0])\n",
+    "                track['x'] = [xhat]\n",
+    "                track['P'] = [Phat]\n",
+    "                if t in associations and t not in track['associations']:\n",
+    "                    track['associations'].append(t)\n",
+    "                track['Lt'] = Lt\n",
+    "                tracks[track_identity] = track\n",
+    "            if tracks[track_identity]['stage'] == 'confirmed':\n",
+    "                if track_identity not in confirmed_tracks.keys():\n",
+    "                    confirmed_tracks[track_identity] = tracks[track_identity]\n",
+    "    return tracks.values(), confirmed_tracks.values()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "3652a059-9eda-402b-ae08-8d78fe92caf2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "marg_tracks, marg_confirmed_tracks = recreate_trajectories(hypothesis, True)\n",
+    "map_tracks, map_confirmed_tracks = recreate_trajectories(hypothesis, False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "34c1ba31-3819-4c83-bf92-cbda68a03bf8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x1152 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "Yt = np.hstack(Y)\n",
+    "yx, yy = plotters.radar_to_pos(Yt)\n",
+    "fig = plt.figure(constrained_layout=True, figsize=(20, 16))\n",
+    "gs = fig.add_gridspec(4, 2)\n",
+    "ax = [fig.add_subplot(gs[0, :]),\n",
+    "     fig.add_subplot(gs[1:, :])]\n",
+    "for track in map_tracks:\n",
+    "    x = np.vstack(track['x'])\n",
+    "    t = np.hstack(track['t']).flatten()\n",
+    "    assoc = np.hstack(track['associations']).flatten()\n",
+    "    if track in map_confirmed_tracks:\n",
+    "        ls = '-'\n",
+    "        l = ax[0].plot(t, track['identity']*np.ones(t.shape), ls=ls, markersize=3)[0]\n",
+    "        ax[0].plot(assoc, track['identity']*np.ones(assoc.shape), ls='', color=l.get_color(), marker='x', markersize=6)\n",
+    "        ax[1].plot(x[:, 0], x[:, 1], ls=ls, color=l.get_color(), lw=3)\n",
+    "    else:\n",
+    "        ls = '--'\n",
+    "        ax[1].plot(x[:, 0], x[:, 1], ls=ls, lw=2)\n",
+    "ax[0].set_ylabel('Track identity')\n",
+    "ax[0].set_title('Confirmed tracks over time')\n",
+    "ax[0].set_xlabel('Time index, k')\n",
+    "ax[1].plot(yx, yy, '.', color='k')\n",
+    "ax[1].set_xlabel(r'$p_x$')\n",
+    "ax[1].set_ylabel(r'$p_y$')\n",
+    "ax[1].set_title('Measurements and measurement predictions + tracks')\n",
+    "ax[1].set_xlim([-100, 2200])\n",
+    "ax[1].set_ylim([0, 2000])\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "id": "0e0335ad-1e02-4f1e-a098-aeac8b352242",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x864 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "lines = dict()\n",
+    "plt.figure(figsize=(16, 12))\n",
+    "for t, hyp_t in hypothesis.items():\n",
+    "    for hyp in hyp_t:\n",
+    "        for track in hyp['tracks']:\n",
+    "            x = np.vstack(track['x'])\n",
+    "            t = np.hstack(track['t']).flatten()\n",
+    "            if track['stage'] == 'confirmed':\n",
+    "                if track['identity'] not in lines.keys():\n",
+    "                    lines[track['identity']] = plt.plot(x[:, 0], x[:, 1])[0]\n",
+    "                else:\n",
+    "                    plt.plot(x[:, 0], x[:, 1], color=lines[track['identity']].get_color())\n",
+    "            else:\n",
+    "                plt.plot(x[:, 0], x[:, 1], 'k--', marker='*')\n",
+    "                \n",
+    "                \n",
+    "plt.show()\n",
+    "# hypothesis[70][0]['tracks'][0]['identity']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30f60524-b6cb-48c6-bbee-c69d8f72bdf2",
+   "metadata": {},
+   "source": [
+    "#### Apply GNN and JPDA\n",
+    "\n",
+    "Generates measurements from the true tracks and evaluates those measurements with the JPDA and GNN tracker."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "31e8ca55-8bb0-4662-977a-857d8cdf4ea2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "jpda = trackers.JPDA(logic.score_logic, logic_params, init_track, filt, gater, clutter_model)\n",
+    "gnn = trackers.GNN(logic.score_logic, logic_params, init_track, filt, gater, clutter_model)\n",
+    "Y = generate_data(filtered_trajs, sensor_model, clutter_model, rng)\n",
+    "jpda_tracks, jpda_confirmed_tracks = jpda.evaluate(Y)\n",
+    "gnn_tracks, gnn_confirmed_tracks = gnn.evaluate(Y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16eb8a37-895f-40a6-aefd-3d523e035d64",
+   "metadata": {},
+   "source": [
+    "#### Match the tracks to ground truth\n",
+    "\n",
+    "The tracks are matched according to the following criteria:\n",
+    "\n",
+    "- The initial point of each track is matched to the closest point of each true trajectory.\n",
+    "- The RMSE to each track is then calculated and the lowest RMSE is chosen as the true trajectory for this track.\n",
+    "\n",
+    "Limitations: several tracks can match a specific true trajectory. (Hopefully not an issue, at least not here)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "0c29b3fb-55ac-4c19-9acb-b493e536bd8d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from src.utility import match_tracks_to_ground_truth\n",
+    "# jpda_matches = match_tracks_to_ground_truth(jpda_confirmed_tracks, filtered_trajs)\n",
+    "mht_matches = match_tracks_to_ground_truth(map_confirmed_tracks, filtered_trajs)\n",
+    "mhtresult = dict(matches=mht_matches,\n",
+    "                  tracks=map_tracks,\n",
+    "                  confirmed_tracks=map_confirmed_tracks,\n",
+    "                  Y=Y)\n",
+    "# gnn_matches = match_tracks_to_ground_truth(gnn_confirmed_tracks, filtered_trajs)\n",
+    "# jpdaresult = dict(matches=jpda_matches, \n",
+    "#                   tracks=jpda_tracks, \n",
+    "#                   confirmed_tracks=jpda_confirmed_tracks,\n",
+    "#                   Y=Y)\n",
+    "# gnnresult = dict(matches=gnn_matches, \n",
+    "#                   tracks=gnn_tracks, \n",
+    "#                   confirmed_tracks=gnn_confirmed_tracks,\n",
+    "#                   Y=Y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3be8ea4b-7d23-42a3-a4b2-bff1ab331767",
+   "metadata": {},
+   "source": [
+    "#### Plots\n",
+    "\n",
+    "Produces three plots for each tracker.\n",
+    "\n",
+    "- Plot 1: All the confirmed tracks over time with their birth and death.\n",
+    "- Plot 2: RMSE of each confirmed track to its matched true trajectory. Plotted over the normalized trajectory length.\n",
+    "- Plot 3: The tracks and all of the measurements together with the ground truths."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "41a6fabc-4074-4c6e-8e44-80693c4409a9",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "operands could not be broadcast together with shapes (2,0) (2,3) ",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_3138/1739879927.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# jpdafig = plotters.plot_result_ex2_2(jpdaresult, filtered_trajs)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# plt.suptitle('JPDA', fontsize=20)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mmhtfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplotters\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_result_ex2_2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmhtresult\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfiltered_trajs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msuptitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'MHT'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfontsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/work/src/plotters.py\u001b[0m in \u001b[0;36mplot_result_ex2_2\u001b[0;34m(result, trajs)\u001b[0m\n\u001b[1;32m    100\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    101\u001b[0m             \u001b[0mN\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 102\u001b[0;31m         \u001b[0mxrmse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mT\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    103\u001b[0m         \u001b[0mterr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgtf\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mtf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    104\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mn\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (2,0) (2,3) "
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# gnnfig = plotters.plot_result_ex2_2(gnnresult, filtered_trajs)\n",
+    "# plt.suptitle('GNN', fontsize=20)\n",
+    "# jpdafig = plotters.plot_result_ex2_2(jpdaresult, filtered_trajs)\n",
+    "# plt.suptitle('JPDA', fontsize=20)\n",
+    "mhtfig = plotters.plot_result_ex2_2(mhtresult, filtered_trajs)\n",
+    "plt.suptitle('MHT', fontsize=20)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2681a406-0615-49f7-8043-b306887d5fe0",
+   "metadata": {},
+   "source": [
+    "#### Comments\n",
+    "Both the GNN and JPDA capture all four tracks good. The GNN has a slightly lower RMSE overall which seems reasonable given the \"low\" clutter rate and only a few track cross-overs."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8058636f-682b-493c-aad5-374fb6f845df",
+   "metadata": {},
+   "source": [
+    "### Task 2.4 - Mysterious Data\n",
+    "\n",
+    "A GNN and a JPDA tracker were applied to the mysterious data set. The design choices are listed below.\n",
+    "\n",
+    "##### **Sensor Model**\n",
+    "The sensor model is the standard distance and bearing radar as before with the same noise parameters. The probability of detection was set to $P_D=0.9$.\n",
+    "\n",
+    "##### **Gating**\n",
+    "Mahalanobis gating was used with $\\gamma=9.2$.\n",
+    "\n",
+    "##### **Clutter Model**\n",
+    "The tracking volume was established by inspecting the measurement data in the positional domain. The volume is rectangular with $-2000\\leq x\\leq 2000$ and $-21000\\leq y\\leq-17000$. As before $\\beta_{FA}V=2$.\n",
+    "\n",
+    "##### **Track Logic**\n",
+    "A score-based track logic was used with an exponential forgetting factor to avoid integrator wind-up. The forgetting factor was tuned to $\\lambda=0.95$. The new target rate $\\beta_{NT}=\\beta_{FA}$. Further, the probability of confirming false tracks $P_{FC}0.1\\%$ and the probability of rejecting true tracks is $P_{TM}=1\\%$.\n",
+    "\n",
+    "##### **Motion Model**\n",
+    "After inspection of the measurement data in the positional domain, a CV model was chosen as the motion model. The process noise was tuned to $\\mathbf{Q}=5e4\\mathbf{I}$ which yielded good tracking performance for both GNN and JPDA.\n",
+    "\n",
+    "##### **Filter**\n",
+    "The filter was chosen as an EKF for simplicity (and it seemed to work fine).\n",
+    "\n",
+    "##### **Initialization**\n",
+    "The tracks were initialized at the measurement (converted to the positional domain) with a $0$ velocity. The initial uncertainty was set to $\\mathbf{P}_0=\\mathsc{diag}[100, 100, 1000, 1000]$ to account for the unknown initial velocity. The track score is initially set to $L_t=0$.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd9637ca-ccc3-46fe-bdfe-4f32faddd2a8",
+   "metadata": {},
+   "source": [
+    "##### **Model setup**\n",
+    "\n",
+    "Makes the necessary changes to the model setup."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8add90a-bb80-446d-9380-74d26ee43661",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scipy.io import loadmat\n",
+    "dat = loadmat('data/ex2data.mat')\n",
+    "dat['Y'] = [yk.reshape(2, -1) for yk in dat['Y'].flatten()]\n",
+    "T = 0.26\n",
+    "volume = dict(xmin=-2000, xmax=2000, ymin=-21000, ymax=-17000)\n",
+    "\n",
+    "q = 5e4\n",
+    "motion_model = models.cv_model(Q=q*np.identity(2), D=2, T=T)\n",
+    "\n",
+    "V = (volume['xmax']-volume['xmin'])*(volume['ymax']-volume['ymin'])\n",
+    "Bfa = lam/V\n",
+    "clutter_model = dict(volume=volume, lam=lam, Bfa=Bfa)\n",
+    "\n",
+    "P0 = np.diag([100, 100, 1000, 1000])\n",
+    "logic_params['lam'] = 0.95\n",
+    "logic_params['Bnt'] = Bfa\n",
+    "\n",
+    "filt = filters.EKF(motion_model, sensor_model)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "62d5a1a0-fd3d-4419-87bb-b989d2c1b1d4",
+   "metadata": {},
+   "source": [
+    "#### Apply the JPDA and GNN trackers\n",
+    "\n",
+    "Applies the JPDA and GNN to the provided data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d955d2bc-9ee6-4ca2-bd0f-4ddf9c88ff68",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "jpda = trackers.JPDA(logic.score_logic, logic_params, init_track, filt, gater, clutter_model)\n",
+    "gnn = trackers.GNN(logic.score_logic, logic_params, init_track, filt, gater, clutter_model)\n",
+    "jpda_tracks, jpda_confirmed_tracks = jpda.evaluate(dat['Y'])\n",
+    "gnn_tracks, gnn_confirmed_tracks = gnn.evaluate(dat['Y'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c1038ba5-c8e7-46d0-a91a-7be7cd9ef4bc",
+   "metadata": {},
+   "source": [
+    "#### Plots\n",
+    "\n",
+    "Produces two plots per tracker.\n",
+    "- Plot 1: Confirmed tracks over time with birth and possible death of tracks.\n",
+    "- Plot 2: The tracks and all of the measurements."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "059a5880-31fe-40ba-acf7-755e1b002ec5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "jpda_result = dict(Y=dat['Y'], \n",
+    "                   tracks=jpda_tracks, \n",
+    "                   confirmed_tracks=jpda_confirmed_tracks)\n",
+    "gnn_result = dict(Y=dat['Y'],\n",
+    "                  tracks=gnn_tracks, \n",
+    "                  confirmed_tracks=gnn_confirmed_tracks)\n",
+    "plotters.plot_result_ex2_24(gnn_result)\n",
+    "plt.suptitle('GNN', fontsize=20)\n",
+    "plotters.plot_result_ex2_24(jpda_result)\n",
+    "plt.suptitle('JPDA', fontsize=20)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "50563376-26b3-40f8-98bc-6ded016a0eb3",
+   "metadata": {},
+   "source": [
+    "#### Comments\n",
+    "Both the GNN and JPDA manage to keep both tracks the entire time. The GNN results in two \"U\"-shaped tracks whereas the JPDA results in \"S\"-shaped tracks. Without more information, it is impossible to say which is correct. However, the JPDA tracker results in a smoother trajectory, probably because of the soft measurement assignments."
+   ]
+  }
+ ],
+ "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.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}