qkit 0.5.2__tar.gz → 0.5.4__tar.gz

qkit-0.5.4/.git

@@ -0,0 +1 @@
+gitdir: ../.git/modules/qkit

{qkit-0.5.2 → qkit-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: qkit
-Version: 0.5.2
+Version: 0.5.4
 Summary: qKIT quantum measurement suite in python
 Project-URL: Homepage, https://github.com/qkitgroup/qkit
 Project-URL: Bug Tracker, https://github.com/qkitgroup/qkit/issues
@@ -345,8 +345,6 @@ License:                     GNU GENERAL PUBLIC LICENSE
         library.  If this is what you want to do, use the GNU Lesser General
         Public License instead of this License.
         
-License-File: AUTHORS
-License-File: LICENSE
 Keywords: Data Acquisition,Framework,Measurement,Quantum
 Classifier: Framework :: Jupyter :: JupyterLab :: 3
 Classifier: Intended Audience :: Science/Research
@@ -365,6 +363,7 @@ Requires-Dist: pyvisa>=1.13
 Requires-Dist: pyzmq>=25
 Requires-Dist: scipy>=1.10
 Requires-Dist: tomli>=2.0.1
+Requires-Dist: tqdm>=4.67.0
 Provides-Extra: analysis
 Requires-Dist: matplotlib>=3.7; extra == 'analysis'
 Requires-Dist: peakutils>=1.3; extra == 'analysis'
@@ -380,7 +379,7 @@ Requires-Dist: zerorpc>=0.6; extra == 'timedomain'
 Provides-Extra: url
 Requires-Dist: parsita~=2.2.2; extra == 'url'
 Provides-Extra: zurich-instruments
-Requires-Dist: zhinst~=23.2; extra == 'zurich-instruments'
+Requires-Dist: laboneq>=2.59.0; extra == 'zurich-instruments'
 Description-Content-Type: text/markdown
 
 <p align="center">

{qkit-0.5.2 → qkit-0.5.4}/pyproject.toml

@@ -32,7 +32,8 @@ dependencies = [
     "tomli>=2.0.1",
     "ipython",
     "packaging",
-    "filelock>=3.17"
+    "filelock>=3.17",
+    "tqdm>=4.67.0"
 ]
 
 [project.scripts]
@@ -48,7 +49,7 @@ jupyter = [
     "ipywidgets>=8.0"
 ]
 zurich-instruments = [
-    "zhinst~=23.2"
+    "LabOneQ>=2.59.0"
 ]
 analysis = [
     "matplotlib>=3.7",

qkit-0.5.4/src/qkit/_version.py

@@ -0,0 +1 @@
+__version__ = "0.5.4"

qkit-0.5.4/src/qkit/analysis/circle_fit/another_circle_fit.py

@@ -0,0 +1,66 @@
+import numpy as np
+from sympy import symbols, matrices, Expr, Poly
+from scipy import optimize, linalg
+
+# Matrix B from eq. (7)
+CONSTRAINT_MATRIX = np.array([
+    [0, 0, 0, -2],
+    [0, 1, 0, 0],
+    [0, 0, 1, 0],
+    [-2, 0, 0, 0]
+])
+
+def compute_moments(z_data: np.ndarray) -> np.ndarray:
+    """
+    Calculate the moments as defined in eq. 6.
+    """
+    # Split out data into x (real), y (imag), and z (x**2 + y**2)
+    x = z_data.real
+    y = z_data.imag
+    z = x*x + y*y
+    n = np.shape(z_data)[0] # Length of data.
+
+    # Calculate the sums over x,y,z
+    m_x = np.sum(x) # Simple sums
+    m_y = np.sum(y)
+    m_z = np.sum(z)
+
+    # Calculate the moments, as sum over the element-wise products
+    m_xx = np.sum(x*x)
+    m_yy = np.sum(y*y)
+    m_zz = np.sum(z*z)
+    m_xy = np.sum(x * y)
+    m_xz = np.sum(x * z)
+    m_yz = np.sum(y * z)
+
+    # Build the moment matrix
+    return np.array([
+        [m_zz, m_xz, m_yz, m_z],
+        [m_xz, m_xx, m_xy, m_x],
+        [m_yz, m_xy, m_yy, m_y],
+        [m_z,  m_x,  m_y,  n]
+    ])
+
+def fit_circle_algebraic(z_data: np.ndarray):
+    """
+    Fit a circle in the complex plane using a algebraic method.
+
+    Stable against noise, can be used to get very good start parameters for iterative fit.
+    """
+    # Build the characteristic polynomial and solve it.
+    x = symbols('x')
+    M = compute_moments(z_data)
+    polynomial: Poly = matrices.det(M - x * CONSTRAINT_MATRIX).as_poly()
+    assert polynomial
+    derivative = polynomial.diff(x)
+    x0, infodict, ier, mesg = optimize.fsolve(polynomial.eval, 0., fprime=derivative.eval)
+
+    # Retrieve the corresponding EV
+    U, s, Vt = np.linalg.svd(M - x0 * CONSTRAINT_MATRIX)
+    A_vec = Vt[np.argmin(s), :]
+
+    # Calculate center position and radius
+    x_c = -A_vec[1]/(2 * A_vec[0])
+    y_c = -A_vec[2]/(2 * A_vec[0])
+    radius = np.sqrt(A_vec[1]*A_vec[1] + A_vec[2] * A_vec[2] - 4 * A_vec[0] * A_vec[3]) / 2 * np.abs(A_vec[0])
+    return x_c, y_c, radius

qkit-0.5.4/src/qkit/analysis/numerical_derivative.py

@@ -0,0 +1,99 @@
+import itertools
+from typing import override
+
+from scipy import signal
+
+from qkit.measure.unified_measurements import AnalysisTypeAdapter, MeasurementTypeAdapter, DataView, DataViewSet, DataReference
+
+
+class SavgolNumericalDerivative(AnalysisTypeAdapter):
+    """
+    Apply a numerical derivative to the measurement data.
+
+    Performs pair-wise differentiation of the measurement data.
+
+    Assumes that measurement data comes in (I, V, I, V, ...) format or equivalent.
+    Assumes that names are in the form of '[IV]_(?:b_)?_[0-9]'
+    """
+
+    _window_length: int
+    _polyorder: int
+    _derivative: int
+
+    def __init__(self, window_length: int = 15, polyorder: int = 3, derivative: int = 1):
+        super().__init__()
+        self._window_length = window_length
+        self._polyorder = polyorder
+        self._derivative = derivative
+
+    @override
+    def perform_analysis(self, data: tuple['MeasurementTypeAdapter.GeneratedData', ...]) -> tuple[
+        'MeasurementTypeAdapter.GeneratedData', ...]:
+        parent_schema = tuple([element.descriptor for element in data])
+        output_schema = self.expected_structure(parent_schema)
+        out = []
+        for ((dxdy, dydx), (x, y)) in zip(itertools.batched(output_schema, 2), itertools.batched(data, 2)):
+            out.append(dxdy.with_data(
+                signal.savgol_filter(x.data, window_length=self._window_length, polyorder=self._polyorder, deriv=self._derivative)\
+                / signal.savgol_filter(y.data, window_length=self._window_length, polyorder=self._polyorder, deriv=self._derivative)
+            ))
+            out.append(dydx.with_data(
+                signal.savgol_filter(y.data, window_length=self._window_length, polyorder=self._polyorder, deriv=self._derivative)\
+                / signal.savgol_filter(x.data, window_length=self._window_length, polyorder=self._polyorder, deriv=self._derivative)
+            ))
+        return tuple(out)
+
+
+    @override
+    def expected_structure(self, parent_schema: tuple['MeasurementTypeAdapter.DataDescriptor', ...]) -> tuple['MeasurementTypeAdapter.DataDescriptor', ...]:
+        structure = []
+        for (x, y) in itertools.batched(parent_schema, 2):
+            assert x.axes == y.axes
+            structure += [
+                MeasurementTypeAdapter.DataDescriptor(
+                    name=f"d{x.name}_d{y.name}",
+                    unit=f"{x.unit}_{y.unit}",
+                    axes=x.axes, 
+                    category="analysis"
+                ),
+                MeasurementTypeAdapter.DataDescriptor(
+                    name=f"d{y.name}_d{x.name}",
+                    unit=f"{y.unit}_{x.unit}",
+                    axes=x.axes,
+                    category="analysis"
+                )
+            ]
+        return tuple(structure)
+
+    @override
+    def default_views(self, parent_schema: tuple['MeasurementTypeAdapter.DataDescriptor', ...]) -> dict[str, DataView]:
+        schema = self.expected_structure(parent_schema)
+        variable_names = (schema[0].name.split('_')[0], schema[1].name.split('_')[0])
+        return { # dx/dy
+            f'{variable_names[0]}_{variable_names[1]}': DataView(
+                view_params={
+                    "labels": (schema[0].axes[0].name, f'{variable_names[0]}_{variable_names[1]}'),
+                    'plot_style': 1,
+                    'markersize': 5
+                },
+                view_sets=[
+                    DataViewSet(
+                        x_path=DataReference(entry.axes[0].name,),
+                        y_path=DataReference(entry.name, category='analysis')
+                    ) for entry in schema[0::2]
+                ]
+            ), # dy/dx
+            f'{variable_names[1]}_{variable_names[0]}': DataView(
+                view_params={
+                    "labels": (schema[1].axes[0].name, f'{variable_names[1]}_{variable_names[0]}'),
+                    'plot_style': 1,
+                    'markersize': 5
+                },
+                view_sets=[
+                    DataViewSet(
+                        x_path=DataReference(entry.axes[0].name),
+                        y_path=DataReference(entry.name, category='analysis')
+                    ) for entry in schema[1::2]
+                ]
+            )
+        }

{qkit-0.5.2 → qkit-0.5.4}/src/qkit/core/lib/file_service/breadcrumbs.py

@@ -16,10 +16,10 @@ UUID=rel_path\n
 
 The UUID is 6 symbols long. It is followed by an `=` symbol. The rest of the line is the relative path.
 """
-
+import os
 from pathlib import Path
 import qkit
-import os
+from os import PathLike
 import itertools
 from filelock import FileLock, Timeout
 import logging
@@ -68,7 +68,7 @@ class BreadCrumbCreator():
             log.error("Could not acquire lock file for clearing breadcrumbs.")
             raise
 
-    def append_entry(self, uuid: str, path: Path|str):
+    def append_entry(self, uuid: str, path: PathLike):
         rel_path = Path(path).relative_to(self._breadcrumb_path.parent)
         try:
             with self._lock:

qkit-0.5.4/src/qkit/drivers/AbstractIVDevice.py

@@ -0,0 +1,49 @@
+from abc import ABC, abstractmethod
+from typing import Literal, Any
+
+import numpy as np
+
+
+class AbstractIVDevice(ABC):
+
+    @abstractmethod
+    def take_IV(self, sweep: tuple[float, float, float, float]) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Perform an IV sweep. Returns (bias, sense).
+        Sweep is (start, stop, step, sleep)
+        """
+        pass
+
+    @abstractmethod
+    def get_sweep_mode(self) -> Literal[0, 1, 2]:
+        """
+        Get the sweep mode: 0 (VV-mode) | 1 (IV-mode) | 2 (VI-mode)
+        """
+        pass
+
+    @abstractmethod
+    def get_sweep_bias(self) -> Literal[0, 1]:
+        """
+        Get the sweep bias: 0 (current bias) | 1 (voltage bias)
+
+        Only relevant for units.
+        """
+        pass
+
+    @abstractmethod
+    def get_sweep_channels(self) -> list:
+        """
+        Get a list of channels to sweep.
+        """
+        pass
+
+    @abstractmethod
+    def set_status(self, status: bool, channel: Any):
+        """
+        Sets the status of a channel.
+        """
+        pass
+
+    def set_overall_status(self, status: bool):
+        for channel in self.get_sweep_channels():
+            self.set_status(status, channel)

qkit-0.5.4/src/qkit/drivers/AbstractThermometer.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+from typing import Any, Literal
+
+
+class AbstractThermometer(ABC):
+    """
+    The interface for a generic multichannel thermometer.
+
+    It measures in [unit] (to be implemented). Returns measurement via get_temperature.
+    """
+
+    @property
+    def unit(self) -> Literal['K', '°C']:
+        """
+        The unit of the measurement. Override to change.
+        """
+        return 'K'
+
+    @abstractmethod
+    def get_temperature(self, channel: Any) -> float:
+        pass

{qkit-0.5.2 → qkit-0.5.4}/src/qkit/drivers/AbstractVNA.py

@@ -36,7 +36,7 @@ class AbstractVNA(ABC):
         return freqs[-1] - freqs[0]
 
     @abstractmethod
-    def get_tracedata(self, RealImag = None) -> tuple((np.ndarray, np.ndarray)):
+    def get_tracedata(self, RealImag = None) -> tuple[np.ndarray, np.ndarray]:
         """
         When the measurement succeeded, this method returns the resulting data.
         The behaviour depends on the [RealImag] keyword argument.

{qkit-0.5.2 → qkit-0.5.4}/src/qkit/drivers/IVVI_BiasDAC.py

@@ -108,8 +108,8 @@ class IVVI_BiasDAC(Instrument):
             self.v_div = None # for voltage bias
         def get_sweep_mode(self):
             # 0: V bias V measure, 1: I bias V measure, 2: V bias I measure
-            # technically mode 2 also possible, this class cant determine 0 vs 2 without hidden knowledge about measure function though
-            return 1 - self.pseudo_bias_mode
+            # technically mode 0 also possible, this class cant determine 0 vs 2 without hidden knowledge about measure function though
+            return 1 + self.pseudo_bias_mode
         def get_sweep_bias(self):
             return self.pseudo_bias_mode
         def get_sweep_channels(self):

{qkit-0.5.2 → qkit-0.5.4}/src/qkit/gui/plot/url_launcher.py

@@ -36,7 +36,7 @@ class QviewkitURLParser(ParserContext):
     _kv = _argument_name << lit('=') & _argument_value
     _arguments = (lit('?') >> rep1sep(_kv, lit('&')) << eof > dict) | (eof > constant({}))
     _uuid = reg(r'[A-Z0-9]{6}') > str
-    url_pattern = _prefix >> _uuid & _arguments
+    url_pattern = _prefix >> _uuid << opt(lit('/')) & _arguments
 
     @classmethod
     def parse(cls, data) -> Tuple[str, Optional[dict]]:

{qkit-0.5.2 → qkit-0.5.4}/src/qkit/install/install.py

@@ -2,7 +2,7 @@ import logging
 from pathlib import Path
 import platform
 from types import ModuleType
-from typing import Callable, Literal
+from typing import Callable, Literal, Optional
 import shutil
 import sys
 
@@ -55,7 +55,7 @@ def get_binary(name: str) -> str:
     return str(candidate)
 
 
-def copy_named_template(source_cache: Traversable, target_path: Path, target_name: str, human_readable: str | None = None):
+def copy_named_template(source_cache: Traversable, target_path: Path, target_name: str, human_readable: Optional[str] = None):
     package_file: Traversable = source_cache / f'{target_name}-tpl'
     logging.debug("Got reference %s: %s", human_readable if human_readable is not None else target_name, package_file)
     target = (target_path / target_name)
@@ -68,7 +68,7 @@ def copy_named_template(source_cache: Traversable, target_path: Path, target_nam
 UNIVERSAL_SCRIPTS: list[Callable[[Path], None]] = []
 SYSTEM_SCRIPTS: dict[str, list[Callable[[Path], None]]] = {}
 
-def platform(target: Literal["Windows", "Linux", "Darwin", "All"]):
+def on_platform(target: Literal["Windows", "Linux", "Darwin", "All"]):
     def decorator(f: Callable[[Path], None]):
         if target == "All":
             UNIVERSAL_SCRIPTS.append(f)
@@ -84,7 +84,7 @@ def platform(target: Literal["Windows", "Linux", "Darwin", "All"]):
 # Define Universal Scripts Here #
 #################################
 
-@platform("All")
+@on_platform("All")
 def create_base_structure(pwd: Path):
     """
     Check if the PWD exists and create the folders 'notebooks', 'data' and 'logs'.
@@ -113,7 +113,7 @@ def create_base_structure(pwd: Path):
 # Define System Scripts Here #
 ##############################
 
-@platform("Windows")
+@on_platform("Windows")
 def windows_install_scripts(pwd: Path):
     with open(pwd / "launch.bat", "w") as f:
         jupyter_path = get_binary('jupyter')
@@ -125,7 +125,7 @@ def windows_install_scripts(pwd: Path):
             logging.warning("No activate.bat found, assuming no venv exists. Calling jupyter directly.")
             f.write(f'"{jupyter_path}" lab --config=./jupyter_lab_config.py\r\n')
 
-@platform("Windows")
+@on_platform("Windows")
 @windows_admin_required
 @optional("Install qviewkit url handler. Modifies the Registry.")
 def windows_install_qviewkit_url_handler(pwd: Path):
@@ -151,11 +151,11 @@ def windows_install_qviewkit_url_handler(pwd: Path):
         url_handler_key = winreg.CreateKeyEx(winreg.HKEY_CLASSES_ROOT, r"qviewkit")
         winreg.SetValueEx(url_handler_key, "URL Protocol", 0, winreg.REG_SZ, "")
         winreg.CloseKey(url_handler_key)
-        command_key = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, r"qviewkit\shell\open\command")
+        command_key = winreg.CreateKeyEx(winreg.HKEY_CLASSES_ROOT, r"qviewkit\shell\open\command")
         winreg.SetValue(command_key, None, winreg.REG_SZ, qviewkit_url_launch_command)
         winreg.CloseKey(command_key)
 
-@platform("Windows")
+@on_platform("Windows")
 @windows_admin_required
 @optional("Associate .h5 files with Qviewkit. Modifies the Registry.")
 def windows_associate_h5(pwd: Path):
@@ -194,14 +194,14 @@ def windows_associate_h5(pwd: Path):
         (value, type) = winreg.QueryValueEx(key, None)
         if value != r"qviewkit.h5":
             logging.info("Different association found. Overwriting...")
-            winreg.SetValue(key, None, winreg.REG_SZ, r"qviewkit.h5")
+            winreg.SetValue(key, None, winreg.REG_SZ, r"qviewkit.h5") #TODO: This is buggy
     except FileNotFoundError:
         assoc_key = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT, r".h5")
         winreg.SetValue(assoc_key, None, winreg.REG_SZ, "qviewkit.h5")
         winreg.CloseKey(assoc_key)
         logging.info("Association created.")
 
