Merge pull request #7398 from trlemon/feature/add-cryomagnetics-tm620-driver

Add Driver for Cryomagnetics TM-620 Cryogenic Temperature Monitor

Author: jenshnielsen

docs/changes/newsfragments/7398.new_driver

@@ -0,0 +1 @@
+Added Cryomagnetics TM-620 driver

docs/examples/driver_examples/Qcodes example with Cryomagnetics TM-620.ipynb

@@ -0,0 +1,125 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Cryomagnetics TM-620 QCoDeS Driver Example\n",
+    "\n",
+    "This notebook showcases how to interface with a Cryomagnetics TM-620 Cryogenic Temperature Monitor using QCoDeS. The Cryomagnetics TM-620 Cryogenic Temperature Monitor is commonly used in research settings for precise temperature monitoring, including superconductivity studies and material science.\n",
+    "\n",
+    "## Setup\n",
+    "\n",
+    "First, ensure you have the required drivers and QCoDeS installed. The connection to the instrument is assumed to be via GPIB. Let's establish the connection and set up the initial parameters for reading temperatures.\n",
+    "\n",
+    "Please note that you will need to update the address according to your connection type (e.g., USB, Ethernet, etc.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qcodes.instrument_drivers.cryomagnetics import CryomagneticsModelTM620\n",
+    "\n",
+    "tm620 = CryomagneticsModelTM620(\n",
+    "    name=\"cryomag_tm620\",\n",
+    "    address=\"GPIB::1::INSTR\",\n",
+    "    pyvisa_sim_file=\"cryo_tm620.yaml\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Basic Operations\n",
+    "\n",
+    "The following sections demonstrate how to perform basic operations with the Cryomagnetics TM-620 instrument. We will cover checking the temperatures of both the shield and magnet parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Reading the shield temperature\n",
+    "shield_temp = tm620.shield()\n",
+    "print(f\"55K Shield Temperature = {shield_temp}K\")\n",
+    "\n",
+    "# Reading the magnet temperature\n",
+    "magnet_temp = tm620.magnet()\n",
+    "print(f\"4K Magnet Temperature = {magnet_temp}K\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "\n",
+    "# Function to plot shield and magnet temperatures over time.\n",
+    "def plot_temperature_over_time(cryo_instr, duration, measurement_interval=0.5):\n",
+    "    times = []\n",
+    "    shield_temps = []\n",
+    "    magnet_temps = []\n",
+    "    start_time = time.time()\n",
+    "    while (time.time() - start_time) < duration:\n",
+    "        shield_temps.append(cryo_instr.shield())\n",
+    "        magnet_temps.append(cryo_instr.magnet())\n",
+    "        times.append(time.time() - start_time)\n",
+    "        time.sleep(measurement_interval)\n",
+    "    plt.plot(times, shield_temps, marker=\"o\", label=\"55K Shield Temp\")\n",
+    "    plt.plot(times, magnet_temps, marker=\"x\", label=\"4K Magnet Temp\")\n",
+    "    plt.xlabel(\"Time (s)\")\n",
+    "    plt.ylabel(\"Temperature (K)\")\n",
+    "    plt.title(\"Time vs Temperature (K)\")\n",
+    "    plt.legend()\n",
+    "    plt.show()\n",
+    "\n",
+    "\n",
+    "# Example usage:\n",
+    "plot_temperature_over_time(\n",
+    "    tm620, 60\n",
+    ")  # plot for 60 seconds while setting the field to 1 T"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Notes\n",
+    "\n",
+    "For further information, consult the official documentation and user manuals provided by the manufacturer. Always prioritize safe operating practices and maintain the instrument according to the recommended guidelines."
+   ]
+  }
+ ],
+ "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"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

src/qcodes/instrument/sims/cryo_tm620.yaml

@@ -0,0 +1,30 @@
+spec: "1.0"
+devices:
+  cryomag_tm620:
+    eom:
+      GPIB INSTR:
+        q: "\r\n"
+        r: "\r\n"
+    error: ERROR
+    dialogues:
+      - q: "*IDN?"
+        r: "Cryomagnetics,TM-620_simulation,2002,2.00"
+      - q: "MEAS? A"
+        r: "{RANDOM(54, 56, 1):.2f}K\r\n"
+      - q: "MEAS? B"
+        r: "{RANDOM(3, 5, 1):.2f}K\r\n"
+
+    properties:
+      shield:
+        getter:
+          q: "MEAS? A"
+          r: "{RANDOM(54, 56, 1):.2f}K\r\n"
+      magnet:
+        getter:
+          q: "MEAS? B"
+          r: "{RANDOM(3, 5, 1):.2f}K\r\n"
+
+
+resources:
+  GPIB::1::INSTR:
+    device: cryomag_tm620

src/qcodes/instrument_drivers/cryomagnetics/_TM620.py

