qkit 0.5.3__tar.gz → 0.5.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qkit
-Version: 0.5.3
+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

qkit-0.5.4/src/qkit/_version.py

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

{qkit-0.5.3 → qkit-0.5.4}/src/qkit/analysis/numerical_derivative.py

@@ -53,12 +53,14 @@ class SavgolNumericalDerivative(AnalysisTypeAdapter):
                 MeasurementTypeAdapter.DataDescriptor(
                     name=f"d{x.name}_d{y.name}",
                     unit=f"{x.unit}_{y.unit}",
-                    axes=x.axes
+                    axes=x.axes, 
+                    category="analysis"
                 ),
                 MeasurementTypeAdapter.DataDescriptor(
                     name=f"d{y.name}_d{x.name}",
                     unit=f"{y.unit}_{x.unit}",
-                    axes=x.axes
+                    axes=x.axes,
+                    category="analysis"
                 )
             ]
         return tuple(structure)
@@ -67,16 +69,26 @@ class SavgolNumericalDerivative(AnalysisTypeAdapter):
     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 {
-            f'd{variable_names[0]}_d{variable_names[1]}': DataView(
+        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]
                 ]
-            ),
-            f'd{variable_names[1]}_d{variable_names[0]}': DataView(
+            ), # 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),

{qkit-0.5.3 → qkit-0.5.4}/src/qkit/drivers/AbstractIVDevice.py

@@ -7,9 +7,10 @@ import numpy as np
 class AbstractIVDevice(ABC):
 
     @abstractmethod
-    def take_IV(self, sweep: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    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
 

{qkit-0.5.3 → 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.3 → 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.3 → qkit-0.5.4}/src/qkit/measure/transport_measurement.py

@@ -8,8 +8,7 @@ import numpy as np
 import itertools
 
 from qkit.drivers.AbstractIVDevice import AbstractIVDevice
-from qkit.measure.unified_measurements import MeasurementTypeAdapter, Axis
-from qkit.storage.thin_hdf import HDF5
+from qkit.measure.unified_measurements import MeasurementTypeAdapter, Axis, DataView, DataViewSet, DataReference
 
 
 @dataclass(frozen=True)
@@ -20,36 +19,44 @@ class _MeasureMode:
     measure_unit: str
 
 class MeasureModes(Enum):
+    """
+    TODO DocString BiasSense (?)
+    """
     IV = _MeasureMode('i', 'A', 'v', 'V')
     VI = _MeasureMode('v', 'V', 'i', 'A')
 
 class TransportMeasurement(MeasurementTypeAdapter):
 
     _measurement_descriptors: list[tuple[MeasurementTypeAdapter.DataDescriptor, MeasurementTypeAdapter.DataDescriptor]]
+    _sweep_parameters: list[tuple[float, float, float]]
     _iv_device: AbstractIVDevice
     _mode: MeasureModes
     _sleep: float
+    _extend_range: bool
 
-    def __init__(self, iv_device: AbstractIVDevice, mode: MeasureModes = MeasureModes.IV, sleep: float = 0):
+    def __init__(self, iv_device: AbstractIVDevice, mode: MeasureModes = MeasureModes.IV, sleep: float = 0, extend_range=False):
         super().__init__()
         self._iv_device = iv_device
         self._mode = mode
         self._measurement_descriptors = []
+        self._sweep_parameters = []
         self._sleep = sleep
+        self._extend_range = extend_range
         if mode == MeasureModes.IV:
-            assert iv_device.get_sweep_mode() == 1
+            assert iv_device.get_sweep_bias() == 0
         elif mode == MeasureModes.VI:
-            assert iv_device.get_sweep_mode() == 2
+            assert iv_device.get_sweep_bias() == 1
 
     def add_sweep(self, start: float, stop: float, step: float):
         axis = Axis(
-            name=f'{self._mode.value.bias_symbol}_{len(self._measurement_descriptors)}',
+            name=f'{self._mode.value.bias_symbol}_b_{len(self._measurement_descriptors)}',
             unit=self._mode.value.bias_unit,
-            range=np.arange(start, stop, step)
+            range=np.arange(start, stop if not self._extend_range else (stop + step/2), step)
         )
-        self._measurement_descriptors += (
+        self._sweep_parameters += [(start, stop, step)] # TODO: Refactor by lazy DataDescriptor creation based on sweep parameters
+        self._measurement_descriptors += [(
             MeasurementTypeAdapter.DataDescriptor(
-                name=f'{self._mode.value.bias_symbol}_b_{len(self._measurement_descriptors)}',
+                name=f'{self._mode.value.bias_symbol}_{len(self._measurement_descriptors)}',
                 unit=self._mode.value.bias_unit,
                 axes=(axis,)
             ),
@@ -58,7 +65,7 @@ class TransportMeasurement(MeasurementTypeAdapter):
                 unit=self._mode.value.measure_unit,
                 axes=(axis,)
             )
-        )
+        )]
 
     def add_4_quadrant_sweep(self, start: float, stop: float, step: float, offset: float = 0):
         """
@@ -101,8 +108,8 @@ class TransportMeasurement(MeasurementTypeAdapter):
         offset: float
             Offset value by which <start> and <stop> are shifted. Default is 0.
         """
