{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "0a3990b0", "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "\n", "try {\n", "require(['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": [ "\n", "try {\n", "require(['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": [ "Populating the interactive namespace from numpy and matplotlib\n" ] } ], "source": [ "# Import the QICK drivers and auxiliary libraries\n", "from qick import *\n", "from tqdm.notebook import tqdm\n", "from scipy.signal import welch\n", "%pylab inline" ] }, { "cell_type": "code", "execution_count": 2, "id": "9f31dee8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "resetting clocks: 204.8\n", "\n", "QICK configuration:\n", "\n", "\tBoard: ZCU111\n", "\n", "\tGlobal clocks (MHz): tProcessor 384.000, RF reference 204.800\n", "\n", "\t7 signal generator channels:\n", "\t0:\taxis_signal_gen_v6 - tProc output 1, switch ch 0, maxlen 65536\n", "\t\tDAC tile 0, ch 0, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\t1:\taxis_signal_gen_v6 - tProc output 2, switch ch 1, maxlen 65536\n", "\t\tDAC tile 0, ch 1, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\t2:\taxis_signal_gen_v6 - tProc output 3, switch ch 2, maxlen 65536\n", "\t\tDAC tile 0, ch 2, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\t3:\taxis_signal_gen_v6 - tProc output 4, switch ch 3, maxlen 65536\n", "\t\tDAC tile 1, ch 0, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\t4:\taxis_signal_gen_v6 - tProc output 5, switch ch 4, maxlen 65536\n", "\t\tDAC tile 1, ch 1, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\t5:\taxis_signal_gen_v6 - tProc output 6, switch ch 5, maxlen 65536\n", "\t\tDAC tile 1, ch 2, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\t6:\taxis_signal_gen_v6 - tProc output 7, switch ch 6, maxlen 65536\n", "\t\tDAC tile 1, ch 3, 32-bit DDS, fabric=384.000 MHz, fs=6144.000 MHz\n", "\n", "\t2 readout channels:\n", "\t0:\tADC tile 0, ch 0, 32-bit DDS, fabric=384.000 MHz, fs=3072.000 MHz\n", "\t\tmaxlen 16384 (avg) 1024 (decimated), trigger bit 14, tProc input 0\n", "\t1:\tADC tile 0, ch 1, 32-bit DDS, fabric=384.000 MHz, fs=3072.000 MHz\n", "\t\tmaxlen 16384 (avg) 1024 (decimated), trigger bit 15, tProc input 1\n", "\n", "\t7 DACs:\n", "\t\tDAC tile 0, ch 0 is DAC228_T0_CH0 or RF board output 0\n", "\t\tDAC tile 0, ch 1 is DAC228_T0_CH1 or RF board output 1\n", "\t\tDAC tile 0, ch 2 is DAC228_T0_CH2 or RF board output 2\n", "\t\tDAC tile 1, ch 0 is DAC229_T1_CH0 or RF board output 4\n", "\t\tDAC tile 1, ch 1 is DAC229_T1_CH1 or RF board output 5\n", "\t\tDAC tile 1, ch 2 is DAC229_T1_CH2 or RF board output 6\n", "\t\tDAC tile 1, ch 3 is DAC229_T1_CH3 or RF board output 7\n", "\n", "\t2 ADCs:\n", "\t\tADC tile 0, ch 0 is ADC224_T0_CH0 or RF board AC input 0\n", "\t\tADC tile 0, ch 1 is ADC224_T0_CH1 or RF board AC input 1\n", "\n", "\t8 digital output pins (tProc output 0):\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: 8192 words program memory, 4096 words data memory\n", "\t\texternal start pin: PMOD1_0_LS\n" ] } ], "source": [ "from qick.rfboard import RFQickSocV2\n", "soc = RFQickSocV2('qick_111_rfbrd_v2.bit')\n", "# Load bitstream with custom overlay\n", "# soc = QickSoc()\n", "# Since we're running locally on the QICK, we don't need a separate QickConfig object.\n", "# If running remotely, you could generate a QickConfig from the QickSoc:\n", "# soccfg = QickConfig(soc.get_cfg())\n", "# or save the config to file, and load it later:\n", "# with open(\"qick_config.json\", \"w\") as f:\n", "# f.write(soc.dump_cfg())\n", "# soccfg = QickConfig(\"qick_config.json\")\n", "\n", "soccfg = soc\n", "print(soccfg)" ] }, { "cell_type": "markdown", "id": "055745c5", "metadata": {}, "source": [ "### SET UP CONFIGURATION" ] }, { "cell_type": "code", "execution_count": 3, "id": "3e5a0e7d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " i | f_vco | DIV | DLY_SEL | n | osc_2x | R | mult | R_pre | f_pfd | f_out | Delta f | Metric \n", "----|----------|-----|---------|------|--------|------|------|-------|---------|----------|---------|------------\n", " 0 | 13762.56 | 2 | 2 | 112 | False | 1 | 1 | 1 | 122.88 | 6881.28 | 0.00 | 2.2400e+02\n", "\n", "Choosing solution 0 with minimal metric 224.\n", "LO locked on attempt 1 after 0.01 sec\n", " i | f_vco | DIV | DLY_SEL | n | osc_2x | R | mult | R_pre | f_pfd | f_out | Delta f | Metric \n", "----|----------|-----|---------|------|--------|------|------|-------|---------|----------|---------|------------\n", " 0 | 13762.56 | 4 | 2 | 112 | False | 1 | 1 | 1 | 122.88 | 3440.64 | 0.00 | 4.4800e+02\n", "\n", "Choosing solution 0 with minimal metric 448.\n", "LO locked on attempt 1 after 0.01 sec\n", " i | f_vco | DIV | DLY_SEL | n | osc_2x | R | mult | R_pre | f_pfd | f_out | Delta f | Metric \n", "----|----------|-----|---------|------|--------|------|------|-------|---------|----------|---------|------------\n", " 0 | 13762.56 | 2 | 2 | 112 | False | 1 | 1 | 1 | 122.88 | 6881.28 | 0.00 | 2.2400e+02\n", "\n", "Choosing solution 0 with minimal metric 224.\n", "LO locked on attempt 1 after 0.01 sec\n", "qubit IF=1216.460000, readout IF=1052.780000\n" ] } ], "source": [ "# darkfreq800 = [6.18807, 5.8285, 6.075045, 5.95940] # Best for 800 gain\n", "# qubitresPulse = [4.800, 4.6571, 4.4928, 4.6518]\n", "\n", "hw_cfg={\"res_ch\":5,\n", " \"qubit_ch\":2,\n", " \"ro_ch\":1,\n", " \"f_res\":5828.5,\n", " \"f_ge\": 4657.1\n", " }\n", "\n", "rfb_cfg={\"f_lo_ro\":122.88*56,\n", " \"f_lo_qubit\":122.88*28,\n", " \"att_res\":(0,14.5),\n", " \"att_qubit\":(0,16),\n", " \"att_ro\":30\n", " }\n", "soc.rfb_set_lo(rfb_cfg['f_lo_ro'], ch=0, verbose=True) # ADCs\n", "soc.rfb_set_lo(rfb_cfg['f_lo_qubit'], ch=1, verbose=True) # DACs 0-3\n", "soc.rfb_set_lo(rfb_cfg['f_lo_ro'], ch=2, verbose=True) # DACs 4-7\n", "\n", "# as long as you're not saturating at any point in the chain (check with gain sweep), better to attenuate later\n", "soc.rfb_set_gen_rf(gen_ch=hw_cfg['res_ch'], att1=rfb_cfg['att_res'][0], att2=rfb_cfg['att_res'][1])\n", "soc.rfb_set_gen_rf(gen_ch=hw_cfg['qubit_ch'], att1=rfb_cfg['att_qubit'][0], att2=rfb_cfg['att_qubit'][1])\n", "soc.rfb_set_ro_rf(ro_ch=hw_cfg['ro_ch'], att=rfb_cfg['att_ro'])\n", "\n", "meas_cfg={\"pulse_gain\":800,\n", " \"if_res\": abs(soc.rfb_get_lo(gen_ch=hw_cfg['res_ch']) - hw_cfg['f_res']), # MHz, start value\n", " \"if_ge\": abs(soc.rfb_get_lo(gen_ch=hw_cfg['qubit_ch']) - hw_cfg['f_ge']), # MHz, start value\n", " \"nqz\":1\n", " }\n", "\n", "print(\"qubit IF=%f, readout IF=%f\"%(meas_cfg['if_ge'], meas_cfg['if_res']))" ] }, { "cell_type": "code", "execution_count": 4, "id": "7cbc5e4b", "metadata": {}, "outputs": [], "source": [ "#res_range = [5800, 6200]\n", "#qubit_range = [4400, 4900]\n", "\n", "# high LO for readout, low LO for qubit, 2:1 relation\n", "# f_lo_ro = 122.88*56 # 6881\n", "# f_lo_qubit = 122.88*28 # 3441\n", "\n", "# common LO: low LO for readout, high LO for qubit\n", "# want to keep readout sidebands outside qubit range:\n", "# put LO closer to readout\n", "# f_lo_ro = 122.88*46 # 5652\n", "# f_lo_qubit = 122.88*46\n", "# put LO closer to qubit - probably preferred, since external filter will kill RO lower sideband\n", "# f_lo_ro = 122.88*41 # 5038\n", "# f_lo_qubit = 122.88*41\n", "\n", "# various considerations, not all mutually compatible:\n", "\n", "# LO performance is best if you use an integer multiple of the reference clock (122.88 MHz)\n", "# LO freqs <7.5 GHz are generated using a divider, so you will see some of the original VCO freq (some multiple of the LO)\n", "# the mixers allow a fair bit of LO leakage, and there also seems to be some crosstalk between LOs\n", "# so you get a cleaner spectrum if you use a single LO\n", "# second best: use LOs that are simple multiples of each other\n", "\n", "# the low-pass filter we use on both ADC and DAC IF (LFCN-1800D) is ~2.1 GHz\n", "# the ADC Nyquist freq is ~1.5 GHz, so IFs above ~900 MHz see up to 3 dB more (2x) noise power\n", "# this assumes the noise spectrum is broadband and white\n", "# and it may not be the limiting factor in the measurement - have to see\n", "\n", "# on the DAC side, the max IF is just set by the low-pass\n", "# anything up to 1.8 GHz (rated band of the filter) should be OK\n", "\n", "# we're using double-sideband mixers, so you will always see both LO+IF and LO-IF, only one of which is desired\n", "# for your qubit drive, this means dumping a lot of power at some random freq - might be harmless?\n", "# for readout, the spur is also going to get mixed back down to your IF, so this basically means you have a second readout path that is always off-resonance\n", "# the RF outputs are low-passed at ~7 GHz (LFCW-6800), so it's nice if you can set your LO high enough that only LO-IF is passed\n", "# or of course you can add an external filter\n", "# VBFZ-6260 only starts really killing stuff below ~4.8, so it is not perfect protection for the qubits\n", "# \n", "\n" ] }, { "cell_type": "markdown", "id": "eaaa0a32", "metadata": {}, "source": [ "### SET UP SWEEP" ] }, { "cell_type": "code", "execution_count": 5, "id": "c3354baf", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ca78276d57e8478b8d3825ea7ebe4d40", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/20100 [00:00" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "class GainSweepProgram(RAveragerProgram):\n", " def initialize(self):\n", " cfg=self.cfg \n", "\n", " # set the nyquist zone\n", " self.declare_gen(ch=cfg[\"res_ch\"], nqz=cfg['nqz'], ro_ch=cfg[\"ro_ch\"])\n", "\n", " self.r_rp=self.ch_page(self.cfg[\"res_ch\"]) # get register page for res_ch\n", " self.r_gain=self.sreg(cfg[\"res_ch\"], \"gain\") #Get gain register for res_ch\n", " \n", " #configure the readout lengths and downconversion frequencies\n", " self.declare_readout(ch=cfg[\"ro_ch\"], freq=cfg[\"if_res\"],\n", " length=soccfg.us2cycles(cfg['length']+cfg['readout_padding'], ro_ch=cfg[\"ro_ch\"]),\n", " gen_ch=cfg[\"res_ch\"])\n", "\n", " self.set_pulse_registers(ch=cfg[\"res_ch\"], style=\"const\",\n", " length=soccfg.us2cycles(cfg['length'], gen_ch=cfg['res_ch']),\n", " freq=soccfg.freq2reg(cfg['if_res'],gen_ch=cfg['res_ch'],ro_ch=cfg[\"ro_ch\"]),\n", " gain=cfg[\"start\"],\n", " phase=0)\n", " self.synci(200) # give processor some time to configure pulses\n", "\n", " def body(self):\n", " self.measure(pulse_ch=self.cfg[\"res_ch\"], \n", " adcs=self.ro_chs,\n", " pins=[0], \n", " adc_trig_offset=soccfg.us2cycles(self.cfg[\"adc_trig_offset\"]),\n", " wait=True,\n", " syncdelay=self.us2cycles(self.cfg[\"relax_delay\"]))\n", " \n", " def update(self):\n", " self.mathi(self.r_rp, self.r_gain, self.r_gain, '+', self.cfg[\"step\"]) # update gain of the pulse\n", "\n", "sweepconfig={\n", " 'nqz': 1,\n", " 'adc_trig_offset': 0.35,\n", " 'length': 10,\n", " 'readout_padding': 0.2,\n", " 'relax_delay': 1,\n", " 'reps': 100,\n", " \"expts\": 201,\n", " \"start\":0, # [DAC units]\n", " \"step\":int(meas_cfg['pulse_gain']/100) # [DAC units]\n", " }\n", "config={**hw_cfg,**rfb_cfg,**meas_cfg, **sweepconfig} #combine configs\n", "\n", "prog =GainSweepProgram(soccfg, config)\n", "expt_pts, avgi, avgq = prog.acquire(soc, load_pulses=True, progress=True)\n", "\n", "# Plot results.\n", "sig = avgi[0][0] + 1j*avgq[0][0]\n", "avgamp0 = np.abs(sig)\n", "plt.figure(1)\n", "plt.plot(expt_pts, avgi[0][0], label=\"I value\")\n", "plt.plot(expt_pts, avgq[0][0], label=\"Q value\")\n", "plt.plot(expt_pts, avgamp0, label=\"Amplitude\")\n", "gain = avgamp0[config['expts']//3]/expt_pts[config['expts']//3]\n", "plt.plot(expt_pts, expt_pts*gain, label=\"gain=%f\"%(gain))\n", "plt.ylabel(\"a.u.\")\n", "plt.xlabel(\"Pulse gain (DAC units)\")\n", "plt.title(\"Averages = \" + str(config[\"reps\"]))\n", "plt.legend()\n", "\n", "plt.axvline(meas_cfg['pulse_gain'])\n", "# plt.savefig(\"images/Gain_sweep.pdf\", dpi=350)" ] }, { "cell_type": "code", "execution_count": 6, "id": "8ccd498f", "metadata": { "scrolled": false }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ff0816f45b9d4a699f2556f3a885427d", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/1 [00:00" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "class FSGenLoopbackProgram(AveragerProgram):\n", " def initialize(self):\n", " cfg = self.cfg\n", " self.declare_gen(ch=cfg[\"res_ch\"], nqz=cfg['nqz'],\n", " ro_ch=cfg[\"ro_ch\"])\n", " self.declare_readout(ch=cfg[\"ro_ch\"], freq=cfg[\"if_res\"],\n", " length=soccfg.us2cycles(cfg['length']+cfg['readout_padding'], ro_ch=cfg[\"ro_ch\"]),\n", " gen_ch=cfg[\"res_ch\"])\n", "\n", " self.set_pulse_registers(ch=cfg[\"res_ch\"], style=\"const\",\n", " length=soccfg.us2cycles(cfg['length'], gen_ch=cfg['res_ch']),\n", " freq=soccfg.freq2reg(cfg['if_res'],gen_ch=cfg['res_ch'],ro_ch=cfg[\"ro_ch\"]),\n", " gain=cfg['pulse_gain'],\n", " phase=0,\n", "# mode='periodic'\n", " mode='oneshot'\n", " )\n", " self.synci(200) # give processor some time to configure pulses\n", "\n", " def body(self):\n", " self.measure(pulse_ch=self.cfg[\"res_ch\"], \n", " adcs=self.ro_chs,\n", " pins=[0], \n", " adc_trig_offset=soccfg.us2cycles(self.cfg[\"adc_trig_offset\"]),\n", " wait=True,\n", " syncdelay=self.us2cycles(self.cfg[\"relax_delay\"]))\n", "\n", "sweepconfig = {\n", " 'adc_trig_offset': 0.35,\n", " 'length': 2,\n", " 'readout_padding': 0.2,\n", " 'relax_delay': 1,\n", " 'reps': 1,\n", " 'soft_avgs': 1\n", "}\n", "config={**hw_cfg,**rfb_cfg,**meas_cfg, **sweepconfig} #combine configs\n", "\n", "prog = FSGenLoopbackProgram(soccfg, config)\n", "\n", "iq_list = prog.acquire_decimated(soc, load_pulses=True, progress=True, debug=False)\n", "\n", "# Plot results.\n", "iq = iq_list[0]\n", "fig, axs = plt.subplots(2,1,figsize=(10,10))\n", "plot = axs[0]\n", "plot.plot(iq[0], label=\"I value, ADC %d\"%(config['ro_ch']))\n", "plot.plot(iq[1], label=\"Q value, ADC %d\"%(config['ro_ch']))\n", "plot.plot(np.abs(iq[0]+1j*iq[1]), label=\"mag, ADC %d\"%(config['ro_ch']))\n", "plot.set_ylabel(\"a.u.\")\n", "plot.set_xlabel(\"Clock ticks\")\n", "plot.set_title(\"Averages = \" + str(config[\"soft_avgs\"]))\n", "plot.legend()\n", "\n", "plot = axs[1]\n", "fft_mag = np.abs(np.fft.fft(iq[0]+1j*iq[1]))\n", "fft_freqs = np.fft.fftfreq(n=iq.shape[-1], d=1/soccfg['readouts'][0]['f_fabric'])\n", "plot.semilogy(np.fft.fftshift(fft_freqs), np.fft.fftshift(fft_mag))\n", "print(\"peak at %f MHz\" % (config['if_res'] - fft_freqs[np.argmax(fft_mag)]))" ] }, { "cell_type": "code", "execution_count": 7, "id": "4832a328", "metadata": {}, "outputs": [], "source": [ "def noise(di, dq, verbose=True):\n", " diq = di+1j*dq\n", " dmean = np.mean(diq)\n", " dmag = np.abs(dmean)\n", " if verbose: print(\"mean signal is %s (magnitude %f)\" % (str(dmean), dmag))\n", " drotated = diq*np.exp(-1j*np.angle(dmean))\n", " drmsmag = np.std(np.real(drotated)) # noise in the radial direction\n", " drmsrot = np.std(np.imag(drotated)) # noise in the azimuth direction\n", " if verbose:\n", " print(\"amplitude noise: %f ADU, %f as a fraction of the signal\" % (drmsmag, drmsmag/dmag))\n", " print(\"phase noise: %f ADU, %f radians\" % (drmsrot, drmsrot/dmag))\n", " return drmsmag, drmsrot" ] }, { "cell_type": "code", "execution_count": 8, "id": "c5212bdc", "metadata": { "scrolled": true }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5abe19879ca146b08d31a0cfe90b4724", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/59 [00:00]" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "config['length'] = 10\n", "config['reps'] = 10000\n", "\n", "freqs = np.arange(100, 3001, 50)\n", "\n", "mags = np.zeros((len(freqs),2))\n", "noises = np.zeros((len(freqs),2))\n", "\n", "for i, f in tqdm(list(enumerate(freqs))):\n", " config['if_res'] = f\n", " \n", " for j in range(1):\n", " config['nqz'] = j+1\n", " prog = FSGenLoopbackProgram(soccfg, config)\n", " res = prog.acquire(soc, load_pulses=True, progress=False, debug=False)\n", " res = np.array(res).T[0]\n", " mags[i,j] = np.abs(res[:,0]+1j*res[:,1])\n", " rmsmag, rmsrot = noise(prog.di_buf, prog.dq_buf, verbose=False)\n", " noises[i,j] = rmsmag/soccfg.us2cycles(config['length']+config['readout_padding'], ro_ch=config[\"ro_ch\"])\n", " \n", "# (prog.di_buf+1j*prog.dq_buf)\n", "# plt.semilogy(soc.rfb_get_lo(gen_ch=config['res_ch']) - freqs, mags[:,0])\n", "plt.semilogy(freqs, mags[:,0], label='gain')\n", "plt.semilogy(freqs, noises[:,0], label='noise')\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "38efa57a", "metadata": {}, "outputs": [], "source": [ "#scratchwork below" ] }, { "cell_type": "code", "execution_count": null, "id": "04cf8e98", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "3759ba5f", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "a0f1eb35", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "4ff735ba", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "10e8ed07", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "20e79b48", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.2" } }, "nbformat": 4, "nbformat_minor": 5 }