@@ -0,0 +1,130 @@
+import re
+from typing import TYPE_CHECKING
+
+from qcodes.instrument import VisaInstrument, VisaInstrumentKWArgs
+
+if TYPE_CHECKING:
+    from typing_extensions import Unpack
+
+    from qcodes.parameters import Parameter
+
+
+class CryomagneticsModelTM620(VisaInstrument):
+    """
+    Driver for the Cryomagnetics TM 620 temperature monitor.
+
+    Units are kG right now
+
+    Args:
+        name: a name for the instrument
+
+        address: VISA address of the device
+
+    """
+
+    float_pattern = re.compile(r"[0-9]+\.[0-9]+")
+
+    def __init__(
+        self,
+        name: str,
+        address: str,
+        **kwargs: "Unpack[VisaInstrumentKWArgs]",
+    ) -> None:
+        super().__init__(name, address, **kwargs)
+
+        self.shield: Parameter = self.add_parameter(
+            name="shield",
+            unit="K",
+            get_cmd=self._get_A,
+            get_parser=float,
+            docstring="55K Shield Temp",
+        )
+        """55K shield temperature"""
+
+        self.magnet: Parameter = self.add_parameter(
+            name="magnet",
+            unit="K",
+            get_cmd=self._get_B,
+            get_parser=float,
+            docstring="4K Magnet Temp",
+        )
+        """4K magnet temperature"""
+
+        self.operating_mode()
+        self.connect_message()
+
+    def operating_mode(self, remote: bool = True) -> None:
+        """
+        Sets the device's operating mode to either remote or local.
+
+        Args:
+            remote: If True, sets to remote mode, otherwise sets to local mode.
+
+        """
+        if remote:
+            self.write("REMOTE")
+        else:
+            self.write("LOCAL")
+
+    def _get_A(self) -> float:
+        """Get 55k shield temperature
+
+        Returns:
+            Temperature in Kelvin
+
+        """
+        output = self.ask("MEAS? A")
+        output = self._parse_output(output)
+        numeric_output = self._convert_to_numeric(output)
+
+        return numeric_output
+
+    def _get_B(self) -> float:
+        """Get 4k magnet temp
+
+        Returns:
+            Temperature in Kelvin
+
+        """
+        output = self.ask("MEAS? B")
+        output = self._parse_output(output)
+        numeric_output = self._convert_to_numeric(output)
+
+        return numeric_output
+
+    def _parse_output(self, output: str) -> str:
+        """Extract floating point number from the instrument output string.
+
+        Args:
+            output: the string returned from the instrument.
+
+        Returns:
+            parsed string containing extracted floating point number.
+
+        """
+
+        match = self.float_pattern.search(output)
+
+        if match:
+            return match.group(0)
+
+        self.log.error(f"No floating point number found in output: '{output}'")
+        raise ValueError(f"No floating point number found in output: '{output}'")
+
+    def _convert_to_numeric(self, raw_value: str) -> float:
+        """
+        Convert a raw string value to a numeric float.
+
+        Args:
+            raw_value: The raw string value to convert.
+
+        Returns:
+            The converted float value.
+
+        """
+        try:
+            numeric_value = float(raw_value)
+            return numeric_value
+        except ValueError:
+            self.log.error(f"Error converting '{raw_value}' to float")
+            raise ValueError(f"Unable to convert '{raw_value}' to float")

src/qcodes/instrument_drivers/cryomagnetics/__init__.py

@@ -4,10 +4,12 @@
     CryomagneticsModel4G,
     CryomagneticsOperatingState,
 )
+from ._TM620 import CryomagneticsModelTM620
 
 __all__ = [
     "Cryomagnetics4GException",
     "Cryomagnetics4GWarning",
     "CryomagneticsModel4G",
+    "CryomagneticsModelTM620",
     "CryomagneticsOperatingState",
 ]

tests/drivers/test_cryomagnetics_TM620.py

@@ -0,0 +1,61 @@
+from unittest.mock import patch
+
+import pytest
+
+from qcodes.instrument_drivers.cryomagnetics import CryomagneticsModelTM620
+
+
+@pytest.fixture(name="tm620", scope="function")
+def fixture_tm620():
+    """
+    Fixture to create and yield a CryomagneticsModelTM620 object and close it after testing.
+    """
+    instrument = CryomagneticsModelTM620(
+        name="test_cryo_tm620",
+        address="GPIB::2::INSTR",
+        terminator="\r\n",
+        pyvisa_sim_file="cryo_tm620.yaml",
+    )
+    yield instrument
+    instrument.close()
+
+
+def test_initialization(tm620):
+    assert tm620.name == "test_cryo_tm620"
+    assert tm620._address == "GPIB::2::INSTR"
+    assert hasattr(tm620, "shield")
+    assert hasattr(tm620, "magnet")
+
+
+def test_get_A_success(tm620):
+    with patch.object(tm620, "ask", return_value="55.12K"):
+        assert tm620._get_A() == 55.12
+
+
+def test_get_B_success(tm620):
+    with patch.object(tm620, "ask", return_value="4.21K"):
+        assert tm620._get_B() == 4.21
+
+
+def test_parse_output_valid(tm620):
+    assert tm620._parse_output("55.12K") == "55.12"
+    assert tm620._parse_output("4.34C") == "4.34"
+
+
+def test_parse_output_invalid(tm620, caplog):
+    with caplog.at_level("ERROR"):
+        with pytest.raises(ValueError, match="No floating point number found"):
+            tm620._parse_output("Invalid output")
+    assert "No floating point number found in output" in caplog.text
+
+
+def test_convert_to_numerics_valid(tm620):
+    assert tm620._convert_to_numeric("55.12") == 55.12
+    assert tm620._convert_to_numeric("4.34") == 4.34
+
+
+def test_convert_to_numerics_invalid(tm620, caplog):
+    with caplog.at_level("ERROR"):
+        with pytest.raises(ValueError, match="Unable to convert"):
+            tm620._convert_to_numeric("not_a_number")
+    assert "Error converting 'not_a_number' to float" in caplog.text