doc/source/examples/04PulseStorage.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Storing Pulse Templates: `PulseStorage` and Serialization\n",
    "\n",
    "So far, we have constructed new pulse templates in code for each session (which were discarded afterwards). We now want to store them persistently in the file system to be able to reuse them in later sessions. For this, qupulse offers us serialization and deserialization using the `PulseStorage` and `StorageBackend` classes.\n",
    "\n",
    "The pulse storage manages the (de-)serialization to JSON and requires a storage backend to persistently store the serialized data. This can for example be a `FilesystemBackend` or a `DictBackend`. Let us first use a `DictBackend` to inspect the serialized pulse.\n",
    "\n",
    "__Attention:__ Due to the fact that PulseStorage enforces unique identifiers, executing the cells in this notebook out of order or rerunning them will likely result in errors. You will have to restart the Kernel in that case.\n",
    "\n",
    "## Single Pulses\n",
    "First we will have a look at how to store pulses that do not contain other pulse templates. To store a pulse, __the pulse needs to have an identifier__. If you forgot to give the pulse an identifier one can use the `rename` method which returns a new pulse with the requested identifier.\n",
    "\n",
    "### Storing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'my_pulse': '{\\n'\n",
      "             '    \"#identifier\": \"my_pulse\",\\n'\n",
      "             '    \"#type\": '\n",
      "             '\"qupulse.pulses.table_pulse_template.TablePulseTemplate\",\\n'\n",
      "             '    \"entries\": {\\n'\n",
      "             '        \"default\": [\\n'\n",
      "             '            [\\n'\n",
      "             '                \"t_begin\",\\n'\n",
      "             '                \"v_begin\",\\n'\n",
      "             '                \"hold\"\\n'\n",
      "             '            ],\\n'\n",
      "             '            [\\n'\n",
      "             '                \"t_end\",\\n'\n",
      "             '                \"v_end\",\\n'\n",
      "             '                \"linear\"\\n'\n",
      "             '            ]\\n'\n",
      "             '        ]\\n'\n",
      "             '    },\\n'\n",
      "             '    \"measurements\": [],\\n'\n",
      "             '    \"parameter_constraints\": []\\n'\n",
      "             '}'}\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "from qupulse.pulses import TablePT\n",
    "from qupulse.serialization import PulseStorage, DictBackend\n",
    "\n",
    "dict_backend = DictBackend()\n",
    "dict_pulse_storage = PulseStorage(dict_backend)\n",
    "\n",
    "table_pulse = TablePT({'default': [('t_begin', 'v_begin', 'hold'),\n",
    "                                   ('t_end', 'v_end', 'linear')]}, identifier='my_pulse')\n",
    "\n",
    "dict_pulse_storage['my_pulse'] = table_pulse\n",
    "\n",
    "pprint.pprint(dict_backend.storage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now to store this in a file system we need to replace the `DictBackend` with a `FilesystemBackend`. The following code will create the file `'./serialized_pulses/my_pulse.json'`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qupulse.serialization import FilesystemBackend\n",
    "\n",
    "filesystem_backend = FilesystemBackend('./serialized_pulses')\n",
    "file_pulse_storage = PulseStorage(filesystem_backend)\n",
    "\n",
    "if 'my_pulse' in file_pulse_storage:\n",
    "    del file_pulse_storage['my_pulse']\n",
    "\n",
    "file_pulse_storage['my_pulse'] = table_pulse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading\n",
    "Now we will load a pulse that is shipped only as a JSON file. It is a single sine with frequency `omega`. Note that loading the same pulse multiple times will give you the same object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading the same pulse multiple times gives you the same object\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import math\n",
    "from qupulse.pulses.plotting import plot as plot\n",
    "\n",
    "sine = file_pulse_storage['my_other_pulse']\n",
    "\n",
    "_ = plot(sine, {'omega': 2*math.pi}, sample_rate=1000, show=False)\n",
    "\n",
    "if sine is file_pulse_storage['my_other_pulse']:\n",
    "    print('Loading the same pulse multiple times gives you the same object')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Composed pulses and the role of identifiers\n",
    "If we have a pulse that contains other pulses all pulses that have an identifier are stored seperatly. Each `PulseStorage` instance expects that identifiers are unique (see below). Anonymous subpulses are stored together with their parent.\n",
    "\n",
    "We will now only use a dictionary as a backend it is easier to see what happens.\n",
    "\n",
    "### Storing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'combined': '{\\n'\n",
      "             '    \"#identifier\": \"combined\",\\n'\n",
      "             '    \"#type\": '\n",
      "             '\"qupulse.pulses.sequence_pulse_template.SequencePulseTemplate\",\\n'\n",
      "             '    \"subtemplates\": [\\n'\n",
      "             '        {\\n'\n",
      "             '            \"#type\": '\n",
      "             '\"qupulse.pulses.repetition_pulse_template.RepetitionPulseTemplate\",\\n'\n",
      "             '            \"body\": {\\n'\n",
      "             '                \"#identifier\": \"my_other_pulse\",\\n'\n",
      "             '                \"#type\": \"reference\"\\n'\n",
      "             '            },\\n'\n",
      "             '            \"repetition_count\": \"N_sine\"\\n'\n",
      "             '        },\\n'\n",
      "             '        {\\n'\n",
      "             '            \"#identifier\": \"my_pulse\",\\n'\n",
      "             '            \"#type\": \"reference\"\\n'\n",
      "             '        }\\n'\n",
      "             '    ]\\n'\n",
      "             '}',\n",
      " 'my_other_pulse': '{\\n'\n",
      "                   '    \"#identifier\": \"my_other_pulse\",\\n'\n",
      "                   '    \"#type\": '\n",
      "                   '\"qupulse.pulses.function_pulse_template.FunctionPulseTemplate\",\\n'\n",
      "                   '    \"channel\": \"default\",\\n'\n",
      "                   '    \"duration_expression\": \"2*pi/omega\",\\n'\n",
      "                   '    \"expression\": \"sin(omega*t)\",\\n'\n",
      "                   '    \"measurements\": [],\\n'\n",
      "                   '    \"parameter_constraints\": []\\n'\n",
      "                   '}',\n",
      " 'my_pulse': '{\\n'\n",
      "             '    \"#identifier\": \"my_pulse\",\\n'\n",
      "             '    \"#type\": '\n",
      "             '\"qupulse.pulses.table_pulse_template.TablePulseTemplate\",\\n'\n",
      "             '    \"entries\": {\\n'\n",
      "             '        \"default\": [\\n'\n",
      "             '            [\\n'\n",
      "             '                \"t_begin\",\\n'\n",
      "             '                \"v_begin\",\\n'\n",
      "             '                \"hold\"\\n'\n",
      "             '            ],\\n'\n",
      "             '            [\\n'\n",
      "             '                \"t_end\",\\n'\n",
      "             '                \"v_end\",\\n'\n",
      "             '                \"linear\"\\n'\n",
      "             '            ]\\n'\n",
      "             '        ]\\n'\n",
      "             '    },\\n'\n",
      "             '    \"measurements\": [],\\n'\n",
      "             '    \"parameter_constraints\": []\\n'\n",
      "             '}'}\n"
     ]
    }
   ],
   "source": [
    "from qupulse.pulses import RepetitionPT, SequencePT\n",
    "\n",
    "# anonymous pulse template\n",
    "repeated_sine = RepetitionPT(sine, 'N_sine')\n",
    "\n",
    "my_sequence = SequencePT(repeated_sine, table_pulse, identifier='combined')\n",
    "\n",
    "dict_pulse_storage['combined'] = my_sequence\n",
    "\n",
    "pprint.pprint(dict_backend.storage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you see, the serialization of 'combined' explicitly contains the anonymous `RepetitionPulseTemplate` but references to 'my_pulse' and 'my_other_pulse' which are stored as separate entries.\n",
    "\n",
    "## Pulse registry and unique identifiers\n",
    "There is the possibility to store pulse templates on construction into a pulse registry. This can be a `PulseStorage`. To set a pulse storage as the default pulse registry call `set_to_default_registry`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'combined': '{\\n'\n",
      "             '    \"#identifier\": \"combined\",\\n'\n",
      "             '    \"#type\": '\n",
      "             '\"qupulse.pulses.sequence_pulse_template.SequencePulseTemplate\",\\n'\n",
      "             '    \"subtemplates\": [\\n'\n",
      "             '        {\\n'\n",
      "             '            \"#type\": '\n",
      "             '\"qupulse.pulses.repetition_pulse_template.RepetitionPulseTemplate\",\\n'\n",
      "             '            \"body\": {\\n'\n",
      "             '                \"#identifier\": \"my_other_pulse\",\\n'\n",
      "             '                \"#type\": \"reference\"\\n'\n",
      "             '            },\\n'\n",
      "             '            \"repetition_count\": \"N_sine\"\\n'\n",
      "             '        },\\n'\n",
      "             '        {\\n'\n",
      "             '            \"#identifier\": \"my_pulse\",\\n'\n",
      "             '            \"#type\": \"reference\"\\n'\n",
      "             '        }\\n'\n",
      "             '    ]\\n'\n",
      "             '}',\n",
      " 'my_other_pulse': '{\\n'\n",
      "                   '    \"#identifier\": \"my_other_pulse\",\\n'\n",
      "                   '    \"#type\": '\n",
      "                   '\"qupulse.pulses.function_pulse_template.FunctionPulseTemplate\",\\n'\n",
      "                   '    \"channel\": \"default\",\\n'\n",
      "                   '    \"duration_expression\": \"2*pi/omega\",\\n'\n",
      "                   '    \"expression\": \"sin(omega*t)\",\\n'\n",
      "                   '    \"measurements\": [],\\n'\n",
      "                   '    \"parameter_constraints\": []\\n'\n",
      "                   '}',\n",
      " 'my_pulse': '{\\n'\n",
      "             '    \"#identifier\": \"my_pulse\",\\n'\n",
      "             '    \"#type\": '\n",
      "             '\"qupulse.pulses.table_pulse_template.TablePulseTemplate\",\\n'\n",
      "             '    \"entries\": {\\n'\n",
      "             '        \"default\": [\\n'\n",
      "             '            [\\n'\n",
      "             '                \"t_begin\",\\n'\n",
      "             '                \"v_begin\",\\n'\n",
      "             '                \"hold\"\\n'\n",
      "             '            ],\\n'\n",
      "             '            [\\n'\n",
      "             '                \"t_end\",\\n'\n",
      "             '                \"v_end\",\\n'\n",
      "             '                \"linear\"\\n'\n",
      "             '            ]\\n'\n",
      "             '        ]\\n'\n",
      "             '    },\\n'\n",
      "             '    \"measurements\": [],\\n'\n",
      "             '    \"parameter_constraints\": []\\n'\n",
      "             '}',\n",
      " 'new_pulse': '{\\n'\n",
      "              '    \"#identifier\": \"new_pulse\",\\n'\n",
      "              '    \"#type\": '\n",
      "              '\"qupulse.pulses.function_pulse_template.FunctionPulseTemplate\",\\n'\n",
      "              '    \"channel\": \"default\",\\n'\n",
      "              '    \"duration_expression\": 1,\\n'\n",
      "              '    \"expression\": 0,\\n'\n",
      "              '    \"measurements\": [],\\n'\n",
      "              '    \"parameter_constraints\": []\\n'\n",
      "              '}'}\n"
     ]
    }
   ],
   "source": [
    "from qupulse.pulses import FunctionPT\n",
    "\n",
    "dict_pulse_storage.set_to_default_registry()\n",
    "\n",
    "new_pulse = FunctionPT(0, 1, identifier='new_pulse')\n",
    "\n",
    "pprint.pprint(dict_backend.storage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you see each newly created pulse is put into the pulse storage. Creating a new pulse with the same name will fail:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Oh No!!!\n",
      "('Pulse with name already exists', 'new_pulse')\n",
      "\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    new_pulse = FunctionPT(0, 1, identifier='new_pulse')\n",
    "except RuntimeError as err:\n",
    "    print('Oh No!!!')\n",
    "    print(err)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have to either explicitly overwrite the registry or delete the old pulse from it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting the registry works!\n",
      "Deleting the pulse works, too!\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    new_pulse = FunctionPT(0, 1, identifier='new_pulse', registry=dict())\n",
    "except:\n",
    "    raise\n",
    "else:\n",
    "    print('Overwriting the registry works!')\n",
    "\n",
    "del dict_pulse_storage['new_pulse']\n",
    "try:\n",
    "    new_pulse = FunctionPT(0, 1, identifier='new_pulse')\n",
    "except:\n",
    "    raise\n",
    "else:\n",
    "    print('Deleting the pulse works, too!')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}