QCCS state discrimination calibraton.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# QCCS: This program is a simple algorithm for finding the most optimum thresholds by optimizing rotation coefficients and QA sample delay\n",
    "\n",
    "## This will run 128 measurements of a qubit each in ground and excited state.\n",
    "\n",
    "### Table of Contents\n",
    "\n",
    "* [1) Imports and helper functions](#chapter1)\n",
    "* [2) Device initialization/connection](#chapter2)\n",
    "* [3) Configure PQSC](#chapter3)\n",
    "* [4) Configure HDAWG](#chapter4)\n",
    "* [5) Configure UHFQA](#chapter5)\n",
    "    * [5.2 Configure UHFQA QCCS mode](#section_5_1)\n",
    "    * [5.2 Configure UHFQA for 2-qubit](#section_5_2)\n",
    "* [6) Initialise and upload UHF/HD AWG programs](#chapter6)\n",
    "* [7) Configure Upload and Run program](#chapter7)\n",
    "* [8) Read results (under work)](#chapter8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1) Imports and helper functions <a class=\"anchor\" id=\"chapter1\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import zhinst.ziPython as zi\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "\n",
    "# Compile AWG seqC code\n",
    "def awg_compile_upload_elf(awgModule, awgIndex, awg_program):\n",
    "    \"\"\"Compile and upload awg_program as .elf file\"\"\"\n",
    "    awgModule.set('awgModule/index', awgIndex)\n",
    "    awgModule.set('awgModule/compiler/sourcestring', awg_program)\n",
    "\n",
    "    while awgModule.getInt('awgModule/compiler/status') == -1:\n",
    "        time.sleep(0.1)\n",
    "    if awgModule.getInt('awgModule/compiler/status') == 1:\n",
    "        raise Exception(awgModule.getString('awgModule/compiler/statusstring'))\n",
    "\n",
    "    if awgModule.getInt('awgModule/compiler/status') == 2:\n",
    "        print(\"Compilation successful with warnings, will upload the program to the instrument.\")\n",
    "        print(\"Compiler warning: \", awgModule.getString('awgModule/compiler/statusstring'))\n",
    "\n",
    "    time.sleep(0.2)\n",
    "    i = 0\n",
    "    while (awgModule.getDouble('awgModule/progress') < 1.0) and (awgModule.getInt('awgModule/elf/status') != 1):\n",
    "        time.sleep(0.5)\n",
    "        i += 1\n",
    "\n",
    "    if awgModule.getInt('awgModule/elf/status') == 1:\n",
    "        raise Exception(\"Upload to the instrument failed.\")\n",
    "        \n",
    "# Rotation in I/Q plane\n",
    "def rotate(number, degree):\n",
    "    n = number\n",
    "    return (math.e**(math.radians(degree)*1j)) * n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) Specify your data server + devices used <a class=\"anchor\" id=\"chapter2\"></a>\n",
    "#### Note: variable UHFQA_watch can be ignored"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "SERVER = '127.0.0.1'\n",
    "\n",
    "daq = zi.ziDAQServer(SERVER, 8004, 1)\n",
    "\n",
    "# Define device IDs\n",
    "PQSC = 'dev10006'\n",
    "UHFQA = 'dev2171'\n",
    "HDAWG = 'dev8147'\n",
    "\n",
    "# On the continuity setup, this device is not connected to anything or perform any function\n",
    "UHFQA_watch = 'dev2004' \n",
    "\n",
    "\n",
    "# Connection to data server\n",
    "daq.connectDevice(PQSC, '1gbe')\n",
    "daq.connectDevice(UHFQA, '1gbe')\n",
    "daq.connectDevice(HDAWG, '1gbe')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3) Configure the PQSC for register forwarding (conditional unit TBD)  <a class=\"anchor\" id=\"chapter3\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Configure PQSC\n",
    "\n",
    "# Use external reference clock coming from the UHFQA\n",
    "daq.setInt(f'/{PQSC}/system/clocks/referenceclock/in/source', 1)\n",
    "\n",
    "## Configure execution engine\n",
    "# Send a single trigger to start the HDAWG and the UHFQA\n",
    "daq.setInt(f'/{PQSC}/execution/repetitions', 1)\n",
    "# Wait for feedback to arrive from UHFQA (10us is more than enough)\n",
    "daq.setDouble(f'/{PQSC}/execution/holdoff', 10e-6)\n",
    "\n",
    "## Register forwarding\n",
    "# ZSync output port to the receiver HDAWG\n",
    "port = 0\n",
    "# Program register bank forwarding\n",
    "fwd_length = 4\n",
    "fwd = range(0, 4)\n",
    "daq.setVector(f'/{PQSC}/raw/regs/{port}/fwd', np.array(fwd).astype(np.uint32))\n",
    "# Enable forwarding on output port\n",
    "daq.setInt(f'/{PQSC}/raw/zsyncs/{port}/txmux/fwd_en', 1)\n",
    "\n",
    "## Condition unit\n",
    "# ZSync output port to the receiver HDAWG\n",
    "port = 0\n",
    "# Program condition unit sources\n",
    "src_length = 8\n",
    "src = range(0, 8)\n",
    "daq.setVector(f'/{PQSC}/raw/cond/src', np.array(src).astype(np.uint32))\n",
    "# Program condition unit function\n",
    "lut_length = 2**src_length\n",
    "offset = 512\n",
    "lut = range(offset, offset+lut_length)\n",
    "daq.setVector(f'/{PQSC}/raw/cond/lut', np.array(lut).astype(np.uint32))\n",
    "# Program condition unit byte selection\n",
    "sel_length = 18\n",
    "sel = [1] * sel_length\n",
    "daq.setVector(f'/{PQSC}/raw/cond/sel', np.array(sel).astype(np.uint32))\n",
    "\n",
    "# Enable condition output on forwarding port\n",
    "daq.setInt(f'/{PQSC}/raw/zsyncs/{port}/txmux/cond_en', 0) # This should be 0 according to Niels, cond not working"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4) Configure HDAWG to QCCS mode  <a class=\"anchor\" id=\"chapter4\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Configure HDAWG\n",
    "\n",
    "# Use ZSync clock\n",
    "daq.setInt(f'/{HDAWG}/system/clocks/referenceclock/source', 2)\n",
    "\n",
    "## Configure DIO\n",
    "# Configure DIO switch to QCCS mode\n",
    "daq.setInt(f'/{HDAWG}/dios/0/mode', 3)\n",
    "# Drive the two most significant bytes of the DIO port\n",
    "# The UHFQA drives the two least significant bytes of the DIO port\n",
    "daq.setInt(f'/{HDAWG}/dios/0/drive', 0b1100)\n",
    "# Configure DIO triggering to match ZSync input\n",
    "daq.setInt(f'{HDAWG}/awgs/0/dio/strobe/slope', 0)\n",
    "daq.setInt(f'{HDAWG}/awgs/0/dio/valid/polarity', 0)\n",
    "\n",
    "## Configure AWG\n",
    "# Setup AWG module\n",
    "awg_hd = daq.awgModule()\n",
    "awg_hd.set('device', HDAWG)\n",
    "awg_hd.set('index', 0)\n",
    "awg_hd.execute()\n",
    "\n",
    "# Turn on HDAWG outputs\n",
    "daq.setInt(f'/{HDAWG}/sigouts/0/on', 1)\n",
    "daq.setInt(f'/{HDAWG}/sigouts/1/on', 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5) Configure UHFQA <a class=\"anchor\" id=\"chapter5\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1) Configure UHFQA for QCCS mode <a class=\"anchor\" id=\"section_5_1\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Configure UHFQA\n",
    "\n",
    "# UHFQA uses its own clock in this experiment\n",
    "\n",
    "## Configure DIO\n",
    "# Sample DIO data at 50 MHz\n",
    "daq.setInt(f'{UHFQA}/dios/0/extclk', 2)\n",
    "# Set DIO output to QA result QCCS\n",
    "daq.setInt(f'{UHFQA}/dios/0/mode', 4)\n",
    "# Drive the two least significant bytes of the DIO port\n",
    "# The HDAWG drives the two most significant bytes of the DIO port\n",
    "daq.setInt(f'{UHFQA}/dios/0/drive', 0b0011)\n",
    "# Configure DIO triggering to match HDAWG DIO input\n",
    "daq.setInt(f'/{UHFQA}/awgs/0/dio/strobe/slope', 0)\n",
    "daq.setInt(f'/{UHFQA}/awgs/0/dio/valid/polarity', 2)\n",
    "daq.setInt(f'/{UHFQA}/awgs/0/dio/valid/index', 16)\n",
    "\n",
    "## QA readout configuration\n",
    "# Bypass crosstalk to reduce latency\n",
    "daq.setInt(f'{UHFQA}/qas/0/crosstalk/bypass', 1)\n",
    "# Set length of integration (arbitrary value of 128)\n",
    "daq.setInt(f'{UHFQA}/qas/0/integration/length', 128)\n",
    "# Set threshold levels to a low value so qubit readout is always high\n",
    "for i in range(10):\n",
    "    daq.setDouble(f'/{UHFQA}/qas/0/thresholds/{i}/level', -100)\n",
    "# Reset QA results\n",
    "daq.setInt(f'{UHFQA}/qas/0/result/reset', 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2) Configure UHFQA for two-qubit readout + upload integration weights <a class=\"anchor\" id=\"section_5_2\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Input/Output settings\n",
    "daq.setInt(f'/{UHFQA}/sigins/0/imp50', 1)\n",
    "daq.setInt(f'/{UHFQA}/sigins/1/imp50', 1)\n",
    "daq.setDouble(f'/{UHFQA}/sigins/0/range', 1.5)\n",
    "daq.setDouble(f'/{UHFQA}/sigins/1/range', 1.5)\n",
    "daq.setInt(f'/{UHFQA}/sigouts/0/on', 1)\n",
    "daq.setInt(f'/{UHFQA}/sigouts/1/on', 1)\n",
    "\n",
    "\n",
    "# Configure QA setup\n",
    "### Sample delay begins at 0: Find the delay present from signal output to QA integrator input\n",
    "daq.setInt(f'/{UHFQA}/qas/0/delay', 0) # JS: \n",
    "# Integration length chosen 128 since the signal to be read and integrated is exactly 128 samples long\n",
    "daq.setDouble(f'/{UHFQA}/qas/0/integration/length', 128) # JS: Does reducing the length = less time used for integration? Probably not\n",
    "daq.setInt(f'/{UHFQA}/qas/0/integration/mode', 0)\n",
    "daq.setInt(f'/{UHFQA}/qas/0/integration/sources/0', 0)\n",
    "daq.setInt(f'/{UHFQA}/qas/0/integration/sources/1', 0)\n",
    "\n",
    "daq.setDouble(f'/{UHFQA}/qas/0/result/length', 128)\n",
    "\n",
    "# Set QA result mode to \"Integration\" mode in I/Q plane\n",
    "daq.setInt(f'/{UHFQA}/qas/0/result/source', 7)\n",
    "\n",
    "\n",
    "# Upload integration weights\n",
    "ch1_freq = 28.125e6 # Oscillator frequency\n",
    "ch2_freq = 56.25e6 # Oscillator frequency\n",
    "fs_uhfqa = 1.8e9 # Sampling frequency of UHF-QA\n",
    "integrationPoints = 4096 # Number of sampled used for integration\n",
    "ampl = 0.38 # Vpk of weights signal\n",
    "\n",
    "ch1_w_real = ampl*np.sin(2*np.pi*ch1_freq*np.arange(integrationPoints)/fs_uhfqa)\n",
    "ch1_w_imag = ampl*np.cos(2*np.pi*ch1_freq*np.arange(integrationPoints)/fs_uhfqa)\n",
    "\n",
    "ch2_w_real = ampl*np.sin(2*np.pi*ch2_freq*np.arange(integrationPoints)/fs_uhfqa)\n",
    "ch2_w_imag = ampl*np.cos(2*np.pi*ch2_freq*np.arange(integrationPoints)/fs_uhfqa)\n",
    "\n",
    "daq.setVector(f'/{UHFQA}/qas/0/integration/weights/0/real', ch1_w_real)\n",
    "daq.setVector(f'/{UHFQA}/qas/0/integration/weights/0/imag', ch1_w_imag)\n",
    "\n",
    "daq.setVector(f'/{UHFQA}/qas/0/integration/weights/1/real', ch2_w_real)\n",
    "daq.setVector(f'/{UHFQA}/qas/0/integration/weights/1/imag', ch2_w_imag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6) Compile & upload AWG programs and start the program for four repetitions\n",
    "## Note: The UHF-AWG is looped for 128 times - HD-AWG is looped for 64 times with two DIO triggers each loop\n",
    "## In total: PQSC will send out 128 triggers which should finish both the programs.\n",
    "<a class=\"anchor\" id=\"chapter6\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "UHF_qubitSim_prog = '''\n",
    "const ampl = 0.5;\n",
    " \n",
    "wave I_q0_state_0 = zeros(128);\n",
    "wave Q_q0_state_0 = zeros(128);\n",
    "wave I_q0_state_1 = sine(128, ampl, 0, 2);\n",
    "wave Q_q0_state_1 = cosine(128, ampl, 0, 2);\n",
    " \n",
    "wave I_q1_state_0 = zeros(128);\n",
    "wave Q_q1_state_0 = zeros(128);\n",
    "wave I_q1_state_1 = sine(128, ampl, 0, 4);\n",
    "wave Q_q1_state_1 = cosine(128, ampl, 0, 4);\n",
    " \n",
    "wave I_state_00 = I_q1_state_0 + I_q0_state_0;\n",
    "wave Q_state_00 = Q_q1_state_0 + Q_q0_state_0;\n",
    " \n",
    "wave I_state_01 = I_q1_state_0 + I_q0_state_1;\n",
    "wave Q_state_01 = Q_q1_state_0 + Q_q0_state_1;\n",
    " \n",
    "wave I_state_10 = I_q1_state_1 + I_q0_state_0;\n",
    "wave Q_state_10 = Q_q1_state_1 + Q_q0_state_0;\n",
    " \n",
    "wave I_state_11 = I_q1_state_1 + I_q0_state_1;\n",
    "wave Q_state_11 = Q_q1_state_1 + Q_q0_state_1;\n",
    "\n",
    "var qubitState = getUserReg(0); \n",
    "\n",
    "repeat(128){\n",
    "waitDIOTrigger();\n",
    "setID(0);\n",
    "\n",
    "\n",
    "\n",
    "switch (qubitState) {\n",
    "  case 0: playWave(I_state_00, Q_state_00);startQAResult(0x300 << 16, 0b1111);waitQAResultTrigger();\n",
    "  case 1: playWave(I_state_01, Q_state_01);startQAResult(0x300 << 16, 0b1111);waitQAResultTrigger();\n",
    "  case 2: playWave(I_state_10, Q_state_10);startQAResult(0x300 << 16, 0b1111);waitQAResultTrigger();\n",
    "  case 3: playWave(I_state_11, Q_state_11);startQAResult(0x300 << 16, 0b1111);waitQAResultTrigger();\n",
    "}\n",
    "}\n",
    "'''\n",
    "\n",
    "HD_rstpulse_prog = '''\n",
    "setUserReg(0,0);\n",
    "setUserReg(1,0);\n",
    "setUserReg(2,0);\n",
    "setUserReg(3,0);\n",
    "\n",
    "repeat(64){\n",
    "// At start of program\n",
    "waitDIOTrigger();\n",
    "// Wait for qubit measurement result\n",
    "waitDIOTrigger();\n",
    "var res = getDIOTriggered();\n",
    "\n",
    "}\n",
    "\n",
    "'''\n",
    "\n",
    "# Channels to test\n",
    "channels = [0,1]\n",
    "\n",
    "# Setup UHF AWG module\n",
    "awg_uhf = daq.awgModule()\n",
    "awg_uhf.set('device', UHFQA)\n",
    "awg_uhf.set('index', 0)\n",
    "awg_uhf.execute()\n",
    "awg_uhf.set('awg/enable', 0)\n",
    "\n",
    "# Setup HD AWG module\n",
    "awg_hd = daq.awgModule()\n",
    "awg_hd.set('device', HDAWG)\n",
    "awg_hd.set('index', 0)\n",
    "awg_hd.execute()\n",
    "awg_hd.set('awg/enable', 0)\n",
    "\n",
    "# Upload HD program\n",
    "awg_compile_upload_elf(awg_uhf, 0, UHF_qubitSim_prog)\n",
    "\n",
    "# Upload UHF program\n",
    "awg_compile_upload_elf(awg_hd, 0, HD_rstpulse_prog)\n",
    "\n",
    "# PQSC holdoff time in seconds (must be multiple of 10)\n",
    "daq.setDouble(f'/{PQSC}/execution/repetitions', 128)\n",
    "daq.setDouble(f'/{PQSC}/execution/holdoff', 100e-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7) Run each of the four possible qubit states 128 times\n",
    "#### Rotate the resulting complex result 360* and find the maximum real value\n",
    "#### The maximum real value along with the corresponding angle rotation will be stored for each state\n",
    "<a class=\"anchor\" id=\"chapter6\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.1) Find qubit 1 and qubit 2 ground state threshold: 00  <a class=\"anchor\" id=\"chapter7\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acquiring data...\n",
      "Done.\n"
     ]
    }
   ],
   "source": [
    "for ch in channels:\n",
    "    daq.setDouble('/{:s}/qas/0/thresholds/{:d}/level'.format(UHFQA, ch), 0)\n",
    "\n",
    "# 0 --> both qubits are in ground state\n",
    "daq.setInt(f'/{UHFQA}/AWGS/0/USERREGS/0', 0)\n",
    "    \n",
    "# Now we're ready for readout. Enable result unit and start acquisition.\n",
    "daq.setInt('/{:s}/qas/0/result/reset'.format(UHFQA), 1)\n",
    "daq.setInt('/{:s}/qas/0/result/enable'.format(UHFQA), 1)\n",
    "daq.sync()\n",
    "#\n",
    "# Subscribe to result waves\n",
    "paths = []\n",
    "for ch in channels:\n",
    "    path = '/{:s}/qas/0/result/data/{:d}/wave'.format(UHFQA, ch)\n",
    "    paths.append(path)\n",
    "daq.subscribe(paths)\n",
    "\n",
    "# Arm the device\n",
    "daq.asyncSetInt('/{:s}/awgs/0/single'.format(UHFQA), 1)\n",
    "daq.syncSetInt('/{:s}/awgs/0/enable'.format(UHFQA), 1)\n",
    "\n",
    "time.sleep(2)\n",
    "\n",
    "daq.asyncSetInt(f'/{PQSC}/execution/enable', 1)\n",
    "\n",
    "# Perform acquisition\n",
    "print('Acquiring data...')\n",
    "# Since we are acquiring 128 data samples (maybe over-doing it, but reliable), and each PQSC trigger is 100 ms\n",
    "# We will need to poll for at least 128*100ms = 12.8 seconds, so below I chose 20 seconds just to be safe.\n",
    "data = daq.poll(20, 20000, 4, True)\n",
    "#data = acquisition_poll(daq, paths, result_length)\n",
    "print('Done.')\n",
    "\n",
    "# Stop result unit\n",
    "daq.unsubscribe(paths)\n",
    "daq.setInt('/{:s}/qas/0/result/enable'.format(UHFQA), 0)\n",
    "\n",
    "avgCh1 = np.average(data[paths[0]][0]['vector'])\n",
    "avgCh2 = np.average(data[paths[1]][0]['vector'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimum rotation found at a rotation of 229 degrees which gives a real value for qubit 1 ground state at 0.002367931188146823\n",
      "Optimum rotation found at a rotation of 222 degrees which gives a real value for qubit 2 ground state at 0.00035690125467061496\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": [
    "maxVal = avgCh1\n",
    "for i in range(0, 365):\n",
    "    tempVal = rotate(avgCh1, i)\n",
    "    \n",
    "    if(np.real(tempVal) > np.real(maxVal)):\n",
    "        maxVal = tempVal\n",
    "        rotDegrees = i\n",
    "\n",
    "plt.polar([0,np.angle(maxVal)],[0,abs(maxVal)],marker='o')\n",
    "print(f'Optimum rotation found at a rotation of {rotDegrees} degrees which gives a real value for qubit 1 ground state at {np.real(maxVal)}')        \n",
    "    \n",
    "# Stores maximum value of qubit 1 when 00\n",
    "ch0_00 = maxVal\n",
    "ch0_00_rot = rotDegrees\n",
    "\n",
    "maxVal = avgCh2\n",
    "for i in range(0, 365):\n",
    "    tempVal = rotate(avgCh2, i)\n",
    "    \n",
    "    if(np.real(tempVal) > np.real(maxVal)):\n",
    "        maxVal = tempVal\n",
    "        rotDegrees = i\n",
    "        \n",
    "plt.polar([0,np.angle(maxVal)],[0,abs(maxVal)],marker='o')\n",
    "print(f'Optimum rotation found at a rotation of {rotDegrees} degrees which gives a real value for qubit 2 ground state at {np.real(maxVal)}')\n",
    "\n",
    "# Stores maximum value of qubit 2 when 00\n",
    "ch1_00 = maxVal\n",
    "ch1_00_rot = rotDegrees"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2) Find qubit 1 and qubit 2 excited state threshold : 11 <a class=\"anchor\" id=\"chapter7\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acquiring data...\n",
      "Done.\n"
     ]
    }
   ],
   "source": [
    "for ch in channels:\n",
    "    daq.setDouble('/{:s}/qas/0/thresholds/{:d}/level'.format(UHFQA, ch), 0)\n",
    "\n",
    "# 0 --> both qubits are in excited state\n",
    "daq.setInt(f'/{UHFQA}/AWGS/0/USERREGS/0', 3)\n",
    "    \n",
    "# Now we're ready for readout. Enable result unit and start acquisition.\n",
    "daq.setInt('/{:s}/qas/0/result/reset'.format(UHFQA), 1)\n",
    "daq.setInt('/{:s}/qas/0/result/enable'.format(UHFQA), 1)\n",
    "daq.sync()\n",
    "#\n",
    "# Subscribe to result waves\n",
    "paths = []\n",
    "for ch in channels:\n",
    "    path = '/{:s}/qas/0/result/data/{:d}/wave'.format(UHFQA, ch)\n",
    "    paths.append(path)\n",
    "daq.subscribe(paths)\n",
    "#\n",
    "# Arm the device\n",
    "daq.asyncSetInt('/{:s}/awgs/0/single'.format(UHFQA), 1)\n",
    "daq.syncSetInt('/{:s}/awgs/0/enable'.format(UHFQA), 1)\n",
    "\n",
    "daq.setInt(f'/{PQSC}/execution/enable', 1)\n",
    "\n",
    "# Perform acquisition\n",
    "print('Acquiring data...')\n",
    "# Since we are acquiring 128 data samples (maybe over-doing it, but reliable), and each PQSC trigger is 100 ms\n",
    "# We will need to poll for at least 128*100ms = 12.8 seconds, so below I chose 20 seconds just to be safe.\n",
    "data = daq.poll(20, 20000, 4, True)\n",
    "#data = acquisition_poll(daq, paths, result_length)\n",
    "print('Done.')\n",
    "\n",
    "# Stop result unit\n",
    "daq.unsubscribe(paths)\n",
    "daq.setInt('/{:s}/qas/0/result/enable'.format(UHFQA), 0)\n",
    "\n",
    "avgCh1 = np.average(data[paths[0]][0]['vector'])\n",
    "avgCh2 = np.average(data[paths[1]][0]['vector'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimum rotation found at a rotation of 317 degrees which gives a real value for qubit 1 excited state at 6.662619511220351\n",
      "Optimum rotation found at a rotation of 317 degrees which gives a real value for qubit 2 excited state at 6.229995711882447\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": [
    "maxVal = avgCh1\n",
    "for i in range(0, 365):\n",
    "    tempVal = rotate(avgCh1, i)\n",
    "    \n",
    "    if(np.real(tempVal) > np.real(maxVal)):\n",
    "        maxVal = tempVal\n",
    "        rotDegrees = i\n",
    "\n",
    "plt.polar([0,np.angle(maxVal)],[0,abs(maxVal)],marker='o')\n",
    "print(f'Optimum rotation found at a rotation of {rotDegrees} degrees which gives a real value for qubit 1 excited state at {np.real(maxVal)}')        \n",
    "        \n",
    "# Stores maximum value of qubit 1 when 11\n",
    "ch0_11 = maxVal\n",
    "ch0_11_rot = rotDegrees\n",
    "\n",
    "\n",
    "maxVal = avgCh2\n",
    "for i in range(0, 365):\n",
    "    tempVal = rotate(avgCh2, i)\n",
    "    \n",
    "    if(np.real(tempVal) > np.real(maxVal)):\n",
    "        maxVal = tempVal\n",
    "        rotDegrees = i\n",
    "        \n",
    "plt.polar([0,np.angle(maxVal)],[0,abs(maxVal)],marker='o')\n",
    "print(f'Optimum rotation found at a rotation of {rotDegrees} degrees which gives a real value for qubit 2 excited state at {np.real(maxVal)}')\n",
    "\n",
    "# Stores maximum value of qubit 1 when 11\n",
    "ch1_11 = maxVal\n",
    "ch1_11_rot = rotDegrees"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3) Find qubit 1 excited state threshold: 01  <a class=\"anchor\" id=\"chapter7\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acquiring data...\n",
      "Done.\n"
     ]
    }
   ],
   "source": [
    "for ch in channels:\n",
    "    daq.setDouble('/{:s}/qas/0/thresholds/{:d}/level'.format(UHFQA, ch), 0)\n",
    "\n",
    "# 0 --> both qubits are in excited state\n",
    "daq.setInt(f'/{UHFQA}/AWGS/0/USERREGS/0', 1)\n",
    "    \n",
    "# Now we're ready for readout. Enable result unit and start acquisition.\n",
    "daq.setInt('/{:s}/qas/0/result/reset'.format(UHFQA), 1)\n",
    "daq.setInt('/{:s}/qas/0/result/enable'.format(UHFQA), 1)\n",
    "daq.sync()\n",
    "#\n",
    "# Subscribe to result waves\n",
    "paths = []\n",
    "for ch in channels:\n",
    "    path = '/{:s}/qas/0/result/data/{:d}/wave'.format(UHFQA, ch)\n",
    "    paths.append(path)\n",
    "daq.subscribe(paths)\n",
    "#\n",
    "# Arm the device\n",
    "daq.asyncSetInt('/{:s}/awgs/0/single'.format(UHFQA), 1)\n",
    "daq.syncSetInt('/{:s}/awgs/0/enable'.format(UHFQA), 1)\n",
    "\n",
    "daq.setInt(f'/{PQSC}/execution/enable', 1)\n",
    "\n",
    "# Perform acquisition\n",
    "print('Acquiring data...')\n",
    "# Since we are acquiring 128 data samples (maybe over-doing it, but reliable), and each PQSC trigger is 100 ms\n",
    "# We will need to poll for at least 128*100ms = 12.8 seconds, so below I chose 20 seconds just to be safe.\n",
    "data = daq.poll(20, 20000, 4, True)\n",
    "#data = acquisition_poll(daq, paths, result_length)\n",
    "print('Done.')\n",
    "\n",
    "# Stop result unit\n",
    "daq.unsubscribe(paths)\n",
    "daq.setInt('/{:s}/qas/0/result/enable'.format(UHFQA), 0)\n",
    "\n",
    "avgCh1 = np.average(data[paths[0]][0]['vector'])\n",
    "avgCh2 = np.average(data[paths[1]][0]['vector'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimum rotation found at a rotation of 316 degrees which gives a real value for qubit 1 excited state at 6.780792667912355\n",
      "Optimum rotation found at a rotation of 86 degrees which gives a real value for qubit 2 ground state at 0.1457076984477823\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": [
    "maxVal = avgCh1\n",
    "for i in range(0, 365):\n",
    "    tempVal = rotate(avgCh1, i)\n",
    "    \n",
    "    if(np.real(tempVal) > np.real(maxVal)):\n",
    "        maxVal = tempVal\n",
    "        rotDegrees = i\n",
    "\n",
    "plt.polar([0,np.angle(maxVal)],[0,abs(maxVal)],marker='o')\n",
    "print(f'Optimum rotation found at a rotation of {rotDegrees} degrees which gives a real value for qubit 1 excited state at {np.real(maxVal)}')        \n",
    "\n",
    "# Stores maximum value of qubit 1 when 01\n",
    "ch0_01 = maxVal\n",
    "ch0_01_rot = rotDegrees\n",
    "\n",
    "\n",
    "maxVal = avgCh2\n",
    "for i in range(0, 365):\n",
    "    tempVal = rotate(avgCh2, i)\n",
    "    \n",
    "    if(np.real(tempVal) > np.real(maxVal)):\n",
    "        maxVal = tempVal\n",
    "        rotDegrees = i\n",
    "        \n",
    "plt.polar([0,np.angle(maxVal)],[0,abs(maxVal)],marker='o')\n",
    "print(f'Optimum rotation found at a rotation of {rotDegrees} degrees which gives a real value for qubit 2 ground state at {np.real(maxVal)}')\n",
    "\n",
    "# Stores maximum value of qubit 2 when 01\n",
    "ch1_01 = maxVal\n",
    "ch1_01_rot = rotDegrees"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.4) Find qubit 2 excited state threshold:10  <a class=\"anchor\" id=\"chapter7\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Acquiring data...\n",
      "Done.\n"
     ]
    }
   ],
   "source": [
    "for ch in channels:\n",
    "    daq.setDouble('/{:s}/qas/0/thresholds/{:d}/level'.format(UHFQA, ch), 0)\n",
    "\n",
    "# 0 --> both qubits are in excited state\n",
    "daq.setInt(f'/{UHFQA}/AWGS/0/USERREGS/0', 2)\n",
    "    \n",
    "# Now we're ready for readout. Enable result unit and start acquisition.\n",
    "daq.setInt('/{:s}/qas/0/result/reset'.format(UHFQA), 1)\n",
    "daq.setInt('/{:s}/qas/0/result/enable'.format(UHFQA), 1)\n",
    "daq.sync()\n",
    "#\n",
    "# Subscribe to result waves\n",
    "paths = []\n",
    "for ch in channels:\n",
    "    path = '/{:s}/qas/0/result/data/{:d}/wave'.format(UHFQA, ch)\n",
    "    paths.append(path)\n",
    "daq.subscribe(paths)\n",
    "#\n",
    "# Arm the device\n",
    "daq.asyncSetInt('/{:s}/awgs/0/single'.format(UHFQA), 1)\n",
    "daq.syncSetInt('/{:s}/awgs/0/enable'.format(UHFQA), 1)\n",
    "\n",
    "daq.setInt(f'/{PQSC}/execution/enable', 1)\n",
    "\n",
    "# Perform acquisition\n",
    "print('Acquiring data...')\n",
    "# Since we are acquiring 128 data samples (maybe over-doing it, but reliable), and each PQSC trigger is 100 ms\n",
    "# We will need to poll for at least 128*100ms = 12.8 seconds, so below I chose 20 seconds just to be safe.\n",
    "data = daq.poll(20, 20000, 4, True)\n",
    "#data = acquisition_poll(daq, paths, result_length)\n",
    "print('Done.')\n",
    "\n",
    "# Stop result unit\n",
    "daq.unsubscribe(paths)\n",
    "daq.setInt('/{:s}/qas/0/result/enable'.format(UHFQA), 0)\n",
    "\n",
    "avgCh1 = np.average(data[paths[0]][0]['vector'])\n",
    "avgCh2 = np.average(data[paths[1]][0]['vector'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimum rotation found at a rotation of 86 degrees which gives a real value for qubit 1 ground state at 0.14020886194239507\n",
      "Optimum rotation found at a rotation of 316 degrees which gives a real value for qubit 2 excited state at 6.346715273433425\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": [
    "maxVal = avgCh1\n",
    "for i in range(0, 365):\n",
    "    tempVal = rotate(avgCh1, i)\n",
    "    \n",
    "    if(np.real(tempVal) > np.real(maxVal)):\n",
    "        maxVal = tempVal\n",
    "        rotDegrees = i\n",
    "\n",
    "plt.polar([0,np.angle(maxVal)],[0,abs(maxVal)],marker='o')\n",
    "print(f'Optimum rotation found at a rotation of {rotDegrees} degrees which gives a real value for qubit 1 ground state at {np.real(maxVal)}')        \n",
    "\n",
    "# Stores maximum value of qubit 1 when 01\n",
    "ch0_10 = maxVal\n",
    "ch0_10_rot = i\n",
    "\n",
    "\n",
    "maxVal = avgCh2\n",
    "for i in range(0, 365):\n",
    "    tempVal = rotate(avgCh2, i)\n",
    "    \n",
    "    if(np.real(tempVal) > np.real(maxVal)):\n",
    "        maxVal = tempVal\n",
    "        rotDegrees = i\n",
    "        \n",
    "plt.polar([0,np.angle(maxVal)],[0,abs(maxVal)],marker='o')\n",
    "print(f'Optimum rotation found at a rotation of {rotDegrees} degrees which gives a real value for qubit 2 excited state at {np.real(maxVal)}')\n",
    "\n",
    "# Stores maximum value of qubit 2 when 01\n",
    "ch1_10 = maxVal\n",
    "ch1_10_rot = rotDegrees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "316.5\n",
      "316.5\n",
      "3.389212368362104\n",
      "3.173179186089377\n"
     ]
    }
   ],
   "source": [
    "# Channel 1 and 2 rotated values\n",
    "\n",
    "ch0rot = (ch0_01_rot + ch0_11_rot)/2\n",
    "\n",
    "ch1rot = (ch1_10_rot + ch1_11_rot)/2\n",
    "\n",
    "print(f'{ch0rot}')\n",
    "print(f'{ch1rot}')\n",
    "\n",
    "# Find rotation co-efficients\n",
    "ch0rot = complex(np.cos(math.radians(ch0rot)), np.sin(math.radians(ch0rot)))\n",
    "ch1rot = complex(np.cos(math.radians(ch1rot)), np.sin(math.radians(ch1rot)))\n",
    "\n",
    "# Find threshold for channels 0 and 1\n",
    "ch0_threshold = (np.real(ch0_01) - np.real(ch0_00))/2\n",
    "ch1_threshold = (np.real(ch1_10) - np.real(ch1_00))/2\n",
    "\n",
    "\n",
    "print(f'{ch0_threshold}')\n",
    "print(f'{ch1_threshold}')\n",
    "\n",
    "# Set the optimum rotations for channels 0 and 1\n",
    "daq.setComplex(f'/{UHFQA}/qas/0/rotations/0', ch0rot)\n",
    "daq.setComplex(f'/{UHFQA}/qas/0/rotations/1', ch1rot)\n",
    "\n",
    "# Set the optimum thresholds for channels 0 and 1\n",
    "daq.setDouble(f'/{UHFQA}/qas/0/thresholds/0/level', ch0_threshold)\n",
    "daq.setDouble(f'/{UHFQA}/qas/0/thresholds/1/level', ch1_threshold)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}