diff --git a/technologies/caching/Cache_time_test.ipynb b/technologies/caching/Cache_time_test.ipynb
new file mode 100644
index 0000000..d6b4cf4
--- /dev/null
+++ b/technologies/caching/Cache_time_test.ipynb
@@ -0,0 +1,784 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "64d2ce94",
+   "metadata": {},
+   "source": [
+    "Intro:\n",
+    "------ \n",
+    "Cache performance is critical when working with large datasets obtained from several iterations of the add_results() method. In some cases successive expansions of the existing cache result in severe slowing of system performance. To this end Jens has added the shaped cache feature, which pre-allocates the memory for caching, avoiding the intensive process of cache expansion. To demonstrate and test this new feature, we have run 7 test cases to assess cache performance featuring contexts without cache, with the default cache, and pre-allocated cache enabled. We have also included variants which write to the regular SQLite database, or keep all data in memory. Lastly, these are compared to the DoNd functions which already pre-allocate cache size based on data shape.\n",
+    "\n",
+    "Approach:\n",
+    "---------\n",
+    "We will base this on a simple dummy instrument setup used typically to introduce qcodes to new users. We will make multiple measurements of two dummy instruments via 2 nested loops within a specific measurement context. The execution time of a function is estimated by bracketing 'time.pref_counter()' calls, and these values will be averaged for each outer loop execution. These averaged execution times can be used to assess the cache and database performance as more data is recorded.\n",
+    "\n",
+    "Conclusions:\n",
+    "------------ \n",
+    "\n",
+    "1. Dynamically allocated cache underperforms in all cases.\n",
+    "2. DoNd with and without cache offer equivalent performance.\n",
+    "3. SQLite database writes do not hinder performance."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f252f623",
+   "metadata": {},
+   "source": [
+    "Set up dataset sizes\n",
+    "--------------------\n",
+    "Datasets are sized by a, b, and n corresponding to the outer, inner and repeat loops respectively. \n",
+    "Iterations times are recorded for each execution of 'add_result()' in the inner loop, and averaged with each execution of the outer loop. This averages out periodic database writes (when relevant).\n",
+    "\n",
+    "Note that no logic handles averaging over the outermost (repeat) loops, this was mostly for testing. Generally size_n should remain as 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "72fe8350",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Loop sizes\n",
+    "size_a = 500\n",
+    "size_b = 200\n",
+    "size_n = 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1dafe9aa",
+   "metadata": {},
+   "source": [
+    "Environment setup\n",
+    "-----------------\n",
+    "This section imports modules and then sets up the instruments in subsequent cells."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "fecfbabd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Logging hadn't been started.\n",
+      "Activating auto-logging. Current session state plus future input saved.\n",
+      "Filename       : C:\\Users\\a-davidpoole\\.qcodes\\logs\\command_history.log\n",
+      "Mode           : append\n",
+      "Output logging : True\n",
+      "Raw input log  : False\n",
+      "Timestamping   : True\n",
+      "State          : active\n",
+      "Qcodes Logfile : C:\\Users\\a-davidpoole\\.qcodes\\logs\\211115-1704-qcodes.log\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Imports\n",
+    "\n",
+    "import os\n",
+    "import time\n",
+    "import tqdm\n",
+    "import numpy as np\n",
+    "import qcodes as qc\n",
+    "from qcodes.utils.dataset.doNd import do1d, do2d, dond, plot, LinSweep, LogSweep\n",
+    "from qcodes.dataset.descriptions.detect_shapes import detect_shape_of_measurement\n",
+    "from qcodes.tests.instrument_mocks import DummyInstrument, DummyInstrumentWithMeasurement\n",
+    "\n",
+    "\n",
+    "from qcodes.dataset import (\n",
+    "    load_or_create_experiment,\n",
+    "    load_by_guid,\n",
+    "    load_by_run_spec,\n",
+    "    initialise_or_create_database_at,\n",
+    "    Measurement,\n",
+    "    DataSetType,\n",
+    ")\n",
+    "from qcodes.tests.instrument_mocks import (\n",
+    "    DummyInstrument,\n",
+    "    DummyInstrumentWithMeasurement,\n",
+    ")\n",
+    "from qcodes.dataset.plotting import plot_dataset\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "5dc4bb12",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Set up local database\n",
+    "\n",
+    "testing_db_path = os.path.join(os.getcwd(), 'local.db')\n",
+    "initialise_or_create_database_at(testing_db_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "64cca5d7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# preparatory mocking of physical setup\n",
+    "dac = DummyInstrument('dac', gates=['ch1', 'ch2'])\n",
+    "dmm = DummyInstrumentWithMeasurement('dmm', setter_instr=dac)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a86fd3c",
+   "metadata": {},
+   "source": [
+    "Measurement setups\n",
+    "------------------\n",
+    "These cells set up the experiment, and measurements with (meas_with_shape) and without (meas) pre-allocated data shapes. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "93b9a581",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<qcodes.dataset.measurements.Measurement at 0x295aff633d0>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\n",
+    "# Setting up Measurement\n",
+    "testing_exp = load_or_create_experiment('loop_1', sample_name='no sample')\n",
+    "\n",
+    "#Setting up measuremetn without shape\n",
+    "meas = Measurement(name= 'simple meas', exp=testing_exp)\n",
+    "meas.register_parameter(dac.ch1)\n",
+    "meas.register_parameter(dac.ch2)\n",
+    "meas.register_parameter(dmm.v1, setpoints=(dac.ch1,dac.ch2))\n",
+    "meas.register_parameter(dmm.v2, setpoints=(dac.ch1,dac.ch2))\n",
+    "\n",
+    "#Setting Up measurement with shapes\n",
+    "meas_with_shape = Measurement(exp=testing_exp, name='shape meas')\n",
+    "meas_with_shape.register_parameter(dac.ch1)  # register the first independent parameter\n",
+    "meas_with_shape.register_parameter(dac.ch2)  # register the second independent parameter\n",
+    "meas_with_shape.register_parameter(dmm.v1, setpoints=(dac.ch1, dac.ch2))  # now register the dependent oone\n",
+    "meas_with_shape.register_parameter(dmm.v2, setpoints=(dac.ch1, dac.ch2))  # now register the dependent oone\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d3e8a6b",
+   "metadata": {},
+   "source": [
+    "Testing cache with context manager\n",
+    "----------------------------------\n",
+    "This section is where the for loops live. With each output is included the average, this is not as useful as the scatterplot below, but it may be nice in some cases so it was left in."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "1f1c9f0c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2021-11-15 18:56:44,721 ¦ py.warnings ¦ WARNING ¦ warnings ¦ _showwarnmsg ¦ 109 ¦ C:\\Users\\A-DAVI~1\\AppData\\Local\\Temp/ipykernel_1704/616408506.py:4: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
+      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
+      "  bar = tqdm.tqdm_notebook(total=size_a*size_b*size_n)\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "106b08cb98064c1da6a141296f92d918",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100000 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting experimental run with id: 7. \n",
+      "0.7725711649999891\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Measurement with context manager with cache\n",
+    "t_a = []\n",
+    "\n",
+    "bar = tqdm.tqdm_notebook(total=size_a*size_b*size_n)\n",
+    "\n",
+    "for _ in range(size_n):\n",
+    "    with meas.run() as datasaver:\n",
+    "        for dac1_sweep in np.linspace(-1, 1, size_a): # sweep points over channel 1\n",
+    "            dac.ch1(dac1_sweep)\n",
+    "            t = []\n",
+    "            for dac2_sweep in np.linspace(-1, 1, size_b): # sweep points over channel 2\n",
+    "                dac.ch2(dac2_sweep)\n",
+    "                t0 = time.perf_counter()\n",
+    "                datasaver.add_result(\n",
+    "                    (dac.ch1, dac.ch1()),\n",
+    "                    (dac.ch2, dac.ch2()),\n",
+    "                    (dmm.v1, dmm.v1()),\n",
+    "                    (dmm.v2, dmm.v2())\n",
+    "                    )\n",
+    "                t1 = time.perf_counter()\n",
+    "                t.append(t1-t0)\n",
+    "                bar.update(1)\n",
+    "            t_a.append(sum(t)/len(t)*1000)\n",
+    "        dataset2 = datasaver.dataset\n",
+    "\n",
+    "print(sum(t_a)/len(t_a))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "1e1f4390",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2021-11-15 18:58:07,143 ¦ py.warnings ¦ WARNING ¦ warnings ¦ _showwarnmsg ¦ 109 ¦ C:\\Users\\A-DAVI~1\\AppData\\Local\\Temp/ipykernel_1704/2853598699.py:4: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
+      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
+      "  bar = tqdm.tqdm_notebook(total=size_a*size_b*size_n)\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2276a8060cfc482e8b5a1ffa897d65be",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100000 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting experimental run with id: 8. \n",
+      "0.22837625199998926\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Measurement with context manager with shaped cache\n",
+    "meas_with_shape.set_shapes(detect_shape_of_measurement((dmm.v1,dmm.v2), (size_a, size_b)))\n",
+    "\n",
+    "bar = tqdm.tqdm_notebook(total=size_a*size_b*size_n)\n",
+    "\n",
+    "t_b = []\n",
+    "for _ in range(size_n):\n",
+    "    with meas_with_shape.run() as datasaver:\n",
+    "        for dac1_sweep in np.linspace(-1, 1, size_a): \n",
+    "            dac.ch1(dac1_sweep)\n",
+    "            t = []\n",
+    "            for dac2_sweep in np.linspace(-1, 1, size_b):\n",
+    "                dac.ch2(dac2_sweep)\n",
+    "                t0 = time.perf_counter()\n",
+    "                datasaver.add_result(\n",
+    "                    (dac.ch1, dac.ch1()),\n",
+    "                    (dac.ch2, dac.ch2()),\n",
+    "                    (dmm.v1, dmm.v1()),\n",
+    "                    (dmm.v2, dmm.v2())\n",
+    "                    )\n",
+    "                t1 = time.perf_counter()\n",
+    "                t.append(t1-t0)\n",
+    "                bar.update(1)\n",
+    "            t_b.append(sum(t)/len(t)*1000)\n",
+    "        dataset2 = datasaver.dataset\n",
+    "print(sum(t_b)/len(t_b))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "d20226f4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2021-11-15 18:58:33,123 ¦ py.warnings ¦ WARNING ¦ warnings ¦ _showwarnmsg ¦ 109 ¦ C:\\Users\\A-DAVI~1\\AppData\\Local\\Temp/ipykernel_1704/2863477060.py:3: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
+      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
+      "  bar = tqdm.tqdm_notebook(total=size_a*size_b*size_n)\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "766eb9270a564fa7a8190f5a376dc7c0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100000 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting experimental run with id: 9. \n",
+      "0.1254850570000386\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Measurement with context manager without cache\n",
+    "t_c = []\n",
+    "bar = tqdm.tqdm_notebook(total=size_a*size_b*size_n)\n",
+    "\n",
+    "for _ in range(size_n):\n",
+    "    with meas.run(in_memory_cache=False) as datasaver:\n",
+    "        for dac1_sweep in np.linspace(-1, 1, size_a): \n",
+    "            dac.ch1(dac1_sweep)\n",
+    "            t = []\n",
+    "            for dac2_sweep in np.linspace(-1, 1, size_b):\n",
+    "                dac.ch2(dac2_sweep)\n",
+    "                #bar.update(1)\n",
+    "                t0 = time.perf_counter()\n",
+    "                datasaver.add_result(\n",
+    "                    (dac.ch1, dac.ch1()),\n",
+    "                    (dac.ch2, dac.ch2()),\n",
+    "                    (dmm.v1, dmm.v1()),\n",
+    "                    (dmm.v2, dmm.v2())\n",
+    "                    )\n",
+    "                t1 = time.perf_counter()\n",
+    "                t.append(t1-t0)\n",
+    "                bar.update(1)\n",
+    "            t_c.append(sum(t)/len(t)*1000)\n",
+    "        dataset2 = datasaver.dataset\n",
+    "\n",
+    "print(sum(t_c)/len(t_c))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "0fa5716a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2021-11-15 18:58:48,206 ¦ py.warnings ¦ WARNING ¦ warnings ¦ _showwarnmsg ¦ 109 ¦ C:\\Users\\A-DAVI~1\\AppData\\Local\\Temp/ipykernel_1704/1923311262.py:3: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
+      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
+      "  bar = tqdm.tqdm_notebook(total=size_a*size_b*size_n)\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9117a956f74443488f3874a1b7bcd7b8",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100000 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting experimental run with id: 10. \n",
+      "0.4090112040000139\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Measurement with context manager with cache, dataset in memory.\n",
+    "t_d = []\n",
+    "bar = tqdm.tqdm_notebook(total=size_a*size_b*size_n)\n",
+    "\n",
+    "for _ in range(size_n):\n",
+    "    with meas.run(dataset_class=DataSetType.DataSetInMem) as datasaver:\n",
+    "        for dac1_sweep in np.linspace(-1, 1, size_a): \n",
+    "            dac.ch1(dac1_sweep)\n",
+    "            t = []\n",
+    "            for dac2_sweep in np.linspace(-1, 1, size_b): \n",
+    "                dac.ch2(dac2_sweep)\n",
+    "                #bar.update(1)\n",
+    "                t0 = time.perf_counter()\n",
+    "                datasaver.add_result(\n",
+    "                    (dac.ch1, dac.ch1()),\n",
+    "                    (dac.ch2, dac.ch2()),\n",
+    "                    (dmm.v1, dmm.v1()),\n",
+    "                    (dmm.v2, dmm.v2())\n",
+    "                    )\n",
+    "                t1 = time.perf_counter()\n",
+    "                t.append(t1-t0)\n",
+    "                bar.update(1)\n",
+    "            t_d.append(sum(t)/len(t)*1000)\n",
+    "        dataset2 = datasaver.dataset\n",
+    "print(sum(t_d)/len(t_d))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "5a3111b6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2021-11-15 18:59:32,651 ¦ py.warnings ¦ WARNING ¦ warnings ¦ _showwarnmsg ¦ 109 ¦ C:\\Users\\A-DAVI~1\\AppData\\Local\\Temp/ipykernel_1704/1493501015.py:5: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
+      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
+      "  bar = tqdm.tqdm_notebook(total=size_a*size_b*size_n)\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ec89d70af2f3436990566404d540d812",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100000 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting experimental run with id: 11. \n",
+      "0.17479894299996857\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Measurement with context manager with shaped cache and dataset in memory\n",
+    "meas_with_shape.set_shapes(detect_shape_of_measurement((dmm.v1,dmm.v2), (size_a, size_b)))\n",
+    "\n",
+    "t_e = []\n",
+    "bar = tqdm.tqdm_notebook(total=size_a*size_b*size_n)\n",
+    "\n",
+    "for _ in range(size_n):\n",
+    "    with meas_with_shape.run(dataset_class=DataSetType.DataSetInMem) as datasaver:\n",
+    "        for dac1_sweep in np.linspace(-1, 1, size_a): \n",
+    "            dac.ch1(dac1_sweep)\n",
+    "            t = []\n",
+    "            for dac2_sweep in np.linspace(-1, 1, size_b):\n",
+    "                dac.ch2(dac2_sweep)\n",
+    "                t0 = time.perf_counter()\n",
+    "                datasaver.add_result(\n",
+    "                    (dac.ch1, dac.ch1()),\n",
+    "                    (dac.ch2, dac.ch2()),\n",
+    "                    (dmm.v1, dmm.v1()),\n",
+    "                    (dmm.v2, dmm.v2())\n",
+    "                    )\n",
+    "                t1 = time.perf_counter()\n",
+    "                t.append(t1-t0)\n",
+    "                bar.update(1)\n",
+    "            t_e.append(sum(t)/len(t)*1000)\n",
+    "        dataset2 = datasaver.dataset\n",
+    "print(sum(t_e)/len(t_e))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c9d27965",
+   "metadata": {},
+   "source": [
+    "Testing cache with doNd\n",
+    "------------------------\n",
+    "This section is like those above, but it runs with the doNd function rather than the context manager. This is mostly for comparison of average execution times, see table below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "75b8ccf2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting experimental run with id: 12. Using 'qcodes.utils.dataset.doNd.dond'\n",
+      "0.210344111\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Measurement with doNd, estimated time by total dataset size\n",
+    "#Bar is not included since this may add a slight delay.\n",
+    "sweep_1 = LinSweep(dac.ch1, -1, 1, size_a)\n",
+    "sweep_2 = LinSweep(dac.ch2, -1, 1, size_b)\n",
+    "t_f = []\n",
+    "for _ in range(size_n):\n",
+    "    t0 = time.perf_counter()\n",
+    "    dond(sweep_1, sweep_2, dmm.v1, dmm.v2, exp=testing_exp) \n",
+    "    t1 = time.perf_counter()\n",
+    "    t_f.append(t1-t0)\n",
+    "print(sum(t_f)/len(t_f)/size_a/size_b*1000)   "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7250ac6a",
+   "metadata": {},
+   "source": [
+    "Plots, output, data.\n",
+    "--------------------\n",
+    "This section provides the useful data from the test. Wherein you will find a scatter plot of the rolling average results obtained above, and histograms to show the distribution of the data.\n",
+    "\n",
+    "Note that historgrams are skewed by database writes, so these are not as useful compared to the scatterplot."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "61046b59",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#plotting the measurement context results in a single figure.\n",
+    "import matplotlib.mlab as mlab\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.plot(t_a, '.r', label='Regular cache, disk DB') \n",
+    "plt.plot(t_b, '.b', label='Shaped cache, disk DB')\n",
+    "plt.plot(t_c, '.k', label='No cache, disk DB')\n",
+    "plt.plot(t_d, '.m', label='Regular cache, memory only')\n",
+    "plt.plot(t_e, '.g', label='Shaped cache, memory only')\n",
+    "#plt.ylim(0,0.01)\n",
+    "plt.ylabel('Iter time (s)') \n",
+    "plt.xlabel('Iter #') \n",
+    "plt.legend()\n",
+    "plt.show() "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "5048cbcf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEKCAYAAAD9xUlFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAcbUlEQVR4nO3deXhV9b3v8fdXQBAQGQRKSS7DKUqAEJAU8VpKZLBYuICK1OkyHL1YVFq1tXrP9T72nGtbbbEip5QWq4B1QIvHwvE4VBGOcgQZKqJGi4hYggoRBRVECHzvH3vlxwYzrITsIeHzep79ZK3fWuu3vys7ySdrNndHREQE4IRMFyAiItlDoSAiIoFCQUREAoWCiIgECgUREQkUCiIiEqQ0FMxsi5m9ZmbrzWxt1NbWzJ41s7ejr22idjOzWWa2ycw2mNkZqaxNRES+Kh1bCue4ez93L4zGbwaWunsPYGk0DnAe0CN6TQXmpKE2ERFJkondR2OBBdHwAmBcUvv9nrAKaG1mnTJQn4jIcatxivt34C9m5sDv3X0u0NHdP4imfwh0jIY7A1uTli2J2j5IasPMppLYkqBFixYDevbsmcLyRUQannXr1n3k7u0rmpbqUPiWu28zsw7As2b2VvJEd/coMGKLgmUuQGFhoa9du7buqhUROQ6Y2XuVTUvp7iN33xZ93QE8DgwEtpfvFoq+7ohm3wbkJi2eE7WJiEiapCwUzKyFmZ1cPgycC7wOLAEmRbNNAhZHw0uAidFZSIOA3Um7mUREJA1SufuoI/C4mZW/z0Pu/rSZrQEeNbMrgPeACdH8TwLfBTYBe4EpKaxNREQqkLJQcPfNQEEF7TuBYRW0O3BNquoRqYkDBw5QUlLCvn37Ml2KSK01a9aMnJwcmjRpEnuZVB9oFqmXSkpKOPnkk+natSvR1q5IveLu7Ny5k5KSErp16xZ7Od3mQqQC+/bto127dgoEqbfMjHbt2tV4a1ehIFIJBYLUd7X5GVYoiIhIoGMKIjEst+V12l+RF1U7T6NGjcjPz6esrIxu3brxxz/+kdatW9dtHUVFzJgxg8LCwupnTpGf/vSntGzZkh//+McZq6E+SfVnpi0FkSx10kknsX79el5//XXatm3L7NmzM10SBw8ezHQJ9UJZWVmmS6g1hYJIPXDWWWexbVviAv933nmHkSNHMmDAAAYPHsxbb70V2gcNGkR+fj633HILLVu2BGD58uWMHj069HXttdcyf/78r7zHtGnTKCwspHfv3tx6662hvWvXrtx0002cccYZ/OlPfzpime3bt3P++edTUFBAQUEBL730EgDjxo1jwIAB9O7dm7lz54b5n376ac444wwKCgoYNuzwmenFxcUUFRXRvXt3Zs2aFdofeOABBg4cSL9+/bjqqquqDaWioiKuv/56CgsLycvLY82aNVxwwQX06NGDW265pdp+W7ZsyY033kjv3r0ZPnw4q1evDnUtWbIESJyEMGXKFPLz8+nfvz/Lli0DYP78+YwZM4ahQ4cybNgwJk6cyJ///OfwnpdddhmLFy8mmbtz44030qdPH/Lz83nkkUeAxGdWVFTE+PHj6dmzJ5dddhmJs/YPu++++7juuuvC+D333MP1119f5fcnFnevt68BAwa4SCoUFxcfMb6MZXX6iqNFixbu7l5WVubjx4/3p556yt3dhw4d6hs3bnR391WrVvk555zj7u6jRo3yhx56yN3d58yZE5ZftmyZjxo1KvR7zTXX+Lx589zdfciQIb5mzRp3d9+5c2d4vyFDhvirr77q7u5dunTxO+64o8IaJ0yY4HfddVdYbteuXUf0tXfvXu/du7d/9NFHvmPHDs/JyfHNmzcfMc+tt97qZ511lu/bt89LS0u9bdu2vn//fi8uLvbRo0f7/v373d192rRpvmDBgiq/Z0OGDPGf/OQn7u4+c+ZM79Spk7///vu+b98+79y5s3/00UdV9gv4k08+6e7u48aN8xEjRvj+/ft9/fr1XlBQ4O7uM2bM8ClTpri7+5tvvum5ubn+xRdf+Lx587xz585hvZYvX+5jx451d/ddu3Z5165d/cCBA0fUu2jRIh8+fLiXlZX5hx9+6Lm5uf7+++/7smXLvFWrVr5161Y/ePCgDxo0yF988cUjPrPPPvvMu3fvHtbjrLPO8g0bNnzle3L0z3K0nmu9kr+rOqYgkqW++OIL+vXrx7Zt28jLy2PEiBF8/vnnvPTSS1x00UVhvi+//BKAlStXhv9ML7300hrvo3/00UeZO3cuZWVlfPDBBxQXF9O3b18Avve971W4zPPPP8/9998PJI6BnHLKKQDMmjWLxx9/HICtW7fy9ttvU1payre//e1wznzbtm1DP6NGjaJp06Y0bdqUDh06sH37dpYuXcq6dev45je/Gb4fHTp0qHY9xowZA0B+fj69e/emU6fEHfi7d+/O1q1bWbFiRaX9nnjiiYwcOTIs37RpU5o0aUJ+fj5btmwBYMWKFUyfPh2Anj170qVLFzZu3AjAiBEjwnoNGTKEq6++mtLSUh577DEuvPBCGjc+8k/uihUruOSSS2jUqBEdO3ZkyJAhrFmzhlatWjFw4EBycnIA6NevH1u2bOFb3/pWWLZly5YMHTqUJ554gry8PA4cOEB+fn6135/qKBREslT5MYW9e/fyne98h9mzZzN58mRat27N+vXrY/fTuHFjDh06FMYrOm/93XffZcaMGaxZs4Y2bdowefLkI+Zr0aJF7Pdbvnw5zz33HCtXrqR58+YUFRVVe65806ZNw3CjRo0oKyvD3Zk0aRK/+MUvYr93cl8nnHDCEf2ecMIJ1fbbpEmTcBpn8vLly1bn6O/TxIkTeeCBB1i4cCHz5s2r1XrA4e/J0a688kp+/vOf07NnT6ZMqZs7A+mYgkiWa968ObNmzeLOO++kefPmdOvWLezbd3deffVVAAYNGsRjjz0GwMKFC8PyXbp0obi4mC+//JJdu3axdOnSr7zHp59+SosWLTjllFPYvn07Tz31VKzahg0bxpw5iYckHjx4kN27d7N7927atGlD8+bNeeutt1i1alWo74UXXuDdd98F4OOPP66270WLFrFjx44w/3vvJe74PHHiRFavXh2rxpr0G8fgwYN58MEHAdi4cSN///vfOf300yucd/LkycycOROAXr16VdjXI488wsGDByktLeWFF15g4MCBsWs588wz2bp1Kw899BCXXHJJ7OWqoi0FkRjinEKaSv3796dv3748/PDDPPjgg0ybNo3bbruNAwcOcPHFF1NQUMDMmTO5/PLL+dnPfsbIkSPDrpzc3FwmTJhAnz596NatG/379/9K/wUFBfTv35+ePXuSm5vL2WefHauuu+++m6lTp3LvvffSqFEj5syZw8iRI/nd735HXl4ep59+OoMGDQKgffv2zJ07lwsuuIBDhw7RoUMHnn322Ur77tWrF7fddhvnnnsuhw4dokmTJsyePZsuXbqwYcMGvv71r9fiO1l1v3FcffXVTJs2jfz8fBo3bsz8+fOP+K8+WceOHcnLy2PcuHEVTj///PNZuXIlBQUFmBm//OUv+drXvhZOHohjwoQJrF+/njZt2sRepkqVHWyoDy8daJZUqejgXLbbs2ePHzp0yN3dH374YR8zZkyGK0qN3bt3+/jx4zNdRix79uzx7t27hwPwqTBq1Ch/7rnnKp1e0wPN2n0k0kCsW7eOfv360bdvX377299y5513ZrqklGjVqtVXTo3NRs899xx5eXlMnz49bLXVpV27dnHaaadx0kknHXF677HS7iORBmLw4MHh+IJk3vDhw2t0rKKmWrduHc56qkvaUhCphHuNHh8uknVq8zOsUBCpQLNmzdi5c6eCQeotj56n0KxZsxotp91HIhXIycmhpKSE0tLSTJciUmvlT16rCYWCSAWaNGlSo6dViTQU2n0kIiKBQkFERAKFgoiIBAoFEREJFAoiIhIoFEREJFAoiIhIoFAQEZFAoSAiIoFCQUREAoWCiIgECgUREQkUCiIiEigUREQkUCiIiEigUBARkSDloWBmjczsFTN7IhrvZmYvm9kmM3vEzE6M2ptG45ui6V1TXZuIiBwpHVsKPwTeTBq/A7jL3b8BfAJcEbVfAXwStd8VzSciImmU0lAwsxxgFPCHaNyAocCiaJYFwLhoeGw0TjR9WDS/iIikSaq3FGYCPwEORePtgF3uXhaNlwCdo+HOwFaAaPruaP4jmNlUM1trZmv1UHURkbqVslAws9HADndfV5f9uvtcdy9098L27dvXZdciIse9xins+2xgjJl9F2gGtALuBlqbWeNoayAH2BbNvw3IBUrMrDFwCrAzhfWJiMhRUral4O7/291z3L0rcDHwvLtfBiwDxkezTQIWR8NLonGi6c+7u6eqPhER+apMXKdwE3CDmW0icczg3qj9XqBd1H4DcHMGahMROa6lcvdR4O7LgeXR8GZgYAXz7AMuSkc9IiJSMV3RLCIigUJBREQChYKIiAQKBRERCRQKIiISKBRERCRQKIiISKBQEBGRQKEgIiKBQkFERAKFgoiIBAoFEREJFAoiIhIoFEREJFAoiIhIoFAQEZFAoSAiIoFCQUREAoWCiIgECgUREQkUCiIiEigUREQkUCiIiEigUBARkUChICIigUJBREQChYKIiAQKBRERCRQKIiISKBRERCRQKIiISKBQEBGRQKEgIiKBQkFERIKUhYKZNTOz1Wb2qpm9YWb/HLV3M7OXzWyTmT1iZidG7U2j8U3R9K6pqk1ERCqWyi2FL4Gh7l4A9ANGmtkg4A7gLnf/BvAJcEU0/xXAJ1H7XdF8IiKSRo3jzGRmTYELga7Jy7j7v1S2jLs78Hk02iR6OTAUuDRqXwD8FJgDjI2GARYBvzEzi/oREZE0iLulsJjEH+0yYE/Sq0pm1sjM1gM7gGeBd4Bd7l4WzVICdI6GOwNbAaLpu4F2FfQ51czWmtna0tLSmOWLiEgcsbYUgBx3H1nTzt39INDPzFoDjwM9a9pHBX3OBeYCFBYWaitCRKQOxd1SeMnM8mv7Ju6+C1gGnAW0NrPyMMoBtkXD24BcgGj6KcDO2r6niIjUXNxQ+Bawzsz+ZmYbzOw1M9tQ1QJm1j7aQsDMTgJGAG+SCIfx0WyTSOyaAlgSjRNNf17HE0RE0ivu7qPzatF3J2CBmTUiET6PuvsTZlYMLDSz24BXgHuj+e8F/mhmm4CPgYtr8Z4iInIMYoWCu79nZgXA4KjpRXd/tZplNgD9K2jfDAysoH0fcFGcekREJDVi7T4ysx8CDwIdotcDZjY9lYWJiEj6xd19dAVwprvvATCzO4CVwL+mqjAREUm/uAeaDTiYNH4wahMRkQYk7pbCPOBlM3s8Gh/H4QPEIiLSQMQ90PxrM1tO4tRUgCnu/krKqhIRkYyoMhTMrJW7f2pmbYEt0at8Wlt3/zi15YmISDpVt6XwEDAaWEfiZnblLBrvnqK6REQkA6oMBXcfHX3tlp5yREQkk+Jep7A0TpuIiNRv1R1TaAY0B041szYcPg21FYdveS0iIg1EdccUrgKuA75O4rhCeSh8CvwmdWWJiEgmVHdM4W7gbjOb7u66ellEpIGLe53Cv5pZH6AX0Cyp/f5UFSYiIukX9xnNtwJFJELhSRK30l4BKBRERBqQuPc+Gg8MAz509ylAAYkno4mISAMSNxS+cPdDQJmZtQJ2ED06U0REGo64N8RbGz1a8x4SZyF9TuLW2SIi0oDEPdB8dTT4OzN7GmgVPVlNREQakOouXjujqmnu/te6L0lERDKlui2FO6uY5sDQOqxFREQyrLqL185JVyEiIpJ5ca9TmFhRuy5eExFpWOKeffTNpOFmJK5Z+Cu6eE1EpEGJe/bR9OTx6PTUhakoSEREMifuxWtH2wPowTsiIg1M3GMK/87hx3E2AvKAR1NVlIiIZEbcYwozkobLgPfcvSQF9YiISAbF2n3k7v8J/I3ETfDakggGERFpYOI+o/lKYDVwAYk7pq4ys39MZWEiIpJ+cXcf3Qj0d/edAGbWDngJuC9VhYmISPrFPftoJ/BZ0vhnUZuIiDQgcbcUNgEvm9liEmchjQU2mNkNAO7+6xTVJyIiaRQ3FN6JXuUWR19PrttyREQkk+Je0fzPAGbWMhr/PJVFiYhIZsQ9+6iPmb0CvAG8YWbrzKx3aksTEZF0i3ugeS5wg7t3cfcuwI9IPJqzUmaWa2bLzKzYzN4wsx9G7W3N7Fkzezv62iZqNzObZWabzGxDVQ/4ERGR1IgbCi3cfVn5iLsvB1pUs0wZ8CN37wUMAq4xs17AzcBSd+8BLI3GAc4DekSvqcCcuCshIiJ1I24obDaz/2tmXaPXLcDmqhZw9w/KH9fp7p8BbwKdSZy5tCCabQEwLhoeC9zvCauA1mbWqWarIyIixyJuKPwj0B74N+Ax4NSoLRYz6wr0B14GOrr7B9GkD4GO0XBnYGvSYiVR29F9TTWztWa2trS0NG4JIiISQ5VnH5lZM+D7wDeA10jsDjpQkzeIzlh6DLjO3T81szDN3d3MvNKFK+Duc0kc46CwsLBGy4qISNWq21JYABSSCITzgF/VpHMza0IiEB5093+LmreX7xaKvu6I2rcBuUmL50RtIiKSJtWFQi93v9zdf0/iRnjfjtuxJTYJ7gXePOqK5yXApGh4EocvhFsCTIzOQhoE7E7azSQiImlQ3cVrYVeRu5cl7/qJ4WzgfwKvmdn6qO2fgNuBR83sCuA9YEI07UnguyRuqbEXmFKTNxMRkWNXXSgUmNmn0bABJ0XjRuKQQKvKFnT3FdF8FRlWwfwOXFN9ySIikipVhoK7N0pXISIiknlxT0kVEZHjgEJBREQChYKIiAQKBRERCRQKIiISKBRERCRQKIiISKBQEBGRQKEgIiKBQkFERAKFgoiIBAoFEREJFAoiIhIoFEREJFAoiIhIoFAQEZFAoSAiIoFCQUREAoWCiIgECgUREQkUCiIiEigUREQkUCiIiEigUBARkUChICIigUJBREQChYKIiAQKBRERCRQKIiISKBRERCRQKIiISKBQEBGRQKEgIiJBykLBzO4zsx1m9npSW1sze9bM3o6+tonazcxmmdkmM9tgZmekqi4REalcKrcU5gMjj2q7GVjq7j2ApdE4wHlAj+g1FZiTwrpERKQSKQsFd38B+Pio5rHAgmh4ATAuqf1+T1gFtDazTqmqTUREKpbuYwod3f2DaPhDoGM03BnYmjRfSdT2FWY21czWmtna0tLS1FUqInIcytiBZnd3wGux3Fx3L3T3wvbt26egMhGR41e6Q2F7+W6h6OuOqH0bkJs0X07UJiIiaZTuUFgCTIqGJwGLk9onRmchDQJ2J+1mEhGRNGmcqo7N7GGgCDjVzEqAW4HbgUfN7ArgPWBCNPuTwHeBTcBeYEqq6hIRkcqlLBTc/ZJKJg2rYF4HrklVLSIiEo+uaBYRkUChICIigUJBREQChYKIiAQKBRERCRQKIiISKBRERCRQKIiISKBQEBGRQKEgIiKBQkFERAKFgoiIBAoFEREJFAoiIhIoFEREJFAoiIhIoFAQEZFAoSAiIoFCQUREAoWCiIgECgUREQkUCiIiEigUREQkUCiIiEigUBARkUChICIigUJBREQChYKIiASNM11AfbHcllc6rciL6qSvmvYjIlLXFAopVFWQiIhkI4VCHdAffxFpKBQK9VhNd0M15N1WWjeRuqFQyCIN+Ze/vq9bfa+/No7HdRaFQr2Q6t1TdbXFkQ41fe9Mfe9qI9UnLDSEP/I1/X7Xp3XLFgqFo+j4QHbQ55C96tM/EZVpCAGZKubuma4hMLORwN1AI+AP7n57VfMXFhb62rVra/Ve2fiDKiLZqaGFhZmtc/fCiqZlzZaCmTUCZgMjgBJgjZktcffizFYmIse742nLImtCARgIbHL3zQBmthAYCygURCQrpeO4TroDKZtCoTOwNWm8BDjz6JnMbCowNRr93Mz+lobaKnIq8FGG3ruuaV2yk9YlO1W/LlbDHms6f22XOaxLZROyKRRicfe5wNxM12FmayvbJ1ffaF2yk9YlOzWkdalINt0QbxuQmzSeE7WJiEiaZFMorAF6mFk3MzsRuBhYkuGaRESOK1mz+8jdy8zsWuAZEqek3ufub2S4rKpkfBdWHdK6ZCetS3ZqSOvyFVl1nYKIiGRWNu0+EhGRDFMoiIhIoFCogpmNNLO/mdkmM7u5guk3mFmxmW0ws6VmVum5v5kWY12+b2avmdl6M1thZr0yUWdc1a1P0nwXmpmbWdaeQhjjs5lsZqXRZ7PezK7MRJ1xxPlczGxC9Hvzhpk9lO4a44rxudyV9JlsNLNdGSiz7rm7XhW8SBzsfgfoDpwIvAr0Omqec4Dm0fA04JFM130M69IqaXgM8HSm6z6W9YnmOxl4AVgFFGa67mP4bCYDv8l0rXW0Lj2AV4A20XiHTNd9LD9jSfNPJ3FyTMZrP9aXthQqF2674e77gfLbbgTuvszd90ajq0hcW5GN4qzLp0mjLYBsPgOh2vWJ/D/gDmBfOourobjrUh/EWZf/Bcx2908A3H1HmmuMq6afyyXAw2mpLMUUCpWr6LYbnauY/wrgqZRWVHux1sXMrjGzd4BfAj9IU221Ue36mNkZQK67/0c6C6uFuD9nF0a7KReZWW4F07NBnHU5DTjNzP7LzFZFd0bORrF//6Pdxt2A59NQV8opFOqAmV0OFAK/ynQtx8LdZ7v7PwA3Abdkup7aMrMTgF8DP8p0LXXk34Gu7t4XeBZYkOF6jkVjEruQikj8d32PmbXOZEF14GJgkbsfzHQhdUGhULlYt90ws+HA/wHGuPuXaaqtpmp6C5GFwLhUFnSMqlufk4E+wHIz2wIMApZk6cHmaj8bd9+Z9LP1B2BAmmqrqTg/ZyXAEnc/4O7vAhtJhES2qcnvzMU0kF1HgA40V/Yi8R/NZhKbheUHmnofNU9/EgejemS63jpYlx5Jw/8DWJvpuo9lfY6afznZe6A5zmfTKWn4fGBVpus+hnUZCSyIhk8lsYumXaZrr+3PGNAT2EJ0IXBDeGXNbS6yjVdy2w0z+xcSfzCXkNhd1BL4k5kB/N3dx2Ss6ErEXJdro62eA8AnwKTMVVy1mOtTL8Rclx+Y2RigDPiYxNlIWSfmujwDnGtmxcBB4EZ335m5qitWg5+xi4GFHiVEQ6DbXIiISKBjCiIiEigUREQkUCiIiEigUBARkUChICIigUJBBDCzz6OvXc3s0jro75+OGn/pWPsUSQeFgsiRugI1CgUzq+h6nyNCwd3/+zHUJJI2CgWRI90ODI7ukX+9mTUys1+Z2ZrohnRXAZhZkZm9aGZLgOLkDszsduCkqI8Ho7bPk5b7TzNbbGabzex2M7vMzFZHz7P4h2i+9mb2WPS+a8zs7LR+F+S4pYvXREj80Xb3lmZWBPzY3UdH7VNJ3PP/NjNrCvwXcBHQBfgPoI8n7uFTYX+V9P9nII/E1cmbgT+4+61m9kOgm7tfFz185rfuvsLM/hvwjLvnpWr9RcrpNhciVTsX6Gtm46PxU0jcwG0/sLqiQIhhjbt/ABDdqvwvUftrJB7cBDAc6BXdPgWglZm1dPfPa/F+IrEpFESqZsB0d3/miMbEf/x7atln8t10DyWNH+Lw7+QJwCB3z+YHBEkDpGMKIkf6jMStt8s9A0wzsyYAZnaambWI0c+B8mVq6S8kHvFI9L79jqEvkdgUCiJH2gAcNLNXzex6Es8vKAb+amavA78n3hb2XGBD+YHmWvgBUBgd3C4Gvl/LfkRqRAeaRUQk0JaCiIgECgUREQkUCiIiEigUREQkUCiIiEigUBARkUChICIiwf8HKanYqFhZ1lwAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#plotting the measurement context results as a histogram.\n",
+    "import matplotlib.mlab as mlab\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.hist(t_a, 50, facecolor= 'r', label='Regular cache, disk DB') \n",
+    "plt.ylabel('Population')\n",
+    "plt.ylim(0, size_a)\n",
+    "plt.xlabel('Iter time') \n",
+    "plt.legend()\n",
+    "plt.show() \n",
+    "plt.hist(t_b, 50, facecolor= 'b', label='Shaped cache, disk DB')\n",
+    "plt.ylabel('Population')\n",
+    "plt.ylim(0, size_a)\n",
+    "plt.xlabel('Iter time') \n",
+    "plt.legend()\n",
+    "plt.show() \n",
+    "plt.hist(t_c, 50, facecolor= 'k', label='No cache, disk DB')\n",
+    "plt.ylabel('Population')\n",
+    "plt.ylim(0, size_a)\n",
+    "plt.xlabel('Iter time') \n",
+    "plt.legend()\n",
+    "plt.show() \n",
+    "plt.hist(t_d, 50, facecolor= 'm', label='Regular cache, memory only')\n",
+    "plt.ylabel('Population')\n",
+    "plt.ylim(0, size_a)\n",
+    "plt.xlabel('Iter time') \n",
+    "plt.legend()\n",
+    "plt.show() \n",
+    "plt.hist(t_e, 50, facecolor= 'g', label='Shaped cache, memory only')\n",
+    "plt.ylabel('Population')\n",
+    "plt.ylim(0, size_a)\n",
+    "plt.xlabel('Iter time') \n",
+    "plt.legend()\n",
+    "plt.show() "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a2df18b1",
+   "metadata": {},
+   "source": [
+    "Tabulated data of total execution times\n",
+    "---------------------------------------\n",
+    "Here are some details which show the total time spent for each execution. It is clear that the dynamic cache is slower with larger data sets.\n",
+    "\n",
+    "Reference:\n",
+    "1 - Measurement with context manager with cache                              \n",
+    "2 - Measurement with context manager with shaped cache                       \n",
+    "3 - Measurement with context manager without cache                           \n",
+    "4 - Measurement with context manager with cache, dataset in memory.          \n",
+    "5 - Measurement with context manager with shaped cache and dataset in memory.\n",
+    "6 - Measurement with doNd, iteration time estimated from total execution\n",
+    "7 - Measurement with doNd (nocache) iteration time estimated from total execution\n",
+    "\n",
+    "Timed function: add_result() (exp 1-5), DoNd() (exp 6-7).\n",
+    "\n",
+    "|n(iter)|exp_1|exp_2|exp_3|exp_4|exp_5|exp_6|exp_7|\n",
+    "|-------|-----|-----|-----|-----|-----|-----|-----|\n",
+    "|1      |0.934|0.879|0.321|0.377|0.473|60.51|57.48|\n",
+    "|2      |0.413|0.478|0.256|0.496|0.471|45.12|29.89|\n",
+    "|5      |0.418|0.291|0.295|0.324|0.488|16.85|12.11|\n",
+    "|10     |0.452|0.324|0.283|0.491|0.363|7.071|7.071|\n",
+    "|50     |0.311|0.527|0.309|0.322|0.341|2.442|1.532|\n",
+    "|100    |0.288|0.326|0.127|0.317|0.346|1.457|0.753|\n",
+    "|1000   |0.257|0.217|0.125|0.209|0.214|0.319|0.269|\n",
+    "|10000  |0.289|0.267|0.141|0.227|0.219|0.238|0.238|\n",
+    "|20000  |0.287|0.252|0.126|0.262|0.217|0.247|0.227|\n",
+    "|50000  |0.342|0.305|0.142|0.297|0.230|0.234|0.234|\n",
+    "|100000 |0.591|0.251|0.180|0.589|0.293|0.253|0.228|\n",
+    "|200000 |2.042|0.257|0.180|1.863|0.203|0.268|0.229|\n"
+   ]
+  }
+ ],
+ "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.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}