-@platform("Windows")
+@on_platform("Windows")
 @windows_admin_required
 @optional("Disable Smart Sorting in Windows Explorer. Edits the registry.")
 def windows_disable_smart_sorting(pwd: Path):
@@ -209,13 +209,13 @@ def windows_disable_smart_sorting(pwd: Path):
     key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer")
     winreg.SetValue(key, "NoStrCmpLogical", winreg.REG_DWORD, 1)
 
-@platform("Windows")
+@on_platform("Windows")
 def windows_set_config_path(pwd: Path):
     import os
     config_path = pwd / "qkit_local_config.py"
     os.system(f'setx QKIT_LOCAL_CONFIG "{str(config_path.absolute())}"')
 
-@platform("Linux")
+@on_platform("Linux")
 def linux_set_env(pwd: Path):
     import os
     if 'QKIT_LOCAL_CONFIG' in os.environ or 'QKIT_VENV' in os.environ:
@@ -231,7 +231,7 @@ def linux_set_env(pwd: Path):
     with open(Path.home() / ".profile", mode="a") as f:
         f.write(var_export)
 
-@platform("Linux")
+@on_platform("Linux")
 def linux_install_desktop_files(pwd: Path):
     def install_file(fname):
         import os

qkit-0.5.4/src/qkit/measure/laboneq_measurement.py

