doc/source/examples/03FreeInductionDecayExample.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Free Induction Decay - A Real Use Case\n",
    "\n",
    "The following will give an example of a complex pulse using many of the features discussed in the previous tutorial examles: We will use two channels, parameters and parameter constraints, parameterized measurements and atomic and non-atomic pulse templates. This is based on real experiments. To see another, a bit more artificial example for a pulse setup use case that offers more verbose explanations, see [Gate Configuration - A Full Use Case](03GateConfigurationExample.ipynb).\n",
    "\n",
    "We start by creating some atomic pulse templates using `PointPT` which will be the building blocks for the more complex pulse structure we have in mind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qupulse.pulses import PointPT, SequencePT, ForLoopPT, RepetitionPT, MappingPT\n",
    "import qupulse.pulses.plotting\n",
    "import numpy as np\n",
    "import sympy as sp\n",
    "from sympy import sympify as S\n",
    "\n",
    "channel_names = ['RFX', 'RFY']\n",
    "\n",
    "S_init = PointPT([(0,        'S_init'),\n",
    "                  ('t_init', 'S_init')],\n",
    "                 channel_names=channel_names, identifier='S_init')\n",
    "\n",
    "meas_wait = PointPT([(0,             'meas'),\n",
    "                     ('t_meas_wait', 'meas')],\n",
    "                   channel_names=channel_names)\n",
    "\n",
    "adprep = PointPT([(0,           'meas'),\n",
    "                  ('t_ST_prep', 'ST_plus - ST_jump/2', 'linear'),\n",
    "                  ('t_ST_prep', 'ST_plus + ST_jump/2'),\n",
    "                  ('t_op',      'op', 'linear')],\n",
    "                 parameter_constraints=['Abs(ST_plus - ST_jump/2 - meas) <= Abs(ST_plus - meas)',\n",
    "                                        'Abs(ST_plus - ST_jump/2 - meas)/t_ST_prep <= max_ramp_speed',\n",
    "                                        'Abs(ST_plus + ST_jump/2 - op)/Abs(t_ST_prep-t_op) <= max_ramp_speed'],\n",
    "                 channel_names=channel_names, identifier='adprep')\n",
    "\n",
    "adread = PointPT([(0,           'op'),\n",
    "                  ('t_ST_read', 'ST_plus + ST_jump/2', 'linear'),\n",
    "                  ('t_ST_read', 'ST_plus - ST_jump/2'),\n",
    "                  ('t_meas_start',      'meas', 'linear'),\n",
    "                  ('t_meas_start + t_meas_duration', 'meas')],\n",
    "                 parameter_constraints=['Abs(ST_plus - ST_jump/2 - meas) <= Abs(ST_plus - meas)',\n",
    "                                        'Abs(ST_plus - ST_jump/2 - meas)/t_ST_read <= max_ramp_speed',\n",
    "                                        'Abs(ST_plus + ST_jump/2 - op)/Abs(t_ST_read-t_op) <= max_ramp_speed'],\n",
    "                 channel_names=channel_names, identifier='adread',\n",
    "                 measurements=[('m', 't_meas_start', 't_meas_duration')])\n",
    "\n",
    "free_induction = PointPT([(0, 'op-eps_J'),\n",
    "                          ('t_fid', 'op-eps_J')], channel_names=channel_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next step, we combine our building blocks into more complex pulses step by step.\n",
    "We first define our core functionality pulse template `stepped_free_induction`.\n",
    "The pulse template `pulse` surrounds our functionality with pulses to reset/initialize our qubit and allow for data acquisition.\n",
    "We will use `pulse` in a `ForLoopPT` `looped_pulse` to perform a parameter sweep. Our final pulse template `experiment` repeats  this whole thing a number of times to allow for statistical aggregating of measurement data and represents the complete pulse template for our experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "stepped_free_induction = MappingPT(free_induction, parameter_mapping={'t_fid': 't_start + i_fid*t_step'}, allow_partial_parameter_mapping=True)\n",
    "\n",
    "pulse = SequencePT(S_init, meas_wait, adprep, stepped_free_induction, adread)\n",
    "\n",
    "looped_pulse = ForLoopPT(pulse, loop_index='i_fid', loop_range='N_fid_steps')\n",
    "\n",
    "experiment = RepetitionPT(looped_pulse, 'N_repetitions', identifier='free_induction_decay')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(experiment.parameter_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use some reasonable (but low) values for our parameters and plot our `experiment` pulse (we set the number of repeititions of `looped_pulse` only to 2 so that the plot does not get too stuffed).\n",
    "\n",
    "Note that we provide numpy arrays of length 2 for some parameters to assign different values for different channels (see also [The PointPulseTemplate](00PointPulse.ipynb))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "\n",
    "example_values = dict(meas=[0, 0],\n",
    "                      op=[5, -5],\n",
    "                      eps_J=[1, -1],\n",
    "                      ST_plus=[2.5, -2.5],\n",
    "                      S_init=[-1, -1],\n",
    "                      ST_jump=[1, -1],\n",
    "                      max_ramp_speed=0.3,\n",
    "                      \n",
    "                      t_init=5,\n",
    "                      \n",
    "                      t_meas_wait = 1,\n",
    "                      \n",
    "                      t_ST_prep = 10,\n",
    "                      t_op = 20,\n",
    "                      \n",
    "                      t_ST_read = 10,\n",
    "                      t_meas_start = 20,\n",
    "                      t_meas_duration=5,\n",
    "                     \n",
    "                      t_start=0,\n",
    "                      t_step=5,\n",
    "                      N_fid_steps=5, N_repetitions=2)\n",
    "\n",
    "from qupulse.pulses.plotting import plot\n",
    "\n",
    "_ = plot(experiment, example_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can clearly make out the many repetitions of our basic functionality pulse and also the varying duration between the voltage peaks due to our parameter sweep (as well as the two-fold repetition of the sweep itself).\n",
    "\n",
    "Let's also quickly plot only a single repetition by setting according parameters for our `experiment` pulse template."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_values['N_fid_steps'] = 1\n",
    "example_values['N_repetitions'] = 1\n",
    "example_values['t_start'] = 5\n",
    "\n",
    "_ = plot(experiment, example_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a last step we will save the pulse and some example parameters so we can use it in other examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "from qupulse.serialization import FilesystemBackend, PulseStorage\n",
    "\n",
    "pulse_storage = PulseStorage(FilesystemBackend('./serialized_pulses'))\n",
    "\n",
    "# overwrite all pulses explicitly\n",
    "pulse_storage.overwrite('adprep', adprep)\n",
    "pulse_storage.overwrite('S_init', S_init)\n",
    "pulse_storage.overwrite('adread', adread)\n",
    "pulse_storage.overwrite('free_induction_decay', experiment)\n",
    "\n",
    "with open('parameters/free_induction_decay.json', 'w') as parameter_file:\n",
    "    json.dump(example_values, parameter_file)\n",
    "\n",
    "print('Successfully saved pulse and example parameters')"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}