diff --git a/firmware/hdl/fifo_dc_axi_xpm.sv b/firmware/hdl/fifo_dc_axi_xpm.sv index 39c434d31..b7ddb0419 100644 --- a/firmware/hdl/fifo_dc_axi_xpm.sv +++ b/firmware/hdl/fifo_dc_axi_xpm.sv @@ -462,4 +462,4 @@ module fifo_dc_axi_xpm // End of xpm_fifo_async_inst instantiation -endmodule; +endmodule diff --git a/firmware/notebooks/qick_rb/RB_tProc_v1_experiment.ipynb b/firmware/notebooks/qick_rb/RB_tProc_v1_experiment.ipynb new file mode 100644 index 000000000..fd67c079e --- /dev/null +++ b/firmware/notebooks/qick_rb/RB_tProc_v1_experiment.ipynb @@ -0,0 +1,638 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e369c3a6", + "metadata": {}, + "source": [ + "# Randomized Benchmarking experiment for tProc_v1\n", + "\n", + "This notebook runs the experiment used in the QICK paper for randomized benchmarking (devForLBNL/RB_code_demo/qsystem2_paper_data-Ankur-final.ipynb) ported to run on the current tProc_v1 firmware (original code ran on something called qsystem, previous version of tProc_v1) It was created to measure the runtime of the algorithm and compare it with the implementation on the tProc_v2 firmware." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f2d666f1", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": "\ntry {\nrequire(['notebook/js/codecell'], function(codecell) {\n codecell.CodeCell.options_default.highlight_modes[\n 'magic_text/x-csrc'] = {'reg':[/^%%microblaze/]};\n Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n Jupyter.notebook.get_cells().map(function(cell){\n if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n });\n});\n} catch (e) {};\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": "\ntry {\nrequire(['notebook/js/codecell'], function(codecell) {\n codecell.CodeCell.options_default.highlight_modes[\n 'magic_text/x-csrc'] = {'reg':[/^%%pybind11/]};\n Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n Jupyter.notebook.get_cells().map(function(cell){\n if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n });\n});\n} catch (e) {};\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QICK running on ZCU111, software version 0.2.370\n", + "\n", + "Firmware configuration (built Wed Aug 16 13:39:03 2023):\n", + "\n", + "\tGlobal clocks (MHz): tProc dispatcher timing 384.000, RF reference 204.800\n", + "\tGroups of related clocks: [tProc clock, DAC tile 0], [DAC tile 1], [ADC tile 0]\n", + "\n", + "\t7 signal generator channels:\n", + "\t0:\taxis_signal_gen_v6 - fs=6144.000 Msps, fabric=384.000 MHz\n", + "\t\tenvelope memory: 65536 complex samples (10.667 us)\n", + "\t\t32-bit DDS, range=6144.000 MHz\n", + "\t\tDAC tile 0, blk 0 is DAC228_T0_CH0, or RF board DAC port 0\n", + "\t1:\taxis_signal_gen_v6 - fs=6144.000 Msps, fabric=384.000 MHz\n", + "\t\tenvelope memory: 65536 complex samples (10.667 us)\n", + "\t\t32-bit DDS, range=6144.000 MHz\n", + "\t\tDAC tile 0, blk 1 is DAC228_T0_CH1, or RF board DAC port 1\n", + "\t2:\taxis_signal_gen_v6 - fs=6144.000 Msps, fabric=384.000 MHz\n", + "\t\tenvelope memory: 65536 complex samples (10.667 us)\n", + "\t\t32-bit DDS, range=6144.000 MHz\n", + "\t\tDAC tile 0, blk 2 is DAC228_T0_CH2, or RF board DAC port 2\n", + "\t3:\taxis_signal_gen_v6 - fs=6144.000 Msps, fabric=384.000 MHz\n", + "\t\tenvelope memory: 65536 complex samples (10.667 us)\n", + "\t\t32-bit DDS, range=6144.000 MHz\n", + "\t\tDAC tile 1, blk 0 is DAC229_T1_CH0, or RF board DAC port 4\n", + "\t4:\taxis_signal_gen_v6 - fs=6144.000 Msps, fabric=384.000 MHz\n", + "\t\tenvelope memory: 65536 complex samples (10.667 us)\n", + "\t\t32-bit DDS, range=6144.000 MHz\n", + "\t\tDAC tile 1, blk 1 is DAC229_T1_CH1, or RF board DAC port 5\n", + "\t5:\taxis_signal_gen_v6 - fs=6144.000 Msps, fabric=384.000 MHz\n", + "\t\tenvelope memory: 65536 complex samples (10.667 us)\n", + "\t\t32-bit DDS, range=6144.000 MHz\n", + "\t\tDAC tile 1, blk 2 is DAC229_T1_CH2, or RF board DAC port 6\n", + "\t6:\taxis_signal_gen_v6 - fs=6144.000 Msps, fabric=384.000 MHz\n", + "\t\tenvelope memory: 65536 complex samples (10.667 us)\n", + "\t\t32-bit DDS, range=6144.000 MHz\n", + "\t\tDAC tile 1, blk 3 is DAC229_T1_CH3, or RF board DAC port 7\n", + "\n", + "\t2 readout channels:\n", + "\t0:\taxis_readout_v2 - configured by PYNQ\n", + "\t\tfs=4096.000 Msps, decimated=512.000 MHz, 32-bit DDS, range=4096.000 MHz\n", + "\t\taxis_avg_buffer v1.0 (no edge counter, no weights)\n", + "\t\tmemory 16384 accumulated, 1024 decimated (2.000 us)\n", + "\t\ttriggered by output 0, pin 14, feedback to tProc input 0\n", + "\t\tADC tile 0, blk 0 is ADC224_T0_CH0, or RF board ADC AC port 0\n", + "\t1:\taxis_readout_v2 - configured by PYNQ\n", + "\t\tfs=4096.000 Msps, decimated=512.000 MHz, 32-bit DDS, range=4096.000 MHz\n", + "\t\taxis_avg_buffer v1.0 (no edge counter, no weights)\n", + "\t\tmemory 16384 accumulated, 1024 decimated (2.000 us)\n", + "\t\ttriggered by output 0, pin 15, feedback to tProc input 1\n", + "\t\tADC tile 0, blk 2 is ADC224_T0_CH1, or RF board ADC AC port 1\n", + "\n", + "\t8 digital output pins:\n", + "\t0:\tPMOD0_0_LS\n", + "\t1:\tPMOD0_1_LS\n", + "\t2:\tPMOD0_2_LS\n", + "\t3:\tPMOD0_3_LS\n", + "\t4:\tPMOD0_4_LS\n", + "\t5:\tPMOD0_5_LS\n", + "\t6:\tPMOD0_6_LS\n", + "\t7:\tPMOD0_7_LS\n", + "\n", + "\ttProc: axis_tproc64x32_x8 (\"v1\") rev 4, program memory 8192 words, data memory 4096 words\n", + "\t\texternal start pin: PMOD1_0_LS\n", + "\n", + "\tDDR4 memory buffer: 1073741824 samples (2.097 sec), 256 samples/transfer\n", + "\t\twired to readouts [0, 1]\n", + "\n", + "\tMR buffer: 8192 samples (2.000 us), wired to readouts [0, 1]\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "from scipy.optimize import curve_fit\n", + "from datetime import datetime\n", + "\n", + "# Import the QICK drivers and auxiliary libraries\n", + "from qick import *\n", + "\n", + "# Load bitstream with custom overlay\n", + "soc = QickSoc()\n", + "soccfg = soc\n", + "print(soccfg)\n" + ] + }, + { + "cell_type": "markdown", + "id": "7a1dc341", + "metadata": {}, + "source": [ + "## RB sequence generator" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a8e30449", + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"Writing the sequences in terms of Clifford group algebra\n", + " The Clifford gate set forms a closed group => \n", + " 1. Multiplication of any two gates results in a gate part of the group \n", + " 2. Each gate has an inverse\n", + " 3. The inverse of a product of multiple Clifford gates is unique\n", + "\"\"\"\n", + "def generate_rbsequence(depth):\n", + " \n", + " \"\"\"Single qubit RB program to generate a sequence of 'd' gates followed \n", + " by an inverse gate to bring the qubit back in 'g' state\n", + " \"\"\"\n", + "\n", + " gate_symbol = ['I', 'Z', 'X', 'Y', 'Z/2', 'X/2', 'Y/2', '-Z/2', '-X/2', '-Y/2']\n", + " inverse_gate_symbol = ['I', '-Y/2', 'X/2', 'X', 'Y/2', '-X/2']\n", + "\n", + " \"\"\"Modeled the bloch sphere as 6-node graph, each rotation in the RB sequence is effectively\n", + " exchanging the node label on the bloch sphere.\n", + " For example: Z rotation is doing this: (+Z->+Z, -Z->-Z, +X->+Y, +Y->-X, -X->-Y, -Y->+X)\n", + " \"\"\"\n", + " matrix_ref = {}\n", + " \"\"\"Matrix columns are [Z, X, Y, -Z, -X, -Y]\"\"\"\n", + "\n", + " matrix_ref['0'] = np.matrix([[1, 0, 0, 0, 0, 0],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [0, 0, 0, 0, 0, 1]])\n", + " matrix_ref['1'] = np.matrix([[1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [0, 0, 0, 0, 0, 1],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 1, 0, 0, 0]])\n", + " matrix_ref['2'] = np.matrix([[0, 0, 0, 1, 0, 0],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1],\n", + " [1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [0, 0, 1, 0, 0, 0]])\n", + " matrix_ref['3'] = np.matrix([[0, 0, 0, 1, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [1, 0, 0, 0, 0, 0],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1]])\n", + " matrix_ref['4'] = np.matrix([[1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 1, 0]])\n", + " matrix_ref['5'] = np.matrix([[0, 0, 1, 0, 0, 0],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 0, 0, 0, 0, 1],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [1, 0, 0, 0, 0, 0]])\n", + " matrix_ref['6'] = np.matrix([[0, 0, 0, 0, 1, 0],\n", + " [1, 0, 0, 0, 0, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 0, 0, 0, 0, 1]])\n", + " matrix_ref['7'] = np.matrix([[1, 0, 0, 0, 0, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 0, 0, 0, 0, 1],\n", + " [0, 1, 0, 0, 0, 0]])\n", + " matrix_ref['8'] = np.matrix([[0, 0, 0, 0, 0, 1],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [1, 0, 0, 0, 0, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [0, 0, 0, 1, 0, 0]])\n", + " matrix_ref['9'] = np.matrix([[0, 1, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1]])\n", + " \n", + " \"\"\"Generate a random gate sequence of a certain depth 'd'\"\"\"\n", + " gate_seq = []\n", + " for ii in range(depth):\n", + " gate_seq.append(np.random.randint(0, 9))\n", + " \"\"\"Initial node\"\"\"\n", + " a0 = np.matrix([[1], [0], [0], [0], [0], [0]])\n", + " anow = a0\n", + " for i in gate_seq:\n", + " anow = np.dot(matrix_ref[str(i)], anow)\n", + " anow1 = np.matrix.tolist(anow.T)[0]\n", + " \"\"\"Returns the \"\"\"\n", + " max_index = anow1.index(max(anow1))\n", + " symbol_seq = [gate_symbol[i] for i in gate_seq ]\n", + " symbol_seq.append(inverse_gate_symbol[max_index])\n", + " return symbol_seq" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cc9aee50", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Z/2', 'Y', '-Z/2', 'X']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "generate_rbsequence(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "39bf0f0f", + "metadata": {}, + "outputs": [], + "source": [ + "class RBSequenceProgram(AveragerProgram):\n", + " def __init__(self,soccfg, cfg):\n", + " super().__init__(soccfg, cfg)\n", + "\n", + " def initialize(self):\n", + " cfg = self.cfg\n", + "\n", + " self.gate_seq = cfg['gate_seq']\n", + " self.gate_set = cfg['gate_set']\n", + "\n", + "# r_freq=self.sreg(cfg[\"rr_ch\"], \"freq\") #Get frequency register for res_ch\n", + "# f_res=freq2reg(adcfreq(cfg[\"rr_freq\"])) # convert frequency to dac frequency (ensuring it is an available adc frequency)\n", + "\n", + "# # rr_freq = self.sreg(self.device_cfg[\"rr_ch\"], self.device_cfg[\"rr_freq\"]) #Get frequency register for res_ch\n", + "# self.cfg[\"adc_lengths\"]=[self.cfg[\"rr_length\"]]*2 #add length of adc acquisition to config\n", + "# self.cfg[\"adc_freqs\"]=[adcfreq(self.cfg[\"rr_freq\"])]*2 #add frequency of adc ddc to config\n", + "# self.f_ge=freq2reg(cfg[\"qubit_freq\"])\n", + "\n", + " pulse_length = self.us2cycles(0.025)\n", + "\n", + " ro_chs = cfg['ro_chs']\n", + " gen_ch = cfg['qubit_ch']\n", + "\n", + " # configure the readout lengths and downconversion frequencies\n", + " for ro_ch in ro_chs:\n", + " self.declare_readout(ch=ro_ch, \n", + " length=self.us2cycles(cfg['rr_length']),\n", + " freq=self.cfg['rr_freq'],\n", + " gen_ch=cfg['rr_ch'])\n", + "\n", + " self.declare_gen(ch=cfg[\"rr_ch\"], nqz=1) #Readout\n", + "\n", + " \"\"\"Add a sequence of fixed number of gates, analytically compute\n", + " the inverse operation after the final gate to bring the qubit back\n", + " to |g> state (minimizes errors due to readout) before reading out the state.\n", + " Repeat this experiment several times with the fixed number of gates.\n", + " \"\"\"\n", + "# self.add_pulse(ch=self.cfg[\"qubit_ch\"], name=\"qubit\", style=\"arb\", idata=gauss(mu=cfg[\"pi_sigma\"]*16*5/2,si=cfg[\"pi_sigma\"]*16, length=5*cfg[\"pi_sigma\"]*16, maxv=32000))\n", + "\n", + " \n", + " \"\"\"This adds the different types of pulses to the pulse library which can be played on demand later\"\"\"\n", + " for name, ginfo in self.gate_set.items():\n", + " self.add_pulse(ch=self.cfg[\"qubit_ch\"], name=name, \n", + " idata=ginfo[\"idata\"],\n", + " qdata=ginfo[\"qdata\"],\n", + " # style=ginfo[\"style\"]\n", + " )\n", + "\n", + "\n", + " # self.add_pulse(ch=self.cfg[\"rr_ch\"], name=\"measure\",\n", + " # # style=\"const\", \n", + " # length=self.cfg[\"rr_length\"]\n", + " # ) #add a constant pulse to the pulse library of res_ch\n", + "\n", + " # \"\"\"Pre-initialze the pulse (not necessary)\"\"\"\n", + " # self.pulse(ch=self.cfg[\"rr_ch\"], name=\"measure\", freq=f_res, \n", + " # phase=self.cfg[\"rr_phase\"], gain=self.cfg[\"rr_gain\"],\n", + " # length=self.cfg['rr_length'] , t=0, play=False) # pre-configure readout pulse\n", + "\n", + " idata = 30000*np.ones(16*cfg[\"rr_length\"])\n", + " self.add_pulse(ch=cfg['rr_ch'], name=\"measure\", idata=idata)\n", + "\n", + " self.set_pulse_registers(ch=cfg[\"rr_ch\"], \n", + " style=\"const\", \n", + " freq=cfg[\"rr_freq\"], \n", + " phase=0, \n", + " gain=cfg[\"rr_gain\"],\n", + " length=cfg[\"rr_length\"])\n", + "\n", + "\n", + " self.sync_all(1000) # give processor some time to configure pulses\n", + " \n", + " def body(self):\n", + " self.phase_ref=0\n", + " for g in self.gate_seq:\n", + " ginfo=self.cfg[\"gate_set\"][g]\n", + " \"\"\"For the Z gates (virtual rotation), we need to advance the phase of all the pulses which follows afterwards\"\"\"\n", + " if g==\"Z\":\n", + " self.phase_ref+=180\n", + " elif g==\"Z/2\":\n", + " self.phase_ref+=90\n", + " elif g==\"-Z/2\":\n", + " self.phase_ref+=-90\n", + " else:\n", + " # self.pulse(ch=self.cfg[\"qubit_ch\"], name=g, phase=deg2reg(self.phase_ref+ginfo[\"phase\"]), gain=ginfo[\"gain\"], play=True)\n", + " pass\n", + " self.setup_and_pulse(ch=self.cfg[\"qubit_ch\"], \n", + " waveform=g, \n", + " phase=self.deg2reg(self.phase_ref+ginfo[\"phase\"]), \n", + " gain=ginfo[\"gain\"], \n", + " style=ginfo[\"style\"],\n", + " freq=self.cfg[\"qubit_freq\"],\n", + " )\n", + "\n", + " self.sync_all(self.us2cycles(0.01)) # align channels and wait 10ns\n", + " # self.trigger_adc(adc1=1, adc2=1, adc_trig_offset=self.cfg[\"adc_trig_offset\"]) # trigger the adc acquisition\n", + " self.trigger(adcs=self.cfg['ro_chs'],\n", + " pins=[0], \n", + " adc_trig_offset=self.cfg[\"adc_trig_offset\"])\n", + " # self.pulse(ch=self.cfg[\"rr_ch\"], length = self.cfg[\"rr_length\"], play=True) # play readout pulse\n", + " self.pulse(ch=self.cfg['rr_ch'], t=0) # play readout pulse\n", + " self.sync_all(self.us2cycles(self.cfg[\"relax_delay\"])) # sync all channels" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3da4c2fa", + "metadata": {}, + "outputs": [], + "source": [ + "from qick.helpers import gauss\n", + "\n", + "pi_sigma = 10 # us2cycles(0.025) -> tProc @384MHz -> 10 cycles\n", + "pi_gain = 1\n", + "pi_2_gain = 1\n", + "nu_q_new = 100\n", + "f_res = 100\n", + "rot_angle = 0\n", + "\n", + "qubit_params = {'pi_sigma': pi_sigma, 'pi_gain': pi_gain, 'pi_2_gain': pi_2_gain}\n", + "\n", + "RO_CH = [0,1]\n", + "\n", + "rb_config = {\n", + " \"ro_chs\" : RO_CH, # --Fixed\n", + " 'qubit_freq' : nu_q_new, 'qubit_ch' : 3, \n", + " 'rr_freq' : f_res, 'rr_ch' : 6, \n", + " 'rr_length' : 3, \n", + " 'rr_gain' : 10000,\n", + " 'rr_phase' : rot_angle, \n", + " \"adc_trig_offset\" : 250, 'beta' : 0,\n", + " # 'relax_delay' : 500,\n", + " 'relax_delay' : 1,\n", + " 'reps' : 1000, 'rounds' : 0,\n", + " 'gate_seq' : generate_rbsequence(3), \n", + " 'gate_set' : {\n", + " \"I\": {\n", + " \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000),\n", + " \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000), \n", + " \"phase\":0, \"gain\":0, \"style\":\"arb\",\n", + " \n", + " },\n", + " \"X\": {\n", + " \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000),\n", + " \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000), \n", + " \"phase\":0, \"gain\":qubit_params['pi_gain'], \"style\":\"arb\",\n", + " },\n", + " \"Y\": {\n", + " \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000),\n", + " \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000),\n", + " \"phase\":-90, \"gain\":qubit_params['pi_gain'], \"style\":\"arb\",\n", + " },\n", + " \"Z\": {\n", + " \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000),\n", + " \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000), \n", + " \"phase\":0, \"gain\":0, \"style\":\"arb\",\n", + " },\n", + " \"X/2\": {\n", + " \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000),\n", + " \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000), \n", + " \"phase\":0, \"gain\":qubit_params['pi_2_gain'], \"style\":\"arb\",\n", + " },\n", + " \"-X/2\": {\n", + " \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000),\n", + " \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000), \n", + " \"phase\":180, \"gain\":qubit_params['pi_2_gain'], \"style\":\"arb\",\n", + " },\n", + "\n", + " \"Y/2\": {\n", + " \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000), \n", + " \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000), \n", + " \"phase\":-90, \"gain\":qubit_params['pi_2_gain'], \"style\":\"arb\",\n", + " },\n", + " \"-Y/2\": {\n", + " \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000), \n", + " \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000), \n", + " \"phase\":90, \"gain\":qubit_params['pi_2_gain'], \"style\":\"arb\",\n", + " },\n", + " \"Z/2\": {\n", + " \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000),\n", + " \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000), \n", + " \"phase\":0, \"gain\":0, \"style\":\"arb\",\n", + " },\n", + " \"-Z/2\": {\n", + " \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000),\n", + " \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,\n", + " length=4*pi_sigma*16,maxv=32000), \n", + " \"phase\":0, \"gain\":0, \"style\":\"arb\",\n", + " },\n", + "\n", + " } \n", + " }\n", + "\n", + "# \"\"\"Testing if it runs\"\"\"\n", + "# # config['gate_seq'] = generate_rbsequence(10)\n", + "# rb_config['gate_seq'] = ['Y', 'X/2']\n", + "# # rb_config['gate_seq'] = ['Y', 'X/2', 'X/2']\n", + "# rb_config['gate_seq'] = ['X', 'Y/2']\n", + "\n", + "\n", + "# print(rb_config['gate_seq'])\n", + "# rb_config['reps'] = 5000\n", + "# rb=RBSequenceProgram(soccfg, cfg=rb_config)\n", + "# results = rb.acquire(soc, load_pulses=True, progress=True)\n", + "# np.mean(results[3])" + ] + }, + { + "cell_type": "markdown", + "id": "c3ae8bf0", + "metadata": {}, + "source": [ + "## Experiment" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "80e8b05f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "- Experiment Start Time: 1761678244290016903 ns\n", + " - Depth array 1 - time: 1761678244293387583 ns, elapsed: 3370680 ns\n", + " - Sequence run time: (0): 2091 ms (1): 2051 ms (2): 2051 ms (3): 2051 ms (4): 2051 ms (5): 2050 ms (6): 2050 ms (7): 2053 ms (8): 2054 ms (9): 2050 ms (10): 2051 ms (11): 2050 ms (12): 2052 ms (13): 2050 ms (14): 2052 ms (15): 2050 ms (16): 2051 ms (17): 2051 ms (18): 2051 ms (19): 2051 ms (20): 2051 ms (21): 2050 ms (22): 2052 ms (23): 2051 ms (24): 2051 ms (25): 2050 ms (26): 2052 ms (27): 2051 ms (28): 2051 ms (29): 2050 ms (30): 2051 ms (31): 2050 ms (32): 2055 ms (33): 2051 ms (34): 2051 ms (35): 2050 ms (36): 2051 ms (37): 2050 ms (38): 2054 ms (39): 2052 ms \n", + " - Sequence Total time: 82668 ms (Run time: 82109 ms - Overhead time: 559 ms)\n", + " - Depth array 16 - time: 1761678326961805924 ns, elapsed: 82671789021 ns\n", + " - Sequence run time: (0): 2062 ms (1): 2061 ms (2): 2062 ms (3): 2067 ms (4): 2063 ms (5): 2069 ms (6): 2063 ms (7): 2061 ms (8): 2067 ms (9): 2062 ms (10): 2061 ms (11): 2061 ms (12): 2061 ms (13): 2061 ms (14): 2062 ms (15): 2061 ms (16): 2061 ms (17): 2061 ms (18): 2061 ms (19): 2061 ms (20): 2068 ms (21): 2061 ms (22): 2062 ms (23): 2062 ms (24): 2062 ms (25): 2061 ms (26): 2062 ms (27): 2061 ms (28): 2061 ms (29): 2063 ms (30): 2061 ms (31): 2061 ms (32): 2069 ms (33): 2062 ms (34): 2061 ms (35): 2061 ms (36): 2061 ms (37): 2061 ms (38): 2062 ms (39): 2061 ms \n", + " - Sequence Total time: 83443 ms (Run time: 82512 ms - Overhead time: 930 ms)\n", + " - Depth array 64 - time: 1761678410405049753 ns, elapsed: 166115032850 ns\n", + " - Sequence run time: (0): 2082 ms (1): 2081 ms (2): 2090 ms (3): 2083 ms (4): 2082 ms (5): 2082 ms (6): 2082 ms (7): 2081 ms (8): 2082 ms (9): 2081 ms (10): 2095 ms (11): 2082 ms (12): 2082 ms (13): 2082 ms (14): 2082 ms (15): 2082 ms (16): 2081 ms (17): 2081 ms (18): 2081 ms (19): 2082 ms (20): 2082 ms (21): 2082 ms (22): 2082 ms (23): 2082 ms (24): 2081 ms (25): 2082 ms (26): 2081 ms (27): 2097 ms (28): 2082 ms (29): 2082 ms (30): 2082 ms (31): 2082 ms (32): 2082 ms (33): 2081 ms (34): 2082 ms (35): 2082 ms (36): 2081 ms (37): 2082 ms (38): 2082 ms (39): 2083 ms \n", + " - Sequence Total time: 85603 ms (Run time: 83322 ms - Overhead time: 2280 ms)\n", + " - Depth array 128 - time: 1761678496008335304 ns, elapsed: 251718318401 ns\n", + " - Sequence run time: (0): 2108 ms (1): 2108 ms (2): 2108 ms (3): 2108 ms (4): 2108 ms (5): 2108 ms (6): 2108 ms (7): 2109 ms (8): 2109 ms (9): 2109 ms (10): 2108 ms (11): 2121 ms (12): 2108 ms (13): 2108 ms (14): 2108 ms (15): 2108 ms (16): 2109 ms (17): 2108 ms (18): 2109 ms (19): 2108 ms (20): 2121 ms (21): 2108 ms (22): 2108 ms (23): 2108 ms (24): 2109 ms (25): 2109 ms (26): 2109 ms (27): 2109 ms (28): 2109 ms (29): 2122 ms (30): 2109 ms (31): 2108 ms (32): 2108 ms (33): 2108 ms (34): 2108 ms (35): 2108 ms (36): 2108 ms (37): 2108 ms (38): 2122 ms (39): 2109 ms \n", + " - Sequence Total time: 88518 ms (Run time: 84407 ms - Overhead time: 4111 ms)\n", + " - Depth array 512 - time: 1761678584526531991 ns, elapsed: 340236515088 ns\n", + " - Sequence run time: (0): 2280 ms (1): 2269 ms (2): 2270 ms (3): 2270 ms (4): 2270 ms (5): 2270 ms (6): 2270 ms (7): 2270 ms (8): 2270 ms (9): 2270 ms (10): 2270 ms (11): 2270 ms (12): 2269 ms (13): 2270 ms (14): 2269 ms (15): 2270 ms (16): 2269 ms (17): 2270 ms (18): 2270 ms (19): 2270 ms (20): 2270 ms (21): 2269 ms (22): 2270 ms (23): 2270 ms (24): 2270 ms (25): 2270 ms (26): 2270 ms (27): 2270 ms (28): 2269 ms (29): 2270 ms (30): 2270 ms (31): 2270 ms (32): 2270 ms (33): 2269 ms (34): 2269 ms (35): 2269 ms (36): 2269 ms (37): 2270 ms (38): 2270 ms (39): 2270 ms \n", + " - Sequence Total time: 107704 ms (Run time: 90816 ms - Overhead time: 16887 ms)\n", + " - Depth array 768 - time: 1761678692230818292 ns, elapsed: 447940801389 ns\n", + " - Sequence run time: (0): 2378 ms (1): 2378 ms (2): 2378 ms (3): 2377 ms (4): 2377 ms (5): 2378 ms (6): 2377 ms (7): 2377 ms (8): 2377 ms (9): 2377 ms (10): 3050 ms (11): 2379 ms (12): 2383 ms (13): 2378 ms (14): 2382 ms (15): 2377 ms (16): 2382 ms (17): 2377 ms (18): 2382 ms (19): 2377 ms (20): 2382 ms (21): 2377 ms (22): 2378 ms (23): 2378 ms (24): 2378 ms (25): 2377 ms (26): 2378 ms (27): 2378 ms (28): 2378 ms (29): 2377 ms (30): 2377 ms (31): 2377 ms (32): 2377 ms (33): 2378 ms (34): 2378 ms (35): 2377 ms (36): 2378 ms (37): 2378 ms (38): 2377 ms (39): 2377 ms \n", + " - Sequence Total time: 119178 ms (Run time: 95816 ms - Overhead time: 23362 ms)\n", + " - Depth array 1024 - time: 1761678811409119857 ns, elapsed: 567119102954 ns\n", + " - Sequence run time: (0): 2485 ms (1): 2485 ms (2): 2485 ms (3): 2486 ms (4): 2485 ms (5): 2484 ms (6): 2485 ms (7): 2485 ms (8): 2485 ms (9): 2485 ms (10): 2485 ms (11): 2485 ms (12): 2486 ms (13): 2485 ms (14): 2485 ms (15): 2485 ms (16): 2485 ms (17): 2485 ms (18): 2485 ms (19): 2485 ms (20): 2486 ms (21): 2491 ms (22): 2490 ms (23): 2490 ms (24): 2490 ms (25): 2489 ms (26): 2489 ms (27): 2489 ms (28): 2490 ms (29): 2486 ms (30): 2485 ms (31): 2485 ms (32): 2485 ms (33): 2485 ms (34): 2485 ms (35): 2485 ms (36): 2485 ms (37): 2484 ms (38): 2486 ms (39): 2485 ms \n", + " - Sequence Total time: 131964 ms (Run time: 99462 ms - Overhead time: 32502 ms)\n", + "- End Time: 1761678943374441906 - elapsed: 699084425003\n" + ] + } + ], + "source": [ + "# from datetime import datetime\n", + "import time\n", + "\n", + "I2 = []\n", + "I2_err = []\n", + "\n", + "# Original settings\n", + "depth_array = [1, 2, 3, 4, 5, 6, 8, 10, 12, 16, 20, 24, 32, 40, 48, 64, 80, 96, 128, 192, \n", + " 256, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024, 1088, 1152, 1216, 1280, 1344, 1408,\n", + " 1472, 1536, 1600, 1664, 1728, 1750]\n", + "rb_config['reps'] = 4000\n", + "rb_config['rounds'] = 0\n", + "variety = 40\n", + "\n", + "# # Test settings 1\n", + "# rb_config['reps'] = 4000\n", + "# depth_array = [1, 16, 128, 1024]\n", + "# variety = 2\n", + "\n", + "# # Test settings 2\n", + "# rb_config['relax_delay'] = 100\n", + "# rb_config['reps'] = 4000\n", + "# depth_array = [1, 16, 64, 128, 512, 768, 1024]\n", + "# variety = 3\n", + "\n", + "# # Test settings 3\n", + "# rb_config['relax_delay'] = 500 # us\n", + "# depth_array = [1, 1024]\n", + "# rb_config['reps'] = 4000\n", + "# variety = 5\n", + "\n", + "# Test settings 4\n", + "rb_config['relax_delay'] = 500 # us\n", + "depth_array = [1, 16, 64, 128, 512, 768, 1024]\n", + "reps = 4000\n", + "variety = 40\n", + "\n", + "exp_start_time_ns = time.time_ns()\n", + "print('- Experiment Start Time: %0d ns' % (exp_start_time_ns))\n", + "\n", + "th = -30\n", + "\n", + "# Loop for different lengths\n", + "for d in depth_array:\n", + " sequence_time_ns = time.time_ns()\n", + " print(' - Depth array %0d - time: %0d ns, elapsed: %0d ns' % (d,sequence_time_ns,(sequence_time_ns-exp_start_time_ns)) )\n", + " i2_temp = []\n", + " run_time_total_ns = 0\n", + " # Loop for different random sequences\n", + " print(' - Sequence run time: ', end=\" \")\n", + " for jj in range(variety):\n", + " rb_config['gate_seq'] = generate_rbsequence(d)\n", + " # print(rb_config['gate_seq'])\n", + " rb = RBSequenceProgram(soccfg, cfg=rb_config)\n", + " # avgi0, avgq0, avgi1, avgq1 = rb.acquire(soc, load_pulses=True, progress=False, debug=False, single_shot=True)\n", + " run_time_start_ns = time.time_ns()\n", + " adc1, adc2 = rb.acquire(soc, progress=False)\n", + " run_time_end_ns = time.time_ns()\n", + " run_time_total_ns += (run_time_end_ns-run_time_start_ns)\n", + " print(' (%0d): %0d ms' % (jj, (run_time_end_ns-run_time_start_ns)/1e6), end=\" \")\n", + " avgi0 = adc1[0]\n", + " avgq0 = adc1[1]\n", + " avgi1 = adc2[0]\n", + " avgq1 = adc2[1]\n", + " df = pd.DataFrame(avgi1, columns=['data'])\n", + " g = df['data'].apply(lambda x: 0 if x < th else 1).mean()\n", + " i2_temp.append(g) \n", + " print('')\n", + " I2.append(np.mean(i2_temp))\n", + " I2_err.append(np.std(i2_temp)/np.sqrt(variety))\n", + " seq_end_time_ns = time.time_ns()\n", + " print(' - Sequence Total time: %0d ms (Run time: %0d ms - Overhead time: %0d ms)' % ((seq_end_time_ns - sequence_time_ns)/1e6, run_time_total_ns/1e6, (seq_end_time_ns - sequence_time_ns)/1e6 - run_time_total_ns/1e6))\n", + "\n", + "exp_end_time_ns = int(time.time_ns())\n", + "print('- End Time: %0d - elapsed: %0d' % (exp_end_time_ns, (exp_end_time_ns-exp_start_time_ns)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5f90c068", + "metadata": {}, + "outputs": [], + "source": [ + "print(rb)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/firmware/notebooks/qick_rb/RB_tProc_v2_experiment.ipynb b/firmware/notebooks/qick_rb/RB_tProc_v2_experiment.ipynb new file mode 100644 index 000000000..732d6463d --- /dev/null +++ b/firmware/notebooks/qick_rb/RB_tProc_v2_experiment.ipynb @@ -0,0 +1,1724 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "32982695-822e-40aa-ac5c-9777a4d94fb2", + "metadata": {}, + "source": [ + "## setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3b5c048a", + "metadata": {}, + "outputs": [], + "source": [ + "# jupyter setup boilerplate\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from qick import *\n", + "\n", + "# for now, all the tProc v2 classes need to be individually imported (can't use qick.*)\n", + "\n", + "# the main program class\n", + "from qick.asm_v2 import AveragerProgramV2\n", + "# for defining sweeps\n", + "from qick.asm_v2 import QickSpan, QickSweep1D" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ab849bc3", + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": "\ntry {\nrequire(['notebook/js/codecell'], function(codecell) {\n codecell.CodeCell.options_default.highlight_modes[\n 'magic_text/x-csrc'] = {'reg':[/^%%microblaze/]};\n Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n Jupyter.notebook.get_cells().map(function(cell){\n if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n });\n});\n} catch (e) {};\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": "\ntry {\nrequire(['notebook/js/codecell'], function(codecell) {\n codecell.CodeCell.options_default.highlight_modes[\n 'magic_text/x-csrc'] = {'reg':[/^%%pybind11/]};\n Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n Jupyter.notebook.get_cells().map(function(cell){\n if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n });\n});\n} catch (e) {};\n" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QICK running on ZCU216, software version 0.2.371\n", + "\n", + "Firmware configuration (built Tue Oct 21 16:43:27 2025):\n", + "\n", + "\tGlobal clocks (MHz): tProc dispatcher timing 430.080, RF reference 245.760\n", + "\tGroups of related clocks: [tProc timing clock, DAC tile 1, DAC tile 2, DAC tile 3], [DAC tile 0], [ADC tile 2]\n", + "\n", + "\t1 signal generator channels:\n", + "\t0:\taxis_signal_gen_v6 - fs=9584.640 Msps, fabric=599.040 MHz\n", + "\t\tenvelope memory: 65536 complex samples (6.838 us)\n", + "\t\t32-bit DDS, range=9584.640 MHz\n", + "\t\tDAC tile 0, blk 0 is 0_228 on JHC1, or QICK box DAC port 0\n", + "\n", + "\t1 readout channels:\n", + "\t0:\taxis_dyn_readout_v1 - configured by tProc output 4\n", + "\t\tfs=2457.600 Msps, decimated=307.200 MHz, 32-bit DDS, range=2457.600 MHz\n", + "\t\taxis_avg_buffer v1.2 (has edge counter, no weights)\n", + "\t\tmemory 8192 accumulated, 4096 decimated (13.333 us)\n", + "\t\ttriggered by tport 10, pin 0, feedback to tProc input 0\n", + "\t\tADC tile 2, blk 0 is 0_226 on JHC7, or QICK box ADC port 4\n", + "\n", + "\t8 digital output pins:\n", + "\t0:\tPMOD0_0_LS\n", + "\t1:\tPMOD0_1_LS\n", + "\t2:\tPMOD0_2_LS\n", + "\t3:\tPMOD0_3_LS\n", + "\t4:\tPMOD0_4_LS\n", + "\t5:\tPMOD0_5_LS\n", + "\t6:\tPMOD0_6_LS\n", + "\t7:\tPMOD0_7_LS\n", + "\n", + "\ttProc: qick_processor (\"v2\") rev 27, core execution clock 200.000 MHz\n", + "\t\tmemories (words): program 16384, data 16384, waveform 1024\n", + "\t\texternal start pin: None\n", + "\t\texternal stop pin: None\n", + "\n", + "\tDDR4 memory buffer: 1073741824 samples (3.495 sec), 128 samples/transfer\n", + "\t\twired to readouts [0]\n", + "\n", + "\tMR buffer: 8192 samples (3.333 us), wired to readouts [0]\n" + ] + } + ], + "source": [ + "# soc = QickSoc('/home/xilinx/jupyter_notebooks/fw/2025-06-15_216_tprocv2r24_standard/qick_216.bit')\n", + "# soc = QickSoc('/home/xilinx/jupyter_notebooks/fw/qick_tprocv2_216_standard_1ch_250828_2/qick_216.bit')\n", + "# soc = QickSoc('/home/xilinx/jupyter_notebooks/fw/qick_tprocv2_216_standard_1ch_250829_2/qick_216.bit')\n", + "soc = QickSoc('/home/xilinx/jupyter_notebooks/fw/qick_tprocv2_216_standard_1ch_251021_1/qick_216.bit')\n", + "\n", + "# soc = QickSoc('/home/xilinx/jupyter_notebooks/fw/qick_tprocv2_111_standard_250801_1/qick_111.bit')\n", + "# soc = QickSoc('/home/xilinx/jupyter_notebooks/fw/qick_tprocv2_111_standard_1ch_251020_1/qick_111.bit')\n", + "\n", + "soccfg = soc\n", + "print(soccfg)" + ] + }, + { + "cell_type": "markdown", + "id": "bb1f8b6c-563f-48b5-a864-4e9adac68a7d", + "metadata": {}, + "source": [ + "## Randomized Benchmarking\n", + "RB sequence generator: based on https://github.com/openquantumhardware/devForLBNL/blob/master/RB_code_demo/20220201-3DTransmon-Chacracterization%2BRB.ipynb\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "d6a246e2", + "metadata": {}, + "outputs": [], + "source": [ + "import random, time\n", + "from qick.asm_v2 import AcquireProgramV2, AveragerProgramV2, AsmV2, AsmInst\n", + "from qick.tprocv2_assembler import LFSR\n", + "\n", + "class RBSequenceProgram(AveragerProgramV2):\n", + "\n", + " def _initialize(self, cfg):\n", + "\n", + " t=time.time_ns(); dbg_i=0\n", + "\n", + " ro_ch = cfg['ro_ch']\n", + " gen_ch = cfg['gen_ch']\n", + "\n", + " self.declare_gen(ch=gen_ch, nqz=1)\n", + " self.declare_readout(ch=ro_ch, length=cfg['ro_len'])\n", + "\n", + " self.add_reg(name='lfsr_seed')\n", + " self.add_reg(name='seq_length')\n", + "\n", + "\n", + " self.gates_set = cfg['gates_set']\n", + "\n", + " if cfg['pulse_len_us']:\n", + " self.gauss_len = cfg['pulse_len_us']\n", + " else:\n", + " # If None generate minimum length gaussian pulses\n", + " self.gauss_len = self.cycles2us(3, gen_ch=gen_ch)\n", + " # self.gauss_len = self.cycles2us(100, gen_ch=gen_ch)\n", + " self.add_gauss(ch=gen_ch, name=\"gauss_env\", sigma=self.gauss_len/10, length=self.gauss_len, even_length=False)\n", + " \n", + " \"\"\"This adds the different types of pulses to the pulse library which can be played on demand later\"\"\"\n", + " gates_print = \"\"\n", + " for gate_idx, gate in enumerate(self.gates_set):\n", + " gates_print += \"%0d: %s ; \"%(gate_idx, gate['gate_symbol'])\n", + " # print(\"%0d: %s\"%(gate_idx, gate['gate_symbol']))\n", + " ginfo = gate['gate_pulse']\n", + " self.add_pulse(ch=gen_ch, name=gate['gate_symbol'],\n", + " style = ginfo[\"style\"],\n", + " envelope = ginfo[\"envelope\"],\n", + " freq = ginfo[\"freq\"],\n", + " phase = ginfo[\"phase\"],\n", + " gain = ginfo[\"gain\"],\n", + " )\n", + " if cfg['verbose']:\n", + " print(gates_print)\n", + "\n", + " # Pulse for Readout\n", + " self.add_pulse(ch=gen_ch, name=\"ro_pulse\", ro_ch=ro_ch, \n", + " style = \"const\", \n", + " freq = cfg['freq'], \n", + " # length = 1.0, \n", + " length = 0.1, \n", + " phase = 0,\n", + " gain = 0.2,\n", + " )\n", + "\n", + " # For debug, pulse to signal end of sequence\n", + " self.add_pulse(ch=gen_ch, name=\"end_seq_pulse\", ro_ch=ro_ch, \n", + " style = \"const\", \n", + " freq = cfg['freq'], \n", + " length = 0.1, \n", + " phase = 0,\n", + " gain = 0.2,\n", + " )\n", + "\n", + " # Subroutine to generate random sequence using tProc LFSR\n", + " sub_gen_rnd_seq = AsmV2()\n", + " if sub_gen_rnd_seq and cfg['use_lfsr']:\n", + " # Initialize Seed of LFSR (write s1/s_rand with seed literal)\n", + " sub_gen_rnd_seq.write_reg(dst='s_rand', src='lfsr_seed')\n", + " # Initialize virtual-Z gate phase accumulator (r10)\n", + " sub_gen_rnd_seq.write_reg(dst='r10', src=0)\n", + "\n", + " # Get Random Gate index\n", + " sub_gen_rnd_seq.label('gen_seq_loop')\n", + "\n", + " sub_gen_rnd_seq.cond_jump(label='gen_seq_end', arg1='seq_length', test='Z', op='-', arg2=0)\n", + "\n", + " # Read LFSR (read s1/s_rand) and trunc to 4 lsbs\n", + " sub_gen_rnd_seq.append_macro(AsmInst(inst={'CMD':\"REG_WR\", 'DST': 'r4', 'SRC':'op', 'OP': 's1 AND #h0F'}, addr_inc=1))\n", + " ## Check if index is within Set Range (r4 - arg2(set_size) < 0)\n", + " sub_gen_rnd_seq.cond_jump(label='gen_seq_loop', arg1='r4', test='NS', op='-', arg2=10) # arg2: size of gates set\n", + "\n", + " # Check if Z gate\n", + " sub_gen_rnd_seq.label('gen_seq_checkZ')\n", + " sub_gen_rnd_seq.cond_jump(label='gen_seq_checkZov2', arg1='r4', test='NZ', op='-', arg2=1) # arg2: index of Z in the gates set\n", + " ## Increment Z-phase accumulator r10\n", + " sub_gen_rnd_seq.inc_reg(dst='r10', src='r9')\n", + " sub_gen_rnd_seq.inc_reg(dst='r10', src='r9')\n", + " sub_gen_rnd_seq.jump(label='gen_seq_pulse')\n", + "\n", + " # Check if Z/2 gate\n", + " sub_gen_rnd_seq.label('gen_seq_checkZov2')\n", + " sub_gen_rnd_seq.cond_jump(label='gen_seq_check-Zov2', arg1='r4', test='NZ', op='-', arg2=4) # arg2: index of Z/2 in the gates set\n", + " ## Increment Z-phase accumulator r10\n", + " sub_gen_rnd_seq.append_macro(AsmInst(inst={'CMD':\"REG_WR\", 'DST': 'r10', 'SRC':'op', 'OP': 'r10 + r9'}, addr_inc=1))\n", + " sub_gen_rnd_seq.jump(label='gen_seq_pulse')\n", + "\n", + " # Check if -Z/2 gate\n", + " sub_gen_rnd_seq.label('gen_seq_check-Zov2')\n", + " sub_gen_rnd_seq.cond_jump(label='gen_seq_pulse', arg1='r4', test='NZ', op='-', arg2=7) # arg2: index of -Z/2 in the gates set\n", + " ## Increment Z-phase accumulator r10\n", + " sub_gen_rnd_seq.append_macro(AsmInst(inst={'CMD':\"REG_WR\", 'DST': 'r10', 'SRC':'op', 'OP': 'r10 - r9'}, addr_inc=1))\n", + "\n", + " # Send pulse to Wave Dispatcher\n", + " sub_gen_rnd_seq.label('gen_seq_pulse')\n", + " ## Write r_wave with corresponding waveform from wmem address\n", + " sub_gen_rnd_seq.append_macro(AsmInst(inst={'CMD':\"REG_WR\", 'DST': 'r_wave', 'SRC':'wmem', 'ADDR':'r4'}, addr_inc=1))\n", + " ## Update r_wave phase w1 with Z-phase accumulator\n", + " sub_gen_rnd_seq.append_macro(AsmInst(inst={'CMD':\"REG_WR\", 'DST': 'w1', 'SRC':'op', 'OP': 'w1 + r10'}, addr_inc=1))\n", + " ## Write r_wave to WPORT\n", + " sub_gen_rnd_seq.append_macro(AsmInst(inst={'CMD':\"WPORT_WR\", 'DST': str(cfg['gen_ch']), 'SRC':'r_wave'}, addr_inc=1))\n", + "\n", + " # Repeat L times\n", + " sub_gen_rnd_seq.label('gen_seq_next_gate')\n", + " sub_gen_rnd_seq.inc_reg(dst='seq_length', src=-1)\n", + " # sub_gen_rnd_seq.cond_jump(label='gen_seq_loop', arg1='seq_length', test='NZ', op='-', arg2=0)\n", + " sub_gen_rnd_seq.jump(label='gen_seq_loop')\n", + "\n", + " sub_gen_rnd_seq.label('gen_seq_end')\n", + "\n", + " # End of subroutine\n", + " self.add_subroutine(\"gen_rnd_seq\", sub_gen_rnd_seq)\n", + "\n", + " # Configure Readout\n", + " self.add_readoutconfig(ch=ro_ch, name=\"measure\", freq=cfg['freq'], gen_ch=gen_ch)\n", + "\n", + " # send the config to the dynamic RO\n", + " self.send_readoutconfig(ch=cfg['ro_ch'], name=\"measure\", t=0.0)\n", + "\n", + " t=time.time_ns(); \n", + " # print(' // DBG RB initialize(): %0d - %0d ns' % (dbg_i, time.time_ns()-t)); t=time.time_ns(); dbg_i+=1\n", + "\n", + "\n", + " def _body(self, cfg):\n", + " t=time.time_ns(); dbg_i=0\n", + " # print(' // DBG RB body() start: %0d - %0d ns' % (dbg_i, time.time_ns()-t)); t=time.time_ns(); dbg_i+=1\n", + "\n", + " ## N_G: number of different gates sequences: e.g.: 5\n", + " N_G = cfg['N_G']\n", + " ## N_L: number of length of the sequences - e.g.: 3\n", + " N_L = cfg['N_L']\n", + " ## l: length of sequences - e.g.: [10, 100, 1000]\n", + " L = cfg['L']\n", + " ## N_E: number of times the same sequence is applied\n", + " N_E = cfg['N_E']\n", + "\n", + " # Initialize total iterations counter (for debug)\n", + " self.write_reg(dst='r8', src=0)\n", + " # Convert 90deg to phase representation value in r9\n", + " self.write_reg(dst='r9', src=self.deg2reg(deg=90, gen_ch=self.cfg[\"gen_ch\"]))\n", + "\n", + " # Wait for 1us from reference_time\n", + " self.delay(1.0)\n", + "\n", + " # Pause tProc until absolute time matches reference time (mainly to align stages in simulation)\n", + " self.wait(0.0)\n", + "\n", + " # Iterate over different sequences\n", + " for n_g in range(0, N_G):\n", + " \n", + " # Iterate over different lengths\n", + " for n_l in range(0, N_L):\n", + " dbg_i=0\n", + " # Generate a random sequence of length l\n", + " if cfg['lfsr_seed']:\n", + " seed = cfg['lfsr_seed']\n", + " else:\n", + " seed = np.random.randint(123456789,987654321)\n", + " # print('Sequence Seed: %0d' % (seed))\n", + "\n", + " t=time.time_ns(); \n", + " if cfg['test_seq']:\n", + " depth = len(cfg['test_seq'])\n", + " self.gate_seq = cfg['test_seq']\n", + " else:\n", + " depth = L[n_l]\n", + " self.gate_seq = self.generate_rbsequence(depth=depth, gates_set=self.gates_set, use_lfsr=cfg['use_lfsr'], lfsr_seed=seed)\n", + " # print(' // DBG generate_rbsequence: %0d - %0d ns' % (dbg_i, time.time_ns()-t)); t=time.time_ns(); dbg_i+=1\n", + "\n", + "\n", + " self.seq_load_time = len(self.gate_seq) * 40 * 0.005\n", + " self.seq_play_time = len(self.gate_seq) * self.gauss_len\n", + "\n", + " # for n_e in range(0, N_E):\n", + " for n_e in range(0, 1):\n", + " # self.open_loop(n=N_E, name='N_E_loop_%0d'%(n_g*N_L+n_l))\n", + " # if (True): # just to indent\n", + "\n", + " if cfg['verbose']:\n", + " print(self.gate_seq) # for debug\n", + " print('Sequence Load Time: %0.3f us'%(self.seq_load_time))\n", + " print('Sequence Play Time: %0.3f us'%(self.seq_play_time))\n", + "\n", + " if cfg['use_lfsr']:\n", + " # Delay start of play sequence\n", + " ## Increase reference_time in delay time (delay should be the estimated time in takes to write the full sequence in the dispatcher)\n", + " self.delay(self.seq_load_time, tag='pre_seq_delay_%0d%0d%0d'%(n_g,n_l,n_e))\n", + " # self.delay(self.seq_load_time, tag='pre_seq_delay_%0d%0d%0d'%(n_g,n_l,0))\n", + "\n", + " if not cfg['use_lfsr']:\n", + " self.phase_ref = 0\n", + " self.write_reg(dst='r10', src=0)\n", + " for gate_symbol in self.gate_seq:\n", + " \"\"\"For the Z gates (virtual rotation), we need to advance the phase of all the pulses which follows afterwards\"\"\"\n", + " if gate_symbol == \"Z\":\n", + " self.phase_ref += 180\n", + " self.inc_reg(dst='r10', src=self.deg2reg(deg=180, gen_ch=self.cfg[\"gen_ch\"]))\n", + " # self.call(\"virt_z\")\n", + " elif gate_symbol == \"Z/2\":\n", + " self.phase_ref += 90\n", + " self.inc_reg(dst='r10', src=self.deg2reg(deg=90, gen_ch=self.cfg[\"gen_ch\"]))\n", + " # self.call(\"virt_z_ov_2\")\n", + " elif gate_symbol == \"-Z/2\":\n", + " self.phase_ref += -90\n", + " self.inc_reg(dst='r10', src=self.deg2reg(deg=-90, gen_ch=self.cfg[\"gen_ch\"]))\n", + " # self.call(\"virt_z_ov_2\")\n", + " else:\n", + " # self.pulse(ch=self.cfg[\"qubit_ch\"], name=gate, phase=deg2reg(self.phase_ref+ginfo[\"phase\"]), gain=ginfo[\"gain\"], play=True)\n", + " # self.pulse(ch=self.cfg[\"gen_ch\"], name=gate, phase=ginfo[\"phase\"]+self.phase_ref, gain=ginfo[\"gain\"])\n", + " # self.pulse(ch=self.cfg[\"gen_ch\"], name=gate, t='auto')\n", + " pass\n", + " # # Execute always even if Z gate to see the same number of pulses as gates\n", + " # self.pulse(ch=self.cfg[\"gen_ch\"], name=gate, t='auto')\n", + " gate_idx = next((idx for idx, gate in enumerate(self.gates_set) if gate['gate_symbol'] == gate_symbol), -1)\n", + " self.write_reg(dst='r4', src=gate_idx)\n", + " ## Write r_wave with corresponding waveform from wmem address\n", + " self.append_macro(AsmInst(inst={'CMD':\"REG_WR\", 'DST': 'r_wave', 'SRC':'wmem', 'ADDR':'r4'}, addr_inc=1))\n", + " ## Update r_wave phase w1 with Z-phase accumulator\n", + " self.append_macro(AsmInst(inst={'CMD':\"REG_WR\", 'DST': 'w1', 'SRC':'op', 'OP': 'w1 + r10'}, addr_inc=1))\n", + " ## Write r_wave to WPORT\n", + " self.append_macro(AsmInst(inst={'CMD':\"WPORT_WR\", 'DST': str(cfg['gen_ch']), 'SRC':'r_wave'}, addr_inc=1))\n", + "\n", + " # print(' // DBG RB gate_seq code NO_LFSR: %0d - %0d ns' % (dbg_i, time.time_ns()-t)); t=time.time_ns(); dbg_i+=1\n", + "\n", + " else:\n", + " # Initialize tProc LFSR, Configure LFSR seed in lfsr_seed\n", + " self.write_reg(dst='lfsr_seed', src=seed)\n", + " # Configure Random Sequence Length in seq_length\n", + " self.write_reg(dst='seq_length', src=depth-1)\n", + " # Generate Random Sequence - will generate the same sequence as python generate_rbsequence()\n", + " self.call(\"gen_rnd_seq\")\n", + " # Add last gate (taken from the python generated sequence)\n", + " last_gate_idx = next((idx for idx, gate in enumerate(self.gates_set) if gate['gate_symbol'] == self.gate_seq[-1]), -1)\n", + " # gate = self.gate_seq[-1]\n", + " # self.pulse(ch=self.cfg[\"gen_ch\"], name=gate, t=0.0)\n", + " self.write_reg(dst='r4', src=last_gate_idx)\n", + " ## Write r_wave with corresponding waveform from wmem address\n", + " self.append_macro(AsmInst(inst={'CMD':\"REG_WR\", 'DST': 'r_wave', 'SRC':'wmem', 'ADDR':'r4'}, addr_inc=1))\n", + " ## Update r_wave phase w1 with Z-phase accumulator\n", + " self.append_macro(AsmInst(inst={'CMD':\"REG_WR\", 'DST': 'w1', 'SRC':'op', 'OP': 'w1 + r10'}, addr_inc=1))\n", + " ## Write r_wave to WPORT\n", + " self.append_macro(AsmInst(inst={'CMD':\"WPORT_WR\", 'DST': str(cfg['gen_ch']), 'SRC':'r_wave'}, addr_inc=1))\n", + "\n", + " # print(' // DBG RB gate_seq code LFSR: %0d - %0d ns' % (dbg_i, time.time_ns()-t)); t=time.time_ns(); dbg_i+=1\n", + "\n", + "\n", + " if cfg['acquire_mode'] == 'DEC':\n", + " # Generate readout pulse\n", + " # self.send_readoutconfig(ch=cfg['ro_ch'], name=\"measure\", t=0.0)\n", + "\n", + " # Send Readout Pulse\n", + " self.pulse(ch=cfg[\"gen_ch\"], name='ro_pulse', t=0.0)\n", + "\n", + " # Trigger to capture the full sequence before being played\n", + " self.trigger(ros=[cfg['ro_ch']], pins=[0], t=cfg['trig_time'], ddr4=True)\n", + "\n", + " # Delay until the sequence is applied (will be proportional to sequence length)\n", + " self.delay(self.seq_play_time, tag='post_seq_delay_%0d%0d%0d'%(n_g,n_l,n_e))\n", + " # self.delay(self.seq_play_time, tag='post_seq_delay_%0d%0d%0d'%(n_g,n_l,0))\n", + "\n", + " if cfg['acquire_mode'] == 'AVG':\n", + " # Generate readout pulse\n", + " # self.send_readoutconfig(ch=cfg['ro_ch'], name=\"measure\", t=0.0)\n", + "\n", + " # Send Readout Pulse\n", + " self.pulse(ch=cfg[\"gen_ch\"], name='ro_pulse', t=0.0)\n", + "\n", + " # Trigger after the sequence has been played\n", + " self.trigger(ros=[cfg['ro_ch']], pins=[0], t=0.0, ddr4=False)\n", + "\n", + " # # Add End of Sequence pulse (for debug)\n", + " # self.pulse(ch=cfg[\"gen_ch\"], name='end_seq_pulse', t=0.0)\n", + "\n", + " # Delay some more time to ensure capture has finished\n", + " self.delay(1.0)\n", + "\n", + " # Pause tProc until absolute time matches reference time (mainly to align stages in simulation)\n", + " self.wait(0.0)\n", + "\n", + " # Increment total iterations counter (for debug)\n", + " self.inc_reg(dst='r8', src=1)\n", + "\n", + " # self.close_loop()\n", + "\n", + " # print(' // DBG RB N_E Loop: %0d - %0d ns' % (dbg_i, time.time_ns()-t)); t=time.time_ns(); dbg_i+=1\n", + "\n", + " def generate_rbsequence(self, depth, gates_set, use_lfsr=False, lfsr_seed=0):\n", + " \"\"\"Single qubit RB program to generate a sequence of 'd' gates followed \n", + " by an inverse gate to bring the qubit back in 'g' state\n", + " \"\"\"\n", + "\n", + " \"\"\"Writing the sequences in terms of Clifford group algebra\n", + " The Clifford gate set forms a closed group => \n", + " 1. Multiplication of any two gates results in a gate part of the group \n", + " 2. Each gate has an inverse\n", + " 3. The inverse of a product of multiple Clifford gates is unique\n", + " \"\"\"\n", + " # gate_symbol = ['I', 'Z', 'X', 'Y', 'Z/2', 'X/2', 'Y/2', '-Z/2', '-X/2', '-Y/2']\n", + " inverse_gate_symbol = ['I', '-Y/2', 'X/2', 'X', 'Y/2', '-X/2']\n", + "\n", + " # Generate a random gate sequence of a certain depth 'd'\n", + " gates_symbols = [g['gate_symbol'] for g in gates_set]\n", + " gates_set_size = len(gates_set)\n", + " gate_seq_idx = []\n", + " gate_seq = []\n", + " if not use_lfsr:\n", + " gate_seq_idx = np.random.randint(0,gates_set_size,depth-1)\n", + " else:\n", + " lfsr_gen = LFSR()\n", + " lfsr_gen.seed(lfsr_seed)\n", + " idx = lfsr_seed & 0x0F\n", + " for ii in range(depth-1):\n", + " while (idx > gates_set_size-1):\n", + " idx = lfsr_gen.nxt() & 0x0F\n", + " # lfsr_gen.print(debug=True)\n", + " gate_seq_idx.append(idx)\n", + " idx = gates_set_size\n", + " # print(gate_seq_idx)\n", + " # Map indexes to gates symbol\n", + " gate_seq = [gates_set[i]['gate_symbol'] for i in gate_seq_idx]\n", + "\n", + " # Initial node\n", + " a0 = np.matrix([[1], [0], [0], [0], [0], [0]])\n", + " # print('State Initial: ',a0.T)\n", + " anow = a0\n", + " for ii, gate_symbol in enumerate(gate_seq):\n", + " anow = np.dot(gates_set[gates_symbols.index(gate_symbol)]['gate_matrix'], anow)\n", + " # print('State',ii+1,':',anow.T)\n", + "\n", + " # Get the recover gate\n", + " gate_inverse = inverse_gate_symbol[list(anow).index(max(anow))]\n", + " gate_seq.append(gate_inverse)\n", + "\n", + " # Calculate final state for check\n", + " anow = np.dot(gates_set[gates_symbols.index(gate_inverse)]['gate_matrix'], anow)\n", + " # print('State Final:',anow.T)\n", + "\n", + " return gate_seq\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "a8b9a691", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0: I ; 1: Z ; 2: X ; 3: Y ; 4: Z/2 ; 5: X/2 ; 6: Y/2 ; 7: -Z/2 ; 8: -X/2 ; 9: -Y/2 ; \n", + "['X/2', '-X/2']\n", + "Sequence Load Time: 0.400 us\n", + "Sequence Play Time: 0.200 us\n", + "['X/2', 'X/2', '-Z/2', '-Y/2', '-Y/2']\n", + "Sequence Load Time: 1.000 us\n", + "Sequence Play Time: 0.500 us\n", + "['X/2', '-X/2']\n", + "Sequence Load Time: 0.400 us\n", + "Sequence Play Time: 0.200 us\n", + "['X/2', 'X/2', '-Z/2', '-Y/2', '-Y/2']\n", + "Sequence Load Time: 1.000 us\n", + "Sequence Play Time: 0.500 us\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a4b53aea6d7b4601821f95c4216036c8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "SIM = True\n", + "TRIG_TIME = 0.2\n", + "FREQ = 500\n", + "RO_LEN = 2.0\n", + "USE_LFSR = True\n", + "LFSR_SEED = 123456789\n", + "# LFSR_SEED = None # use None to randomize the seed from python\n", + "ACQUIRE_MODE = 'AVG' # AVG, DEC\n", + "# ACQUIRE_MODE = 'DEC' # AVG, DEC\n", + "\n", + "if SIM:\n", + " GEN_CH = 0 # DAC228_T0_CH0\n", + " RO_CH = 0 # ADC224_T0_CH0\n", + "else:\n", + " GEN_CH = 7 # DAC229_T1_CH3\n", + " RO_CH = 1 # ADC224_T0_CH1\n", + "\n", + "qubit_params = {'pi_gain': 1.0, 'pi_2_gain': 0.5, 'freq': FREQ, 'z_gain': 0.2}\n", + "\n", + "# Define the Gates Set\n", + "\"\"\"Modeled the bloch sphere as 6-node graph, each rotation in the RB sequence is effectively\n", + "exchanging the node label on the bloch sphere.\n", + "For example: Z rotation is doing this: (+Z->+Z, -Z->-Z, +X->+Y, +Y->-X, -X->-Y, -Y->+X)\n", + "\"\"\"\n", + "\"\"\"Matrix columns are [Z, X, Y, -Z, -X, -Y]\"\"\"\n", + "GATES_SET = []\n", + "GATES_SET.append({ 'gate_symbol': 'I',\n", + " 'gate_matrix': np.matrix([[1, 0, 0, 0, 0, 0],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [0, 0, 0, 0, 0, 1]]\n", + " ),\n", + " 'gate_pulse': {\n", + " # \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000),\n", + " # \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000),\n", + " # \"phase\":0, \"gain\":0, \"style\":\"arb\",\n", + " \"style\": \"arb\",\n", + " \"envelope\": \"gauss_env\",\n", + " \"freq\": qubit_params['freq'],\n", + " \"phase\": 0, \n", + " \"gain\": 0.1, \n", + " }\n", + "})\n", + "GATES_SET.append({ 'gate_symbol': 'Z',\n", + " 'gate_matrix': np.matrix([[1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [0, 0, 0, 0, 0, 1],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 1, 0, 0, 0]]\n", + " ),\n", + " 'gate_pulse': {\n", + " # \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000),\n", + " # \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000), \n", + " # \"phase\":0, \"gain\":0, \"style\":\"arb\",\n", + " \"style\": \"arb\",\n", + " \"envelope\": \"gauss_env\",\n", + " \"freq\": qubit_params['freq'],\n", + " \"phase\": 0, \n", + " \"gain\": qubit_params['z_gain'],\n", + " }\n", + "})\n", + "GATES_SET.append({ 'gate_symbol': 'X',\n", + " 'gate_matrix': np.matrix([[0, 0, 0, 1, 0, 0],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1],\n", + " [1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [0, 0, 1, 0, 0, 0]]\n", + " ),\n", + " 'gate_pulse': {\n", + " # \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000),\n", + " # \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000), \n", + " # \"phase\":0, \"gain\":qubit_params['pi_gain'], \"style\":\"arb\",\n", + " \"style\": \"arb\",\n", + " \"envelope\": \"gauss_env\",\n", + " \"freq\": qubit_params['freq'],\n", + " \"phase\": 0, \n", + " \"gain\": qubit_params['pi_gain'], \n", + " }\n", + "})\n", + "GATES_SET.append({ 'gate_symbol': 'Y',\n", + " 'gate_matrix': np.matrix([[0, 0, 0, 1, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [1, 0, 0, 0, 0, 0],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1]]\n", + " ),\n", + " 'gate_pulse': {\n", + " # \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000),\n", + " # \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000),\n", + " # \"phase\":-90, \"gain\":qubit_params['pi_gain'], \"style\":\"arb\",\n", + " \"style\": \"arb\",\n", + " \"envelope\": \"gauss_env\",\n", + " \"freq\": qubit_params['freq'],\n", + " \"phase\": -90, \n", + " \"gain\": qubit_params['pi_gain'], \n", + " }\n", + "})\n", + "GATES_SET.append({ 'gate_symbol': 'Z/2',\n", + " 'gate_matrix': np.matrix([[1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 1, 0]]\n", + " ),\n", + " 'gate_pulse': {\n", + " # \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000),\n", + " # \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000), \n", + " # \"phase\":0, \"gain\":0, \"style\":\"arb\",\n", + " \"style\": \"arb\",\n", + " \"envelope\": \"gauss_env\",\n", + " \"freq\": qubit_params['freq'],\n", + " \"phase\": 0, \n", + " \"gain\": qubit_params['z_gain'],\n", + " }\n", + "})\n", + "GATES_SET.append({ 'gate_symbol': 'X/2',\n", + " 'gate_matrix': np.matrix([[0, 0, 1, 0, 0, 0],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 0, 0, 0, 0, 1],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [1, 0, 0, 0, 0, 0]]\n", + " ),\n", + " 'gate_pulse': {\n", + " # \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000),\n", + " # \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000), \n", + " # \"phase\":0, \"gain\":qubit_params['pi_2_gain'], \"style\":\"arb\",\n", + " \"style\": \"arb\",\n", + " \"envelope\": \"gauss_env\",\n", + " \"freq\": qubit_params['freq'],\n", + " \"phase\": 0, \n", + " \"gain\": qubit_params['pi_2_gain'], \n", + " }\n", + "})\n", + "GATES_SET.append({ 'gate_symbol': 'Y/2',\n", + " 'gate_matrix': np.matrix([[0, 0, 0, 0, 1, 0],\n", + " [1, 0, 0, 0, 0, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 0, 0, 0, 0, 1]]\n", + " ),\n", + " 'gate_pulse': {\n", + " # \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000), \n", + " # \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000), \n", + " # \"phase\":-90, \"gain\":qubit_params['pi_2_gain'], \"style\":\"arb\",\n", + " \"style\": \"arb\",\n", + " \"envelope\": \"gauss_env\",\n", + " \"freq\": qubit_params['freq'],\n", + " \"phase\": -90, \n", + " \"gain\": qubit_params['pi_2_gain'], \n", + " }\n", + "})\n", + "GATES_SET.append({ 'gate_symbol': '-Z/2',\n", + " 'gate_matrix': np.matrix([[1, 0, 0, 0, 0, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 0, 0, 0, 0, 1],\n", + " [0, 1, 0, 0, 0, 0]]\n", + " ),\n", + " 'gate_pulse': {\n", + " # \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000),\n", + " # \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000), \n", + " # \"phase\":0, \"gain\":0, \"style\":\"arb\",\n", + " \"style\": \"arb\",\n", + " \"envelope\": \"gauss_env\",\n", + " \"freq\": qubit_params['freq'],\n", + " \"phase\": 0, \n", + " \"gain\": qubit_params['z_gain'],\n", + " }\n", + "})\n", + "GATES_SET.append({ 'gate_symbol': '-X/2',\n", + " 'gate_matrix': np.matrix([[0, 0, 0, 0, 0, 1],\n", + " [0, 1, 0, 0, 0, 0],\n", + " [1, 0, 0, 0, 0, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [0, 0, 0, 1, 0, 0]]\n", + " ),\n", + " 'gate_pulse': {\n", + " # \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000),\n", + " # \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000), \n", + " # \"phase\":180, \"gain\":qubit_params['pi_2_gain'], \"style\":\"arb\",\n", + " \"style\": \"arb\",\n", + " \"envelope\": \"gauss_env\",\n", + " \"freq\": qubit_params['freq'],\n", + " \"phase\": 180, \n", + " \"gain\": qubit_params['pi_2_gain'], \n", + " }\n", + "})\n", + "GATES_SET.append({ 'gate_symbol': '-Y/2',\n", + " 'gate_matrix': np.matrix([[0, 1, 0, 0, 0, 0],\n", + " [0, 0, 0, 1, 0, 0],\n", + " [0, 0, 1, 0, 0, 0],\n", + " [0, 0, 0, 0, 1, 0],\n", + " [1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 0, 1]]\n", + " ),\n", + " 'gate_pulse': {\n", + " # \"idata\": gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000), \n", + " # \"qdata\": 0*gauss(mu=pi_sigma*16*4/2,si=pi_sigma*16,length=4*pi_sigma*16,maxv=32000), \n", + " # \"phase\":90, \"gain\":qubit_params['pi_2_gain'], \"style\":\"arb\",\n", + " \"style\": \"arb\",\n", + " \"envelope\": \"gauss_env\",\n", + " \"freq\": qubit_params['freq'],\n", + " \"phase\": 90, \n", + " \"gain\": qubit_params['pi_2_gain'], \n", + " }\n", + "})\n", + "\n", + "\n", + "# Configure tProc LFSR to step on s1/s_rand read\n", + "soc.tproc.set_lfsr_cfg(2)\n", + "\n", + "rb_config = {\n", + " 'gen_ch' : GEN_CH,\n", + " 'ro_ch' : RO_CH,\n", + " 'ro_len' : RO_LEN,\n", + " 'freq' : FREQ,\n", + " 'trig_time' : TRIG_TIME,\n", + " 'acquire_mode' : ACQUIRE_MODE,\n", + " 'relax_delay' : 1,\n", + " # 'rounds' : 1,\n", + " 'gates_set' : GATES_SET,\n", + " 'pulse_len_us' : 0.01,\n", + " 'test_seq' : None,\n", + " 'use_lfsr' : USE_LFSR,\n", + " 'lfsr_seed' : LFSR_SEED,\n", + " 'N_G' : 1,\n", + " 'N_L' : 3,\n", + " 'L' : np.array([1, 3, 5]).dot(1),\n", + " 'N_E' : 1\n", + " }\n", + "\n", + "\n", + "# # Experiment Settings\n", + "# rb_config['L'] = [1, 2, 3, 4, 5, 6, 8, 10, 12, 16, 20, 24, 32, 40, 48, 64, 80, 96, 128, 192, \n", + "# 256, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024, 1088, 1152, 1216, 1280, 1344, 1408,\n", + "# 1472, 1536, 1600, 1664, 1728, 1750]\n", + "# rb_config['N_L'] = len(rb_config['L'])\n", + "# rb_config['N_G'] = 40\n", + "# rb_config['N_E'] = 4000\n", + "\n", + "# # Test settings 1a - Averaged Acquire - NO LSFR\n", + "# rb_config['acquire_mode'] = 'AVG'\n", + "# rb_config['use_lfsr'] = False\n", + "# rb_config['L'] = [1, 16, 64, 128, 512, 768, 1024]\n", + "# # rb_config['L'] = [1, 16, 64]\n", + "# rb_config['L'] = [768, 16, 1]\n", + "# # rb_config['L'] = [2, 3]\n", + "# rb_config['N_L'] = len(rb_config['L'])\n", + "# rb_config['N_G'] = 1 # a.k.a: rounds\n", + "# rb_config['N_E'] = 1 # a.k.a: reps\n", + "# rb_config['verbose'] = True\n", + "\n", + "# # Test settings 1b - Averaged Acquire - LSFR\n", + "# rb_config['acquire_mode'] = 'AVG'\n", + "# rb_config['use_lfsr'] = True\n", + "# rb_config['L'] = [1, 16, 64, 128, 512, 768, 1024]\n", + "# # rb_config['L'] = [1, 16, 64]\n", + "# rb_config['L'] = [768, 16, 1]\n", + "# # rb_config['L'] = [2, 3]\n", + "# rb_config['N_L'] = len(rb_config['L'])\n", + "# rb_config['N_G'] = 1 # a.k.a: rounds\n", + "# rb_config['N_E'] = 1 # a.k.a: reps\n", + "# rb_config['verbose'] = True\n", + "\n", + "# Test settings 2a - Decimation Acquire - NO LFSR\n", + "rb_config['acquire_mode'] = 'DEC'\n", + "rb_config['ro_len'] = 1.0\n", + "rb_config['pulse_len_us'] = 0.1\n", + "rb_config['use_lfsr'] = False\n", + "rb_config['L'] = [2, 5]\n", + "rb_config['N_L'] = len(rb_config['L'])\n", + "rb_config['N_G'] = 2 # a.k.a: rounds\n", + "rb_config['N_E'] = 1 # a.k.a: reps\n", + "rb_config['verbose'] = True\n", + "\n", + "# Test settings 2b - Decimation Acquire - LFSR\n", + "rb_config['acquire_mode'] = 'DEC'\n", + "rb_config['ro_len'] = 1.0\n", + "rb_config['pulse_len_us'] = 0.1\n", + "rb_config['use_lfsr'] = True\n", + "rb_config['L'] = [2, 5]\n", + "rb_config['N_L'] = len(rb_config['L'])\n", + "rb_config['N_G'] = 2 # a.k.a: rounds\n", + "rb_config['N_E'] = 1 # a.k.a: reps\n", + "rb_config['verbose'] = True\n", + "\n", + "\n", + "prog = RBSequenceProgram(soccfg, reps=rb_config['N_E'], final_delay=rb_config['relax_delay'], cfg=rb_config)\n", + "\n", + "\n", + "if (rb_config['acquire_mode'] == 'DEC'):\n", + " iq_list = prog.acquire_decimated(soc, rounds=1)\n", + " t = prog.get_time_axis(ro_index=0)\n", + "\n", + " if rb_config['N_E'] > 1:\n", + " iq_list = iq_list[0]\n", + "\n", + " print(iq_list[0].shape)\n", + "\n", + " plt.figure(figsize=[20,15])\n", + " N = len(iq_list[0])\n", + " for trig, iq in enumerate(iq_list[0]):\n", + " plt.subplot(N,1,trig+1)\n", + " plt.plot(t, iq[:,0], label=\"I value\")\n", + " plt.plot(t, iq[:,1], label=\"Q value\")\n", + " plt.plot(t, np.abs(iq.dot([1,1j])), label=\"magnitude\", ls='--')\n", + " plt.legend()\n", + " plt.ylabel(\"a.u.\")\n", + " plt.xlabel(\"us\")\n", + "\n", + "\n", + "if (rb_config['acquire_mode'] == 'AVG'):\n", + " iq_list = prog.acquire(soc, rounds=1)\n", + " # iq_list = prog.acquire(soc, rounds=rb_config['N_G'])\n", + "\n", + " print(iq_list[0].shape)\n", + "\n", + " plt.figure(figsize=[20,10])\n", + " plt.plot(np.abs(iq_list[0].dot([1,1j])), label=\"magnitude\", ls='--', marker='x')\n", + " plt.legend()\n", + " plt.ylabel(\"a.u.\")\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1512a77e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "macros:\n", + "\tWriteReg(dst='s_core_w1', src=0)\n", + "\tConfigReadout(ch=0, name='measure', t=0.0, tag=None, t_params={'t': }, t_regs={'t': 0})\n", + "\tDelay(t=1.0, auto=True, gens=True, ros=True, tag=None, t_params={'t': }, t_regs={'t': 430})\n", + "\tOpenLoop(n=1, name='reps')\n", + "\tWriteReg(dst='r8', src=0)\n", + "\tWriteReg(dst='r9', src=1073741824)\n", + "\tDelay(t=1.0, auto=False, tag=None, t_params={'t': }, t_regs={'t': 430})\n", + "\tWait(t=0.0, auto=False, tag=None, no_warn=False, t_params={'t': }, t_regs={'t': 0})\n", + "\tDelay(t=2.0, auto=False, tag='pre_seq_delay_000', t_params={'t': }, t_regs={'t': 860})\n", + "\tWriteReg(dst='lfsr_seed', src=123456789)\n", + "\tWriteReg(dst='seq_length', src=9)\n", + "\tCall(label='gen_rnd_seq')\n", + "\tWriteReg(dst='r4', src=2)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'r_wave', 'SRC': 'wmem', 'ADDR': 'r4'}, addr_inc=1)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'w1', 'SRC': 'op', 'OP': 'w1 + r10'}, addr_inc=1)\n", + "\tAsmInst(inst={'CMD': 'WPORT_WR', 'DST': '0', 'SRC': 'r_wave'}, addr_inc=1)\n", + "\tPulse(ch=0, name='ro_pulse', t=0.0, tag=None, t_params={'t': }, t_regs={'t': 0})\n", + "\tTrigger(ros=[0], tts=[], pins=[0], t=0.2, width=0.023251488095238096, ddr4=True, mr=False, tag=None, t_params={'t': , 'width': }, t_regs={'t': 86, 'width': 10}, outdict=defaultdict(, {}), trigset={0, 9, 10})\n", + "\tDelay(t=1.0, auto=False, tag='post_seq_delay_000', t_params={'t': }, t_regs={'t': 430})\n", + "\tDelay(t=1.0, auto=False, tag=None, t_params={'t': }, t_regs={'t': 430})\n", + "\tWait(t=0.0, auto=False, tag=None, no_warn=False, t_params={'t': }, t_regs={'t': 0})\n", + "\tIncReg(dst='r8', src=1)\n", + "\tDelay(t=2.0, auto=False, tag='pre_seq_delay_100', t_params={'t': }, t_regs={'t': 860})\n", + "\tWriteReg(dst='lfsr_seed', src=123456789)\n", + "\tWriteReg(dst='seq_length', src=9)\n", + "\tCall(label='gen_rnd_seq')\n", + "\tWriteReg(dst='r4', src=2)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'r_wave', 'SRC': 'wmem', 'ADDR': 'r4'}, addr_inc=1)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'w1', 'SRC': 'op', 'OP': 'w1 + r10'}, addr_inc=1)\n", + "\tAsmInst(inst={'CMD': 'WPORT_WR', 'DST': '0', 'SRC': 'r_wave'}, addr_inc=1)\n", + "\tPulse(ch=0, name='ro_pulse', t=0.0, tag=None, t_params={'t': }, t_regs={'t': 0})\n", + "\tTrigger(ros=[0], tts=[], pins=[0], t=0.2, width=0.023251488095238096, ddr4=True, mr=False, tag=None, t_params={'t': , 'width': }, t_regs={'t': 86, 'width': 10}, outdict=defaultdict(, {}), trigset={0, 9, 10})\n", + "\tDelay(t=1.0, auto=False, tag='post_seq_delay_100', t_params={'t': }, t_regs={'t': 430})\n", + "\tDelay(t=1.0, auto=False, tag=None, t_params={'t': }, t_regs={'t': 430})\n", + "\tWait(t=0.0, auto=False, tag=None, no_warn=False, t_params={'t': }, t_regs={'t': 0})\n", + "\tIncReg(dst='r8', src=1)\n", + "\tWait(t=0, auto=True, gens=False, ros=True, tag=None, no_warn=True, t_params={'t': }, t_regs={'t': 0})\n", + "\tDelay(t=1, auto=True, gens=True, ros=True, tag=None, t_params={'t': }, t_regs={'t': 430})\n", + "\tIncReg(dst='s_core_w1', src=1)\n", + "\tCloseLoop()\n", + "\tEnd()\n", + "\tLabel(label='gen_rnd_seq')\n", + "\tWriteReg(dst='s_rand', src='lfsr_seed')\n", + "\tWriteReg(dst='r10', src=0)\n", + "\tLabel(label='gen_seq_loop')\n", + "\tCondJump(label='gen_seq_end', arg1='seq_length', test='Z', op='-', arg2=0)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'r4', 'SRC': 'op', 'OP': 's1 AND #h0F'}, addr_inc=1)\n", + "\tCondJump(label='gen_seq_loop', arg1='r4', test='NS', op='-', arg2=10)\n", + "\tLabel(label='gen_seq_checkZ')\n", + "\tCondJump(label='gen_seq_checkZov2', arg1='r4', test='NZ', op='-', arg2=1)\n", + "\tIncReg(dst='r10', src='r9')\n", + "\tIncReg(dst='r10', src='r9')\n", + "\tJump(label='gen_seq_pulse')\n", + "\tLabel(label='gen_seq_checkZov2')\n", + "\tCondJump(label='gen_seq_check-Zov2', arg1='r4', test='NZ', op='-', arg2=4)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'r10', 'SRC': 'op', 'OP': 'r10 + r9'}, addr_inc=1)\n", + "\tJump(label='gen_seq_pulse')\n", + "\tLabel(label='gen_seq_check-Zov2')\n", + "\tCondJump(label='gen_seq_pulse', arg1='r4', test='NZ', op='-', arg2=7)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'r10', 'SRC': 'op', 'OP': 'r10 - r9'}, addr_inc=1)\n", + "\tLabel(label='gen_seq_pulse')\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'r_wave', 'SRC': 'wmem', 'ADDR': 'r4'}, addr_inc=1)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'w1', 'SRC': 'op', 'OP': 'w1 + r10'}, addr_inc=1)\n", + "\tAsmInst(inst={'CMD': 'WPORT_WR', 'DST': '0', 'SRC': 'r_wave'}, addr_inc=1)\n", + "\tLabel(label='gen_seq_next_gate')\n", + "\tIncReg(dst='seq_length', src=-1)\n", + "\tJump(label='gen_seq_loop')\n", + "\tLabel(label='gen_seq_end')\n", + "\tAsmInst(inst={'CMD': 'RET'}, addr_inc=1)\n", + "registers:\n", + "\tlfsr_seed: QickRegisterV2(addr=0, init=None)\n", + "\tseq_length: QickRegisterV2(addr=1, init=None)\n", + "\treps: QickRegisterV2(addr=2, init=None)\n", + "pulses:\n", + "\tI: QickPulse(waveforms=[Waveform(name='I_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=3276, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tZ: QickPulse(waveforms=[Waveform(name='Z_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=6553, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tX: QickPulse(waveforms=[Waveform(name='X_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=32766, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tY: QickPulse(waveforms=[Waveform(name='Y_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=-1073741824, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=32766, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tZ/2: QickPulse(waveforms=[Waveform(name='Z/2_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=6553, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tX/2: QickPulse(waveforms=[Waveform(name='X/2_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=16383, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tY/2: QickPulse(waveforms=[Waveform(name='Y/2_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=-1073741824, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=16383, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\t-Z/2: QickPulse(waveforms=[Waveform(name='-Z/2_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=6553, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\t-X/2: QickPulse(waveforms=[Waveform(name='-X/2_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=2147483648, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=16383, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\t-Y/2: QickPulse(waveforms=[Waveform(name='-Y/2_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=1073741824, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=16383, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tro_pulse: QickPulse(waveforms=[Waveform(name='ro_pulse_w0', freq=QickRawParam(par='freq', start=224054700, spans={}, quantize=10, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=6553, spans={}, quantize=1, steps={}), length=QickRawParam(par='length', start=60, spans={}, quantize=1, steps={}), conf=9)])\n", + "\tend_seq_pulse: QickPulse(waveforms=[Waveform(name='end_seq_pulse_w0', freq=QickRawParam(par='freq', start=224054700, spans={}, quantize=10, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=6553, spans={}, quantize=1, steps={}), length=QickRawParam(par='length', start=60, spans={}, quantize=1, steps={}), conf=9)])\n", + "\tmeasure: QickPulse(waveforms=[Waveform(name='measure_w0', freq=QickRawParam(par='freq', start=-873813330, spans={}, quantize=-39, steps={}), phase=0, env=0, gain=0, length=3, conf=264)])\n", + "expanded ASM:\n", + "\t NOP \n", + "\t REG_WR s12 imm #0 \n", + "\t WPORT_WR p4 wmem [&12] @0 \n", + "\t TIME #430 inc_ref \n", + "\t REG_WR r2 imm #0 \n", + "\treps:\n", + "\t REG_WR r8 imm #0 \n", + "\t REG_WR r9 imm #1073741824 \n", + "\t TIME #430 inc_ref \n", + "\t REG_WR s15 imm #10 \n", + "\t WAIT [s15] @0 time \n", + "\t TIME #860 inc_ref \n", + "\t REG_WR r0 imm #123456789 \n", + "\t REG_WR r1 imm #9 \n", + "\t REG_WR s15 label gen_rnd_seq \n", + "\t CALL [s15] \n", + "\t REG_WR r4 imm #2 \n", + "\t REG_WR r_wave wmem [r4] \n", + "\t REG_WR w1 op -op(w1 + r10) \n", + "\t WPORT_WR p0 r_wave \n", + "\t WPORT_WR p0 wmem [&10] @0 \n", + "\t TRIG p0 set @86 \n", + "\t TRIG p9 set @86 \n", + "\t TRIG p10 set @86 \n", + "\t TRIG p0 clr @96 \n", + "\t TRIG p9 clr @96 \n", + "\t TRIG p10 clr @96 \n", + "\t TIME #430 inc_ref \n", + "\t TIME #430 inc_ref \n", + "\t REG_WR s15 imm #31 \n", + "\t WAIT [s15] @0 time \n", + "\t REG_WR r8 op -op(r8 + #1) \n", + "\t TIME #860 inc_ref \n", + "\t REG_WR r0 imm #123456789 \n", + "\t REG_WR r1 imm #9 \n", + "\t REG_WR s15 label gen_rnd_seq \n", + "\t CALL [s15] \n", + "\t REG_WR r4 imm #2 \n", + "\t REG_WR r_wave wmem [r4] \n", + "\t REG_WR w1 op -op(w1 + r10) \n", + "\t WPORT_WR p0 r_wave \n", + "\t WPORT_WR p0 wmem [&10] @0 \n", + "\t TRIG p0 set @86 \n", + "\t TRIG p9 set @86 \n", + "\t TRIG p10 set @86 \n", + "\t TRIG p0 clr @96 \n", + "\t TRIG p9 clr @96 \n", + "\t TRIG p10 clr @96 \n", + "\t TIME #430 inc_ref \n", + "\t TIME #430 inc_ref \n", + "\t REG_WR s15 imm #53 \n", + "\t WAIT [s15] @0 time \n", + "\t REG_WR r8 op -op(r8 + #1) \n", + "\t REG_WR s15 imm #57 \n", + "\t WAIT [s15] @0 time \n", + "\t TIME #430 inc_ref \n", + "\t REG_WR s12 op -op(s12 + #1) \n", + "\t REG_WR s15 label reps \n", + "\t TEST -op(r2 - #0) \n", + "\t JUMP [s15] -if(NZ) -wr(r2 op) -op(r2 + #1) \n", + "\t REG_WR s15 imm #64 \n", + "\t JUMP [s15] \n", + "\tgen_rnd_seq:\n", + "\t REG_WR s1 op -op(r0) \n", + "\t REG_WR r10 imm #0 \n", + "\tgen_seq_loop:\n", + "\t REG_WR s15 label gen_seq_end \n", + "\t TEST -op(r1 - #0) -uf \n", + "\t JUMP [s15] -if(Z) \n", + "\t REG_WR r4 op -op(s1 AND #h0F) \n", + "\t REG_WR s15 label gen_seq_loop \n", + "\t TEST -op(r4 - #10) -uf \n", + "\t JUMP [s15] -if(NS) \n", + "\tgen_seq_checkZ:\n", + "\t REG_WR s15 label gen_seq_checkZov2 \n", + "\t TEST -op(r4 - #1) -uf \n", + "\t JUMP [s15] -if(NZ) \n", + "\t REG_WR r10 op -op(r10 + r9) \n", + "\t REG_WR r10 op -op(r10 + r9) \n", + "\t REG_WR s15 label gen_seq_pulse \n", + "\t JUMP [s15] \n", + "\tgen_seq_checkZov2:\n", + "\t REG_WR s15 label gen_seq_check-Zov2 \n", + "\t TEST -op(r4 - #4) -uf \n", + "\t JUMP [s15] -if(NZ) \n", + "\t REG_WR r10 op -op(r10 + r9) \n", + "\t REG_WR s15 label gen_seq_pulse \n", + "\t JUMP [s15] \n", + "\tgen_seq_check-Zov2:\n", + "\t REG_WR s15 label gen_seq_pulse \n", + "\t TEST -op(r4 - #7) -uf \n", + "\t JUMP [s15] -if(NZ) \n", + "\t REG_WR r10 op -op(r10 - r9) \n", + "\tgen_seq_pulse:\n", + "\t REG_WR r_wave wmem [r4] \n", + "\t REG_WR w1 op -op(w1 + r10) \n", + "\t WPORT_WR p0 r_wave \n", + "\tgen_seq_next_gate:\n", + "\t REG_WR r1 op -op(r1 + #-1) \n", + "\t REG_WR s15 label gen_seq_loop \n", + "\t JUMP [s15] \n", + "\tgen_seq_end:\n", + "\tRET\n", + "\n", + "// PMEM content\n", + "000000000000000000\n", + "8c600000000000000c\n", + "dce001820000000000\n", + "4c080000000000d700\n", + "8c6000000000000022\n", + "8c6000000000000028\n", + "8c6000002000000029\n", + "4c080000000000d700\n", + "8c600000000000050f\n", + "0811000005fffffb00\n", + "2911000005fffffb00\n", + "4c080000000001ae00\n", + "8c60000003ade68aa0\n", + "8c60000000000004a1\n", + "8c600000000000208f\n", + "2c4000000000000000\n", + "8c6000000000000124\n", + "8c4004800000000000\n", + "840000002095000041\n", + "cdc000000000000000\n", + "dce001400000000000\n", + "dda000300000002b00\n", + "dda000348000002b00\n", + "dda000350000002b00\n", + "dda000100000003000\n", + "dda000148000003000\n", + "dda000150000003000\n", + "4c080000000000d700\n", + "4c080000000000d700\n", + "8c6000000000000f8f\n", + "0811000005fffffb00\n", + "2911000005fffffb00\n", + "8800000014000000a8\n", + "4c080000000001ae00\n", + "8c60000003ade68aa0\n", + "8c60000000000004a1\n", + "8c600000000000208f\n", + "2c4000000000000000\n", + "8c6000000000000124\n", + "8c4004800000000000\n", + "840000002095000041\n", + "cdc000000000000000\n", + "dce001400000000000\n", + "dda000300000002b00\n", + "dda000348000002b00\n", + "dda000350000002b00\n", + "dda000100000003000\n", + "dda000148000003000\n", + "dda000150000003000\n", + "4c080000000000d700\n", + "4c080000000000d700\n", + "8c6000000000001a8f\n", + "0811000005fffffb00\n", + "2911000005fffffb00\n", + "8800000014000000a8\n", + "8c6000000000001c8f\n", + "0811000005fffffb00\n", + "2911000005fffffb00\n", + "4c080000000000d700\n", + "88000000060000008c\n", + "8c600000000000028f\n", + "081100001100000000\n", + "2988000011000000a2\n", + "8c600000000000200f\n", + "2c0000000000000000\n", + "840000001000000001\n", + "8c600000000000002a\n", + "8c600000000000308f\n", + "081100001080000000\n", + "2c8000000000000000\n", + "8804000000800007a4\n", + "8c600000000000218f\n", + "081100001200000500\n", + "2e0000000000000000\n", + "8c600000000000288f\n", + "081100001200000080\n", + "2d8000000000000000\n", + "84000000151480002a\n", + "84000000151480002a\n", + "8c6000000000002d8f\n", + "2c0000000000000000\n", + "8c6000000000002b8f\n", + "081100001200000200\n", + "2d8000000000000000\n", + "84000000151480002a\n", + "8c6000000000002d8f\n", + "2c0000000000000000\n", + "8c6000000000002d8f\n", + "081100001200000380\n", + "2d8000000000000000\n", + "84020000151480002a\n", + "8c4004800000000000\n", + "840000002095000041\n", + "cdc000000000000000\n", + "8800000010ffffffa1\n", + "8c600000000000218f\n", + "2c0000000000000000\n", + "2c6000000000000000\n", + "// WMEM content\n", + "// CONF_ LEN_ GAIN_ ENV_ PHASE_ FREQ\n", + "___0008_0000003c_00000ccc_000000_00000000_0d5acdad\n", + "___0008_0000003c_00001999_000000_00000000_0d5acdad\n", + "___0008_0000003c_00007ffe_000000_00000000_0d5acdad\n", + "___0008_0000003c_00007ffe_000000_c0000000_0d5acdad\n", + "___0008_0000003c_00001999_000000_00000000_0d5acdad\n", + "___0008_0000003c_00003fff_000000_00000000_0d5acdad\n", + "___0008_0000003c_00003fff_000000_c0000000_0d5acdad\n", + "___0008_0000003c_00001999_000000_00000000_0d5acdad\n", + "___0008_0000003c_00003fff_000000_80000000_0d5acdad\n", + "___0008_0000003c_00003fff_000000_40000000_0d5acdad\n", + "___0009_0000003c_00001999_000000_00000000_0d5acdac\n", + "___0009_0000003c_00001999_000000_00000000_0d5acdac\n", + "___0108_00000003_00000000_000000_00000000_cbeaaaae\n", + "Dumped SG envelope table memory to file sg_0.mem\n" + ] + } + ], + "source": [ + "# print the program\n", + "print(prog)\n", + "\n", + "# generate rtl simulation inputs\n", + "prog.print_pmem2hex()\n", + "prog.print_wmem2hex()\n", + "prog.print_sg_mem(sg_idx=0, gen_file=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "da2b8ba0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "- Experiment Start Time: 255602 ns\n", + " - Depth array 1 - time elapsed: 3002402 ns\n", + " - Sequence run time: (0): 2023 ms (1): 2021 ms (2): 2021 ms (3): 2021 ms (4): 2021 ms (5): 2021 ms (6): 2025 ms (7): 2021 ms (8): 2021 ms (9): 2021 ms (10): 2021 ms (11): 2021 ms (12): 2025 ms (13): 2021 ms (14): 2021 ms (15): 2021 ms (16): 2021 ms (17): 2021 ms (18): 2025 ms (19): 2021 ms (20): 2021 ms (21): 2021 ms (22): 2021 ms (23): 2021 ms (24): 2025 ms (25): 2021 ms (26): 2021 ms (27): 2021 ms (28): 2021 ms (29): 2021 ms (30): 2025 ms (31): 2021 ms (32): 2021 ms (33): 2021 ms (34): 2021 ms (35): 2021 ms (36): 2025 ms (37): 2021 ms (38): 2021 ms (39): 2021 ms \n", + " - Sequence Total time: 82558 ms (Run time: 80882 ms - Overhead time: 1675 ms)\n", + " - Depth array 16 - time elapsed: 82561095103 ns\n", + " - Sequence run time: (0): 2038 ms (1): 2038 ms (2): 2043 ms (3): 2039 ms (4): 2039 ms (5): 2039 ms (6): 2038 ms (7): 2038 ms (8): 2043 ms (9): 2038 ms (10): 2039 ms (11): 2039 ms (12): 2038 ms (13): 2038 ms (14): 2043 ms (15): 2039 ms (16): 2039 ms (17): 2039 ms (18): 2038 ms (19): 2039 ms (20): 2043 ms (21): 2039 ms (22): 2039 ms (23): 2039 ms (24): 2039 ms (25): 2038 ms (26): 2044 ms (27): 2039 ms (28): 2039 ms (29): 2039 ms (30): 2039 ms (31): 2038 ms (32): 2043 ms (33): 2039 ms (34): 2039 ms (35): 2039 ms (36): 2039 ms (37): 2039 ms (38): 2043 ms (39): 2039 ms \n", + " - Sequence Total time: 83293 ms (Run time: 81595 ms - Overhead time: 1697 ms)\n", + " - Depth array 64 - time elapsed: 165854679625 ns\n", + " - Sequence run time: (0): 2096 ms (1): 2096 ms (2): 2096 ms (3): 2096 ms (4): 2101 ms (5): 2096 ms (6): 2096 ms (7): 2096 ms (8): 2096 ms (9): 2096 ms (10): 2101 ms (11): 2096 ms (12): 2096 ms (13): 2096 ms (14): 2096 ms (15): 2096 ms (16): 2101 ms (17): 2096 ms (18): 2096 ms (19): 2096 ms (20): 2096 ms (21): 2096 ms (22): 2101 ms (23): 2096 ms (24): 2096 ms (25): 2096 ms (26): 2096 ms (27): 2096 ms (28): 2101 ms (29): 2096 ms (30): 2096 ms (31): 2096 ms (32): 2096 ms (33): 2096 ms (34): 2101 ms (35): 2096 ms (36): 2096 ms (37): 2096 ms (38): 2096 ms (39): 2096 ms \n", + " - Sequence Total time: 85653 ms (Run time: 83895 ms - Overhead time: 1757 ms)\n", + " - Depth array 128 - time elapsed: 251508066395 ns\n", + " - Sequence run time: (0): 2178 ms (1): 2174 ms (2): 2173 ms (3): 2173 ms (4): 2173 ms (5): 2173 ms (6): 2178 ms (7): 2174 ms (8): 2173 ms (9): 2173 ms (10): 2173 ms (11): 2173 ms (12): 2178 ms (13): 2173 ms (14): 2173 ms (15): 2173 ms (16): 2173 ms (17): 2173 ms (18): 2178 ms (19): 2173 ms (20): 2173 ms (21): 2173 ms (22): 2173 ms (23): 2173 ms (24): 2178 ms (25): 2173 ms (26): 2173 ms (27): 2173 ms (28): 2173 ms (29): 2173 ms (30): 2178 ms (31): 2173 ms (32): 2173 ms (33): 2173 ms (34): 2173 ms (35): 2173 ms (36): 2178 ms (37): 2173 ms (38): 2173 ms (39): 2173 ms \n", + " - Sequence Total time: 88828 ms (Run time: 86976 ms - Overhead time: 1851 ms)\n", + " - Depth array 512 - time elapsed: 340336535973 ns\n", + " - Sequence run time: (0): 2634 ms (1): 2634 ms (2): 2639 ms (3): 2635 ms (4): 2634 ms (5): 2634 ms (6): 2634 ms (7): 2634 ms (8): 2634 ms (9): 2634 ms (10): 2634 ms (11): 2634 ms (12): 2634 ms (13): 2634 ms (14): 2634 ms (15): 2634 ms (16): 2634 ms (17): 2634 ms (18): 2634 ms (19): 2634 ms (20): 2634 ms (21): 2634 ms (22): 2634 ms (23): 2635 ms (24): 2634 ms (25): 2634 ms (26): 2634 ms (27): 2634 ms (28): 2634 ms (29): 2634 ms (30): 2634 ms (31): 2634 ms (32): 2634 ms (33): 2634 ms (34): 2634 ms (35): 2634 ms (36): 2634 ms (37): 2634 ms (38): 2634 ms (39): 2634 ms \n", + " - Sequence Total time: 109044 ms (Run time: 105378 ms - Overhead time: 3666 ms)\n", + " - Depth array 768 - time elapsed: 449381404075 ns\n", + " - Sequence run time: (0): 2941 ms (1): 2941 ms (2): 2941 ms (3): 2941 ms (4): 2941 ms (5): 2941 ms (6): 2941 ms (7): 2941 ms (8): 2941 ms (9): 2941 ms (10): 2941 ms (11): 2941 ms (12): 2941 ms (13): 2941 ms (14): 2941 ms (15): 2941 ms (16): 2941 ms (17): 2941 ms (18): 2941 ms (19): 2941 ms (20): 2941 ms (21): 2941 ms (22): 2941 ms (23): 2941 ms (24): 2942 ms (25): 2941 ms (26): 2941 ms (27): 2941 ms (28): 2941 ms (29): 2941 ms (30): 2941 ms (31): 2941 ms (32): 2941 ms (33): 2941 ms (34): 2941 ms (35): 2941 ms (36): 2941 ms (37): 2941 ms (38): 2941 ms (39): 2941 ms \n", + " - Sequence Total time: 120182 ms (Run time: 117659 ms - Overhead time: 2523 ms)\n", + " - Depth array 1024 - time elapsed: 569564289222 ns\n", + " - Sequence run time: (0): 3249 ms (1): 3248 ms (2): 3248 ms (3): 3248 ms (4): 3248 ms (5): 3248 ms (6): 3248 ms (7): 3249 ms (8): 3248 ms (9): 3248 ms (10): 3249 ms (11): 3248 ms (12): 3248 ms (13): 3248 ms (14): 3248 ms (15): 3248 ms (16): 3248 ms (17): 3248 ms (18): 3248 ms (19): 3249 ms (20): 3248 ms (21): 3248 ms (22): 3248 ms (23): 3248 ms (24): 3248 ms (25): 3248 ms (26): 3249 ms (27): 3248 ms (28): 3248 ms (29): 3248 ms (30): 3248 ms (31): 3248 ms (32): 3248 ms (33): 3248 ms (34): 3248 ms (35): 3248 ms (36): 3248 ms (37): 3248 ms (38): 3248 ms (39): 3248 ms \n", + " - Sequence Total time: 132758 ms (Run time: 129954 ms - Overhead time: 2804 ms)\n", + "- End Time: 1761689940698562728 - elapsed: 702323504258\n" + ] + } + ], + "source": [ + "# from datetime import datetime\n", + "import time\n", + "import pandas as pd\n", + "\n", + "I2 = []\n", + "I2_err = []\n", + "\n", + "rb_config['L'] = [1]\n", + "rb_config['N_L'] = len(rb_config['L'])\n", + "rb_config['N_G'] = 1 # a.k.a: rounds\n", + "rb_config['N_E'] = 1 # a.k.a: reps\n", + "\n", + "\n", + "# Original Settings\n", + "depth_array = [1, 2, 3, 4, 5, 6, 8, 10, 12, 16, 20, 24, 32, 40, 48, 64, 80, 96, 128, 192, \n", + " 256, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024, 1088, 1152, 1216, 1280, 1344, 1408,\n", + " 1472, 1536, 1600, 1664, 1728, 1750]\n", + "reps = 4000\n", + "variety = 40\n", + "\n", + "\n", + "rb_config['relax_delay'] = 500 # us\n", + "rb_config['pulse_len_us'] = 0.1\n", + "\n", + "# # Test settings 1\n", + "# depth_array = [1, 16, 128, 1024]\n", + "# rb_config['reps'] = 4000\n", + "# variety = 2\n", + "\n", + "\n", + "# Test settings 2a - NO LFSR\n", + "rb_config['verbose'] = False\n", + "rb_config['use_lfsr'] = False\n", + "depth_array = [1, 16, 64, 128, 512, 768, 1024]\n", + "reps = 4000\n", + "variety = 40\n", + "\n", + "# # Test settings 2b - NO LFSR\n", + "# rb_config['verbose'] = False\n", + "# rb_config['use_lfsr'] = False\n", + "# depth_array = [1, 1024]\n", + "# reps = 4000\n", + "# variety = 5\n", + "\n", + "# Test settings 3a - LFSR\n", + "rb_config['verbose'] = False\n", + "rb_config['use_lfsr'] = True\n", + "depth_array = [1, 16, 64, 128, 512, 768, 1024]\n", + "reps = 4000\n", + "variety = 40\n", + "\n", + "# # Test settings 3b - LFSR\n", + "# rb_config['verbose'] = False\n", + "# rb_config['use_lfsr'] = True\n", + "# depth_array = [1, 1024]\n", + "# reps = 4000\n", + "# variety = 5\n", + "\n", + "# # Test settings 4 - LFSR\n", + "# rb_config['verbose'] = False\n", + "# rb_config['use_lfsr'] = True\n", + "# depth_array = [1, 5000]\n", + "# reps = 4000\n", + "# variety = 5\n", + "\n", + "# # Test settings 4 - LFSR\n", + "# rb_config['verbose'] = False\n", + "# rb_config['use_lfsr'] = True\n", + "# depth_array = [10]\n", + "# reps = 4000\n", + "# variety = 5\n", + "\n", + "# Code\n", + "t_start_ns = time.time_ns()\n", + "print('- Experiment Start Time: %0d ns' % (time.time_ns()-t_start_ns))\n", + "\n", + "th = -30\n", + "\n", + "t=time.time_ns()\n", + "\n", + "# Loop for different lengths\n", + "for d in depth_array:\n", + " dbg_i=0\n", + " t_sequence_start_ns = time.time_ns()\n", + " print(' - Depth array %0d - time elapsed: %0d ns' % (d,t_sequence_start_ns-t_start_ns) )\n", + " i2_temp = []\n", + " t_runtime_total_ns = 0\n", + " # Loop for different random sequences\n", + " print(' - Sequence run time: ', end=\" \")\n", + " for jj in range(variety):\n", + " # print('// DBG start: %0d - %0d ns' % (dbg_i, time.time_ns()-t)); t=time.time_ns(); dbg_i+=1\n", + "\n", + " rb_config['test_seq'] = prog.generate_rbsequence(depth=d, gates_set=rb_config['gates_set'])\n", + " # print('// DBG gen_seq: %0d - %0d ns' % (dbg_i, time.time_ns()-t)); t=time.time_ns(); dbg_i+=1\n", + "\n", + " rb_prog = RBSequenceProgram(soccfg, reps=reps, final_delay=rb_config['relax_delay'], cfg=rb_config)\n", + " # print('// DBG RBSeqProgram: %0d - %0d ns' % (dbg_i, time.time_ns()-t)); t=time.time_ns(); dbg_i+=1\n", + "\n", + " t_runtime_start_ns = time.time_ns()\n", + " # avgi0, avgq0, avgi1, avgq1 = rb_prog.acquire(soc, load_pulses=True, progress=False, debug=False, single_shot=True)\n", + " # adc1, adc2 = rb_prog.acquire(soc, progress=False)\n", + " adc1 = rb_prog.acquire(soc, progress=False)\n", + " t_runtime_end_ns = time.time_ns()\n", + " t_runtime_total_ns += (t_runtime_end_ns-t_runtime_start_ns)\n", + " print(' (%0d): %0d ms' % (jj, (t_runtime_end_ns-t_runtime_start_ns)/1e6), end=\" \")\n", + "\n", + " # print('// DBG acquire: %0d - %0d ns' % (dbg_i, time.time_ns()-t)); t=time.time_ns(); dbg_i+=1\n", + " \n", + " avgi0 = np.array([adc1[0][0][0]])\n", + " avgq0 = np.array([adc1[0][0][1]])\n", + " # avgi1 = adc2[0]\n", + " # avgq1 = adc2[1]\n", + " df = pd.DataFrame(avgi0, columns=['data'])\n", + " g = df['data'].apply(lambda x: 0 if x < th else 1).mean()\n", + " i2_temp.append(g) \n", + " # print('// DBG append: %0d - %0d ns' % (dbg_i, time.time_ns()-t)); t=time.time_ns(); dbg_i+=1\n", + "\n", + " print('')\n", + " I2.append(np.mean(i2_temp))\n", + " I2_err.append(np.std(i2_temp)/np.sqrt(variety))\n", + " t_sequence_end_ns = time.time_ns()\n", + " print(' - Sequence Total time: %0d ms (Run time: %0d ms - Overhead time: %0d ms)' % ((t_sequence_end_ns - t_sequence_start_ns)/1e6, t_runtime_total_ns/1e6, (t_sequence_end_ns - t_sequence_start_ns)/1e6 - t_runtime_total_ns/1e6))\n", + "\n", + "t_end_ns = int(time.time_ns())\n", + "print('- End Time: %0d - elapsed: %0d' % (t_end_ns, (t_end_ns-t_start_ns)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "43667010", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "macros:\n", + "\tWriteReg(dst='s_core_w1', src=0)\n", + "\tConfigReadout(ch=0, name='measure', t=0.0, tag=None, t_params={'t': }, t_regs={'t': 0})\n", + "\tDelay(t=1.0, auto=True, gens=True, ros=True, tag=None, t_params={'t': }, t_regs={'t': 430})\n", + "\tOpenLoop(n=4000, name='reps')\n", + "\tWriteReg(dst='r8', src=0)\n", + "\tWriteReg(dst='r9', src=1073741824)\n", + "\tDelay(t=1.0, auto=False, tag=None, t_params={'t': }, t_regs={'t': 430})\n", + "\tWait(t=0.0, auto=False, tag=None, no_warn=False, t_params={'t': }, t_regs={'t': 0})\n", + "\tDelay(t=204.8, auto=False, tag='pre_seq_delay_000', t_params={'t': }, t_regs={'t': 88080})\n", + "\tWriteReg(dst='lfsr_seed', src=123456789)\n", + "\tWriteReg(dst='seq_length', src=1023)\n", + "\tCall(label='gen_rnd_seq')\n", + "\tWriteReg(dst='r4', src=8)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'r_wave', 'SRC': 'wmem', 'ADDR': 'r4'}, addr_inc=1)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'w1', 'SRC': 'op', 'OP': 'w1 + r10'}, addr_inc=1)\n", + "\tAsmInst(inst={'CMD': 'WPORT_WR', 'DST': '0', 'SRC': 'r_wave'}, addr_inc=1)\n", + "\tPulse(ch=0, name='ro_pulse', t=0.0, tag=None, t_params={'t': }, t_regs={'t': 0})\n", + "\tTrigger(ros=[0], tts=[], pins=[0], t=0.2, width=0.023251488095238096, ddr4=True, mr=False, tag=None, t_params={'t': , 'width': }, t_regs={'t': 86, 'width': 10}, outdict=defaultdict(, {}), trigset={0, 9, 10})\n", + "\tDelay(t=102.4, auto=False, tag='post_seq_delay_000', t_params={'t': }, t_regs={'t': 44040})\n", + "\tDelay(t=1.0, auto=False, tag=None, t_params={'t': }, t_regs={'t': 430})\n", + "\tWait(t=0.0, auto=False, tag=None, no_warn=False, t_params={'t': }, t_regs={'t': 0})\n", + "\tIncReg(dst='r8', src=1)\n", + "\tWait(t=0, auto=True, gens=False, ros=True, tag=None, no_warn=True, t_params={'t': }, t_regs={'t': 0})\n", + "\tDelay(t=500, auto=True, gens=True, ros=True, tag=None, t_params={'t': }, t_regs={'t': 215040})\n", + "\tIncReg(dst='s_core_w1', src=1)\n", + "\tCloseLoop()\n", + "\tEnd()\n", + "\tLabel(label='gen_rnd_seq')\n", + "\tWriteReg(dst='s_rand', src='lfsr_seed')\n", + "\tWriteReg(dst='r10', src=0)\n", + "\tLabel(label='gen_seq_loop')\n", + "\tCondJump(label='gen_seq_end', arg1='seq_length', test='Z', op='-', arg2=0)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'r4', 'SRC': 'op', 'OP': 's1 AND #h0F'}, addr_inc=1)\n", + "\tCondJump(label='gen_seq_loop', arg1='r4', test='NS', op='-', arg2=10)\n", + "\tLabel(label='gen_seq_checkZ')\n", + "\tCondJump(label='gen_seq_checkZov2', arg1='r4', test='NZ', op='-', arg2=1)\n", + "\tIncReg(dst='r10', src='r9')\n", + "\tIncReg(dst='r10', src='r9')\n", + "\tJump(label='gen_seq_pulse')\n", + "\tLabel(label='gen_seq_checkZov2')\n", + "\tCondJump(label='gen_seq_check-Zov2', arg1='r4', test='NZ', op='-', arg2=4)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'r10', 'SRC': 'op', 'OP': 'r10 + r9'}, addr_inc=1)\n", + "\tJump(label='gen_seq_pulse')\n", + "\tLabel(label='gen_seq_check-Zov2')\n", + "\tCondJump(label='gen_seq_pulse', arg1='r4', test='NZ', op='-', arg2=7)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'r10', 'SRC': 'op', 'OP': 'r10 - r9'}, addr_inc=1)\n", + "\tLabel(label='gen_seq_pulse')\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'r_wave', 'SRC': 'wmem', 'ADDR': 'r4'}, addr_inc=1)\n", + "\tAsmInst(inst={'CMD': 'REG_WR', 'DST': 'w1', 'SRC': 'op', 'OP': 'w1 + r10'}, addr_inc=1)\n", + "\tAsmInst(inst={'CMD': 'WPORT_WR', 'DST': '0', 'SRC': 'r_wave'}, addr_inc=1)\n", + "\tLabel(label='gen_seq_next_gate')\n", + "\tIncReg(dst='seq_length', src=-1)\n", + "\tJump(label='gen_seq_loop')\n", + "\tLabel(label='gen_seq_end')\n", + "\tAsmInst(inst={'CMD': 'RET'}, addr_inc=1)\n", + "registers:\n", + "\tlfsr_seed: QickRegisterV2(addr=0, init=None)\n", + "\tseq_length: QickRegisterV2(addr=1, init=None)\n", + "\treps: QickRegisterV2(addr=2, init=None)\n", + "pulses:\n", + "\tI: QickPulse(waveforms=[Waveform(name='I_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=3276, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tZ: QickPulse(waveforms=[Waveform(name='Z_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=6553, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tX: QickPulse(waveforms=[Waveform(name='X_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=32766, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tY: QickPulse(waveforms=[Waveform(name='Y_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=-1073741824, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=32766, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tZ/2: QickPulse(waveforms=[Waveform(name='Z/2_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=6553, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tX/2: QickPulse(waveforms=[Waveform(name='X/2_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=16383, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tY/2: QickPulse(waveforms=[Waveform(name='Y/2_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=-1073741824, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=16383, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\t-Z/2: QickPulse(waveforms=[Waveform(name='-Z/2_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=6553, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\t-X/2: QickPulse(waveforms=[Waveform(name='-X/2_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=2147483648, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=16383, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\t-Y/2: QickPulse(waveforms=[Waveform(name='-Y/2_w0', freq=QickRawParam(par='freq', start=224054701, spans={}, quantize=1, steps={}), phase=QickRawParam(par='phase', start=1073741824, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=16383, spans={}, quantize=1, steps={}), length=60, conf=8)])\n", + "\tro_pulse: QickPulse(waveforms=[Waveform(name='ro_pulse_w0', freq=QickRawParam(par='freq', start=224054700, spans={}, quantize=10, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=6553, spans={}, quantize=1, steps={}), length=QickRawParam(par='length', start=60, spans={}, quantize=1, steps={}), conf=9)])\n", + "\tend_seq_pulse: QickPulse(waveforms=[Waveform(name='end_seq_pulse_w0', freq=QickRawParam(par='freq', start=224054700, spans={}, quantize=10, steps={}), phase=QickRawParam(par='phase', start=0, spans={}, quantize=1, steps={}), env=0, gain=QickRawParam(par='gain', start=6553, spans={}, quantize=1, steps={}), length=QickRawParam(par='length', start=60, spans={}, quantize=1, steps={}), conf=9)])\n", + "\tmeasure: QickPulse(waveforms=[Waveform(name='measure_w0', freq=QickRawParam(par='freq', start=-873813330, spans={}, quantize=-39, steps={}), phase=0, env=0, gain=0, length=3, conf=264)])\n", + "expanded ASM:\n", + "\t NOP \n", + "\t REG_WR s12 imm #0 \n", + "\t WPORT_WR p4 wmem [&12] @0 \n", + "\t TIME #430 inc_ref \n", + "\t REG_WR r2 imm #0 \n", + "\treps:\n", + "\t REG_WR r8 imm #0 \n", + "\t REG_WR r9 imm #1073741824 \n", + "\t TIME #430 inc_ref \n", + "\t REG_WR s15 imm #10 \n", + "\t WAIT [s15] @0 time \n", + "\t TIME #88080 inc_ref \n", + "\t REG_WR r0 imm #123456789 \n", + "\t REG_WR r1 imm #1023 \n", + "\t REG_WR s15 label gen_rnd_seq \n", + "\t CALL [s15] \n", + "\t REG_WR r4 imm #8 \n", + "\t REG_WR r_wave wmem [r4] \n", + "\t REG_WR w1 op -op(w1 + r10) \n", + "\t WPORT_WR p0 r_wave \n", + "\t WPORT_WR p0 wmem [&10] @0 \n", + "\t TRIG p0 set @86 \n", + "\t TRIG p9 set @86 \n", + "\t TRIG p10 set @86 \n", + "\t TRIG p0 clr @96 \n", + "\t TRIG p9 clr @96 \n", + "\t TRIG p10 clr @96 \n", + "\t TIME #44040 inc_ref \n", + "\t TIME #430 inc_ref \n", + "\t REG_WR s15 imm #31 \n", + "\t WAIT [s15] @0 time \n", + "\t REG_WR r8 op -op(r8 + #1) \n", + "\t REG_WR s15 imm #35 \n", + "\t WAIT [s15] @0 time \n", + "\t TIME #215040 inc_ref \n", + "\t REG_WR s12 op -op(s12 + #1) \n", + "\t REG_WR s15 label reps \n", + "\t TEST -op(r2 - #3999) \n", + "\t JUMP [s15] -if(NZ) -wr(r2 op) -op(r2 + #1) \n", + "\t REG_WR s15 imm #42 \n", + "\t JUMP [s15] \n", + "\tgen_rnd_seq:\n", + "\t REG_WR s1 op -op(r0) \n", + "\t REG_WR r10 imm #0 \n", + "\tgen_seq_loop:\n", + "\t REG_WR s15 label gen_seq_end \n", + "\t TEST -op(r1 - #0) -uf \n", + "\t JUMP [s15] -if(Z) \n", + "\t REG_WR r4 op -op(s1 AND #h0F) \n", + "\t REG_WR s15 label gen_seq_loop \n", + "\t TEST -op(r4 - #10) -uf \n", + "\t JUMP [s15] -if(NS) \n", + "\tgen_seq_checkZ:\n", + "\t REG_WR s15 label gen_seq_checkZov2 \n", + "\t TEST -op(r4 - #1) -uf \n", + "\t JUMP [s15] -if(NZ) \n", + "\t REG_WR r10 op -op(r10 + r9) \n", + "\t REG_WR r10 op -op(r10 + r9) \n", + "\t REG_WR s15 label gen_seq_pulse \n", + "\t JUMP [s15] \n", + "\tgen_seq_checkZov2:\n", + "\t REG_WR s15 label gen_seq_check-Zov2 \n", + "\t TEST -op(r4 - #4) -uf \n", + "\t JUMP [s15] -if(NZ) \n", + "\t REG_WR r10 op -op(r10 + r9) \n", + "\t REG_WR s15 label gen_seq_pulse \n", + "\t JUMP [s15] \n", + "\tgen_seq_check-Zov2:\n", + "\t REG_WR s15 label gen_seq_pulse \n", + "\t TEST -op(r4 - #7) -uf \n", + "\t JUMP [s15] -if(NZ) \n", + "\t REG_WR r10 op -op(r10 - r9) \n", + "\tgen_seq_pulse:\n", + "\t REG_WR r_wave wmem [r4] \n", + "\t REG_WR w1 op -op(w1 + r10) \n", + "\t WPORT_WR p0 r_wave \n", + "\tgen_seq_next_gate:\n", + "\t REG_WR r1 op -op(r1 + #-1) \n", + "\t REG_WR s15 label gen_seq_loop \n", + "\t JUMP [s15] \n", + "\tgen_seq_end:\n", + "\tRET\n", + "\n", + "// PMEM content\n", + "000000000000000000\n", + "8c600000000000000c\n", + "dce001820000000000\n", + "4c080000000000d700\n", + "8c6000000000000022\n", + "8c6000000000000028\n", + "8c6000002000000029\n", + "4c080000000000d700\n", + "8c600000000000050f\n", + "0811000005fffffb00\n", + "2911000005fffffb00\n", + "4c0800000000ac0800\n", + "8c60000003ade68aa0\n", + "8c600000000001ffa1\n", + "8c600000000000158f\n", + "2c4000000000000000\n", + "8c6000000000000424\n", + "8c4004800000000000\n", + "840000002095000041\n", + "cdc000000000000000\n", + "dce001400000000000\n", + "dda000300000002b00\n", + "dda000348000002b00\n", + "dda000350000002b00\n", + "dda000100000003000\n", + "dda000148000003000\n", + "dda000150000003000\n", + "4c0800000000560400\n", + "4c080000000000d700\n", + "8c6000000000000f8f\n", + "0811000005fffffb00\n", + "2911000005fffffb00\n", + "8800000014000000a8\n", + "8c600000000000118f\n", + "0811000005fffffb00\n", + "2911000005fffffb00\n", + "4c0800000001a40000\n", + "88000000060000008c\n", + "8c600000000000028f\n", + "08110000110007cf80\n", + "2988000011000000a2\n", + "8c600000000000150f\n", + "2c0000000000000000\n", + "840000001000000001\n", + "8c600000000000002a\n", + "8c600000000000258f\n", + "081100001080000000\n", + "2c8000000000000000\n", + "8804000000800007a4\n", + "8c600000000000168f\n", + "081100001200000500\n", + "2e0000000000000000\n", + "8c6000000000001d8f\n", + "081100001200000080\n", + "2d8000000000000000\n", + "84000000151480002a\n", + "84000000151480002a\n", + "8c600000000000228f\n", + "2c0000000000000000\n", + "8c600000000000208f\n", + "081100001200000200\n", + "2d8000000000000000\n", + "84000000151480002a\n", + "8c600000000000228f\n", + "2c0000000000000000\n", + "8c600000000000228f\n", + "081100001200000380\n", + "2d8000000000000000\n", + "84020000151480002a\n", + "8c4004800000000000\n", + "840000002095000041\n", + "cdc000000000000000\n", + "8800000010ffffffa1\n", + "8c600000000000168f\n", + "2c0000000000000000\n", + "2c6000000000000000\n", + "// WMEM content\n", + "// CONF_ LEN_ GAIN_ ENV_ PHASE_ FREQ\n", + "___0008_0000003c_00000ccc_000000_00000000_0d5acdad\n", + "___0008_0000003c_00001999_000000_00000000_0d5acdad\n", + "___0008_0000003c_00007ffe_000000_00000000_0d5acdad\n", + "___0008_0000003c_00007ffe_000000_c0000000_0d5acdad\n", + "___0008_0000003c_00001999_000000_00000000_0d5acdad\n", + "___0008_0000003c_00003fff_000000_00000000_0d5acdad\n", + "___0008_0000003c_00003fff_000000_c0000000_0d5acdad\n", + "___0008_0000003c_00001999_000000_00000000_0d5acdad\n", + "___0008_0000003c_00003fff_000000_80000000_0d5acdad\n", + "___0008_0000003c_00003fff_000000_40000000_0d5acdad\n", + "___0009_0000003c_00001999_000000_00000000_0d5acdac\n", + "___0009_0000003c_00001999_000000_00000000_0d5acdac\n", + "___0108_00000003_00000000_000000_00000000_cbeaaaae\n", + "Dumped SG envelope table memory to file sg_0.mem\n" + ] + } + ], + "source": [ + "# print the program\n", + "print(rb_prog)\n", + "\n", + "# generate rtl simulation inputs\n", + "rb_prog.print_pmem2hex()\n", + "rb_prog.print_wmem2hex()\n", + "rb_prog.print_sg_mem(sg_idx=0, gen_file=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8838aa9d", + "metadata": {}, + "outputs": [], + "source": [ + "from qick.tprocv2_assembler import Assembler\n", + "\n", + "prog_list = []\n", + "dict_label = { 'r_addr':'s15' }\n", + "\n", + "prog_list.append({'CMD':'REG_WR','DST':'r1','SRC':'op','OP':'MSH s7'})\n", + "prog_list.append({'CMD':'WPORT_WR','DST':'4','SRC':'wmem','ADDR':'r0'})\n", + "prog_list.append({'CMD':'DPORT_WR','DST':'0','SRC':'reg','DATA':'r0'})\n", + "\n", + "dict_label['END'] = '&'+str(len(prog_list)+1)\n", + "prog_list.append({'CMD':'JUMP','LABEL':'END'})\n", + "\n", + "p_bin = Assembler.list2bin(prog_list, dict_label)\n", + "p_asm = Assembler.list2asm(prog_list, dict_label)\n", + "\n", + "print(\"// Assembly Code\")\n", + "print(p_asm)\n", + "\n", + "print(\"// Assembly Binary\")\n", + "for l in p_bin[0]:\n", + " print(l)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6cb27449", + "metadata": {}, + "outputs": [], + "source": [ + "asm = \"\"\"\n", + "// TEST program\n", + "// Write CORE_W_DT SREG\n", + "REG_WR s12 imm #12\n", + "DPORT_WR p0 imm 1\n", + "LABEL_ADDR:\n", + "REG_WR s_addr label LABEL_ADDR // write to s15 the address of label \"LABEL_ADDR\"\n", + ".END // replaced by JUMP HERE\n", + "\"\"\"\n", + "\n", + "p_txt, p_bin = Assembler.str_asm2bin(asm)\n", + "\n", + "print(\"// Assembly Binary\")\n", + "for l in p_txt:\n", + " print(l)\n", + "\n", + "# for l in p_bin:\n", + "# print(l)\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.10.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/firmware/testbench/testbench_notebooks/test01_basic_multipulse.ipynb b/firmware/notebooks/qick_testbench/test01_basic_multipulse.ipynb similarity index 100% rename from firmware/testbench/testbench_notebooks/test01_basic_multipulse.ipynb rename to firmware/notebooks/qick_testbench/test01_basic_multipulse.ipynb diff --git a/firmware/testbench/testbench_notebooks/tests_generator.ipynb b/firmware/notebooks/qick_testbench/tests_generator.ipynb similarity index 100% rename from firmware/testbench/testbench_notebooks/tests_generator.ipynb rename to firmware/notebooks/qick_testbench/tests_generator.ipynb diff --git a/firmware/testbench/qick_testbench/qick_testbench.xpr b/firmware/testbench/qick_testbench/qick_testbench.xpr index 5df1a5ee9..d288bc5c1 100644 --- a/firmware/testbench/qick_testbench/qick_testbench.xpr +++ b/firmware/testbench/qick_testbench/qick_testbench.xpr @@ -61,7 +61,7 @@