{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# QCoDeS Example with Itacho" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this notebook, we show how to use Itacho in a simple setup. We sweep the current using a Keithley 2614B sourcemeter as the current source. Itacho 1211 will convert the current to voltage and we readout the voltage using a DMM Agilent 34401A. Our test setup is as the following picture:" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![title](../files/ithaco_setup.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Required imports" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import time\n", "from qcodes.instrument.parameter import Parameter\n", "\n", "from qcodes.utils.dataset.doNd import do1d\n", "from qcodes.dataset.plotting import plot_dataset\n", "from qcodes import load_by_run_spec, load_or_create_experiment,\\\n", "initialise_or_create_database_at\n", "\n", "from qcodes.instrument_drivers.tektronix.Keithley_2600_channels import\\\n", "Keithley_2600 as keith\n", "import qcodes.instrument_drivers.agilent.Agilent_34400A as agi\n", "import qcodes.instrument_drivers.ithaco.Ithaco_1211 as ithaco" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Logging hadn't been started.\n", "Activating auto-logging. Current session state plus future input saved.\n", "Filename : C:\\Users\\QCoDeS_Public\\.qcodes\\logs\\command_history.log\n", "Mode : append\n", "Output logging : True\n", "Raw input log : False\n", "Timestamping : True\n", "State : active\n", "Qcodes Logfile : C:\\Users\\QCoDeS_Public\\.qcodes\\logs\\201109-10868-qcodes.log\n" ] } ], "source": [ "from qcodes.logger import start_all_logging\n", "start_all_logging()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Connecting to the instruments" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Connected to: HEWLETT-PACKARD 34401A (serial:0, firmware:10-5-2) in 0.21s\n", "Connected to: Keithley Instruments Inc. 2614B (serial:4305420, firmware:3.2.2) in 0.08s\n" ] } ], "source": [ "a1 = agi.Agilent_34400A('Agilent1', 'GPIB0::4::INSTR')\n", "k1 = keith('Keithley', 'GPIB0::26::INSTR')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Itacho QCoDeS driver is only a virtual driver without any communication with the instrument. The instrument setting are only controlled via the front and back panel and the used QCoDeS setting must match its corresponding setting on the panel. Now, we instantiate an instance of the instrument:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "camp = ithaco.Ithaco_1211('camp')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Configuration" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We set Ampere per Volt Sensitivity here, which match with the setting on the instrument panel (the rest of the setting are set according to their default values in the driver): " ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "camp.sens.set(1e-4)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we use CurrentParameter class of Itacho to setup the following parameter, which is showing the fed current to the instantiated camp and converted voltage sent to our connected DMM via a1.volt." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "curr = ithaco.CurrentParameter(a1.volt, camp)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's look at the present value of curr (the sourcemeter is not connected yet):" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(6.409e-05, -6.4090000000000005e-09)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "curr()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The current value is practically zero. The voltage value is the current value divided by 1e-4 A/V according to the setting camp.sens.set(1e-4). Thus, Itacho converts the feed to voltage and amplifies it. Let's look at the units of curr:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "('V', 'A')" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "curr.units" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Our connected DMM reads a similar voltage value:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6.4838e-05" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a1.volt()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We set the integration time of our DMM as below:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "a1.NPLC.set(1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's look at the snapshot of our created Itacho instance" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'functions': {},\n", " 'submodules': {},\n", " '__class__': 'qcodes.instrument_drivers.ithaco.Ithaco_1211.Ithaco_1211',\n", " 'parameters': {'IDN': {'__class__': 'qcodes.instrument.parameter.Parameter',\n", " 'full_name': 'camp_IDN',\n", " 'value': None,\n", " 'raw_value': None,\n", " 'ts': None,\n", " 'label': 'IDN',\n", " 'unit': '',\n", " 'vals': '',\n", " 'post_delay': 0,\n", " 'instrument': 'qcodes.instrument_drivers.ithaco.Ithaco_1211.Ithaco_1211',\n", " 'instrument_name': 'camp',\n", " 'inter_delay': 0,\n", " 'name': 'IDN'},\n", " 'sens': {'__class__': 'qcodes.instrument.parameter.Parameter',\n", " 'full_name': 'camp_sens',\n", " 'value': 0.0001,\n", " 'raw_value': 0.0001,\n", " 'ts': '2020-11-09 12:02:45',\n", " 'label': 'Sensitivity',\n", " 'unit': 'A/V',\n", " 'vals': '',\n", " 'post_delay': 0,\n", " 'instrument': 'qcodes.instrument_drivers.ithaco.Ithaco_1211.Ithaco_1211',\n", " 'instrument_name': 'camp',\n", " 'inter_delay': 0,\n", " 'name': 'sens'},\n", " 'invert': {'__class__': 'qcodes.instrument.parameter.Parameter',\n", " 'full_name': 'camp_invert',\n", " 'value': True,\n", " 'raw_value': True,\n", " 'ts': '2020-11-09 12:02:45',\n", " 'label': 'Inverted output',\n", " 'unit': '',\n", " 'vals': '',\n", " 'post_delay': 0,\n", " 'instrument': 'qcodes.instrument_drivers.ithaco.Ithaco_1211.Ithaco_1211',\n", " 'instrument_name': 'camp',\n", " 'inter_delay': 0,\n", " 'name': 'invert'},\n", " 'sens_factor': {'__class__': 'qcodes.instrument.parameter.Parameter',\n", " 'full_name': 'camp_sens_factor',\n", " 'value': 1,\n", " 'raw_value': 1,\n", " 'ts': '2020-11-09 12:02:45',\n", " 'label': 'Sensitivity factor',\n", " 'unit': '',\n", " 'vals': '',\n", " 'post_delay': 0,\n", " 'instrument': 'qcodes.instrument_drivers.ithaco.Ithaco_1211.Ithaco_1211',\n", " 'instrument_name': 'camp',\n", " 'inter_delay': 0,\n", " 'name': 'sens_factor'},\n", " 'suppression': {'__class__': 'qcodes.instrument.parameter.Parameter',\n", " 'full_name': 'camp_suppression',\n", " 'value': 1e-07,\n", " 'raw_value': 1e-07,\n", " 'ts': '2020-11-09 12:02:39',\n", " 'label': 'Suppression',\n", " 'unit': 'A',\n", " 'vals': '',\n", " 'post_delay': 0,\n", " 'instrument': 'qcodes.instrument_drivers.ithaco.Ithaco_1211.Ithaco_1211',\n", " 'instrument_name': 'camp',\n", " 'inter_delay': 0,\n", " 'name': 'suppression'},\n", " 'risetime': {'__class__': 'qcodes.instrument.parameter.Parameter',\n", " 'full_name': 'camp_risetime',\n", " 'value': 0.3,\n", " 'raw_value': 0.3,\n", " 'ts': '2020-11-09 12:02:39',\n", " 'label': 'Rise Time',\n", " 'unit': 'msec',\n", " 'vals': '',\n", " 'post_delay': 0,\n", " 'instrument': 'qcodes.instrument_drivers.ithaco.Ithaco_1211.Ithaco_1211',\n", " 'instrument_name': 'camp',\n", " 'inter_delay': 0,\n", " 'name': 'risetime'}},\n", " 'name': 'camp'}" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "camp.snapshot()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Setting up qcodes database and performing a simple measurement" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we want to feed our Itacho using our Keithley sourcemeter and run a simple qcodes measurement to see the output of the swept values passing through Itacho (for knowing how our sourcemeter works, you can refer to its qcodes notebook in the following:\n", "[Qcodes example with Keithley 2600][mylink]\n", "\n", "[mylink]: ./Qcodes%20example%20with%20Keithley%202600.ipynb" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We initilize a database named \"itacho_db.db\" and save our measured data there. Then, we create an experiment named \"Itacho_measurement\" or load it if is already created:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "initialise_or_create_database_at('itacho_db.db')\n", "exp = load_or_create_experiment('Itacho_measurement', sample_name='no sample')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now, we would like to use qcodes do1d function to sweep over current values\n", "generated by our sourcemeter. The current is fed to Itacho and we measure the converted and amplified voltage using the instantiated curr parameter. Qcodes Measurement can be also used for the same reason, instead.\n", "We set our sourcemeter in the 'current' mode and sweep from 1e-6 A to 1e-3 A in 20 steps with 1 second interdelay between each two consecutive steps:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "k1.smua.mode('current')" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting experimental run with id: 4. \n", "Measurement took 21.38200354576111 seconds\n" ] } ], "source": [ "t1 = time.time()\n", "do1d(k1.smua.curr, 1e-6, 1e-3, 20, 1, curr, do_plot=False)\n", "t2 = time.time()\n", "print(f'Measurement took {t2-t1} seconds')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As expected, the measurement took around 20 seconds. Now, we want to plot our measured dataset. We use qcodes to find the dataset that we want to plot in the database, and tweak plotting axes for showing it in a scatter plot. " ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "exp.data_set" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "dataset = load_by_run_spec(experiment_name='Itacho_measurement',\\\n", " captured_run_id=4)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "scrolled": true }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "axes, cbax = plot_dataset(dataset)\n", "for i in range(2):\n", " axes[i].lines[0].set_marker('o')\n", " axes[i].lines[0].set_markerfacecolor((0.6, 0.6, 0.9))\n", " axes[i].lines[0].set_markeredgecolor((0.4, 0.6, 0.9))\n", " axes[i].lines[0].set_color((0.8, 0.8, 0.8))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We see two results in the figure above; the first and second figures are the converted voltages and fed current, respectively against the swept current. If we look at our attached DMM, we see that it is showing -10.00 V DC, which is the same as the final voltage value in the first figure. Therefore, both results are as expected and showing that our Ithaco's virtual driver is performing as it should." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's explore our dataset, because why not :)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'curr': curr\n", " Keithley_smua_curr \n", " 0.000001 9.443364e-07\n", " 0.000054 5.357243e-05\n", " 0.000106 1.062108e-04\n", " 0.000159 1.588324e-04\n", " 0.000211 2.114506e-04\n", " 0.000264 2.640623e-04\n", " 0.000316 3.166975e-04\n", " 0.000369 3.693167e-04\n", " 0.000422 4.219315e-04\n", " 0.000474 4.745453e-04\n", " 0.000527 5.271591e-04\n", " 0.000579 5.797739e-04\n", " 0.000632 6.324015e-04\n", " 0.000685 6.850098e-04\n", " 0.000737 7.376224e-04\n", " 0.000790 7.902317e-04\n", " 0.000842 8.428346e-04\n", " 0.000895 8.954364e-04\n", " 0.000947 9.480564e-04\n", " 0.001000 1.000660e-03,\n", " 'volt_raw': volt_raw\n", " Keithley_smua_curr \n", " 0.000001 -0.009443\n", " 0.000054 -0.535724\n", " 0.000106 -1.062108\n", " 0.000159 -1.588324\n", " 0.000211 -2.114506\n", " 0.000264 -2.640623\n", " 0.000316 -3.166975\n", " 0.000369 -3.693167\n", " 0.000422 -4.219316\n", " 0.000474 -4.745453\n", " 0.000527 -5.271591\n", " 0.000579 -5.797739\n", " 0.000632 -6.324014\n", " 0.000685 -6.850098\n", " 0.000737 -7.376224\n", " 0.000790 -7.902317\n", " 0.000842 -8.428346\n", " 0.000895 -8.954364\n", " 0.000947 -9.480564\n", " 0.001000 -10.006602}" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dataset.to_pandas_dataframe_dict()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the above two tables, Keithley_smua_curr in both tables are the swept current values generated by our sourcemeter. The top table's second column (with the title curr) is showing the current values and the bottom table's second column (volt_raw) is showing voltage values of our Itacho's curr parameter." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.9" }, "nbsphinx": { "execute": "never" } }, "nbformat": 4, "nbformat_minor": 4 }