Merge branch 'master' into sqlite_read_only_mode

Author: jenshnielsen

.pre-commit-config.yaml

@@ -18,7 +18,7 @@ repos:
     hooks:
       - id: isort
   - repo: https://github.com/asottile/pyupgrade
-    rev: v3.1.0
+    rev: v3.2.0
     hooks:
     - id: pyupgrade
       args: ['--py38-plus']

docs/changes/newsfragments/4759.improved

@@ -0,0 +1,2 @@
+The sweeps used by doNd has gained the ability to perform a get call after setting the parameter and storing
+that value in the dataset rather than the value set.

docs/examples/DataSet/Using_doNd_functions_in_comparison_to_Measurement_context_manager_for_performing_measurements.ipynb

@@ -60,6 +60,7 @@ class ParameterSetEvent:
     should_set: bool
     delay: float
     actions: ActionsT
+    get_after_set: bool
 
 
 class _Sweeper:
@@ -228,6 +229,7 @@ def __getitem__(self, index: int) -> tuple[ParameterSetEvent, ...]:
                 should_set=should_set,
                 delay=sweep.delay,
                 actions=sweep.post_actions,
+                get_after_set=sweep.get_after_set,
             )
             parameter_set_events.append(event)
         return tuple(parameter_set_events)
@@ -708,7 +710,10 @@ def dond(
                             act()
                         time.sleep(set_event.delay)
 
-                    results[set_event.parameter] = set_event.new_value
+                    if set_event.get_after_set:
+                        results[set_event.parameter] = set_event.parameter()
+                    else:
+                        results[set_event.parameter] = set_event.new_value
 
                 meas_value_pair = call_params_meas()
                 for meas_param, value in meas_value_pair:

qcodes/dataset/dond/do_nd.py

@@ -57,6 +57,17 @@ def post_actions(self) -> ActionsT:
         """
         pass
 
+    @property
+    def get_after_set(self) -> bool:
+        """
+        Should we perform a call to get on the parameter after setting it
+        and store that rather than the setpoint value in the dataset?
+
+        This defaults to False for backwards compatibility
+        but subclasses should overwrite this to implement if correctly.
+        """
+        return False
+
 
 class LinSweep(AbstractSweep[np.float64]):
     """
@@ -67,7 +78,10 @@ class LinSweep(AbstractSweep[np.float64]):
         start: Sweep start value.
         stop: Sweep end value.
         num_points: Number of sweep points.
-        delay: Time in seconds between two consecutive sweep points
+        delay: Time in seconds between two consecutive sweep points.
+        post_actions: Actions to do after each sweep point.
+        get_after_set: Should we perform a get on the parameter after setting it
+            and store the value returned by get rather than the set value in the dataset.
     """
 
     def __init__(
@@ -78,13 +92,15 @@ def __init__(
         num_points: int,
         delay: float = 0,
         post_actions: ActionsT = (),
+        get_after_set: bool = False,
     ):
         self._param = param
         self._start = start
         self._stop = stop
         self._num_points = num_points
         self._delay = delay
         self._post_actions = post_actions
+        self._get_after_set = get_after_set
 
     def get_setpoints(self) -> npt.NDArray[np.float64]:
         """
@@ -109,6 +125,10 @@ def num_points(self) -> int:
     def post_actions(self) -> ActionsT:
         return self._post_actions
 
+    @property
+    def get_after_set(self) -> bool:
+        return self._get_after_set
+
 
 class LogSweep(AbstractSweep[np.float64]):
     """
@@ -120,6 +140,9 @@ class LogSweep(AbstractSweep[np.float64]):
         stop: Sweep end value.
         num_points: Number of sweep points.
         delay: Time in seconds between two consecutive sweep points.
+        post_actions: Actions to do after each sweep point.
+        get_after_set: Should we perform a get on the parameter after setting it
+            and store the value returned by get rather than the set value in the dataset.
     """
 
     def __init__(
@@ -130,13 +153,15 @@ def __init__(
         num_points: int,
         delay: float = 0,
         post_actions: ActionsT = (),
+        get_after_set: bool = False,
     ):
         self._param = param
         self._start = start
         self._stop = stop
         self._num_points = num_points
         self._delay = delay
         self._post_actions = post_actions
+        self._get_after_set = get_after_set
 
     def get_setpoints(self) -> npt.NDArray[np.float64]:
         """
@@ -161,6 +186,10 @@ def num_points(self) -> int:
     def post_actions(self) -> ActionsT:
         return self._post_actions
 
+    @property
+    def get_after_set(self) -> bool:
+        return self._get_after_set
+
 
 class ArraySweep(AbstractSweep, Generic[T]):
     """
@@ -171,6 +200,8 @@ class ArraySweep(AbstractSweep, Generic[T]):
         array: array with values to sweep.
         delay: Time in seconds between two consecutive sweep points.
         post_actions: Actions to do after each sweep point.
+        get_after_set: Should we perform a get on the parameter after setting it
+            and store the value returned by get rather than the set value in the dataset.
     """
 
     def __init__(
@@ -179,11 +210,13 @@ def __init__(
         array: Sequence[Any] | npt.NDArray[T],
         delay: float = 0,
         post_actions: ActionsT = (),
+        get_after_set: bool = False,
     ):
         self._param = param
         self._array = np.array(array)
         self._delay = delay
         self._post_actions = post_actions
+        self._get_after_set = get_after_set
 
     def get_setpoints(self) -> npt.NDArray[T]:
         return self._array
@@ -204,6 +237,10 @@ def num_points(self) -> int:
     def post_actions(self) -> ActionsT:
         return self._post_actions
 
+    @property
+    def get_after_set(self) -> bool:
+        return self._get_after_set
+
 
 class TogetherSweep:
     """

qcodes/dataset/dond/sweeps.py

@@ -16,6 +16,7 @@
 
 if TYPE_CHECKING:
     from qcodes.instrument.channel import ChannelTuple, InstrumentModule
+    from qcodes.logger.instrument_logger import InstrumentLoggerAdapter
 
 from qcodes.utils import QCoDeSDeprecationWarning
 
@@ -82,7 +83,7 @@ def __init__(
         # This is needed for snapshot method to work
         self._meta_attrs = ["name", "label"]
 
-        self.log = get_instrument_logger(self, __name__)
+        self.log: InstrumentLoggerAdapter = get_instrument_logger(self, __name__)
 
     @property
     def label(self) -> str:

qcodes/instrument/instrument_base.py

@@ -13,6 +13,7 @@
 
 if TYPE_CHECKING:
     from qcodes.instrument.base import InstrumentBase
+    from qcodes.logger.instrument_logger import InstrumentLoggerAdapter
     from qcodes.validators import Validator
 
 
@@ -180,15 +181,29 @@ def __init__(
         **kwargs: Any,
     ) -> None:
         def _get_manual_parameter() -> ParamRawDataType:
-            log.debug(
+            if self.root_instrument is not None:
+                mylogger: InstrumentLoggerAdapter | logging.Logger = (
+                    self.root_instrument.log
+                )
+            else:
+                mylogger = log
+            mylogger.debug(
                 "Getting raw value of parameter: %s as %s",
                 self.full_name,
                 self.cache.raw_value,
             )
             return self.cache.raw_value
 
         def _set_manual_parameter(x: ParamRawDataType) -> ParamRawDataType:
-            log.debug("Setting raw value of parameter: %s to %s", self.full_name, x)
+            if self.root_instrument is not None:
+                mylogger: InstrumentLoggerAdapter | logging.Logger = (
+                    self.root_instrument.log
+                )
+            else:
+                mylogger = log
+            mylogger.debug(
+                "Setting raw value of parameter: %s to %s", self.full_name, x
+            )
             return x
 
         if instrument is not None and bind_to_instrument:

qcodes/parameters/parameter.py

@@ -34,6 +34,50 @@
 from qcodes.validators import Ints
 
 
+class TrackingParameter(Parameter):
+    """Parameter that keeps track of number of get and set operations"""
+
+    def __init__(self, *args, **kwargs):
+        self.set_count = 0
+        self.get_count = 0
+        super().__init__(*args, **kwargs)
+
+    def set_raw(self, value):
+        self.set_count += 1
+        self.cache._set_from_raw_value(value)
+
+    def get_raw(self):
+        self.get_count += 1
+        return self.cache.raw_value
+
+    def reset_count(self) -> None:
+        self.get_count = 0
+        self.set_count = 0
+
+
+class GetReturnsCountParameter(Parameter):
+    """Parameter that keeps track of number of get and set operations
+    Allows you to set a value but returns the get count rather
+    than the value"""
+
+    def __init__(self, *args, **kwargs):
+        self.set_count = 0
+        self.get_count = 0
+        super().__init__(*args, **kwargs)
+
+    def set_raw(self, value):
+        self.set_count += 1
+        self.cache._set_from_raw_value(value)
+
+    def get_raw(self):
+        self.get_count += 1
+        return self.get_count
+
+    def reset_count(self) -> None:
+        self.get_count = 0
+        self.set_count = 0
+
+
 def test_linear_sweep_get_setpoints(_param):
     start = 0
     stop = 1
@@ -1589,3 +1633,77 @@ def test_default_log_info(caplog):
         dond(LinSweep(param_1, 0, 10, 10), param_2)
 
     assert "Using 'qcodes.dataset.dond'" in caplog.text
+
+
+def test_dond_get_after_set(_param_set, _param_set_2, _param):
+
+    n_points = 10
+
+    a = TrackingParameter("a", initial_value=0)
+    b = TrackingParameter("b", initial_value=0)
+
+    a.reset_count()
+    b.reset_count()
+
+    assert a.get_count == 0
+    assert a.set_count == 0
+    assert b.get_count == 0
+    assert b.set_count == 0
+
+    dond(LinSweep(a, 0, 10, n_points, get_after_set=True), b)
+
+    assert a.get_count == n_points
+    assert a.set_count == n_points
+    assert b.get_count == n_points
+    assert b.set_count == 0
+
+
+def test_dond_no_get_after_set(_param_set, _param_set_2, _param):
+
+    n_points = 10
+
+    a = TrackingParameter("a", initial_value=0)
+    b = TrackingParameter("b", initial_value=0)
+
+    a.reset_count()
+    b.reset_count()
+
+    assert a.get_count == 0
+    assert a.set_count == 0
+    assert b.get_count == 0
+    assert b.set_count == 0
+
+    dond(LinSweep(a, 0, 10, n_points, get_after_set=False), b)
+
+    assert a.get_count == 0
+    assert a.set_count == n_points
+    assert b.get_count == n_points
+    assert b.set_count == 0
+
+
+def test_dond_get_after_set_stores_get_value(_param_set, _param_set_2, _param):
+
+    n_points = 11
+
+    a = GetReturnsCountParameter("a", initial_value=0)
+    b = TrackingParameter("b", initial_value=0)
+
+    a.reset_count()
+    b.reset_count()
+
+    assert a.get_count == 0
+    assert a.set_count == 0
+    assert b.get_count == 0
+    assert b.set_count == 0
+
+    ds, _, _ = dond(LinSweep(a, -10, -20, n_points, get_after_set=True), b)
+
+    # since we are using the GetReturnsCountParameter the sweep should be count e.g. 0, 1, ... 11
+    # not the set parameters -10, .. - 20
+    np.testing.assert_array_equal(
+        ds.get_parameter_data()["b"]["a"], np.linspace(1, 11, n_points)
+    )
+    assert a.get_count == n_points
+    assert a.set_count == n_points
+    assert b.get_count == n_points
+    assert b.set_count == 0

qcodes/tests/dataset/dond/test_doNd.py

@@ -209,7 +209,11 @@ def get_raw(self):
         dac = self.root_instrument._setter_instr
         val = self._ed.send(dac.ch1.cache.get())
         next(self._ed)
-        log.debug("Getting raw value of parameter: %s as %s", self.full_name, val)
+        if self.root_instrument is not None:
+            mylogger = self.root_instrument.log
+        else:
+            mylogger = log
+        mylogger.debug("Getting raw value of parameter: %s as %s", self.full_name, val)
         return val
 
     @staticmethod
@@ -241,7 +245,11 @@ def get_raw(self):
         dac = self.root_instrument._setter_instr
         val = self._gauss.send((dac.ch1.cache.get(), dac.ch2.cache.get()))
         next(self._gauss)
-        log.debug("Getting raw value of parameter: %s as %s", self.full_name, val)
+        if self.root_instrument is not None:
+            mylogger = self.root_instrument.log
+        else:
+            mylogger = log
+        mylogger.debug("Getting raw value of parameter: %s as %s", self.full_name, val)
         return val
 
     def _gauss_model(self):