diff --git a/docs/changes/newsfragments/7497.new_driver b/docs/changes/newsfragments/7497.new_driver new file mode 100644 index 00000000000..5d0daa257cf --- /dev/null +++ b/docs/changes/newsfragments/7497.new_driver @@ -0,0 +1,2 @@ +Added Copper Mountain Technologies M5065 driver +Added Copper Mountain Technologies M5180 driver diff --git a/docs/examples/driver_examples/QCoDeS example with CopperMountain_M5065.ipynb b/docs/examples/driver_examples/QCoDeS example with CopperMountain_M5065.ipynb new file mode 100644 index 00000000000..b680f675f2a --- /dev/null +++ b/docs/examples/driver_examples/QCoDeS example with CopperMountain_M5065.ipynb @@ -0,0 +1,534 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "marked-capability", + "metadata": {}, + "source": [ + "# Example with Copper Mountain Model M5065 Vector Network Analyzer\n", + "This notebook was adapted from `qcodes_contrib_drivers` for Copper Mountain M5180. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "placed-maldives", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "NoTagError: `git describe --long --dirty --always --tags '--match=v*'` could not find a tag\n" + ] + } + ], + "source": [ + "import qcodes as qc\n", + "from qcodes.dataset import (\n", + " Measurement,\n", + " load_or_create_experiment,\n", + " plot_by_id,\n", + ")\n", + "from qcodes.instrument_drivers.CopperMountain import CopperMountainM5065\n", + "from qcodes.station import Station" + ] + }, + { + "cell_type": "markdown", + "id": "likely-steps", + "metadata": {}, + "source": [ + "## Connecting to device" + ] + }, + { + "cell_type": "markdown", + "id": "statewide-carroll", + "metadata": {}, + "source": [ + "- Install connection software S2VN, download here: https://coppermountaintech.com/download-free-vna-software-and-documentation/\n", + "- Run the software and go to System > Misc Setup > Network Remote Control Settings and turn on HiSLIP Server" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "first-bacon", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Connected to: CMT M5065 (serial:23047001, firmware:25.3.1/2) in 0.20s\n" + ] + } + ], + "source": [ + "vna = CopperMountainM5065(\n", + " name=\"M5065\",\n", + " address=\"TCPIP0::localhost::hislip0::INSTR\",\n", + " # pyvisa_sim_file=\"CopperMountain_M5065.yaml\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "expected-chorus", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "M5065:\n", + "\tparameter value\n", + "--------------------------------------------------------------------------------\n", + "IDN :\t{'vendor': 'CMT', 'model': 'M5065', 'serial': '230...\n", + "averages :\t10 \n", + "averages_enabled :\tFalse \n", + "averages_trigger_enabled :\tFalse \n", + "center :\t3.2502e+09 (Hz)\n", + "clock_source :\tINT \n", + "data_transfer_format :\tASC \n", + "electrical_delay :\t0 (s)\n", + "electrical_distance :\t0 (m)\n", + "if_bandwidth :\t10000 (Hz)\n", + "number_of_points :\t201 \n", + "number_of_traces :\t1 \n", + "output :\tTrue \n", + "point_check_sweep_first :\tTrue \n", + "point_s11 :\tNot available (('dB', 'rad'))\n", + "point_s11_iq :\tNot available (('V', 'V'))\n", + "point_s12 :\tNot available (('dB', 'rad'))\n", + "point_s12_iq :\tNot available (('V', 'V'))\n", + "point_s21 :\tNot available (('dB', 'rad'))\n", + "point_s21_iq :\tNot available (('V', 'V'))\n", + "point_s22 :\tNot available (('dB', 'rad'))\n", + "point_s22_iq :\tNot available (('V', 'V'))\n", + "power :\t0 (dBm)\n", + "s11 :\tNot available (('dB', 'rad'))\n", + "s12 :\tNot available (('dB', 'rad'))\n", + "s21 :\tNot available (('dB', 'rad'))\n", + "s22 :\tNot available (('dB', 'rad'))\n", + "span :\t6.4997e+09 (Hz)\n", + "start :\t3e+05 (Hz)\n", + "stop :\t6.5e+09 (Hz)\n", + "timeout :\t5 (s)\n", + "trigger_source :\tinternal \n" + ] + } + ], + "source": [ + "# Let's look at all parameters\n", + "vna.print_readable_snapshot(update=True)" + ] + }, + { + "cell_type": "markdown", + "id": "emerging-improvement", + "metadata": {}, + "source": [ + "## Setup db and station for test measurement" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "rural-genealogy", + "metadata": {}, + "outputs": [], + "source": [ + "# create an empty database based on the config file\n", + "qc.initialise_or_create_database_at(\"./test_copper_mountain.db\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "recreational-fight", + "metadata": {}, + "outputs": [], + "source": [ + "exp = load_or_create_experiment(\n", + " experiment_name=\"testing_coppermountain_driver\", sample_name=\"band_pass_filter\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "marine-dependence", + "metadata": {}, + "outputs": [], + "source": [ + "station = Station(vna)" + ] + }, + { + "cell_type": "markdown", + "id": "boring-router", + "metadata": {}, + "source": [ + "## Measure a trace" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a9512c3f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vna.output(\"on\")\n", + "vna.output()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "stretch-survey", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting experimental run with id: 1. \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# define sweep parameters\n", + "vna.power(-20)\n", + "vna.start(1e6)\n", + "vna.stop(2e9)\n", + "vna.if_bandwidth(10e3)\n", + "vna.number_of_points(2001)\n", + "vna.averages(1)\n", + "# do measurement\n", + "meas = Measurement()\n", + "meas.register_parameter(vna.s12)\n", + "with meas.run() as datasaver:\n", + " datasaver.add_result((vna.s12, vna.s12()))\n", + "ax, cbax = plot_by_id(datasaver.run_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "exterior-moderator", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([83.26122803, 80.75750049, 78.44940704, ..., -8.70525495,\n", + " -7.39917296, -7.31888414], shape=(2001,)),\n", + " array([2.12333968, 2.09746786, 2.31121919, ..., 1.87094291, 1.77600748,\n", + " 1.77330165], shape=(2001,)))" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Similarly, other S-parameters can be queried\n", + "vna.s11()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "least-blond", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([33.97829174, 33.97448428, 33.97957474, ..., 33.98113194,\n", + " 33.98184522, 33.98329268], shape=(2001,)),\n", + " array([-0.00055221, 0.00063451, 0.0001414 , ..., -0.0005448 ,\n", + " 0.00014741, 0.00016589], shape=(2001,)))" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vna.s12()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "interesting-patio", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([33.98949561, 33.97715986, 33.97702461, ..., 33.98047712,\n", + " 33.97354075, 33.98591088], shape=(2001,)),\n", + " array([-4.15942817e-04, 1.37116799e-04, 7.08505255e-05, ...,\n", + " -7.18153217e-05, -2.72621708e-04, 6.30044960e-05], shape=(2001,)))" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vna.s21()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "australian-train", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([90.92783872, 82.50446303, 79.43818092, ..., -6.13772571,\n", + " -5.2107447 , -4.70608778], shape=(2001,)),\n", + " array([2.38511826, 2.1903169 , 2.36005996, ..., 7.72382128, 7.73495793,\n", + " 7.74917966], shape=(2001,)))" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vna.s22()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "future-airplane", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([1.0000000e+06, 1.9995000e+06, 2.9990000e+06, ..., 1.9980010e+09,\n", + " 1.9990005e+09, 2.0000000e+09], shape=(2001,)),\n", + " array([84.47317501, 81.60269476, 78.16749988, ..., -8.67102405,\n", + " -8.29143174, -6.9921363 ], shape=(2001,)),\n", + " array([2.04646414, 2.34391646, 2.24344606, ..., 1.83101102, 1.81951768,\n", + " 1.73808504], shape=(2001,)),\n", + " array([33.98352736, 33.98276445, 33.9834625 , ..., 33.9786286 ,\n", + " 33.97991238, 33.97934041], shape=(2001,)),\n", + " array([-5.92542064e-04, 4.47036439e-04, 7.31798169e-05, ...,\n", + " -8.57784213e-05, 4.57500660e-04, -2.98953941e-04], shape=(2001,)),\n", + " array([33.97919244, 33.98117124, 33.97728688, ..., 33.98184053,\n", + " 33.97699258, 33.97804563], shape=(2001,)),\n", + " array([ 3.04302885e-04, 1.87970552e-05, -4.08099008e-04, ...,\n", + " -2.52719173e-04, -2.83636381e-04, 1.26210857e-04], shape=(2001,)),\n", + " array([87.41800913, 82.54938771, 79.75318217, ..., -5.85512024,\n", + " -5.84758912, -4.59886008], shape=(2001,)),\n", + " array([2.47657479, 2.26566822, 2.52302713, ..., 1.43445678, 1.46410281,\n", + " 1.44282067], shape=(2001,)))" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# or all S-parameters at once. Attention this is not a qcodes parameter\n", + "vna.get_s()" + ] + }, + { + "cell_type": "markdown", + "id": "unnecessary-coordinate", + "metadata": {}, + "source": [ + "## Look at the names and the labels of the Sxx parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "burning-tuition", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('M5065 s11 magnitude', 'M5065 s11 phase')" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vna.s11.labels" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "plain-frederick", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('M5065_s11_magnitude', 'M5065_s11_phase')" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vna.s11.names" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "circular-attack", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(('M5065 frequency',), ('M5065 frequency',))" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vna.s11.setpoint_labels" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "comparable-salem", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(('M5065_frequency',), ('M5065_frequency',))" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vna.s11.setpoint_names" + ] + }, + { + "cell_type": "markdown", + "id": "7e1fe8dd", + "metadata": {}, + "source": [ + "### Close the Connection" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "599755aa", + "metadata": {}, + "outputs": [], + "source": [ + "vna.close()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "qcodes", + "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.13.5" + }, + "nbsphinx": { + "execute": "never" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/qcodes/instrument/sims/CopperMountain_M5065.yaml b/src/qcodes/instrument/sims/CopperMountain_M5065.yaml new file mode 100644 index 00000000000..f1bfb19717b --- /dev/null +++ b/src/qcodes/instrument/sims/CopperMountain_M5065.yaml @@ -0,0 +1,123 @@ +spec: "1.0" + +resources: + TCPIP0::localhost::hislip0::INSTR: + device: M5065 + +devices: + M5065: + eom: + TCPIP INSTR: + q: "\n" + r: "\n" + error: ERROR + dialogues: + - q: "*IDN?" + r: "CMT, M5065, 23047001, 25.3.1/2" + properties: + output: + default: 0 + getter: + q: "OUTP:STAT?" + r: "{}" + setter: + q: "OUTP:STAT {}" + specs: + type: int + valid: [0, 1] + power: + default: -20 + getter: + q: "SOUR:POW?" + r: "{}" + setter: + q: "SOUR:POW {}" + specs: + min: -50 + max: 10 + type: float + if_bandwidth: + default: 100000 + getter: + q: "SENS1:BWID?" + r: "{}" + setter: + q: "SENS1:BWID {}" + averages_enabled: + default: 0 + getter: + q: "SENS1:AVER:STAT?" + r: "{}" + setter: + q: "SENS1:AVER:STAT {}" + specs: + type: int + valid: [0, 1] + averages_trigger_enabled: + default: 0 + getter: + q: "TRIG:SEQ:AVER?" + r: "{}" + setter: + q: "TRIG:SEQ:AVER {}" + specs: + type: int + valid: [0, 1] + electrical_delay: + default: 0 + getter: + q: "CALC1:CORR:EDEL:TIME?" + r: "{}" + setter: + q: "CALC1:CORR:EDEL:TIME {}" + electrical_distance: + default: 20 + getter: + q: "CALC1:CORR:EDEL:DIST?" + r: "{}" + setter: + q: "CALC1:CORR:EDEL:DIST {}" + clock_source: + default: "INT" + getter: + q: "SENSe1:ROSCillator:SOURce?" + r: "{}" + setter: + q: "SENSe1:ROSCillator:SOURce {}" + start: + default: 300000 + getter: + q: "SENS1:FREQ:STAR?" + r: "{}" + setter: + q: "SENS1:FREQ:STAR {}" + specs: + type: float + stop: + default: 6500000000 + getter: + q: "SENS1:FREQ:STOP?" + r: "{}" + setter: + q: "SENS1:FREQ:STOP {}" + specs: + type: float + center: + getter: + q: "SENS1:FREQ:CENT?" + r: "{}" + setter: + q: "SENS1:FREQ:CENT {}" + span: + getter: + q: "SENS1:FREQ:SPAN?" + r: "{}" + setter: + q: "SENS1:FREQ:SPAN {}" + number_of_points: + default: 201 + getter: + q: "SENS1:SWE:POIN?" + r: "{}" + setter: + q: "SENS1:SWE:POIN {}" diff --git a/src/qcodes/instrument_drivers/CopperMountain/M5065.py b/src/qcodes/instrument_drivers/CopperMountain/M5065.py new file mode 100644 index 00000000000..69c03af2fed --- /dev/null +++ b/src/qcodes/instrument_drivers/CopperMountain/M5065.py @@ -0,0 +1,20 @@ +from typing import TYPE_CHECKING + +from ._M5xxx import CopperMountainM5xxx + +if TYPE_CHECKING: + from typing_extensions import Unpack + + from qcodes.instrument import VisaInstrumentKWArgs + + +class CopperMountainM5065(CopperMountainM5xxx): + """This is the QCoDeS driver for the M5065 VNA from Copper Mountain Technologies""" + + def __init__( + self, + name: str, + address: str, + **kwargs: "Unpack[VisaInstrumentKWArgs]", + ): + super().__init__(name, address, min_freq=300e3, max_freq=6.5e9, **kwargs) diff --git a/src/qcodes/instrument_drivers/CopperMountain/M5180.py b/src/qcodes/instrument_drivers/CopperMountain/M5180.py new file mode 100644 index 00000000000..73e9fd57b66 --- /dev/null +++ b/src/qcodes/instrument_drivers/CopperMountain/M5180.py @@ -0,0 +1,20 @@ +from typing import TYPE_CHECKING + +from ._M5xxx import CopperMountainM5xxx + +if TYPE_CHECKING: + from typing_extensions import Unpack + + from qcodes.instrument import VisaInstrumentKWArgs + + +class CopperMountainM5180(CopperMountainM5xxx): + """This is the QCoDeS driver for the M5180 VNA from Copper Mountain Technologies""" + + def __init__( + self, + name: str, + address: str, + **kwargs: "Unpack[VisaInstrumentKWArgs]", + ): + super().__init__(name, address, min_freq=300e3, max_freq=18e9, **kwargs) diff --git a/src/qcodes/instrument_drivers/CopperMountain/_M5xxx.py b/src/qcodes/instrument_drivers/CopperMountain/_M5xxx.py new file mode 100644 index 00000000000..b0eb4dd6923 --- /dev/null +++ b/src/qcodes/instrument_drivers/CopperMountain/_M5xxx.py @@ -0,0 +1,879 @@ +import cmath +import logging +import math +from typing import TYPE_CHECKING, Any + +import numpy as np + +from qcodes.instrument import VisaInstrument, VisaInstrumentKWArgs +from qcodes.parameters import ( + ManualParameter, + MultiParameter, + Parameter, + ParamRawDataType, + create_on_off_val_mapping, +) +from qcodes.validators import Bool, Enum, Ints, Numbers + +if TYPE_CHECKING: + from typing_extensions import Unpack + +log = logging.getLogger(__name__) + + +class CopperMountainM5xxx(VisaInstrument): + """ + Base class for QCoDeS drivers for Copper Mountain M-series VNAs. + + Not to be instantiated directly. Use model specific subclass. + https://coppermountaintech.com/help-s2/index.html + + Note: Currently this driver only expects a single channel on the PNA. We + can handle multiple traces, but using traces across multiple channels + may have unexpected results. + """ + + default_terminator = "\n" + + def __init__( + self, + name: str, + address: str, + min_freq: float, + max_freq: float, + **kwargs: "Unpack[VisaInstrumentKWArgs]", + ): + """ + QCoDeS driver for Copper Mountain M-series VNA (M5xxx). + This driver supports only a single channel. + + Args: + name: Identifier for the instrument instance. + address: VISA address of the instrument. + min_freq: Minimum frequency supported by the instrument (in Hz). + max_freq: Maximum frequency supported by the instrument (in Hz). + **kwargs: Additional keyword arguments for VisaInstrument. + + """ + + super().__init__(name=name, address=address, **kwargs) + self.min_freq = min_freq + self.max_freq = max_freq + self.min_points = 2 + self.max_points = 200001 + + self.output: Parameter = self.add_parameter( + name="output", + label="Output", + get_parser=int, + get_cmd="OUTP:STAT?", + set_cmd="OUTP:STAT {}", + val_mapping=create_on_off_val_mapping(on_val=1, off_val=0), + ) + """Use to check state of RF signal output (ON/OFF) and turns the RF signal output ON/OFF""" + + self.power: Parameter = self.add_parameter( + name="power", + label="Power", + get_parser=float, + get_cmd="SOUR:POW?", + set_cmd="SOUR:POW {}", + unit="dBm", + docstring="Sets or reads out the power level for the frequency sweep type in dBm.", + vals=Numbers(min_value=-50, max_value=10), + ) + """Sets or reads out the power level for the frequency sweep type in dBm.""" + + self.if_bandwidth: Parameter = self.add_parameter( + name="if_bandwidth", + label="IF Bandwidth", + get_parser=float, + get_cmd="SENS1:BWID?", + set_cmd="SENS1:BWID {}", + unit="Hz", + vals=Enum( + *np.append( + np.kron([1, 1.5, 2, 3, 5, 7], 10 ** np.arange(5)), + np.kron([1, 1.5, 2, 3], 10**5), + ) + ), + ) + """Sets or reads out the IF bandwidth in Hz.""" + + self.averages_enabled: Parameter = self.add_parameter( + name="averages_enabled", + label="Averages Status", + get_cmd="SENS1:AVER:STAT?", + set_cmd="SENS1:AVER:STAT {}", + val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"), + ) + """Turns the measurement averaging function ON/OFF on channel 1.""" + + self.averages_trigger_enabled: Parameter = self.add_parameter( + "averages_trigger_enabled", + label="Trigger average status", + get_cmd="TRIG:SEQ:AVER?", + set_cmd="TRIG:SEQ:AVER {}", + val_mapping=create_on_off_val_mapping(on_val="1", off_val="0"), + ) + """Turns the averaging trigger function ON/OFF.""" + + self.averages: Parameter = self.add_parameter( + "averages", + label="Averages", + get_cmd="SENS1:AVER:COUN?", + set_cmd="SENS1:AVER:COUN {}", + get_parser=int, + set_parser=int, + unit="", + docstring="Sets or reads out the averaging factor " + "when the averaging function is turned on.", + vals=Numbers(min_value=1, max_value=999), + ) + """Sets or reads out the averaging factor + when the averaging function is turned on.""" + + self.electrical_delay: Parameter = self.add_parameter( + "electrical_delay", + label="Electrical delay", + get_cmd="CALC1:CORR:EDEL:TIME?", + set_cmd="CALC1:CORR:EDEL:TIME {}", + get_parser=float, + set_parser=float, + unit="s", + docstring="Sets or reads out the value of the electrical delay in seconds.", + vals=Numbers(-10, 10), + ) + """Sets or reads out the value of the electrical delay in seconds.""" + + self.electrical_distance: Parameter = self.add_parameter( + "electrical_distance", + label="Electrical distance", + get_cmd="CALC1:CORR:EDEL:DIST?", + set_cmd="CALC1:CORR:EDEL:DIST {}", + get_parser=float, + set_parser=float, + docstring="Sets or reads out the value of the equivalent " + "distance in the electrical delay function.", + vals=Numbers(), + ) + """Sets or reads out the value of the equivalent + distance in the electrical delay function.""" + + self.electrical_distance_units: Parameter = self.add_parameter( + "electrical_distance_units", + label="Electrical distance units", + get_cmd="CALC1:CORR:EDEL:DIST:UNIT?", + set_cmd="CALC1:CORR:EDEL:DIST:UNIT {}", + get_parser=str, + docstring="Sets or reads out the distance units in the electrical delay function.", + vals=Enum("MET", "FEET", "INCH"), + ) + """Sets or reads out the distance units in the electrical delay function.""" + + self.clock_source: Parameter = self.add_parameter( + name="clock_source", + label="Clock source", + get_cmd="SENSe1:ROSCillator:SOURce?", + set_cmd="SENSe1:ROSCillator:SOURce {}", + get_parser=str, + set_parser=str, + docstring="Sets or reads out an internal or external " + "source of the 10 MHz reference frequency.", + vals=Enum( + "int", + "Int", + "INT", + "internal", + "Internal", + "INTERNAL", + "ext", + "Ext", + "EXT", + "external", + "External", + "EXTERNAL", + ), + ) + """Sets or reads out an internal or external + source of the 10 MHz reference frequency.""" + + self.start: Parameter = self.add_parameter( + name="start", + label="Start Frequency", + get_parser=float, + get_cmd="SENS1:FREQ:STAR?", + set_cmd=self._set_start, + unit="Hz", + docstring="Sets or reads out the stimulus start value " + "of the sweep range for linear or logarithmic sweep type.", + vals=Numbers(min_value=self.min_freq, max_value=self.max_freq - 1), + ) + """Sets or reads out the stimulus start value of the sweep + range for linear or logarithmic sweep type.""" + + self.stop: Parameter = self.add_parameter( + name="stop", + label="Stop Frequency", + get_parser=float, + get_cmd="SENS1:FREQ:STOP?", + set_cmd=self._set_stop, + unit="Hz", + docstring="Sets or reads out the stimulus stop value of the " + "sweep range for linear or logarithmic sweep type.", + vals=Numbers(min_value=self.min_freq + 1, max_value=self.max_freq), + ) + """Sets or reads out the stimulus stop value of the sweep + range for linear or logarithmic sweep type.""" + + self.center: Parameter = self.add_parameter( + name="center", + label="Center Frequency", + get_parser=float, + get_cmd="SENS1:FREQ:CENT?", + set_cmd=self._set_center, + unit="Hz", + docstring="Sets or reads out the stimulus center value of " + "the sweep range for linear or logarithmic sweep type.", + vals=Numbers(min_value=self.min_freq + 1, max_value=self.max_freq - 1), + ) + """Sets or reads out the stimulus center value of the sweep range for + linear or logarithmic sweep type.""" + + self.span: Parameter = self.add_parameter( + name="span", + label="Frequency Span", + get_parser=float, + get_cmd="SENS1:FREQ:SPAN?", + set_cmd=self._set_span, + unit="Hz", + docstring="Sets or reads out the stimulus span value of the " + "sweep range for linear or logarithmic sweep type.", + vals=Numbers(min_value=1, max_value=self.max_freq - 1), + ) + """Sets or reads out the stimulus span value of the sweep range + for linear or logarithmic sweep type.""" + + self.number_of_points: Parameter = self.add_parameter( + "number_of_points", + label="Number of points", + get_parser=int, + set_parser=int, + get_cmd="SENS1:SWE:POIN?", + set_cmd=self._set_number_of_points, + docstring="Sets or reads out the number of measurement points.", + vals=Ints(min_value=self.min_points, max_value=self.max_points), + ) + """Sets or reads out the number of measurement points.""" + + self.number_of_traces: Parameter = self.add_parameter( + name="number_of_traces", + label="Number of traces", + get_parser=int, + set_parser=int, + get_cmd="CALC1:PAR:COUN?", + set_cmd="CALC1:PAR:COUN {}", + unit="", + docstring="Sets or reads out the number of traces in the channel.", + vals=Ints(min_value=1, max_value=16), + ) + """Sets or reads out the number of traces in the channel.""" + + self.trigger_source: Parameter = self.add_parameter( + name="trigger_source", + label="Trigger source", + get_parser=str, + get_cmd=self._get_trigger, + set_cmd=self._set_trigger, + docstring="Selects the trigger source.", + vals=Enum("bus", "external", "internal", "manual"), + ) + """Selects the trigger source""" + + self.data_transfer_format: Parameter = self.add_parameter( + name="data_transfer_format", + label="Data format during transfer", + get_parser=str, + get_cmd="FORM:DATA?", + set_cmd="FORM:DATA {}", + docstring="Sets or reads out the data transfer format " + "when responding to certain queries.", + vals=Enum("ascii", "real", "real32"), + ) + """Sets or reads out the data transfer format when + responding to certian queries.""" + + self.s11: FrequencySweepMagPhase = self.add_parameter( + name="s11", + start=self.start(), + stop=self.stop(), + number_of_points=self.number_of_points(), + parameter_class=FrequencySweepMagPhase, + docstring="Input reflection.", + ) + """Input reflection.""" + + self.s12: FrequencySweepMagPhase = self.add_parameter( + name="s12", + start=self.start(), + stop=self.stop(), + number_of_points=self.number_of_points(), + parameter_class=FrequencySweepMagPhase, + docstring="Reverse transmission.", + ) + """Reverse transmission.""" + + self.s21: FrequencySweepMagPhase = self.add_parameter( + name="s21", + start=self.start(), + stop=self.stop(), + number_of_points=self.number_of_points(), + parameter_class=FrequencySweepMagPhase, + docstring="Forward transmission", + ) + """Forward tranmission""" + + self.s22: FrequencySweepMagPhase = self.add_parameter( + name="s22", + start=self.start(), + stop=self.stop(), + number_of_points=self.number_of_points(), + parameter_class=FrequencySweepMagPhase, + docstring="Output reflection", + ) + """Output reflection""" + + self.point_s11: PointMagPhase = self.add_parameter( + name="point_s11", parameter_class=PointMagPhase + ) + + self.point_s12: PointMagPhase = self.add_parameter( + name="point_s12", parameter_class=PointMagPhase + ) + + self.point_s21: PointMagPhase = self.add_parameter( + name="point_s21", parameter_class=PointMagPhase + ) + + self.point_s22: PointMagPhase = self.add_parameter( + name="point_s22", parameter_class=PointMagPhase + ) + + self.point_s11_iq: PointIQ = self.add_parameter( + name="point_s11_iq", parameter_class=PointIQ + ) + + self.point_s12_iq: PointIQ = self.add_parameter( + name="point_s12_iq", parameter_class=PointIQ + ) + + self.point_s21_iq: PointIQ = self.add_parameter( + name="point_s21_iq", parameter_class=PointIQ + ) + + self.point_s22_iq: PointIQ = self.add_parameter( + name="point_s22_iq", parameter_class=PointIQ + ) + + self.point_check_sweep_first: ManualParameter = self.add_parameter( + name="point_check_sweep_first", + parameter_class=ManualParameter, + initial_value=True, + vals=Bool(), + docstring="Parameter that enables a few commands, which are called" + "before each get of a point_sxx parameter checking whether the vna" + "is setup correctly. Is recommended to be True, but can be turned" + "off if one wants to minimize overhead.", + ) + + # Electrical distance default units. + self.electrical_distance_units("MET") + + self.connect_message() + + def reset(self) -> None: + self.write("*RST") + + def _set_start(self, val: float) -> None: + """Sets the start frequency and updates linear trace parameters. + + Args: + val: start frequency to be set + + Raises: + ValueError: If start > stop + + """ + stop = self.stop() + if val >= stop: + raise ValueError("Stop frequency must be larger than start frequency.") + self.write(f"SENS1:FREQ:STAR {val}") + # we get start as the vna may not be able to set it to the + # exact value provided. + start = self.start() + if abs(val - start) >= 1: + log.warning(f"Could not set start to {val} setting it to {start}") + self.update_lin_traces() + + def _set_stop(self, val: float) -> None: + """Sets the start frequency and updates linear trace parameters. + + Args: + val: start frequency to be set + + Raises: + ValueError: If stop < start + + """ + start = self.start() + if val <= start: + raise ValueError("Stop frequency must be larger than start frequency.") + self.write(f"SENS1:FREQ:STOP {val}") + # We get stop as the vna may not be able to set it to the + # exact value provided. + stop = self.stop() + if abs(val - stop) >= 1: + log.warning(f"Could not set stop to {val} setting it to {stop}") + self.update_lin_traces() + + def _set_span(self, val: float) -> None: + """Sets frequency span and updates linear trace parameters. + + Args: + val: frequency span to be set + + """ + self.write(f"SENS1:FREQ:SPAN {val}") + self.update_lin_traces() + + def _set_center(self, val: float) -> None: + """Sets center frequency and updates linear trace parameters. + + Args: + val: center frequency to be set + + """ + self.write(f"SENS1:FREQ:CENT {val}") + self.update_lin_traces() + + def _set_number_of_points(self, val: int) -> None: + """Sets number of points and updates linear trace parameters. + + Args: + val: number of points to be set. + + """ + self.write(f"SENS1:SWE:POIN {val}") + self.update_lin_traces() + + def _get_trigger(self) -> str: + """Gets trigger source. + + Returns: + str: Trigger source. + + """ + r = self.ask("TRIG:SOUR?") + + if r.lower() == "int": + return "internal" + elif r.lower() == "ext": + return "external" + elif r.lower() == "man": + return "manual" + else: + return "bus" + + def _set_trigger(self, trigger: str) -> None: + """Sets trigger source. + + Args: + trigger: Trigger source + + """ + self.write("TRIG:SOUR " + trigger.upper()) + + def _set_trace_formats_to_smith(self, traces: list[int]) -> None: + """ + Sets the format of the specified traces to SMITH (real + imaginary). + + Args: + traces: A list of trace indices to set the format for. + + Returns: + None + + """ + + for trace in traces: + self.write(f"CALC1:TRAC{trace}:FORM SMITH") + + def get_s( + self, expected_measurement_duration: float = 600 + ) -> tuple[ + np.ndarray, + np.ndarray, + np.ndarray, + np.ndarray, + np.ndarray, + np.ndarray, + np.ndarray, + np.ndarray, + np.ndarray, + ]: + """ + Return all S parameters as magnitude in dB and phase in rad. + + Args: + expected_measurement_duration: Expected duration of the measurement in seconds. + + Returns: + Tuple[np.ndarray]: frequency [GHz], + s11 magnitude [dB], s11 phase [rad], + s12 magnitude [dB], s12 phase [rad], + s21 magnitude [dB], s21 phase [rad], + s22 magnitude [dB], s22 phase [rad] + + """ + + with self.timeout.set(max(self.timeout(), expected_measurement_duration)): + self.write("CALC1:PAR:COUN 4") # 4 trace + self.write("CALC1:PAR1:DEF S11") # Choose S11 for trace 1 + self.write("CALC1:PAR2:DEF S12") # Choose S12 for trace 2 + self.write("CALC1:PAR3:DEF S21") # Choose S21 for trace 3 + self.write("CALC1:PAR4:DEF S22") # Choose S22 for trace 4 + self._set_trace_formats_to_smith(traces=[1, 2, 3, 4]) + self.write("TRIG:SEQ:SING") # Trigger a single sweep + self.ask("*OPC?") # Wait for measurement to complete + + # Get data as string + freq_raw = self.ask("SENS1:FREQ:DATA?") + s11_raw = self.ask("CALC1:TRAC1:DATA:FDAT?") + s12_raw = self.ask("CALC1:TRAC2:DATA:FDAT?") + s21_raw = self.ask("CALC1:TRAC3:DATA:FDAT?") + s22_raw = self.ask("CALC1:TRAC4:DATA:FDAT?") + + # Get data as numpy array + freq = np.fromstring(freq_raw, dtype=float, sep=",") + s11 = np.fromstring(s11_raw, dtype=float, sep=",") + s11 = s11[0::2] + 1j * s11[1::2] + s12 = np.fromstring(s12_raw, dtype=float, sep=",") + s12 = s12[0::2] + 1j * s12[1::2] + s21 = np.fromstring(s21_raw, dtype=float, sep=",") + s21 = s21[0::2] + 1j * s21[1::2] + s22 = np.fromstring(s22_raw, dtype=float, sep=",") + s22 = s22[0::2] + 1j * s22[1::2] + + return ( + np.array(freq), + self._db(s11), + np.array(np.angle(s11)), + self._db(s12), + np.array(np.angle(s12)), + self._db(s21), + np.array(np.angle(s21)), + self._db(s22), + np.array(np.angle(s22)), + ) + + def update_lin_traces(self) -> None: + """ + Updates start, stop and number_of_points of all trace parameters so that the + setpoints and shape are updated for the sweep. + """ + start = self.start() + stop = self.stop() + number_of_points = self.number_of_points() + for _, parameter in self.parameters.items(): + if isinstance(parameter, (FrequencySweepMagPhase)): + try: + parameter.set_sweep(start, stop, number_of_points) + except AttributeError: + pass + + def reset_averages(self) -> None: + """ + Resets average count to 0 + """ + self.write("SENS1.AVER.CLE") + + @staticmethod + def _db(data: np.ndarray) -> np.ndarray: + """ + Return dB from magnitude + + Args: + data: data to be transformed into dB. + + Returns: + data: data transformed in dB. + + """ + + return 20.0 * np.log10(np.abs(data)) + + +class FrequencySweepMagPhase(MultiParameter): + """ + Sweep that returns magnitude and phase. + """ + + def __init__( + self, + name: str, + start: float, + stop: float, + number_of_points: int, + instrument: CopperMountainM5xxx, + **kwargs: Any, + ) -> None: + """ + Linear frequency sweep that returns magnitude and phase for a single + trace. + + Args: + name: Name of the linear frequency sweep + start: Start frequency of linear sweep + stop: Stop frequency of linear sweep + number_of_points: Number of points of linear sweep + instrument: Instrument to which sweep is bound to. + **kwargs: Any + + """ + super().__init__( + name, + instrument=instrument, + names=( + f"{instrument.short_name}_{name}_magnitude", + f"{instrument.short_name}_{name}_phase", + ), + labels=( + f"{instrument.short_name} {name} magnitude", + f"{instrument.short_name} {name} phase", + ), + units=("dB", "rad"), + setpoint_units=(("Hz",), ("Hz",)), + setpoint_labels=( + (f"{instrument.short_name} frequency",), + (f"{instrument.short_name} frequency",), + ), + setpoint_names=( + (f"{instrument.short_name}_frequency",), + (f"{instrument.short_name}_frequency",), + ), + shapes=( + (number_of_points,), + (number_of_points,), + ), + **kwargs, + ) + self.set_sweep(start, stop, number_of_points) + + def set_sweep(self, start: float, stop: float, number_of_points: int) -> None: + """Updates the setpoints and shapes based on start, stop and number_of_points. + + Args: + start: start frequency + stop: stop frequency + number_of_points: number of points + + """ + f = tuple(np.linspace(int(start), int(stop), num=number_of_points)) + self.setpoints = ((f,), (f,)) + self.shapes = ((number_of_points,), (number_of_points,)) + + def get_raw(self) -> tuple[ParamRawDataType, ParamRawDataType]: + """Gets data from instrument + + Returns: + Tuple[ParamRawDataType, ...]: magnitude, phase + + """ + assert isinstance(self.instrument, CopperMountainM5xxx) + self.instrument.write("CALC1:PAR:COUN 1") # 1 trace + self.instrument.write(f"CALC1:PAR1:DEF {self.name}") + self.instrument.trigger_source("bus") # set the trigger to bus + self.instrument.write("TRIG:SEQ:SING") # Trigger a single sweep + self.instrument.ask("*OPC?") # Wait for measurement to complete + + # get data from instrument + self.instrument._set_trace_formats_to_smith(traces=[1]) # ensure correct format + sxx_raw = self.instrument.ask("CALC1:TRAC1:DATA:FDAT?") + self.instrument.write("CALC1:TRAC1:FORM MLOG") + + # Get data as numpy array + sxx = np.fromstring(sxx_raw, dtype=float, sep=",") + sxx = sxx[0::2] + 1j * sxx[1::2] + + return self.instrument._db(sxx), np.unwrap(np.angle(sxx)) + + +class PointMagPhase(MultiParameter): + """ + Returns the average Sxx of a frequency sweep. + Work around for a CW mode where only one point is read. + number_of_points=2 and stop = start + 1 (in Hz) is required. + """ + + def __init__( + self, + name: str, + instrument: VisaInstrument, + **kwargs: Any, + ) -> None: + """Magnitude and phase measurement of a single point at start + frequency. + + Args: + name: Name of point measurement + instrument: Instrument to which parameter is bound to. + **kwargs: Any + + """ + + super().__init__( + name, + instrument=instrument, + names=( + f"{instrument.short_name}_{name}_magnitude", + f"{instrument.short_name}_{name}_phase", + ), + labels=( + f"{instrument.short_name} {name} magnitude", + f"{instrument.short_name} {name} phase", + ), + units=("dB", "rad"), + setpoints=( + (), + (), + ), + shapes=( + (), + (), + ), + **kwargs, + ) + + def get_raw(self) -> tuple[ParamRawDataType, ParamRawDataType]: + """Gets data from instrument + + Returns: + Tuple[ParamRawDataType, ...]: magnitude, phase + + """ + + assert isinstance(self.instrument, CopperMountainM5xxx) + # check that number_of_points, start and stop fullfill requirements if point_check_sweep_first is True. + if self.instrument.point_check_sweep_first(): + if self.instrument.number_of_points() != 2: + raise ValueError( + f"number_of_points is not 2 but {self.instrument.number_of_points()}. Please set it to 2" + ) + if self.instrument.stop() - self.instrument.start() != 1: + raise ValueError( + f"Stop-start is not 1 Hz but {self.instrument.stop() - self.instrument.start()} Hz. " + "Please adjust start or stop." + ) + + self.instrument.write("CALC1:PAR:COUN 1") # 1 trace + self.instrument.write(f"CALC1:PAR1:DEF {self.name[-3:]}") + self.instrument.trigger_source("bus") # set the trigger to bus + self.instrument.write("TRIG:SEQ:SING") # Trigger a single sweep + self.instrument.ask("*OPC?") # Wait for measurement to complete + + # get data from instrument + self.instrument._set_trace_formats_to_smith(traces=[1]) # ensure correct format + sxx_raw = self.instrument.ask("CALC1:TRAC1:DATA:FDAT?") + + # Get data as numpy array + sxx = np.fromstring(sxx_raw, dtype=float, sep=",") + sxx = sxx[0::2] + 1j * sxx[1::2] + + # Return the average of the trace, which will have "start" as + # its setpoint + sxx_mean = np.mean(sxx) + return 20 * math.log10(abs(sxx_mean)), (cmath.phase(sxx_mean)) + + +class PointIQ(MultiParameter): + """ + Returns the average Sxx of a frequency sweep, in terms of I and Q. + Work around for a CW mode where only one point is read. + number_of_points=2 and stop = start + 1 (in Hz) is required. + """ + + def __init__( + self, + name: str, + instrument: VisaInstrument, + **kwargs: Any, + ) -> None: + """I and Q measurement of a single point at start + frequency. + + Args: + name: Name of point measurement + instrument: Instrument to which parameter is bound to. + **kwargs: Any + + """ + + super().__init__( + name, + instrument=instrument, + names=( + f"{instrument.short_name}_{name}_i", + f"{instrument.short_name}_{name}_q", + ), + labels=( + f"{instrument.short_name} {name} i", + f"{instrument.short_name} {name} q", + ), + units=("V", "V"), + setpoints=( + (), + (), + ), + shapes=( + (), + (), + ), + **kwargs, + ) + + def get_raw(self) -> tuple[ParamRawDataType, ParamRawDataType]: + """Gets data from instrument + + Returns: + Tuple[ParamRawDataType, ...]: I, Q + + """ + + assert isinstance(self.instrument, CopperMountainM5xxx) + # check that number_of_points, start and stop fullfill requirements if point_check_sweep_first is True. + if self.instrument.point_check_sweep_first(): + if self.instrument.number_of_points() != 2: + raise ValueError( + f"number_of_points is not 2 but {self.instrument.number_of_points()}. Please set it to 2" + ) + if self.instrument.stop() - self.instrument.start() != 1: + raise ValueError( + f"Stop-start is not 1 Hz but {self.instrument.stop() - self.instrument.start()} Hz. Please adjust start or stop." + ) + + self.instrument.write("CALC1:PAR:COUN 1") # 1 trace + self.instrument.write(f"CALC1:PAR1:DEF {self.name[-3:]}") + self.instrument.trigger_source("bus") # set the trigger to bus + self.instrument.write("TRIG:SEQ:SING") # Trigger a single sweep + self.instrument.ask("*OPC?") # Wait for measurement to complete + + # get data from instrument + self.instrument._set_trace_formats_to_smith(traces=[1]) # ensure correct format + sxx_raw = self.instrument.ask("CALC1:TRAC1:DATA:FDAT?") + + # Get data as numpy array + sxx = np.fromstring(sxx_raw, dtype=float, sep=",") + + # Return the average of the trace, which will have "start" as + # its setpoint + return np.mean(sxx[0::2]), np.mean(sxx[1::2]) diff --git a/src/qcodes/instrument_drivers/CopperMountain/__init__.py b/src/qcodes/instrument_drivers/CopperMountain/__init__.py new file mode 100644 index 00000000000..6d1679794d4 --- /dev/null +++ b/src/qcodes/instrument_drivers/CopperMountain/__init__.py @@ -0,0 +1,4 @@ +from .M5065 import CopperMountainM5065 +from .M5180 import CopperMountainM5180 + +__all__ = ["CopperMountainM5065", "CopperMountainM5180"] diff --git a/tests/drivers/test_CopperMountain_M5065.py b/tests/drivers/test_CopperMountain_M5065.py new file mode 100644 index 00000000000..f7ff3bea9c3 --- /dev/null +++ b/tests/drivers/test_CopperMountain_M5065.py @@ -0,0 +1,34 @@ +import pytest + +from qcodes.instrument_drivers.CopperMountain.M5065 import CopperMountainM5065 + + +class DummyM5065: + def __init__(self, *args, **kwargs): + pass + + def start(self): + return 1e6 + + +@pytest.fixture() +def vna(): + instance = CopperMountainM5065( + name="M5065", + address="TCPIP0::localhost::hislip0::INSTR", + pyvisa_sim_file="CopperMountain_M5065.yaml", + ) + instance.reset() + yield instance + instance.close() + + +def test_m5065_instantiation(vna): + assert vna.name == "M5065" + assert vna._address == "TCPIP0::localhost::hislip0::INSTR" + + +def test_idn_command(vna): + idn = vna.get_idn() + assert idn["vendor"] == "CMT" + assert idn["model"] == "M5065"