-        self.add_sweep(amplitude + offset, -amplitude + offset, step)
-        self.add_sweep(-amplitude + offset, amplitude + offset, -step)
+        self.add_sweep(amplitude + offset, -amplitude + offset, -step)
+        self.add_sweep(-amplitude + offset, amplitude + offset, step)
 
     @override
     @property
@@ -111,14 +118,31 @@ class TransportMeasurement(MeasurementTypeAdapter):
 
     @override
     @property
-    def default_views(self) -> dict[str, HDF5.DataView]:
+    def default_views(self) -> dict[str, DataView]:
         return {
-            'IV': HDF5.DataView(
-                view_type=HDF5.DataViewType.ONE_D,
+            'IV': DataView(
+                view_params={
+                    "labels": ('V', 'I'),
+                    'plot_style': 1,
+                    'markersize': 5
+                },
+                view_sets=list(itertools.chain(
+                    DataViewSet(
+                        x_path = DataReference(b.name if self._mode == MeasureModes.VI else m.name),
+                        y_path = DataReference(m.name if self._mode == MeasureModes.VI else b.name),
+                    ) for (b, m) in self._measurement_descriptors
+                ))
+            ),
+            'VI': DataView(
+                view_params={
+                    "labels": ('I', 'V'),
+                    'plot_style': 1,
+                    'markersize': 5
+                },
                 view_sets=list(itertools.chain(
-                    HDF5.DataViewSet(
-                        x_path= HDF5.DataReference(b.name),
-                        y_path= HDF5.DataReference(m.name),
+                    DataViewSet(
+                        x_path = DataReference(b.name if self._mode == MeasureModes.IV else m.name),
+                        y_path = DataReference(m.name if self._mode == MeasureModes.IV else b.name),
                     ) for (b, m) in self._measurement_descriptors
                 ))
             ),
@@ -127,9 +151,8 @@ class TransportMeasurement(MeasurementTypeAdapter):
     @override
     def perform_measurement(self) -> tuple['MeasurementTypeAdapter.GeneratedData', ...]:
         results = []
-        for (bias, measurement) in self._measurement_descriptors:
-            intended_bias_values = bias.axes[0].range
-            bias_data, measurement_data = self._iv_device.take_IV(intended_bias_values)
+        for ((bias, measurement), sweep_params) in zip(self._measurement_descriptors, self._sweep_parameters):
+            bias_data, measurement_data = self._iv_device.take_IV((*sweep_params, self._sleep))
             results.append((
                 bias.with_data(bias_data),
                 measurement.with_data(measurement_data)

{qkit-0.5.3 → qkit-0.5.4}/src/qkit/measure/unified_measurements.py

@@ -170,7 +170,7 @@ class ParentOfMeasurements(ABC):
         """
         if len(self._measurements) == 0:
             return 0
-        return max(map(lambda m: len(m.expected_structure), self._measurements))
+        return max(map(lambda m: m.dimension, self._measurements))
 
     def create_datasets(self, data_file: hdf.Data, swept_axes: list[hdf_dataset]):
         """
@@ -248,6 +248,7 @@ class Sweep(ParentOfSweep, ParentOfMeasurements):
         sweep, size = self._generate_enumeration(data_file)
         try:
             for index, value in tqdm(sweep, desc=self._axis.name, bar_format=bar_format(), total=size, leave=False):
+                measurement_log.debug(f"Sweeping {self._axis.name} index: {index} value: {value}")
                 try:
                     self._setter(value)
                     self._current_value = value
@@ -366,13 +367,6 @@ class DataGenerator(ABC):
     Handles storing data into datasets, and provides the structures for describing the data.
     """
 
-    @property
-    def dataset_category(self) -> Literal['data', 'analysis']:
-        """
-        The category into which the returned data should be sorted.
-        """
-        return 'data'
-
     def store(self, data_file: hdf.Data, data: tuple['MeasurementTypeAdapter.GeneratedData', ...], sweep_indices: tuple[int, ...]):
         """
         Store the generated [data] in the [data_file], while selecting based on the current [sweep_indices].
@@ -395,6 +389,7 @@ class DataGenerator(ABC):
         name: str
         axes: tuple[Axis, ...]
         unit: str = 'a.u.'
+        category: Literal['data', 'analysis'] = "data"
 
         def __post_init__(self):
             assert isinstance(self.name, str), "Name must be a string!"
@@ -402,6 +397,7 @@ class DataGenerator(ABC):
             for axis in self.axes:
                 assert isinstance(axis, Axis), "Axes must be a tuple of Axis objects!"
             assert isinstance(self.unit, str), "Unit must be a string!"
+            assert self.category == "data" or self.category == "analysis", "Category must bei either 'data' or 'analysis'"
 
         def with_data(self, data: Union[np.ndarray, float]) -> 'MeasurementTypeAdapter.GeneratedData':
             """
@@ -421,19 +417,26 @@ class DataGenerator(ABC):
             # The API has different methods, depending on dimensionality, which it then unifies again to a generic case.
             # For political reasons, we have to live with this.
             if len(all_axes) == 0:
-                return file.add_coordinate(name=self.name, unit=self.unit)
+                return file.add_coordinate(name=self.name, unit=self.unit, folder=self.category)
             elif len(all_axes) == 1:
-                return file.add_value_vector(name=self.name,x = all_axes[0], unit=self.unit)
+                return file.add_value_vector(name=self.name,x = all_axes[0], unit=self.unit, folder=self.category)
             elif len(all_axes) == 2:
-                return file.add_value_matrix(name=self.name, x = all_axes[0], y = all_axes[1], unit=self.unit)
+                return file.add_value_matrix(name=self.name, x = all_axes[0], y = all_axes[1], unit=self.unit, folder=self.category)
             elif len(all_axes) == 3:
-                return file.add_value_box(name=self.name, x = all_axes[0], y = all_axes[1], z = all_axes[2], unit=self.unit)
+                return file.add_value_box(name=self.name, x = all_axes[0], y = all_axes[1], z = all_axes[2], unit=self.unit, folder=self.category)
             else:
                 raise NotImplementedError("Qkit Store does not support more than 3 dimensions!")
 
         @property
         def ds_url(self):
-            return f"/entry/data0/{self.name}"
+            return f"/entry/{self.category}0/{self.name}"
+        
+        @property
+        def dimension(self):
+            """
+            The dimensionality of the expected Data.
+            """
+            return len(self.axes)
 
     @dataclass(frozen=True)
     class GeneratedData:
@@ -450,7 +453,7 @@ class DataGenerator(ABC):
             assert isinstance(self.data, np.ndarray), "MeasurementData must be an ndarray!"
             assert len(self.descriptor.axes) == len(self.data.shape), f"Data shape (d={len(self.data.shape)}) incongruent with descriptor (d={len(self.descriptor.axes)})"
             for (i, axis) in enumerate(self.descriptor.axes):
-                assert self.data.shape[i] == len(axis.range), f"Axis ({axis.name}) length and data length mismatch"
+                assert self.data.shape[i] == len(axis.range), f"Axis {i} ({axis.name}) length ({len(axis.range)}) and data length ({self.data.shape[i]}) mismatch"
 
         def write_data(self, file: hdf.Data, sweep_indices: tuple[int, ...]):
             """
@@ -530,11 +533,6 @@ class AnalysisTypeAdapter(DataGenerator, ABC):
             measurement_log.debug(f"Creating View {name} for Analysis.")
             view.write(data_file, name)
 
-    @override
-    @property
-    def dataset_category(self) -> Literal['data', 'analysis']:
-        return 'analysis'
-
     @abstractmethod
     def expected_structure(self, parent_schema: tuple['MeasurementTypeAdapter.DataDescriptor', ...]) -> tuple[
         'MeasurementTypeAdapter.DataDescriptor', ...]:
@@ -587,9 +585,9 @@ class MeasurementTypeAdapter(DataGenerator, ABC):
 
         views = self.default_views
         assert isinstance(views, dict), "Default views must be a dict of str to DataViews!"
-        for name, view in views:
+        for name, view in views.items():
             assert isinstance(name, str), "Name of view must be a string!"
-            assert isinstance(view, DataView), "Each view must be of type DataView!"
+            assert isinstance(view, DataView), f"Each view must be of type DataView! But {name} is {type(view)}"
             measurement_log.debug(f"Creating view {name}.")
             view.write(data_file, name)
 
@@ -618,6 +616,13 @@ class MeasurementTypeAdapter(DataGenerator, ABC):
         assert isinstance(analysis, AnalysisTypeAdapter), "Analysis must be of type AnalysisTypeAdapter!"
         self._analyses.append(analysis)
         return self
+    
+    @property
+    def dimension(self):
+        """
+        Determine the dimensionality of the measurement as the maximum dimensionality of any expected structure.
+        """
+        return max(map(lambda es: es.dimension, self.expected_structure))
 
     @property
     @abstractmethod
@@ -791,6 +796,9 @@ class Experiment(ParentOfSweep, ParentOfMeasurements):
             measurement_log.info("Starting measurement")
             self.run_measurements(data_file, ())
             self._run_child_sweep(data_file, ())
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
         finally:
             # Calling into existing plotting code in the background.
             measurement_log.info("Creating plots...")

qkit-0.5.3/src/qkit/_version.py

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