@@ -0,0 +1,83 @@
+import logging
+
+from laboneq.simple import *
+
+from qkit.measure.unified_measurements import MeasurementTypeAdapter, Axis
+
+from typing import Optional, List, Generator
+
+import numpy as np
+
+
+class LabOneQMeasurement(MeasurementTypeAdapter):
+    """
+    A measurement adapter for LabOneQ experiments.
+    Allows adapting all the LabOneQ measurements to Qkit storage and measurement infrastructure.
+    """
+
+    _session: Session
+    _experiment: Experiment
+    _structure: tuple['MeasurementTypeAdapter.DataDescriptor', ...]
+
+    @staticmethod
+    def sanitize_name(internal_name):
+        return internal_name.replace('/', '_').replace(' ', '_')
+
+    @staticmethod
+    def flatten(l: list) -> Generator:
+        """
+        Takes a list of lists and flattens it into a list. Must handle the case where the root list entries are not lists.
+        """
+        for element in l:
+            if isinstance(element, list):
+                yield from LabOneQMeasurement.flatten(element)
+            else:
+                yield element
+
+    def __init__(self, session: Session, experiment: Experiment, unit: str = 'a.u.', axis_units: Optional[List[str]] = None):
+        super().__init__()
+        self._session = session
+        self._experiment = experiment
+        compiled_experiment = self._session.compile(self._experiment)
+        emulated_session = Session(device_setup=compiled_experiment.device_setup, log_level=logging.WARNING)
+        emulated_session.connect(do_emulation=True)
+        emulated_result = emulated_session.run(compiled_experiment)
+        self._structure = tuple()
+        for (name, entry) in emulated_result.acquired_results.items():
+            sanitized = LabOneQMeasurement.sanitize_name(name)
+            axis_names = list(LabOneQMeasurement.flatten(entry.axis_name))
+            axes = tuple(LabOneQMeasurement.flatten(entry.axis))
+            if axis_units is None:
+                axis_units = ("a.u.",) * len(axis_names)
+            axes = tuple(Axis(name=name, range=values, unit=unit) for (name, values, unit) in zip(axis_names, axes, axis_units))
+            if np.iscomplexobj(entry.data):
+                self._structure += (
+                    MeasurementTypeAdapter.DataDescriptor(name=sanitized + "_real", axes=axes, unit=unit),
+                    MeasurementTypeAdapter.DataDescriptor(name=sanitized + "_imag", axes=axes, unit="i" + unit),
+                    MeasurementTypeAdapter.DataDescriptor(name=sanitized + "_mag", axes=axes, unit=unit),
+                    MeasurementTypeAdapter.DataDescriptor(name=sanitized + "_phase", axes=axes, unit='rad')
+                )
+            else:
+                self._structure += tuple(
+                    MeasurementTypeAdapter.DataDescriptor(name=sanitized, axes=axes, unit=unit)
+                )
+
+    @property
+    def expected_structure(self) -> tuple['MeasurementTypeAdapter.DataDescriptor', ...]:
+        return self._structure
+
+    def perform_measurement(self) -> tuple['MeasurementTypeAdapter.GeneratedData', ...]:
+        compiled_experiment = self._session.compile(self._experiment)
+        result: Results = self._session.run(compiled_experiment)
+        def data_mapper(acquired_results):
+            for (name, entry) in acquired_results.items():
+                if np.iscomplexobj(entry.data):
+                    yield name + "_real", np.real(entry.data)
+                    yield name + "_imag", np.imag(entry.data)
+                    yield name + "_mag", np.abs(entry.data)
+                    yield name + "_phase", np.angle(entry.data)
+                else:
+                    yield name, entry.data
+        return tuple(
+            descriptor.with_data(datum) for descriptor, (_, datum) in zip(self._structure, data_mapper(result.acquired_results))
+        )

