[DEM-943] Resolved review comments.

Author: CumulonimbusCalvus

docs/notebooks/unfinished/example_UHFLI_measurements.py

@@ -26,7 +26,7 @@ def update_stimulus(is_enabled: bool, signal_output: int = 1, signal_input: Opti
     Args:
         is_enabled: True to enable and False to disable.
         signal_output: One of the two outputs on the device.
-        signal_intput: One of the two inputs on the device.
+        signal_input: One of the two inputs on the device.
         amplitude: Amplitude in volts, allowed values are 0.0 - 1.5 V.
         demodulator: Which demodulator used to connect to the signal output to.
     """
@@ -56,7 +56,7 @@ def set_stimulus_oscillator_frequency(frequency: float, oscillator: int = 1) ->
 
 
 def update_scope(period: Optional[float] = None, sample_rate: Optional[float] = 27e3,
-                 input_channels : Optional[Dict[int, str]] = {'Demod 1 R': 1},
+                 input_channels : Optional[Dict[str, int]] = None,
                  input_ranges: Optional[Tuple[float, float]] = (1.0, 1.0),
                  limits: Optional[Tuple[float, float]] = (0.0, 1.0),
                  trigger_enabled: Optional[bool] = False, trigger_level: Optional[float] = 0.5):
@@ -71,6 +71,12 @@ def update_scope(period: Optional[float] = None, sample_rate: Optional[float] =
         trigger_enabled: Will enable the external triggering on 'Trigger input 1' if True.
         trigger_level: The level of the trigger in Volt.
     """
+    if period is not None:
+        scope_reader.period = period
+
+    if input_channels is None:
+        input_channels = {'Demod 1 R': 1}
+
     nearest_sample_rate = scope_reader.get_nearest_sample_rate(sample_rate)
     scope_reader.sample_rate = nearest_sample_rate
 
@@ -80,8 +86,6 @@ def update_scope(period: Optional[float] = None, sample_rate: Optional[float] =
 
     [scope_reader.set_channel_limits(channel, *limits) for channel in unique_channels]
     [scope_reader.set_input_signal(channel, attribute) for (attribute, channel) in input_channels.items()]
-    if period:
-        scope_reader.period = period
 
     scope_reader.trigger_enabled = trigger_enabled
     scope_reader.trigger_channel = 'Trig Input 1'
@@ -90,7 +94,7 @@ def update_scope(period: Optional[float] = None, sample_rate: Optional[float] =
     scope_reader.trigger_delay = 0
 
 
-## Settings
+#  Settings
 
 class HardwareSettings(Instrument):
 
@@ -109,25 +113,25 @@ def __init__(self, name='settings'):
 
 working_directory = "D:\\Workspace\\TNO\\git\\DEM-943\\qtt\\docs\\notebooks\\unfinished"
 
-## Lock-in Amplifier
+#  Lock-in Amplifier
 
-UHFLI_id = 'dev2338'
-file_path_UHFLI = os.path.join(working_directory, f'UHFLI_{UHFLI_id}.dat')
-UHFLI_configuration = load_configuration(file_path_UHFLI)
+uhfli_id = 'dev2338'
+file_path_UHFLI = os.path.join(working_directory, f'UHFLI_{uhfli_id}.dat')
+uhfli_configuration = load_configuration(file_path_UHFLI)
 
-stimulus = UHFLIStimulus(UHFLI_id)
-stimulus.initialize(UHFLI_configuration)
-scope_reader = UHFLIScopeReader(UHFLI_id)
+stimulus = UHFLIStimulus(uhfli_id)
+stimulus.initialize(uhfli_configuration)
+scope_reader = UHFLIScopeReader(uhfli_id)
 
 
-## AWG
+#  AWG
 
-HDAWG8_id = 'dev8048'
-file_path_HDAWG8 = os.path.join(working_directory, f'HDAWG8_{HDAWG8_id}.dat')
-HDAWG8_configuration = load_configuration(file_path_HDAWG8)
+hdawg8_id = 'dev8048'
+file_path_HDAWG8 = os.path.join(working_directory, f'HDAWG8_{hdawg8_id}.dat')
+hdawg8_configuration = load_configuration(file_path_HDAWG8)
 
-awg_adapter = InstrumentAdapterFactory.get_instrument_adapter('ZIHDAWG8InstrumentAdapter', HDAWG8_id)
-awg_adapter.apply(HDAWG8_configuration)
+awg_adapter = InstrumentAdapterFactory.get_instrument_adapter('ZIHDAWG8InstrumentAdapter', hdawg8_id)
+awg_adapter.apply(hdawg8_configuration)
 
 awg_adapter.instrument.warnings_as_errors.append(WARNING_ANY)
 
@@ -144,7 +148,7 @@ def __init__(self, name='settings'):
 awg_adapter.instrument.awgs_0_time(awg_sampling_rate_586KHz)
 
 
-## Virtual AWG
+#  Virtual AWG
 
 settings = HardwareSettings()
 virtual_awg = VirtualAwg([awg_adapter.instrument], settings)
@@ -156,7 +160,7 @@ def __init__(self, name='settings'):
 virtual_awg.digitizer_marker_uptime(marker_uptime)
 
 
-## Station
+#  Station
 
 gates = VirtualIVVI('gates', gates=['P1', 'P2'], model=None)
 station = Station(virtual_awg, scope_reader.adapter.instrument, awg_adapter.instrument, gates)

docs/notebooks/unfinished/example_process_sawtooth_2d.py

@@ -32,10 +32,8 @@ def create_dummy_data_array(width: float, processing: str, sawteeth_count: int,
     scope_data = sawtooth(2 * np.pi * (sawteeth_count * time / period), width)
     offset = {'left': 1 - width, 'center': (1 - width /2), 'right': 0}
     scope_data = np.roll(scope_data, int(offset[processing] * len(scope_data)))
-
     return DataArray(identifier, label, preset_data=scope_data, set_arrays=[set_array])
 
-
 data_set = DataSet()
 data_set.user_data = {'resolution': resolution, 'width': width, 'processing': processing}
 
@@ -46,14 +44,14 @@ def create_dummy_data_array(width: float, processing: str, sawteeth_count: int,
 data_set.add_array(data_array_y)
 
 
-## EXAMPLE PRCCESSING 2D SAWTOOTH
+# EXAMPLE PRCCESSING 2D SAWTOOTH
 
 signal_processor = SignalProcessorRunner()
 signal_processor.add_signal_processor(ProcessSawtooth2D())
 processed_data_set = signal_processor.run(data_set)
 
 
-## PLOTTING
+# PLOTTING
 
 color_cycler = cycle('bgrcmk')
 

src/qtt/measurements/acquisition/interfaces/acquisition_interface.py

@@ -1,7 +1,7 @@
 """ Interface for devices to acquire data."""
 
 from abc import ABC, abstractmethod
-from typing import List
+from typing import List, Optional
 
 from qilib.data_set import DataArray
 from qilib.utils import PythonJsonStructure
@@ -36,7 +36,7 @@ def start_acquisition(self) -> None:
         """
 
     @abstractmethod
-    def acquire(self, number_of_averages: int, timeout: float) -> List[DataArray]:
+    def acquire(self, number_of_averages: int, timeout: Optional[float] = 30) -> List[DataArray]:
         """ Reads raw-data from the acquisition device.
 
             This method should be called after initialising and starting the acquisition.

src/qtt/measurements/acquisition/interfaces/acquisition_scope_interface.py

@@ -14,51 +14,141 @@ class AcquisitionScopeInterface(AcquisitionInterface, ABC):
     def input_range(self) -> Tuple[float, float]:
         """ The input range of the channels."""
 
+    @input_range.setter
+    @abstractmethod
+    def input_range(self, value: Tuple[float, float]) -> None:
+        """ Gets the amplitude input range of the channels.
+
+        Args:
+            value: The input range amplitude in Volts.
+        """
+
     @property
     @abstractmethod
     def sample_rate(self) -> float:
         """ The sample rate of the acquisition device."""
 
+    @sample_rate.setter
+    @abstractmethod
+    def sample_rate(self, value: float) -> None:
+        """ Sets the sample rate of the acquisition device.
+
+        Args:
+            value: The sample rate in samples per second.
+        """
+
     @property
     @abstractmethod
     def period(self) -> float:
         """ The measuring period of the acquisition."""
 
+    @period.setter
+    @abstractmethod
+    def period(self, value: float) -> None:
+        """ Sets the measuring period of the acquisition.
+
+        Args:
+            value: The measuring period in seconds.
+        """
+
     @property
     @abstractmethod
     def number_of_samples(self) -> int:
         """ The number of samples to take during a acquisition."""
 
+    @number_of_samples.setter
+    @abstractmethod
+    def number_of_samples(self, value: int) -> None:
+        """ Sets the sample count to take during a acquisition.
+
+        Args:
+            value: The number of samples.
+        """
+
     @property
     @abstractmethod
     def trigger_enabled(self) -> bool:
         """ The setter sets the external triggering on or off. The getter returns the current trigger value."""
 
+    @trigger_enabled.setter
+    @abstractmethod
+    def trigger_enabled(self, value: bool) -> None:
+        """ Turns the external triggering on or off.
+
+        Args:
+            value: The trigger on/off value.
+        """
+
     @property
     @abstractmethod
     def trigger_channel(self) -> str:
         """ The input signal to trigger the acquisition on."""
 
+    @trigger_channel.setter
+    @abstractmethod
+    def trigger_channel(self, channel: str) -> None:
+        """ Sets the external triggering channel.
+
+        Args:
+            channel: The trigger channel value.
+        """
+
     @property
     @abstractmethod
     def trigger_level(self) -> float:
         """ The trigger-level of the trigger in Volts."""
 
+    @trigger_level.setter
+    @abstractmethod
+    def trigger_level(self, level: float) -> None:
+        """ Sets the external triggering level.
+
+        Args:
+            level: The external trigger level in Volts.
+        """
+
     @property
     @abstractmethod
     def trigger_slope(self) -> str:
         """ The edge of the trigger signal to trigger on."""
 
+    @trigger_slope.setter
+    @abstractmethod
+    def trigger_slope(self, slope: str) -> None:
+        """ Sets the external triggering slope.
+
+        Args:
+            slope: The external trigger slope.
+        """
+
     @property
     @abstractmethod
     def trigger_delay(self) -> float:
         """ The delay between getting a trigger and acquiring in seconds."""
 
+    @trigger_delay.setter
+    @abstractmethod
+    def trigger_delay(self, delay: float) -> None:
+        """ Sets the delay in seconds between the external trigger and acquisition.
+
+        Args:
+            delay: The scope trigger delay in seconds.
+        """
+
     @property
     @abstractmethod
     def enabled_channels(self) -> Tuple[int, ...]:
         """ Reports the enabled input channels."""
 
+    @enabled_channels.setter
+    @abstractmethod
+    def enabled_channels(self, value: Tuple[int, ...]):
+        """ Sets the given channels to enabled and turns off all others.
+
+        Args:
+            value: The channels which needs to be enabled.
+        """
+
     @abstractmethod
     def set_input_signal(self, channel: int, attribute: Optional[str]) -> None:
         """ Adds an input channel to the scope.

src/qtt/measurements/acquisition/uhfli_scope_reader.py

@@ -136,7 +136,6 @@ def period(self, value: float) -> None:
         """
         self.__uhfli.scope_duration.set(value)
 
-
     @property
     def number_of_samples(self) -> int:
         """ Gets the sample count to take during a acquisition.
@@ -330,9 +329,9 @@ def __get_uhfli_scope_records(self, number_of_averages: int, timeout: float) ->
         traces = self.__uhfli.scope.read(True)
         wave_nodepath = f'/{self._address}/scopes/0/wave'
         scope_traces = traces[wave_nodepath][:number_of_averages]
-        return self.__convert_scope_data(scope_traces, number_of_averages)
+        return self.__convert_scope_data(scope_traces)
 
-    def __convert_scope_data(self, scope_traces: np.ndarray, number_of_averages: int) -> List[DataArray]:
+    def __convert_scope_data(self, scope_traces: np.ndarray) -> List[DataArray]:
         data = []
         acquisition_counter = 0
         for channel_index, _ in enumerate(self.enabled_channels):

src/qtt/measurements/scans.py

@@ -1687,18 +1687,20 @@ def measure_segment_uhfli(zi, waveform, channels, number_of_averages=100):
     return [avarage]
 
 
-def measure_segment_scope_reader(minstrhandle, waveform, Naverage, process=True):
+def measure_segment_scope_reader(scope_reader, waveform, number_of_averages, process=True):
     """ Measure block data with scope reader.
 
     Args:
-        minstrhandle (AcquisitionScopeInterface): Instance of scope reader.
+        scope_reader (AcquisitionScopeInterface): Instance of scope reader.
         waveform (dict): Information about the waveform that is to be collected.
         number_of_averages (int) : Number of times the sample is collected.
+        process (bool): If True, cut off the downward sawtooth slopes from the data.
+
     Returns:
         data (numpy array): An array of arrays, one array per input channel.
 
     """
-    data_arrays = minstrhandle.acquire(number_of_averages=Naverage)
+    data_arrays = scope_reader.acquire(number_of_averages)
     raw_data = np.array(data_arrays)
     if not process:
         return raw_data
@@ -1710,7 +1712,7 @@ def measure_segment_scope_reader(minstrhandle, waveform, Naverage, process=True)
 
     resolution = waveform.get('resolution', None)
     start_zero = waveform.get('start_zero', False)
-    sample_rate = minstrhandle.sample_rate
+    sample_rate = scope_reader.sample_rate
     period = waveform['period']
 
     if len(width) == 2:

src/qtt/measurements/videomode.py

@@ -477,8 +477,7 @@ def run(self, start_readout=True):
                 scan_channels = self.scanparams['minstrument'][1]
                 channel_attributes = self.scanparams['minstrument'][2]
                 self.minstrumenthandle.enabled_channels = tuple(scan_channels)
-                for item in zip(scan_channels, channel_attributes):
-                    self.minstrumenthandle.set_input_signal(item[0], item[1])
+                map(self.minstrumenthandle.set_input_signal, scan_channels, channel_attributes)
                 self.minstrumenthandle.start_acquisition()
             self.startreadout()
 

src/tests/measurements/test_scans.py

@@ -131,7 +131,7 @@ def test_measure_segment_scope_reader_2D(self):
                 result_data = measure_segment_scope_reader(mock_scope, waveform, average_count)
 
                 array_mock.assert_called_once_with(mock_data_arrays)
-                mock_scope.acquire.assert_called_once_with(number_of_averages=average_count)
+                mock_scope.acquire.assert_called_once_with(average_count)
                 process_mock.assert_called_with(raw_data_mock, period, sample_rate,
                                                 resolution, width, fig=None, start_zero=False)
                 self.assertEqual(data_mock, result_data)
@@ -156,7 +156,7 @@ def test_measure_segment_scope_reader_1D(self):
                 result_data = measure_segment_scope_reader(mock_scope, waveform, average_count)
 
                 array_mock.assert_called_once_with(mock_data_arrays)
-                mock_scope.acquire.assert_called_once_with(number_of_averages=average_count)
+                mock_scope.acquire.assert_called_once_with(average_count)
                 process_mock.assert_called_with(raw_data_mock, [width], period, sample_rate,
                                                 resolution=None, start_zero=False, fig=None)
                 self.assertEqual(data_mock, result_data)
@@ -169,5 +169,5 @@ def test_measure_segment_scope_reader_no_processing(self):
         numpy_array_mock = MagicMock()
         with patch('numpy.array', return_value=numpy_array_mock):
             result_data = measure_segment_scope_reader(mock_scope, None, average_count, process=False)
-            mock_scope.acquire.assert_called_once_with(number_of_averages=average_count)
+            mock_scope.acquire.assert_called_once_with(average_count)
             self.assertEqual(numpy_array_mock, result_data)