qkit-0.5.4/src/qkit/measure/spectroscopy/spectroscopy_measurement.py

@@ -0,0 +1,52 @@
+import time
+
+from qkit.measure.unified_measurements import MeasurementTypeAdapter, Axis
+from qkit.drivers.AbstractVNA import AbstractVNA
+
+class SpectroscopyMeasurement(MeasurementTypeAdapter):
+
+    _vna: AbstractVNA
+    _frequency_axis: Axis
+
+    def __init__(self, vna: AbstractVNA):
+        super().__init__()
+        self._vna = vna
+        self._frequency_axis = Axis(
+            name='frequency',
+            unit='Hz',
+            range=vna.get_freqpoints()
+        )
+
+    @staticmethod
+    def _phase_descriptor(frequency_axis: Axis):
+        return MeasurementTypeAdapter.DataDescriptor(
+            name="phase",
+            unit="rad",
+            axes=(frequency_axis,)
+        )
+
+    @staticmethod
+    def _amplitude_descriptor(frequency_axis: Axis):
+        return MeasurementTypeAdapter.DataDescriptor(
+            name="amplitude",
+            axes=(frequency_axis,)
+        )
+
+    @property
+    def expected_structure(self) -> tuple['MeasurementTypeAdapter.DataDescriptor', ...]:
+        return (
+            self._amplitude_descriptor(self._frequency_axis),
+            self._phase_descriptor(self._frequency_axis)
+        )
+
+    def perform_measurement(self) -> tuple['MeasurementTypeAdapter.GeneratedData', ...]:
+        self._vna.pre_measurement()
+        self._vna.start_measurement()
+        while not self._vna.ready():
+            time.sleep(0.1)
+        amp, phase = self._vna.get_tracedata()
+        self._vna.post_measurement()
+        return (
+            self._amplitude_descriptor(self._frequency_axis).with_data(amp),
+            self._phase_descriptor(self._frequency_axis).with_data(phase)
+        )

qkit-0.5.4/src/qkit/measure/thermometry_measurement.py

@@ -0,0 +1,34 @@
+from typing import Any
+
+from qkit.drivers.AbstractThermometer import AbstractThermometer
+from qkit.measure.unified_measurements import MeasurementTypeAdapter
+
+
+class ThermometryMeasurement(MeasurementTypeAdapter):
+
+    _thermometer: AbstractThermometer
+    _channel: Any
+    _descriptor: MeasurementTypeAdapter.DataDescriptor
+
+
+    def __init__(self, thermometer: AbstractThermometer, channel: Any, name: str = "temperature"):
+        super().__init__()
+        self._thermometer = thermometer
+        self._channel = channel
+        self._descriptor = MeasurementTypeAdapter.DataDescriptor(
+            name=name,
+            unit=self._thermometer.unit,
+            axes=tuple()
+        )
+
+
+    @property
+    def expected_structure(self) -> tuple['MeasurementTypeAdapter.DataDescriptor', ...]:
+        return (
+            self._descriptor,
+        )
+
+    def perform_measurement(self) -> tuple['MeasurementTypeAdapter.GeneratedData', ...]:
+        return (
+            self._descriptor.with_data(self._thermometer.get_temperature(self._channel)),
+        )