From c7e9355b1b024c186d65261e4b234f66ee1bb43f Mon Sep 17 00:00:00 2001 From: Simon Humpohl Date: Tue, 19 Feb 2019 13:22:15 +0100 Subject: [PATCH 01/25] Add first draft for a virtual AWG that can serve as simulation interface --- qupulse/hardware/awgs/virtual.py | 123 +++++++++++++++++++++++++++++++ qupulse/utils/tree.py | 3 + 2 files changed, 126 insertions(+) create mode 100644 qupulse/hardware/awgs/virtual.py diff --git a/qupulse/hardware/awgs/virtual.py b/qupulse/hardware/awgs/virtual.py new file mode 100644 index 000000000..c45cde7e8 --- /dev/null +++ b/qupulse/hardware/awgs/virtual.py @@ -0,0 +1,123 @@ +"""This module contains the tools to setup a virtual AWG i.e. an AWG that forwards the program into a given callback. +This is handy to setup a simulation to test qupulse pulses.""" +from typing import Union, Sequence, Tuple, Optional, Callable, Set + +import numpy as np + +from qupulse.utils.types import ChannelID, TimeType +from qupulse._program._loop import Loop, make_compatible +from qupulse.hardware.awgs.base import AWG + + +__all__ = ['VirtualAWG'] + + +def _feed_into_callable(program: Loop, callback, channels, dt): + """Maybe there is already a function somewhere for this?""" + binary_waveforms = {} + reverse_lookup = {} + time_array = np.arange(1024, dtype=float) * float(dt) + for p in program.get_depth_first_iterator(): + if p.waveform and p.waveform not in binary_waveforms: + # this waveform is not sampled yet + n_samples = p.waveform.duration / dt + + if time_array.size < n_samples: + # we need to extend the time array + time_array = np.arange(n_samples, dtype=float) * float(dt) + + sample_times = time_array[:n_samples] + sampled = np.nan((len(channels), n_samples)) + for idx, channel in enumerate(channels): + p.waveform.get_sampled(channel, sample_times, output_array=sampled[idx, :]) + + result_hash = hash(sampled.tobytes()) + if result_hash in reverse_lookup: + # save memory for binary equivalent waveforms + np.testing.assert_array_equal(sampled, reverse_lookup[result_hash]) + binary_waveforms[p.waveform] = reverse_lookup[result_hash] + else: + binary_waveforms[p.waveform] = sampled + reverse_lookup[result_hash] = sampled + + stack = [program] + while stack: + current = stack.pop() + if current.waveform: + sampled = binary_waveforms[current.waveform] + for _ in range(current.repetition_count): + callback(sampled) + + else: + for _ in range(current.repetition_count): + stack.extend(reversed(current)) + + +class VirtualAWG(AWG): + """This class allows registering callbacks the given program is fed into.""" + + def __init__(self, identifier: str, channels: int): + super().__init__(identifier) + + self._programs = {} + self._current_program = None + self._channels = tuple(range(channels)) + + self._fixed_sample_rate_callbacks = {} + + @property + def num_channels(self) -> int: + return len(self._channels) + + @property + def num_markers(self) -> int: + return 0 + + def upload(self, name: str, + program: Loop, + channels: Tuple[Optional[ChannelID], ...], + markers: Tuple[Optional[ChannelID], ...], + voltage_transformation: Tuple[Optional[Callable], ...], + force: bool=False): + if name in self._programs and not force: + raise RuntimeError('Program already known') + + self._programs[name] = (program, channels, voltage_transformation) + + def remove(self, name: str): + self._programs.pop(name) + + def clear(self): + self._programs.clear() + self._current_program = None + + def arm(self, name: Optional[str]): + self._current_program = name + + @property + def programs(self) -> Set[str]: + return set(self._programs.keys()) + + @property + def sample_rate(self) -> float: + return float('nan') + + def set_fixed_sample_rate_callback(self, name: str, callback: Callable[[np.ndarray], None], sample_rate): + if callback is None: + self._fixed_sample_rate_callbacks.pop(name, None) + else: + self._fixed_sample_rate_callbacks[name] = (callback, TimeType(sample_rate)) + + def run_current_program(self): + (program, channels, voltage_transformation) = self._programs[self._current_program] + + for callback, sample_rate in self._fixed_sample_rate_callbacks.values(): + dt = 1/sample_rate + c_program = program.copy() + + # assert all waveforms have a length that is a multiple of the time per sample + make_compatible(c_program, 0, dt, sample_rate) + + + + diff --git a/qupulse/utils/tree.py b/qupulse/utils/tree.py index 58be158f5..4e50191f1 100644 --- a/qupulse/utils/tree.py +++ b/qupulse/utils/tree.py @@ -79,6 +79,9 @@ def __getitem__(self: _NodeType, *args, **kwargs) ->Union[_NodeType, List[_NodeT def __len__(self) -> int: return len(self.__children) + def __reversed__(self): + return reversed(self.__children) + def get_depth_first_iterator(self: _NodeType) -> Generator[_NodeType, None, None]: stack = [(self, self.__children)] From ed5765e290a36d3303178f4aa8fc11a54fd54c21 Mon Sep 17 00:00:00 2001 From: Simon Humpohl Date: Wed, 20 Feb 2019 20:40:16 +0100 Subject: [PATCH 02/25] Add first trivial tests --- tests/hardware/virtual_tests.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 tests/hardware/virtual_tests.py diff --git a/tests/hardware/virtual_tests.py b/tests/hardware/virtual_tests.py new file mode 100644 index 000000000..e289c8b98 --- /dev/null +++ b/tests/hardware/virtual_tests.py @@ -0,0 +1,23 @@ +import unittest +import math + +from qupulse.hardware.awgs.virtual import VirtualAWG +from qupulse._program._loop import Loop + + +class VirtualAWGTests(unittest.TestCase): + def test_init(self): + vawg = VirtualAWG('asd', 5) + + self.assertEqual(vawg.identifier, 'asd') + self.assertEqual(vawg.num_channels, 5) + + def test_no_markers(self): + vawg = VirtualAWG('asd', 5) + + self.assertEqual(vawg.num_markers, 0) + + def test_sample_rate(self): + vawg = VirtualAWG('asd', 5) + + self.assertTrue(math.isnan(vawg.sample_rate)) From 6d1003c20fa289e0e85b56abf7cde5f915f16e8e Mon Sep 17 00:00:00 2001 From: Simon Humpohl Date: Wed, 20 Feb 2019 20:41:53 +0100 Subject: [PATCH 03/25] Use voltage transformations instead of silently ignoring them --- qupulse/hardware/awgs/virtual.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/qupulse/hardware/awgs/virtual.py b/qupulse/hardware/awgs/virtual.py index c45cde7e8..d6dac8ab0 100644 --- a/qupulse/hardware/awgs/virtual.py +++ b/qupulse/hardware/awgs/virtual.py @@ -12,7 +12,7 @@ __all__ = ['VirtualAWG'] -def _feed_into_callable(program: Loop, callback, channels, dt): +def _feed_into_callable_fixed_sample_rate(program: Loop, callback, channels, dt, voltage_transformations): """Maybe there is already a function somewhere for this?""" binary_waveforms = {} reverse_lookup = {} @@ -28,8 +28,9 @@ def _feed_into_callable(program: Loop, callback, channels, dt): sample_times = time_array[:n_samples] sampled = np.nan((len(channels), n_samples)) - for idx, channel in enumerate(channels): + for idx, (channel, voltage_transformation) in enumerate(zip(channels, voltage_transformations)): p.waveform.get_sampled(channel, sample_times, output_array=sampled[idx, :]) + sampled[idx, :] = voltage_transformation(sampled[idx, :]) result_hash = hash(sampled.tobytes()) if result_hash in reverse_lookup: @@ -54,7 +55,10 @@ def _feed_into_callable(program: Loop, callback, channels, dt): class VirtualAWG(AWG): - """This class allows registering callbacks the given program is fed into.""" + """This class allows registering callbacks the given program is fed into. + + TODO: + - adaptive sample rate (requires program analysis)""" def __init__(self, identifier: str, channels: int): super().__init__(identifier) @@ -109,7 +113,7 @@ def set_fixed_sample_rate_callback(self, name: str, callback: Callable[[np.ndarr self._fixed_sample_rate_callbacks[name] = (callback, TimeType(sample_rate)) def run_current_program(self): - (program, channels, voltage_transformation) = self._programs[self._current_program] + (program, channels, voltage_transformations) = self._programs[self._current_program] for callback, sample_rate in self._fixed_sample_rate_callbacks.values(): dt = 1/sample_rate @@ -118,6 +122,6 @@ def run_current_program(self): # assert all waveforms have a length that is a multiple of the time per sample make_compatible(c_program, 0, dt, sample_rate) - - + _feed_into_callable_fixed_sample_rate(c_program, callback=callback, channels=channels, dt=dt, + voltage_transformations=voltage_transformations) From 60fd4e657e8cb3e64b2c118a0597e39293fc427a Mon Sep 17 00:00:00 2001 From: Simon Humpohl Date: Thu, 7 Mar 2019 19:42:15 +0100 Subject: [PATCH 04/25] Add an interface that can be used with qutip simulations --- qupulse/_program/_loop.py | 2 +- qupulse/hardware/awgs/virtual.py | 41 ++++++++++++++++++++++++++++---- 2 files changed, 38 insertions(+), 5 deletions(-) diff --git a/qupulse/_program/_loop.py b/qupulse/_program/_loop.py index e0a4e6c98..9b4aecdca 100644 --- a/qupulse/_program/_loop.py +++ b/qupulse/_program/_loop.py @@ -16,7 +16,7 @@ from qupulse._program.waveforms import SequenceWaveform, RepetitionWaveform -__all__ = ['Loop', 'MultiChannelProgram', 'make_compatible'] +__all__ = ['Loop', 'MultiChannelProgram', 'make_compatible', 'to_waveform'] class Loop(Node): diff --git a/qupulse/hardware/awgs/virtual.py b/qupulse/hardware/awgs/virtual.py index d6dac8ab0..e85c34e4c 100644 --- a/qupulse/hardware/awgs/virtual.py +++ b/qupulse/hardware/awgs/virtual.py @@ -1,17 +1,21 @@ """This module contains the tools to setup a virtual AWG i.e. an AWG that forwards the program into a given callback. This is handy to setup a simulation to test qupulse pulses.""" -from typing import Union, Sequence, Tuple, Optional, Callable, Set +from typing import Tuple, Optional, Callable, Set import numpy as np from qupulse.utils.types import ChannelID, TimeType -from qupulse._program._loop import Loop, make_compatible +from qupulse._program._loop import Loop, make_compatible, to_waveform from qupulse.hardware.awgs.base import AWG __all__ = ['VirtualAWG'] +SamplingCallback = Callable[[np.ndarray], np.ndarray] +SamplingCallback.__doc__ = """Maps an array ov times to an array of voltages. The time array has to be ordered""" + + def _feed_into_callable_fixed_sample_rate(program: Loop, callback, channels, dt, voltage_transformations): """Maybe there is already a function somewhere for this?""" binary_waveforms = {} @@ -54,6 +58,25 @@ def _feed_into_callable_fixed_sample_rate(program: Loop, callback, channels, dt, stack.extend(reversed(current)) +def _create_sampling_callbacks(program: Loop, channels, voltage_transformations): + waveform = to_waveform(program) + + duration = float(waveform.duration) + + def get_callback(channel: Optional[ChannelID], voltage_transformation): + if channel is None: + return None + else: + def sample_channel(time: np.ndarray): + return voltage_transformation(waveform.get_sampled(channel, time)) + + return sample_channel + + callbacks = [get_callback(channel, voltage_transformation) + for channel, voltage_transformation in zip(channels, voltage_transformations)] + return (duration, *callbacks) + + class VirtualAWG(AWG): """This class allows registering callbacks the given program is fed into. @@ -68,6 +91,7 @@ def __init__(self, identifier: str, channels: int): self._channels = tuple(range(channels)) self._fixed_sample_rate_callbacks = {} + self._function_handle_callback = None @property def num_channels(self) -> int: @@ -106,11 +130,17 @@ def programs(self) -> Set[str]: def sample_rate(self) -> float: return float('nan') - def set_fixed_sample_rate_callback(self, name: str, callback: Callable[[np.ndarray], None], sample_rate): + def set_fixed_sample_rate_callback(self, name: str, callback: Callable[[np.ndarray], None], sample_rate: TimeType): if callback is None: self._fixed_sample_rate_callbacks.pop(name, None) else: - self._fixed_sample_rate_callbacks[name] = (callback, TimeType(sample_rate)) + self._fixed_sample_rate_callbacks[name] = (callback, sample_rate) + + def set_function_handle_callback(self, + callback: Optional[Callable[[float, SamplingCallback, ...], None]]): + """When run current program is called the given callback is called with the first positional argument being the + duration and following arguments being sampling callbacks as defined above.""" + self._function_handle_callback = callback def run_current_program(self): (program, channels, voltage_transformations) = self._programs[self._current_program] @@ -125,3 +155,6 @@ def run_current_program(self): _feed_into_callable_fixed_sample_rate(c_program, callback=callback, channels=channels, dt=dt, voltage_transformations=voltage_transformations) + if self._function_handle_callback is not None: + duration, *sample_callbacks = _create_sampling_callbacks(program, channels, voltage_transformations) + self._function_handle_callback(duration, *sample_callbacks) From 68d37196fe4fdac0bce2bbf639110f708195c872 Mon Sep 17 00:00:00 2001 From: Simon Humpohl Date: Fri, 8 Mar 2019 12:55:50 +0100 Subject: [PATCH 05/25] Remove fixed sample rate callbacks for now --- qupulse/hardware/awgs/virtual.py | 59 -------------------------------- 1 file changed, 59 deletions(-) diff --git a/qupulse/hardware/awgs/virtual.py b/qupulse/hardware/awgs/virtual.py index e85c34e4c..009e40d6f 100644 --- a/qupulse/hardware/awgs/virtual.py +++ b/qupulse/hardware/awgs/virtual.py @@ -16,48 +16,6 @@ SamplingCallback.__doc__ = """Maps an array ov times to an array of voltages. The time array has to be ordered""" -def _feed_into_callable_fixed_sample_rate(program: Loop, callback, channels, dt, voltage_transformations): - """Maybe there is already a function somewhere for this?""" - binary_waveforms = {} - reverse_lookup = {} - time_array = np.arange(1024, dtype=float) * float(dt) - for p in program.get_depth_first_iterator(): - if p.waveform and p.waveform not in binary_waveforms: - # this waveform is not sampled yet - n_samples = p.waveform.duration / dt - - if time_array.size < n_samples: - # we need to extend the time array - time_array = np.arange(n_samples, dtype=float) * float(dt) - - sample_times = time_array[:n_samples] - sampled = np.nan((len(channels), n_samples)) - for idx, (channel, voltage_transformation) in enumerate(zip(channels, voltage_transformations)): - p.waveform.get_sampled(channel, sample_times, output_array=sampled[idx, :]) - sampled[idx, :] = voltage_transformation(sampled[idx, :]) - - result_hash = hash(sampled.tobytes()) - if result_hash in reverse_lookup: - # save memory for binary equivalent waveforms - np.testing.assert_array_equal(sampled, reverse_lookup[result_hash]) - binary_waveforms[p.waveform] = reverse_lookup[result_hash] - else: - binary_waveforms[p.waveform] = sampled - reverse_lookup[result_hash] = sampled - - stack = [program] - while stack: - current = stack.pop() - if current.waveform: - sampled = binary_waveforms[current.waveform] - for _ in range(current.repetition_count): - callback(sampled) - - else: - for _ in range(current.repetition_count): - stack.extend(reversed(current)) - - def _create_sampling_callbacks(program: Loop, channels, voltage_transformations): waveform = to_waveform(program) @@ -90,7 +48,6 @@ def __init__(self, identifier: str, channels: int): self._current_program = None self._channels = tuple(range(channels)) - self._fixed_sample_rate_callbacks = {} self._function_handle_callback = None @property @@ -130,12 +87,6 @@ def programs(self) -> Set[str]: def sample_rate(self) -> float: return float('nan') - def set_fixed_sample_rate_callback(self, name: str, callback: Callable[[np.ndarray], None], sample_rate: TimeType): - if callback is None: - self._fixed_sample_rate_callbacks.pop(name, None) - else: - self._fixed_sample_rate_callbacks[name] = (callback, sample_rate) - def set_function_handle_callback(self, callback: Optional[Callable[[float, SamplingCallback, ...], None]]): """When run current program is called the given callback is called with the first positional argument being the @@ -145,16 +96,6 @@ def set_function_handle_callback(self, def run_current_program(self): (program, channels, voltage_transformations) = self._programs[self._current_program] - for callback, sample_rate in self._fixed_sample_rate_callbacks.values(): - dt = 1/sample_rate - c_program = program.copy() - - # assert all waveforms have a length that is a multiple of the time per sample - make_compatible(c_program, 0, dt, sample_rate) - - _feed_into_callable_fixed_sample_rate(c_program, callback=callback, channels=channels, dt=dt, - voltage_transformations=voltage_transformations) - if self._function_handle_callback is not None: duration, *sample_callbacks = _create_sampling_callbacks(program, channels, voltage_transformations) self._function_handle_callback(duration, *sample_callbacks) From fc8a26024ed91344af789422e66779968796c496 Mon Sep 17 00:00:00 2001 From: Simon Humpohl Date: Fri, 8 Mar 2019 12:57:19 +0100 Subject: [PATCH 06/25] Add more tests --- qupulse/hardware/awgs/virtual.py | 11 ++++---- tests/hardware/virtual_tests.py | 45 ++++++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+), 5 deletions(-) diff --git a/qupulse/hardware/awgs/virtual.py b/qupulse/hardware/awgs/virtual.py index 009e40d6f..a96da4a39 100644 --- a/qupulse/hardware/awgs/virtual.py +++ b/qupulse/hardware/awgs/virtual.py @@ -16,7 +16,8 @@ SamplingCallback.__doc__ = """Maps an array ov times to an array of voltages. The time array has to be ordered""" -def _create_sampling_callbacks(program: Loop, channels, voltage_transformations): +def _create_sampling_callbacks(program: Loop, channels, voltage_transformations) -> Tuple[float, + Tuple[SamplingCallback, ...]]: waveform = to_waveform(program) duration = float(waveform.duration) @@ -32,7 +33,7 @@ def sample_channel(time: np.ndarray): callbacks = [get_callback(channel, voltage_transformation) for channel, voltage_transformation in zip(channels, voltage_transformations)] - return (duration, *callbacks) + return duration, tuple(callbacks) class VirtualAWG(AWG): @@ -88,7 +89,7 @@ def sample_rate(self) -> float: return float('nan') def set_function_handle_callback(self, - callback: Optional[Callable[[float, SamplingCallback, ...], None]]): + callback: Optional[Callable[[float, Tuple[SamplingCallback, ...]], None]]): """When run current program is called the given callback is called with the first positional argument being the duration and following arguments being sampling callbacks as defined above.""" self._function_handle_callback = callback @@ -97,5 +98,5 @@ def run_current_program(self): (program, channels, voltage_transformations) = self._programs[self._current_program] if self._function_handle_callback is not None: - duration, *sample_callbacks = _create_sampling_callbacks(program, channels, voltage_transformations) - self._function_handle_callback(duration, *sample_callbacks) + duration, sample_callbacks = _create_sampling_callbacks(program, channels, voltage_transformations) + self._function_handle_callback(duration, sample_callbacks) diff --git a/tests/hardware/virtual_tests.py b/tests/hardware/virtual_tests.py index e289c8b98..5115229ba 100644 --- a/tests/hardware/virtual_tests.py +++ b/tests/hardware/virtual_tests.py @@ -1,11 +1,17 @@ import unittest +from unittest import mock import math +import numpy as np + from qupulse.hardware.awgs.virtual import VirtualAWG from qupulse._program._loop import Loop +from tests.pulses.sequencing_dummies import DummyWaveform + class VirtualAWGTests(unittest.TestCase): + def test_init(self): vawg = VirtualAWG('asd', 5) @@ -21,3 +27,42 @@ def test_sample_rate(self): vawg = VirtualAWG('asd', 5) self.assertTrue(math.isnan(vawg.sample_rate)) + + def test_arm(self): + name = 'prognam' + vawg = VirtualAWG('asd', 5) + + vawg.arm(name) + + self.assertEqual(vawg._current_program, name) + + def test_function_handle_callback(self): + callback = mock.MagicMock() + + vawg = VirtualAWG('asd', 3) + + vts = (lambda x: x, lambda x: 2*x, None) + + dummy_program = Loop() + dummy_waveform = DummyWaveform(sample_output={'X': np.sin(np.arange(10)), + 'Y': np.cos(np.arange(10))}, duration=42, + defined_channels={'X', 'Y'}) + vawg.upload('test', dummy_program, ('X', 'Y', None), (), vts) + vawg.arm('test') + vawg.set_function_handle_callback(callback) + with mock.patch('qupulse.hardware.awgs.virtual.to_waveform', autospec=True, return_value=dummy_waveform) as dummy_to_waveform: + vawg.run_current_program() + + dummy_to_waveform.assert_called_once_with(dummy_program) + + callback.assert_called_once() + (duration, sample_callbacks), kwargs = callback.call_args + self.assertEqual(kwargs, {}) + + self.assertEqual(duration, dummy_waveform.duration) + x, y, n = sample_callbacks + self.assertIsNone(n) + + t = np.arange(10)*1. + np.testing.assert_equal(x(t), dummy_waveform.sample_output['X']) + np.testing.assert_equal(y(t), 2*dummy_waveform.sample_output['Y']) From d1994894bb641f7e3e612ba61e6134483dde163b Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Tue, 20 Sep 2022 16:41:22 +0200 Subject: [PATCH 07/25] working on mfli driver --- ...struments_lockin_mfli_daq-checkpoint.ipynb | 566 ++++++++++++++++++ .../zurich_instruments_lockin_mfli_daq.ipynb | 566 ++++++++++++++++++ qupulse/hardware/dacs/mfli.py | 286 +++++++++ 3 files changed, 1418 insertions(+) create mode 100644 qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb create mode 100644 qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb create mode 100644 qupulse/hardware/dacs/mfli.py diff --git a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb new file mode 100644 index 000000000..3b43fd72f --- /dev/null +++ b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb @@ -0,0 +1,566 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "14133f44", + "metadata": {}, + "source": [ + "# Zurich Instruments Lock-In MFLI Data Aquesition" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0a0fdc55", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5a98e00c", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "03a8c5ae", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "575d35da", + "metadata": {}, + "outputs": [], + "source": [ + "from zhinst import ziPython as zhinst_core" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "84863030", + "metadata": {}, + "outputs": [], + "source": [ + "import qupulse" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5e020984", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "z:\\git\\qupulse\\qupulse\\hardware\\awgs\\tektronix.py:13: UserWarning: Could not import Tektronix driver backend. If you wish to use it execute qupulse.hardware.awgs.install_requirements('tektronix')\n", + " warnings.warn(\"Could not import Tektronix driver backend. \"\n" + ] + } + ], + "source": [ + "from qupulse.hardware.dacs.mfli import MFLIDAQ" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "33a97342", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin = MFLIDAQ(device_serial=\"dev3442\", device_interface=\"PCIe\", data_server_addr=\"192.168.53.202\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6681f625", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.register_measurement_channel(program_name=\"test\", channel_path=[\"demods/0/sample.R\", \"auxins/0/sample.AuxIn0.avg\", \"demods/0/sample.X\", \"demods/0/sample.Y\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "bc1e47cb", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"a\": (np.array([0, 3])*1, np.array([1, 10])*1),\"b\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "160c071b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'test': {'channels': ['demods/0/sample.R',\n", + " 'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.X',\n", + " 'demods/0/sample.Y'],\n", + " 'windows': {'a': (array([0, 3]), array([ 1, 10])),\n", + " 'b': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))},\n", + " 'masks': {'a': array([[[ 0., nan, 0., 0.],\n", + " [ 5022., nan, 5022., 5022.]],\n", + " \n", + " [[ 1674., nan, 1674., 1674.],\n", + " [16741., nan, 16741., 16741.]],\n", + " \n", + " [[ 1674., nan, 1674., 1674.],\n", + " [21763., nan, 21763., 21763.]]]),\n", + " 'b': array([[[ 0., nan, 0., 0.],\n", + " [ 3., nan, 3., 3.],\n", + " [ 7., nan, 7., 7.]],\n", + " \n", + " [[ 1., nan, 1., 1.],\n", + " [ 6., nan, 6., 6.],\n", + " [10., nan, 10., 10.]],\n", + " \n", + " [[ 1., nan, 1., 1.],\n", + " [ 9., nan, 9., 9.],\n", + " [17., nan, 17., 17.]]])}}}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.programs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83995f77", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e6e33177", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "333ce31c", + "metadata": {}, + "source": [ + "## Defining a simple qupulse pulse with a measurement window." + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "906d5c5a", + "metadata": {}, + "outputs": [], + "source": [ + "from qupulse.pulses.plotting import plot" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "4b0cc17e", + "metadata": {}, + "outputs": [], + "source": [ + "red_pulse = qupulse.pulses.TablePT({\"red\": [\n", + " (0, 0),\n", + " (1, 4, 'hold'),\n", + " (4, .5, 'linear'),\n", + " (5, 2, 'hold'),\n", + " (6, .5, 'hold'),\n", + " (15, .5, 'jump'),\n", + "]})" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "ab4a8768", + "metadata": {}, + "outputs": [], + "source": [ + "green_pulse = qupulse.pulses.SequencePT(*[\n", + " qupulse.pulses.FunctionPT(\".1\", \"6\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\".1+t**2*.9\", \"1\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"1\", \"1\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"1+sin(t*2*pi)*exp(-(t-2)**2)\", \"5\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"1\", \"1\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"0\", \"1\", channel=\"green\"),\n", + "]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "id": "4268b9d4", + "metadata": {}, + "outputs": [], + "source": [ + "measured_pt = qupulse.pulses.PointPT([(0, 0), (0, 1), (15, 1), (15, 0)],\n", + " channel_names=(\"trigger_out\",),\n", + " measurements=[('A', 3, 1.5), ('A', 12, 3), ('R', 6.5, 1.4), ('R', 14, 1), ('T', 10, 3)])" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "id": "f082459a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "z:\\git\\qupulse\\qupulse\\pulses\\arithmetic_pulse_template.py:72: ImplicitAtomicityInArithmeticPT: ArithmeticAtomicPulseTemplate treats all operands as if they are atomic. You can silence this warning by passing `silent_atomic=True` or by ignoring this category.\n", + " category=ImplicitAtomicityInArithmeticPT)\n" + ] + } + ], + "source": [ + "combined_pulse = red_pulse+green_pulse+measured_pt" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "e0600a11", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'T', 'R', 'A'}\n", + "[]\n", + "set()\n" + ] + } + ], + "source": [ + "print(combined_pulse.measurement_names)\n", + "print(combined_pulse.measurement_declarations)\n", + "print(combined_pulse.measurement_parameters)" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "id": "bb0530ec", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "combined_pulse.get_measurement_windows" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "id": "3c713b54", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot(combined_pulse, sample_rate=300, plot_measurements=combined_pulse.measurement_names) # combined_pulse.measurement_names\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "id": "454dab56", + "metadata": {}, + "outputs": [], + "source": [ + "idle_pulse = qupulse.pulses.TablePT({\"red\": [\n", + " (0, 0),\n", + " (5, 0),\n", + "],\n", + " \"green\": [\n", + " (0, 0),\n", + " (5, 0),\n", + "],\n", + " \"trigger_out\": [\n", + " (0, 0),\n", + " (5, 0),\n", + "]})" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "id": "8332701f", + "metadata": {}, + "outputs": [], + "source": [ + "rep = qupulse.pulses.repetition_pulse_template.RepetitionPulseTemplate(\n", + " body=qupulse.pulses.SequencePT(combined_pulse, idle_pulse),\n", + " repetition_count=10\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "id": "1c891151", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot(rep, sample_rate=300, plot_measurements=combined_pulse.measurement_names)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "69244a9c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "ada25926", + "metadata": {}, + "source": [ + "## Execution\n", + "\n", + "1. map output channels to dummy instrument\n", + "2. arm scan and see if everything works" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "id": "4ef8f47f", + "metadata": {}, + "outputs": [], + "source": [ + "from qupulse.hardware.setup import HardwareSetup, MeasurementMask" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "id": "4d6b9acc", + "metadata": {}, + "outputs": [], + "source": [ + "setup = HardwareSetup()" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "id": "a4731c70", + "metadata": {}, + "outputs": [], + "source": [ + "for n in [\"R\", \"T\", \"A\"]:\n", + " setup.set_measurement(f\"{n}_lockin\", MeasurementMask(my_lockin, n))" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "id": "c885518e", + "metadata": {}, + "outputs": [], + "source": [ + "# for c in [\"red\", \"green\", \"trigger_out\"]:\n", + "# setup.set_channel(f\"{n}\", None)" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "id": "a8ae5cdf", + "metadata": {}, + "outputs": [], + "source": [ + "test_program = combined_pulse.create_program(parameters={})" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "id": "6a404a7a", + "metadata": {}, + "outputs": [ + { + "ename": "KeyError", + "evalue": "\"The following channels are unknown to the HardwareSetup: {'green', 'trigger_out', 'red'}\"", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_14832\\3018318824.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msetup\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mregister_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'puls_test'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtest_program\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrun_callback\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mlambda\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mupdate\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\setup.py\u001b[0m in \u001b[0;36mregister_program\u001b[1;34m(self, name, program, run_callback, update)\u001b[0m\n\u001b[0;32m 100\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mchannels\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_channel_map\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 101\u001b[0m raise KeyError('The following channels are unknown to the HardwareSetup: {}'.format(\n\u001b[1;32m--> 102\u001b[1;33m channels - set(self._channel_map.keys())))\n\u001b[0m\u001b[0;32m 103\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 104\u001b[0m \u001b[0mtemp_measurement_windows\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdefaultdict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mKeyError\u001b[0m: \"The following channels are unknown to the HardwareSetup: {'green', 'trigger_out', 'red'}\"" + ] + } + ], + "source": [ + "setup.register_program('puls_test', test_program, run_callback=lambda *a, **b: None, update=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "id": "6b0dfe3c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 152, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "setup.run_program()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "986388ed", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a06c534e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8c9523b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "baddb8d5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e551db46", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "86907e32", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb new file mode 100644 index 000000000..3b43fd72f --- /dev/null +++ b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb @@ -0,0 +1,566 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "14133f44", + "metadata": {}, + "source": [ + "# Zurich Instruments Lock-In MFLI Data Aquesition" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0a0fdc55", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5a98e00c", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "03a8c5ae", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "575d35da", + "metadata": {}, + "outputs": [], + "source": [ + "from zhinst import ziPython as zhinst_core" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "84863030", + "metadata": {}, + "outputs": [], + "source": [ + "import qupulse" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5e020984", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "z:\\git\\qupulse\\qupulse\\hardware\\awgs\\tektronix.py:13: UserWarning: Could not import Tektronix driver backend. If you wish to use it execute qupulse.hardware.awgs.install_requirements('tektronix')\n", + " warnings.warn(\"Could not import Tektronix driver backend. \"\n" + ] + } + ], + "source": [ + "from qupulse.hardware.dacs.mfli import MFLIDAQ" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "33a97342", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin = MFLIDAQ(device_serial=\"dev3442\", device_interface=\"PCIe\", data_server_addr=\"192.168.53.202\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6681f625", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.register_measurement_channel(program_name=\"test\", channel_path=[\"demods/0/sample.R\", \"auxins/0/sample.AuxIn0.avg\", \"demods/0/sample.X\", \"demods/0/sample.Y\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "bc1e47cb", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"a\": (np.array([0, 3])*1, np.array([1, 10])*1),\"b\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "160c071b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'test': {'channels': ['demods/0/sample.R',\n", + " 'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.X',\n", + " 'demods/0/sample.Y'],\n", + " 'windows': {'a': (array([0, 3]), array([ 1, 10])),\n", + " 'b': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))},\n", + " 'masks': {'a': array([[[ 0., nan, 0., 0.],\n", + " [ 5022., nan, 5022., 5022.]],\n", + " \n", + " [[ 1674., nan, 1674., 1674.],\n", + " [16741., nan, 16741., 16741.]],\n", + " \n", + " [[ 1674., nan, 1674., 1674.],\n", + " [21763., nan, 21763., 21763.]]]),\n", + " 'b': array([[[ 0., nan, 0., 0.],\n", + " [ 3., nan, 3., 3.],\n", + " [ 7., nan, 7., 7.]],\n", + " \n", + " [[ 1., nan, 1., 1.],\n", + " [ 6., nan, 6., 6.],\n", + " [10., nan, 10., 10.]],\n", + " \n", + " [[ 1., nan, 1., 1.],\n", + " [ 9., nan, 9., 9.],\n", + " [17., nan, 17., 17.]]])}}}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.programs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83995f77", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e6e33177", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "333ce31c", + "metadata": {}, + "source": [ + "## Defining a simple qupulse pulse with a measurement window." + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "906d5c5a", + "metadata": {}, + "outputs": [], + "source": [ + "from qupulse.pulses.plotting import plot" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "4b0cc17e", + "metadata": {}, + "outputs": [], + "source": [ + "red_pulse = qupulse.pulses.TablePT({\"red\": [\n", + " (0, 0),\n", + " (1, 4, 'hold'),\n", + " (4, .5, 'linear'),\n", + " (5, 2, 'hold'),\n", + " (6, .5, 'hold'),\n", + " (15, .5, 'jump'),\n", + "]})" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "ab4a8768", + "metadata": {}, + "outputs": [], + "source": [ + "green_pulse = qupulse.pulses.SequencePT(*[\n", + " qupulse.pulses.FunctionPT(\".1\", \"6\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\".1+t**2*.9\", \"1\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"1\", \"1\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"1+sin(t*2*pi)*exp(-(t-2)**2)\", \"5\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"1\", \"1\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"0\", \"1\", channel=\"green\"),\n", + "]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "id": "4268b9d4", + "metadata": {}, + "outputs": [], + "source": [ + "measured_pt = qupulse.pulses.PointPT([(0, 0), (0, 1), (15, 1), (15, 0)],\n", + " channel_names=(\"trigger_out\",),\n", + " measurements=[('A', 3, 1.5), ('A', 12, 3), ('R', 6.5, 1.4), ('R', 14, 1), ('T', 10, 3)])" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "id": "f082459a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "z:\\git\\qupulse\\qupulse\\pulses\\arithmetic_pulse_template.py:72: ImplicitAtomicityInArithmeticPT: ArithmeticAtomicPulseTemplate treats all operands as if they are atomic. You can silence this warning by passing `silent_atomic=True` or by ignoring this category.\n", + " category=ImplicitAtomicityInArithmeticPT)\n" + ] + } + ], + "source": [ + "combined_pulse = red_pulse+green_pulse+measured_pt" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "e0600a11", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'T', 'R', 'A'}\n", + "[]\n", + "set()\n" + ] + } + ], + "source": [ + "print(combined_pulse.measurement_names)\n", + "print(combined_pulse.measurement_declarations)\n", + "print(combined_pulse.measurement_parameters)" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "id": "bb0530ec", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 140, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "combined_pulse.get_measurement_windows" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "id": "3c713b54", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot(combined_pulse, sample_rate=300, plot_measurements=combined_pulse.measurement_names) # combined_pulse.measurement_names\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "id": "454dab56", + "metadata": {}, + "outputs": [], + "source": [ + "idle_pulse = qupulse.pulses.TablePT({\"red\": [\n", + " (0, 0),\n", + " (5, 0),\n", + "],\n", + " \"green\": [\n", + " (0, 0),\n", + " (5, 0),\n", + "],\n", + " \"trigger_out\": [\n", + " (0, 0),\n", + " (5, 0),\n", + "]})" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "id": "8332701f", + "metadata": {}, + "outputs": [], + "source": [ + "rep = qupulse.pulses.repetition_pulse_template.RepetitionPulseTemplate(\n", + " body=qupulse.pulses.SequencePT(combined_pulse, idle_pulse),\n", + " repetition_count=10\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "id": "1c891151", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot(rep, sample_rate=300, plot_measurements=combined_pulse.measurement_names)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "69244a9c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "ada25926", + "metadata": {}, + "source": [ + "## Execution\n", + "\n", + "1. map output channels to dummy instrument\n", + "2. arm scan and see if everything works" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "id": "4ef8f47f", + "metadata": {}, + "outputs": [], + "source": [ + "from qupulse.hardware.setup import HardwareSetup, MeasurementMask" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "id": "4d6b9acc", + "metadata": {}, + "outputs": [], + "source": [ + "setup = HardwareSetup()" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "id": "a4731c70", + "metadata": {}, + "outputs": [], + "source": [ + "for n in [\"R\", \"T\", \"A\"]:\n", + " setup.set_measurement(f\"{n}_lockin\", MeasurementMask(my_lockin, n))" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "id": "c885518e", + "metadata": {}, + "outputs": [], + "source": [ + "# for c in [\"red\", \"green\", \"trigger_out\"]:\n", + "# setup.set_channel(f\"{n}\", None)" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "id": "a8ae5cdf", + "metadata": {}, + "outputs": [], + "source": [ + "test_program = combined_pulse.create_program(parameters={})" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "id": "6a404a7a", + "metadata": {}, + "outputs": [ + { + "ename": "KeyError", + "evalue": "\"The following channels are unknown to the HardwareSetup: {'green', 'trigger_out', 'red'}\"", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_14832\\3018318824.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msetup\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mregister_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'puls_test'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtest_program\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrun_callback\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mlambda\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mupdate\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\setup.py\u001b[0m in \u001b[0;36mregister_program\u001b[1;34m(self, name, program, run_callback, update)\u001b[0m\n\u001b[0;32m 100\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mchannels\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_channel_map\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 101\u001b[0m raise KeyError('The following channels are unknown to the HardwareSetup: {}'.format(\n\u001b[1;32m--> 102\u001b[1;33m channels - set(self._channel_map.keys())))\n\u001b[0m\u001b[0;32m 103\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 104\u001b[0m \u001b[0mtemp_measurement_windows\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdefaultdict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mKeyError\u001b[0m: \"The following channels are unknown to the HardwareSetup: {'green', 'trigger_out', 'red'}\"" + ] + } + ], + "source": [ + "setup.register_program('puls_test', test_program, run_callback=lambda *a, **b: None, update=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "id": "6b0dfe3c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 152, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "setup.run_program()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "986388ed", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a06c534e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8c9523b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "baddb8d5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e551db46", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "86907e32", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py new file mode 100644 index 000000000..ab45ddd95 --- /dev/null +++ b/qupulse/hardware/dacs/mfli.py @@ -0,0 +1,286 @@ +""" This file contains a qupulse driver for the DAQ module of an Zuerich Instruments MFLI. + +May lines of code have been adapted from the zihdawg driver. + +""" +from typing import Dict, Tuple, Iterable +from enum import Enum +import warnings + +from qupulse.utils.types import TimeType +from qupulse.hardware.dacs.dac_base import DAC + +try: + # zhinst fires a DeprecationWarning from its own code in some versions... + with warnings.catch_warnings(): + warnings.simplefilter('ignore', DeprecationWarning) + import zhinst.utils +except ImportError: + warnings.warn('Zurich Instruments LabOne python API is distributed via the Python Package Index. Install with pip.') + raise + +try: + from zhinst import core as zhinst_core +except ImportError: + # backward compability + from zhinst import ziPython as zhinst_core + +# from zhinst.toolkit import Session +import numpy as np + + +""" + + TODO +======== +[X] make TriggerMode class an Enum +[ ] setup minimal connection without changing settings other than buffer lengths +[ ] extract window things +[ ] implement multiple triggers (using rows) (and check how this actually behaves) + [ ] count + [ ] endless + [ ] change in trigger input port +[ ] make sample rate clean +[ ] implement setting recording channel (could that be already something inside qupulse?) +=> this should be sufficient for operation +[ ] have an interface for setting trigger configurations +[ ] an interface for setting the sample rate based on more convenient parameters +=> this should cover the common use cases +[ ] implement scope interface for higher sample rates (if i understood the documentation correctly) +[ ] implement low level interface (subscribe()) + +""" + + +class TriggerType(Enum): + + # https://docs.zhinst.com/pdf/LabOneProgrammingManual.pdf + # | Mode / Trigger Type | Description | Value of type | + # |---------------------|-------------|---------------| + # | Continuous | Continuous recording of data. | 0 | + # | Edge | Edge trigger with noise rejection. | 1 | + # | Pulse | Pulse width trigger with noise rejection. | 3 | + # | Tracking (Edge or Pulse) | Level tracking trigger to compensate for signal drift. | 4 | + # | Digital | Digital trigger with bit masking. | 2 | + # | Hardware | Trigger on one of the instrument’s hardware trigger channels (not available on HF2). | 6 | + # |Pulse Counter | Trigger on the value of an instrument’s pulse counter (requires CNT Option). | 8 | + + CONTINUOUS = 0 + EDGE = 1 + DIGITAL = 2 + PULSE = 3 + TRACKING = 4 + HARDWARE = 6 + PULSE_COUNTER = 8 + + + +class MFLIDAQ(DAC): + """ This class contains the driver for using the DAQ module of an Zuerich Instruments MFLI with qupulse. + """ + def __init__(self, device_serial: str = None, + device_interface: str = '1GbE', + data_server_addr: str = 'localhost', + data_server_port: int = 8004, + api_level_number: int = 6, + reset: bool = False, + timeout: float = 20) -> None: + """ + :param device_serial: Device serial that uniquely identifies this device to the LabOne data server + :param device_interface: Either '1GbE' for ethernet or 'USB' + :param data_server_addr: Data server address. Must be already running. Default: localhost + :param data_server_port: Data server port. Default: 8004 for HDAWG, MF and UHF devices + :param api_level_number: Version of API to use for the session, higher number, newer. Default: 6 most recent + :param reset: Reset device before initialization + :param timeout: Timeout in seconds for uploading + """ + self.api_session = zhinst_core.ziDAQServer(data_server_addr, data_server_port, api_level_number) + # assert zhinst.utils.api_server_version_check(self.api_session) # Check equal data server and api version. + self.device = self.api_session.connectDevice(device_serial, device_interface) + self.default_timeout = timeout + self.serial = device_serial + + self.daq = self.api_session.dataAcquisitionModule() + + if reset: + # Create a base configuration: Disable all available outputs, awgs, demods, scopes,... + zhinst.utils.disable_everything(self.api_session, self.serial) + + self.programs = {} + + + def reset_device(self): + """ This function resets the device to a known default configuration. + """ + + raise NotImplementedError() + + self.clear() + + def register_measurement_channel(self, program_name:str, channel_path:str): + """ This function saves the channel one wants to record with a certain program + + Args: + program_name: Name of the program + channel_path: the channel to record in the shape of "demods/0/sample.R.avg". Note that everything but the things behind the last "/" are considered to relate do the demodulator. If this is not given, you might want to check this driver and extend its functionality. + + """ + + if not isinstance(channel_path, list): + channel_path = [channel_path] + + self.programs.setdefault(program_name, {}).setdefault("channels", []) + self.programs[program_name]["channels"] = channel_path + + def register_measurement_windows(self, program_name: str, windows: Dict[str, Tuple[np.ndarray, + np.ndarray]]) -> None: + """Register measurement windows for a given program. Overwrites previously defined measurement windows for + this program. + + Args: + program_name: Name of the program + windows: Measurement windows by name. + First array are the start points of measurement windows in nanoseconds. + Second array are the corresponding measurement window's lengths in nanoseconds. + """ + + self.programs.setdefault(program_name, {}).setdefault("windows", {}).update(windows) + + for k, v in windows.items(): + self.set_measurement_mask(program_name=program_name, mask_name=k, begins=v[0], lengths=v[1]) + + + def set_measurement_mask(self, program_name: str, mask_name: str, + begins: np.ndarray, + lengths: np.ndarray) -> Tuple[np.ndarray, np.ndarray]: + """Set/overwrite a single the measurement mask for a program. Begins and lengths are in nanoseconds. + + Args: + program_name: Name of the program + mask_name: Name of the mask/measurement windows + begins: Staring points in nanoseconds + lengths: Lengths in nanoseconds + + Returns: + Measurement windows in DAC samples (begins, lengths) + """ + + assert begins.shape == lengths.shape + + # get the sample rates for the requested channels. If no sample rate is found, None will be used. This code is not very nice. + currently_set_sample_rates: List[Union[TimeType, None]] = [] + for c in self.programs[program_name]["channels"]: + try: + timetype_sr = TimeType().from_float(value=self.api_session.getDouble(f"/{self.serial}/{self._get_demod(c)}/rate"), absolute_error=0) + currently_set_sample_rates.append(timetype_sr) + except RuntimeError as e: + if "ZIAPINotFoundException" in e.args[0]: + currently_set_sample_rates.append(None) + else: + raise + + + mask_info = np.full((3, len(begins), len(currently_set_sample_rates)), np.nan) + + for i, sr in enumerate(currently_set_sample_rates): + if sr is not None: + # this code was taken from the already implemented alazar driver. + mask_info[0, :, i] = np.rint(begins * float(sr)).astype(dtype=np.uint64) # the begin + mask_info[1, :, i] = np.floor_divide(lengths * float(sr.numerator), float(sr.denominator)).astype(dtype=np.uint64) # the length + mask_info[2, :, i] = (mask_info[0, :, i] + mask_info[1, :, i]).astype(dtype=np.uint64) # the end + + self.programs.setdefault(program_name, {}).setdefault("masks", {})[mask_name] = mask_info + + # as the lock-in can measure multiple channels with different sample rates, the return value of this function is not defined correctly. + # this could be fixed by only measuring on one channel, or by returning some "summary" value. As of now, there does not to be a use of the return values. + + return (np.min(mask_info[0], axis=-1), np.min(mask_info[2], axis=-1)) + + def register_operations(self, program_name: str, operations) -> None: + """Register operations that are to be applied to the measurement results. + + Args: + program_name: Name of the program + operations: DAC specific instructions what to do with the data recorded by the device. + """ + + self.programs.setdefault(program_name, {}).setdefault("operations", []).append(operations) + + def _get_demod(self, channel:str): + """ This function gets the demodulator corresponding to a channel + """ + elements = channel.split("/") + elements = [e for e in elements if not e.lower()==self.serial.lower()] + elements = [e for e in elements if len(e) > 0] + + return "/".join(elements[:-1]) + + def arm_program(self, program_name: str) -> None: + """Prepare the device for measuring the given program and wait for a trigger event.""" + + # TODO check if program_name specified program is selected and important parameter set to the lock-in + + for c in self.programs[program_name].channels: + # select the value to measure + self.daq.subscribe(f'/{self.serial}/{c}') + + # activate corresponding demodulators + demod = self._get_demod(c) + try: + self.daq.set(f'/{self.serial}/{demod}/enable', 1) + except RuntimeError as e: + if "ZIAPINotFoundException" in e.args[0]: + # ok, the channel can not be enabled. Then the user should be caring about that. + warnigns.warn(f"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.") + pass + else: + raise + + # execute daq + self.daq.execute() + + # wait until changes have taken place + self.daq.sync() + + if program_name != None: + self.programs.setdefault(program_name, {}).setdefault('armed', False) + self.programs[program_name]['armed'] = True + + raise NotImplementedError() + + def unarm_program(self, program_name:str): + """ unarms the lock-in. This should be program independent. + """ + + self.daq.finish() + self.daq.unsubscribe('*') + self.daq.sync() + + if program_name != None: + self.programs.setdefault(program_name, {}).setdefault('armed', False) + self.programs[program_name]['armed'] = False + + def force_trigger(self, program_name:str): + """ forces a trigger + """ + + self.daq.set('forcetrigger', 1) + + def delete_program(self, program_name: str) -> None: + """Delete program from internal memory.""" + + # this does not have an effect on the current implementation of the lock-in driver. + + pass + + def clear(self) -> None: + """Clears all registered programs.""" + + self.unarm_program(program_name=None) + + def measure_program(self, channels: Iterable[str]) -> Dict[str, np.ndarray]: + """Get the last measurement's results of the specified operations/channels""" + + data = self.daq.read() + + print(data) \ No newline at end of file From e609d6da2f7b980b0e9649ac4e5f70be2a204b5b Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Wed, 28 Sep 2022 19:15:16 +0200 Subject: [PATCH 08/25] wip --- ...struments_lockin_mfli_daq-checkpoint.ipynb | 2702 ++++++++++++++++- .../zurich_instruments_lockin_mfli_daq.ipynb | 2702 ++++++++++++++++- qupulse/hardware/awgs/virtual.py | 6 +- qupulse/hardware/dacs/mfli.py | 244 +- qupulse/utils/tree.py | 3 - 5 files changed, 5375 insertions(+), 282 deletions(-) diff --git a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb index 3b43fd72f..395866d67 100644 --- a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb +++ b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "14133f44", + "id": "fceb835c", "metadata": {}, "source": [ "# Zurich Instruments Lock-In MFLI Data Aquesition" @@ -11,7 +11,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "0a0fdc55", + "id": "55c55e0a", "metadata": {}, "outputs": [], "source": [ @@ -22,7 +22,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "5a98e00c", + "id": "708ad356", "metadata": {}, "outputs": [], "source": [ @@ -31,8 +31,18 @@ }, { "cell_type": "code", - "execution_count": 25, - "id": "03a8c5ae", + "execution_count": 3, + "id": "e69e0618", + "metadata": {}, + "outputs": [], + "source": [ + "import time" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f7cb2ae3", "metadata": {}, "outputs": [], "source": [ @@ -41,8 +51,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "575d35da", + "execution_count": 5, + "id": "12279c39", "metadata": {}, "outputs": [], "source": [ @@ -51,8 +61,8 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "84863030", + "execution_count": 6, + "id": "9eef13eb", "metadata": {}, "outputs": [], "source": [ @@ -61,8 +71,8 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "5e020984", + "execution_count": 7, + "id": "c1f9c7ec", "metadata": {}, "outputs": [ { @@ -80,8 +90,8 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "33a97342", + "execution_count": 8, + "id": "9a3bf46e", "metadata": {}, "outputs": [], "source": [ @@ -91,57 +101,47 @@ { "cell_type": "code", "execution_count": 9, - "id": "6681f625", + "id": "baf33df9", "metadata": {}, "outputs": [], "source": [ - "my_lockin.register_measurement_channel(program_name=\"test\", channel_path=[\"demods/0/sample.R\", \"auxins/0/sample.AuxIn0.avg\", \"demods/0/sample.X\", \"demods/0/sample.Y\"])" + "my_lockin_channels = {\n", + " \"R\": [\"demods/0/sample.R\"],\n", + " \"X\": [\"demods/0/sample.X\"],\n", + " \"Y\": [\"demods/0/sample.Y\"],\n", + " \"A\": [\"auxins/0/sample.AuxIn0.avg\"],\n", + " \"many\": [\"demods/0/sample.R\", \"auxins/0/sample.AuxIn0.avg\", \"demods/0/sample.X\", \"demods/0/sample.Y\"]\n", + "}" ] }, { "cell_type": "code", "execution_count": 10, - "id": "bc1e47cb", + "id": "dfd7c42e", "metadata": {}, "outputs": [], "source": [ - "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"a\": (np.array([0, 3])*1, np.array([1, 10])*1),\"b\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" + "for k, v in my_lockin_channels.items():\n", + " my_lockin.register_measurement_channel(program_name=None, channel_path=v, window_name=k)" ] }, { "cell_type": "code", "execution_count": 11, - "id": "160c071b", + "id": "62df1451", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'test': {'channels': ['demods/0/sample.R',\n", + "{'channel_mapping': {'R': ['demods/0/sample.R'],\n", + " 'X': ['demods/0/sample.X'],\n", + " 'Y': ['demods/0/sample.Y'],\n", + " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", + " 'many': ['demods/0/sample.R',\n", " 'auxins/0/sample.AuxIn0.avg',\n", " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y'],\n", - " 'windows': {'a': (array([0, 3]), array([ 1, 10])),\n", - " 'b': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))},\n", - " 'masks': {'a': array([[[ 0., nan, 0., 0.],\n", - " [ 5022., nan, 5022., 5022.]],\n", - " \n", - " [[ 1674., nan, 1674., 1674.],\n", - " [16741., nan, 16741., 16741.]],\n", - " \n", - " [[ 1674., nan, 1674., 1674.],\n", - " [21763., nan, 21763., 21763.]]]),\n", - " 'b': array([[[ 0., nan, 0., 0.],\n", - " [ 3., nan, 3., 3.],\n", - " [ 7., nan, 7., 7.]],\n", - " \n", - " [[ 1., nan, 1., 1.],\n", - " [ 6., nan, 6., 6.],\n", - " [10., nan, 10., 10.]],\n", - " \n", - " [[ 1., nan, 1., 1.],\n", - " [ 9., nan, 9., 9.],\n", - " [17., nan, 17., 17.]]])}}}" + " 'demods/0/sample.Y']}}" ] }, "execution_count": 11, @@ -149,29 +149,133 @@ "output_type": "execute_result" } ], + "source": [ + "my_lockin.programs[None]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b9944369", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"A\": (np.array([0, 3])*1, np.array([1, 10])*1),\"many\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "fec2b04e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{None: {'channel_mapping': {'R': ['demods/0/sample.R'],\n", + " 'X': ['demods/0/sample.X'],\n", + " 'Y': ['demods/0/sample.Y'],\n", + " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", + " 'many': ['demods/0/sample.R',\n", + " 'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.X',\n", + " 'demods/0/sample.Y']}},\n", + " 'test': {'windows': {'A': (array([0, 3]), array([ 1, 10])),\n", + " 'many': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))},\n", + " 'masks': {'A': {'mask': array([[[nan],\n", + " [nan]],\n", + " \n", + " [[nan],\n", + " [nan]],\n", + " \n", + " [[nan],\n", + " [nan]]]),\n", + " 'channels': ['auxins/0/sample.AuxIn0.avg'],\n", + " 'sample_rates': [None]},\n", + " 'many': {'mask': array([[[ 0., nan, 0., 0.],\n", + " [ 3., nan, 3., 3.],\n", + " [ 7., nan, 7., 7.]],\n", + " \n", + " [[ 1., nan, 1., 1.],\n", + " [ 6., nan, 6., 6.],\n", + " [10., nan, 10., 10.]],\n", + " \n", + " [[ 1., nan, 1., 1.],\n", + " [ 9., nan, 9., 9.],\n", + " [17., nan, 17., 17.]]]),\n", + " 'channels': ['demods/0/sample.R',\n", + " 'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.X',\n", + " 'demods/0/sample.Y'],\n", + " 'sample_rates': [TimeType(6857143, 4096),\n", + " None,\n", + " TimeType(6857143, 4096),\n", + " TimeType(6857143, 4096)]}},\n", + " 'all_channels': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", + " 'demods/0/sample.X',\n", + " 'demods/0/sample.Y'},\n", + " 'window_hull': [0.0, 17.0]}}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "my_lockin.programs" ] }, { "cell_type": "code", - "execution_count": null, - "id": "83995f77", + "execution_count": 14, + "id": "35b54564", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "my_lockin.delete_program(program_name=\"test\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "26769d32", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{None: {'channel_mapping': {'R': ['demods/0/sample.R'],\n", + " 'X': ['demods/0/sample.X'],\n", + " 'Y': ['demods/0/sample.Y'],\n", + " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", + " 'many': ['demods/0/sample.R',\n", + " 'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.X',\n", + " 'demods/0/sample.Y']}}}" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.programs" + ] }, { "cell_type": "code", "execution_count": null, - "id": "e6e33177", + "id": "6b95f243", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "333ce31c", + "id": "e20ad339", "metadata": {}, "source": [ "## Defining a simple qupulse pulse with a measurement window." @@ -179,8 +283,8 @@ }, { "cell_type": "code", - "execution_count": 111, - "id": "906d5c5a", + "execution_count": 16, + "id": "648f0722", "metadata": {}, "outputs": [], "source": [ @@ -189,8 +293,8 @@ }, { "cell_type": "code", - "execution_count": 21, - "id": "4b0cc17e", + "execution_count": 17, + "id": "823cf456", "metadata": {}, "outputs": [], "source": [ @@ -206,8 +310,8 @@ }, { "cell_type": "code", - "execution_count": 52, - "id": "ab4a8768", + "execution_count": 18, + "id": "715df81e", "metadata": {}, "outputs": [], "source": [ @@ -224,8 +328,8 @@ }, { "cell_type": "code", - "execution_count": 137, - "id": "4268b9d4", + "execution_count": 19, + "id": "86258f61", "metadata": {}, "outputs": [], "source": [ @@ -236,8 +340,8 @@ }, { "cell_type": "code", - "execution_count": 138, - "id": "f082459a", + "execution_count": 20, + "id": "dabc4f0f", "metadata": {}, "outputs": [ { @@ -255,15 +359,15 @@ }, { "cell_type": "code", - "execution_count": 139, - "id": "e0600a11", + "execution_count": 21, + "id": "86ca9d23", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'T', 'R', 'A'}\n", + "{'R', 'A', 'T'}\n", "[]\n", "set()\n" ] @@ -277,8 +381,8 @@ }, { "cell_type": "code", - "execution_count": 140, - "id": "bb0530ec", + "execution_count": 22, + "id": "18693b31", "metadata": {}, "outputs": [ { @@ -287,7 +391,7 @@ "" ] }, - "execution_count": 140, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -298,13 +402,13 @@ }, { "cell_type": "code", - "execution_count": 142, - "id": "3c713b54", + "execution_count": 23, + "id": "d1142301", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -322,8 +426,8 @@ }, { "cell_type": "code", - "execution_count": 143, - "id": "454dab56", + "execution_count": 24, + "id": "56081907", "metadata": {}, "outputs": [], "source": [ @@ -343,8 +447,8 @@ }, { "cell_type": "code", - "execution_count": 144, - "id": "8332701f", + "execution_count": 25, + "id": "8f367858", "metadata": {}, "outputs": [], "source": [ @@ -356,13 +460,13 @@ }, { "cell_type": "code", - "execution_count": 145, - "id": "1c891151", + "execution_count": 26, + "id": "4beacf1c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -381,14 +485,14 @@ { "cell_type": "code", "execution_count": null, - "id": "69244a9c", + "id": "a443878d", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "ada25926", + "id": "ca0ab7e8", "metadata": {}, "source": [ "## Execution\n", @@ -399,18 +503,38 @@ }, { "cell_type": "code", - "execution_count": 146, - "id": "4ef8f47f", + "execution_count": 27, + "id": "a94273c9", + "metadata": {}, + "outputs": [], + "source": [ + "from qupulse.hardware.awgs.virtual import VirtualAWG" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "4f2f2591", + "metadata": {}, + "outputs": [], + "source": [ + "from qupulse.hardware.setup import HardwareSetup, MeasurementMask, PlaybackChannel" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "00a9186d", "metadata": {}, "outputs": [], "source": [ - "from qupulse.hardware.setup import HardwareSetup, MeasurementMask" + "my_awg = VirtualAWG(\"awg\", channels=3)" ] }, { "cell_type": "code", - "execution_count": 150, - "id": "4d6b9acc", + "execution_count": 30, + "id": "ffdc6396", "metadata": {}, "outputs": [], "source": [ @@ -419,92 +543,2448 @@ }, { "cell_type": "code", - "execution_count": 151, - "id": "a4731c70", + "execution_count": 31, + "id": "4e756118", "metadata": {}, "outputs": [], "source": [ - "for n in [\"R\", \"T\", \"A\"]:\n", - " setup.set_measurement(f\"{n}_lockin\", MeasurementMask(my_lockin, n))" + "for n in my_lockin.programs[None][\"channel_mapping\"].keys():\n", + " setup.set_measurement(f\"{n}\", MeasurementMask(my_lockin, n))" ] }, { "cell_type": "code", - "execution_count": 156, - "id": "c885518e", + "execution_count": 32, + "id": "847713ee", "metadata": {}, "outputs": [], "source": [ - "# for c in [\"red\", \"green\", \"trigger_out\"]:\n", - "# setup.set_channel(f\"{n}\", None)" + "for i, c in enumerate([\"red\", \"green\", \"trigger_out\"]):\n", + " setup.set_channel(f\"{c}\", PlaybackChannel(my_awg, i))" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "4f7e7867", + "metadata": {}, + "outputs": [], + "source": [ + "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "d240e903", + "metadata": {}, + "outputs": [], + "source": [ + "setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(None), update=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "72862ec2", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{None: {'channel_mapping': {'R': ['demods/0/sample.R'],\n", + " 'X': ['demods/0/sample.X'],\n", + " 'Y': ['demods/0/sample.Y'],\n", + " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", + " 'many': ['demods/0/sample.R',\n", + " 'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.X',\n", + " 'demods/0/sample.Y']}},\n", + " 'test': {'windows': {'X': (array([10.]), array([3.])),\n", + " 'R': (array([ 6.5, 14. ]), array([1.4, 1. ])),\n", + " 'A': (array([ 3., 12.]), array([1.5, 3. ]))},\n", + " 'masks': {'X': {'mask': array([[[16741.]],\n", + " \n", + " [[ 5022.]],\n", + " \n", + " [[21763.]]]),\n", + " 'channels': ['demods/0/sample.X'],\n", + " 'sample_rates': [TimeType(6857143, 4096)]},\n", + " 'R': {'mask': array([[[10882.],\n", + " [23438.]],\n", + " \n", + " [[ 2343.],\n", + " [ 1674.]],\n", + " \n", + " [[13225.],\n", + " [25112.]]]),\n", + " 'channels': ['demods/0/sample.R'],\n", + " 'sample_rates': [TimeType(6857143, 4096)]},\n", + " 'A': {'mask': array([[[nan],\n", + " [nan]],\n", + " \n", + " [[nan],\n", + " [nan]],\n", + " \n", + " [[nan],\n", + " [nan]]]),\n", + " 'channels': ['auxins/0/sample.AuxIn0.avg'],\n", + " 'sample_rates': [None]}},\n", + " 'all_channels': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", + " 'demods/0/sample.X'},\n", + " 'window_hull': [10882.0, 21763.0]}}" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.programs" ] }, { "cell_type": "code", - "execution_count": 158, - "id": "a8ae5cdf", + "execution_count": null, + "id": "2a211ced", "metadata": {}, "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "56298e79", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:283: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + " warnings.warn(f\"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.\")\n" + ] + } + ], + "source": [ + "setup.run_program(\"test\")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "5761973b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "{'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664383619736669], dtype=uint64), 'createdtimestamp': array([1393721038376], dtype=uint64), 'changedtimestamp': array([1393721038376], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '001 18:46:59.7359', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 1394500905096,\n", + " 1394500940936, 1394500976776]], dtype=uint64), 'value': array([[ nan, nan, nan, ..., -0.00060027,\n", + " -0.00061161, -0.00062295]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664383619737528], dtype=uint64), 'createdtimestamp': array([1393721038376], dtype=uint64), 'changedtimestamp': array([1393721038376], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '001 18:46:59.7359', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1393721026696, 1393721062536, 1393721098376, ..., 1394500905096,\n", + " 1394500940936, 1394500976776]], dtype=uint64), 'value': array([[1.28582697e-07, 2.34376326e-07, 2.38996428e-07, ...,\n", + " 5.87560559e-07, 5.32019319e-07, 4.14106693e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664383619737107], dtype=uint64), 'createdtimestamp': array([1393721038376], dtype=uint64), 'changedtimestamp': array([1393721038376], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '001 18:46:59.7359', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1393721026696, 1393721062536, 1393721098376, ..., 1394500905096,\n", + " 1394500940936, 1394500976776]], dtype=uint64), 'value': array([[ 3.39232042e-08, -8.97284119e-08, 9.67278307e-09, ...,\n", + " -5.81247741e-07, -5.16688776e-07, -4.03478886e-07]])}]}}}, 'forcetrigger': array([0], dtype=int64), 'triggered': array([0], dtype=int64)}\n" + ] + } + ], + "source": [ + "data = my_lockin.measure_program([\"\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "b8de12f0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "test_program = combined_pulse.create_program(parameters={})" + "data" ] }, { "cell_type": "code", - "execution_count": 159, - "id": "6a404a7a", + "execution_count": 39, + "id": "9907a87f", "metadata": {}, "outputs": [ { "ename": "KeyError", - "evalue": "\"The following channels are unknown to the HardwareSetup: {'green', 'trigger_out', 'red'}\"", + "evalue": "0", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_14832\\3018318824.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msetup\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mregister_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'puls_test'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtest_program\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrun_callback\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mlambda\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mupdate\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\setup.py\u001b[0m in \u001b[0;36mregister_program\u001b[1;34m(self, name, program, run_callback, update)\u001b[0m\n\u001b[0;32m 100\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mchannels\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_channel_map\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 101\u001b[0m raise KeyError('The following channels are unknown to the HardwareSetup: {}'.format(\n\u001b[1;32m--> 102\u001b[1;33m channels - set(self._channel_map.keys())))\n\u001b[0m\u001b[0;32m 103\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 104\u001b[0m \u001b[0mtemp_measurement_windows\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdefaultdict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mKeyError\u001b[0m: \"The following channels are unknown to the HardwareSetup: {'green', 'trigger_out', 'red'}\"" + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_32508\\1360584380.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mKeyError\u001b[0m: 0" ] } ], "source": [ - "setup.register_program('puls_test', test_program, run_callback=lambda *a, **b: None, update=True)" + "data[0][0].values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "89113a7c", + "metadata": {}, + "outputs": [], + "source": [ + "data[0][0].timestamp.values" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "8641d7d5", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "b0693faf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray '/dev3442/demods/0/sample.r' (col: 1, row: 21763)>\n",
+       "array([[1.28582697e-07, 2.34376326e-07, 2.38996428e-07, ...,\n",
+       "        5.87560559e-07, 5.32019319e-07, 4.14106693e-07]])\n",
+       "Coordinates:\n",
+       "    timestamp  (col, row) uint64 1393721026696 1393721062536 ... 1394500976776\n",
+       "Dimensions without coordinates: col, row\n",
+       "Attributes:\n",
+       "    systemtime:        [1664383619737528]\n",
+       "    createdtimestamp:  [1393721038376]\n",
+       "    changedtimestamp:  [1393721038376]\n",
+       "    flags:             [1849]\n",
+       "    moduleflags:       [0]\n",
+       "    chunksizebytes:    [0]\n",
+       "    name:              001 18:46:59.7359\n",
+       "    status:            [0]\n",
+       "    groupindex:        [0]\n",
+       "    color:             [0]\n",
+       "    activerow:         [0]\n",
+       "    triggernumber:     [0]\n",
+       "    gridrows:          [1]\n",
+       "    gridcols:          [21763]\n",
+       "    gridmode:          [4]\n",
+       "    gridoperation:     [1]\n",
+       "    griddirection:     [0]\n",
+       "    gridrepetitions:   [1]\n",
+       "    gridcoldelta:      [0.00059733]\n",
+       "    gridcoloffset:     [-0.001]\n",
+       "    gridrowdelta:      [1.]\n",
+       "    gridrowoffset:     [0.]\n",
+       "    bandwidth:         [nan]\n",
+       "    center:            [0.]\n",
+       "    nenbw:             [nan]
" + ], + "text/plain": [ + "\n", + "array([[1.28582697e-07, 2.34376326e-07, 2.38996428e-07, ...,\n", + " 5.87560559e-07, 5.32019319e-07, 4.14106693e-07]])\n", + "Coordinates:\n", + " timestamp (col, row) uint64 1393721026696 1393721062536 ... 1394500976776\n", + "Dimensions without coordinates: col, row\n", + "Attributes:\n", + " systemtime: [1664383619737528]\n", + " createdtimestamp: [1393721038376]\n", + " changedtimestamp: [1393721038376]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 18:46:59.7359\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [21763]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['/dev3442/demods/0/sample.r'][0]" ] }, { "cell_type": "code", - "execution_count": 152, - "id": "6b0dfe3c", + "execution_count": 48, + "id": "b0864fca", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{}" + "13.000597371565114" ] }, - "execution_count": 152, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "setup.run_program()" + "21763/1.674e3" ] }, { "cell_type": "code", - "execution_count": null, - "id": "986388ed", + "execution_count": 44, + "id": "cd038089", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for name, d in data.items():\n", + " plt.plot(d[0].timestamp.values.reshape((-1)), d[0].values.reshape((-1)), label=d[0].name)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "a0dbfbd2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(385)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 383 \u001b[1;33m \u001b[0mchannel_name\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34mf\"/{device_name}/{input_name}/{signal_name}/{final_level_name}\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 384 \u001b[1;33m\t\t\t\t\t\t\tchannel_data = xr.DataArray(\n", + "\u001b[0m\u001b[1;32m--> 385 \u001b[1;33m \u001b[0mdata\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mfinal_level_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"value\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 386 \u001b[1;33m \u001b[0mcords\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m'timestamp'\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mfinal_level_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'timestamp'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 387 \u001b[1;33m \u001b[0mdims\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'col'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'row'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> final_level_data\n", + "[{'header': {'systemtime': array([1664382261279112], dtype=uint64), 'createdtimestamp': array([1312194966056], dtype=uint64), 'changedtimestamp': array([1312194966056], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '007 18:24:21.2784', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1312194954376, 1312194990216, 1312195026056, ..., 1312974832776,\n", + " 1312974868616, 1312974904456]], dtype=uint64), 'value': array([[-0.00083702, -0.00081435, -0.00079167, ..., -0.00066342,\n", + " -0.00066342, -0.00066342]])}]\n", + "ipdb> final_level_data['values']\n", + "*** TypeError: list indices must be integers or slices, not str\n", + "ipdb> final_level_data['value']\n", + "*** TypeError: list indices must be integers or slices, not str\n", + "ipdb> r\n" + ] + } + ], + "source": [ + "%debug" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "96606726", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'forcetrigger': array([0], dtype=int64), 'triggered': array([1], dtype=int64)}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664381184448982], dtype=uint64), 'createdtimestamp': array([1247600892456], dtype=uint64), 'changedtimestamp': array([1247600892456], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 18:06:24.4482', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1247600880776, 1247600916616, 1247600952456, ..., 1248380759176,\n", + " 1248380795016, 1248380830856]], dtype=uint64), 'value': array([[-2.43316761e-05, -5.26761886e-05, -8.10207011e-05, ...,\n", + " 4.80435375e-04, 5.08779887e-04, 5.37124400e-04]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664381184449458], dtype=uint64), 'createdtimestamp': array([1247600892456], dtype=uint64), 'changedtimestamp': array([1247600892456], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 18:06:24.4482', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1247600880776, 1247600916616, 1247600952456, ..., 1248380759176,\n", + " 1248380795016, 1248380830856]], dtype=uint64), 'value': array([[1.78793064e-07, 2.95350018e-07, 3.64539359e-07, ...,\n", + " 3.68635535e-07, 4.18934422e-07, 6.62816282e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664381184449892], dtype=uint64), 'createdtimestamp': array([1247600892456], dtype=uint64), 'changedtimestamp': array([1247600892456], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 18:06:24.4482', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1247600880776, 1247600916616, 1247600952456, ..., 1248380759176,\n", + " 1248380795016, 1248380830856]], dtype=uint64), 'value': array([[1.52127041e-07, 2.01588166e-07, 1.77798752e-07, ...,\n", + " 3.64727363e-07, 3.53522672e-07, 3.08946072e-07]])}]}}}, 'triggered': array([0], dtype=int64)}\n", + "Progress [1.]\n" + ] + } + ], + "source": [ + "while not my_lockin.daq.finished():\n", + " time.sleep(1)\n", + " result = my_lockin.daq.read()\n", + " print(result)\n", + " print(f\"Progress {my_lockin.daq.progress()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "838d961b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(376)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 374 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 375 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mdevice_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdevice_data\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 376 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0minput_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput_data\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdevice_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 377 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0msignal_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msignal_data\u001b[0m \u001b[1;32min\u001b[0m \u001b[0minput_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 378 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msignal_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> device_data\n", + "array([0], dtype=int64)\n", + "ipdb> data\n", + "{'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664381558471132], dtype=uint64), 'createdtimestamp': array([1270042036776], dtype=uint64), 'changedtimestamp': array([1270042036776], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '005 18:12:38.4705', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1270042025096, 1270042060936, 1270042096776, ..., 1270821903496,\n", + " 1270821939336, 1270821975176]], dtype=uint64), 'value': array([[-0.00225105, -0.00225672, -0.00226239, ..., -0.00142828,\n", + " -0.00145662, -0.00148496]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664381558471577], dtype=uint64), 'createdtimestamp': array([1270042036776], dtype=uint64), 'changedtimestamp': array([1270042036776], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '005 18:12:38.4705', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1270042025096, 1270042060936, 1270042096776, ..., 1270821903496,\n", + " 1270821939336, 1270821975176]], dtype=uint64), 'value': array([[7.96188229e-07, 1.00931080e-06, 9.46633590e-07, ...,\n", + " 4.39649550e-07, 4.78960669e-07, 5.21563402e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664381558471999], dtype=uint64), 'createdtimestamp': array([1270042036776], dtype=uint64), 'changedtimestamp': array([1270042036776], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '005 18:12:38.4705', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1270042025096, 1270042060936, 1270042096776, ..., 1270821903496,\n", + " 1270821939336, 1270821975176]], dtype=uint64), 'value': array([[-7.14710861e-08, -1.44757501e-07, -2.49910226e-07, ...,\n", + " 5.42141045e-08, 1.21691587e-08, -4.78550733e-08]])}]}}}, 'forcetrigger': array([0], dtype=int64), 'triggered': array([0], dtype=int64)}\n", + "ipdb> r\n" + ] + } + ], + "source": [ + "%debug" + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "id": "339755e2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'awgcontrol': array([0], dtype=int64),\n", + " 'bandwidth': array([0.]),\n", + " 'bitmask': array([1], dtype=int64),\n", + " 'bits': array([1], dtype=int64),\n", + " 'buffercount': array([2], dtype=int64),\n", + " 'buffersize': array([0.2]),\n", + " 'clearhistory': array([0], dtype=int64),\n", + " 'count': array([1], dtype=int64),\n", + " 'delay': array([-0.001]),\n", + " 'device': [''],\n", + " 'duration': array([0.]),\n", + " 'edge': array([1], dtype=int64),\n", + " 'enable': array([1], dtype=int64),\n", + " 'endless': array([0], dtype=int64),\n", + " 'eventcount': {'mode': array([1], dtype=int64)},\n", + " 'fft': {'absolute': array([0], dtype=int64),\n", + " 'window': array([1], dtype=int64)},\n", + " 'findlevel': array([0], dtype=int64),\n", + " 'flags': array([8], dtype=int64),\n", + " 'forcetrigger': array([0], dtype=int64),\n", + " 'grid': {'cols': array([21763], dtype=int64),\n", + " 'direction': array([0], dtype=int64),\n", + " 'mode': array([4], dtype=int64),\n", + " 'overwrite': array([0], dtype=int64),\n", + " 'repetitions': array([1], dtype=int64),\n", + " 'rowrepetition': array([0], dtype=int64),\n", + " 'rows': array([1], dtype=int64),\n", + " 'waterfall': array([0], dtype=int64)},\n", + " 'historylength': array([100000], dtype=int64),\n", + " 'holdoff': {'count': array([0], dtype=int64), 'time': array([0.2])},\n", + " 'hysteresis': array([0.]),\n", + " 'level': array([0.]),\n", + " 'preview': array([0], dtype=int64),\n", + " 'pulse': {'max': array([0.001]), 'min': array([0.])},\n", + " 'refreshrate': array([5.]),\n", + " 'save': {'csvlocale': ['C'],\n", + " 'csvseparator': [';'],\n", + " 'directory': ['C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer'],\n", + " 'fileformat': array([0], dtype=int64),\n", + " 'filename': ['dataAcquisitionModule'],\n", + " 'save': array([0], dtype=int64),\n", + " 'saveonread': array([0], dtype=int64)},\n", + " 'spectrum': {'autobandwidth': array([0], dtype=int64),\n", + " 'enable': array([0], dtype=int64),\n", + " 'frequencyspan': array([13000.]),\n", + " 'overlapped': array([1], dtype=int64)},\n", + " 'triggered': array([1], dtype=int64),\n", + " 'triggernode': [''],\n", + " 'type': array([1], dtype=int64)}" + ] + }, + "execution_count": 192, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq_read_return" + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "id": "c5240cf0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(357)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 355 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 356 \u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 357 \u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq_read_return\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 358 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 359 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> data\n", + "{'forcetrigger': array([0], dtype=int64), 'triggered': array([1], dtype=int64)}\n", + "ipdb> r\n" + ] + } + ], + "source": [ + "%debug" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "id": "cb7d26b3", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.clear()" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "id": "36774f10", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 145, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq.read(flat=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "614316d1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 119, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq.read()" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "id": "a9dfa502", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.force_trigger(None)" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "263575fe", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['__class__',\n", + " '__delattr__',\n", + " '__dir__',\n", + " '__doc__',\n", + " '__eq__',\n", + " '__format__',\n", + " '__ge__',\n", + " '__getattribute__',\n", + " '__gt__',\n", + " '__hash__',\n", + " '__init__',\n", + " '__init_subclass__',\n", + " '__le__',\n", + " '__lt__',\n", + " '__module__',\n", + " '__ne__',\n", + " '__new__',\n", + " '__reduce__',\n", + " '__reduce_ex__',\n", + " '__repr__',\n", + " '__setattr__',\n", + " '__sizeof__',\n", + " '__str__',\n", + " '__subclasshook__',\n", + " 'clear',\n", + " 'execute',\n", + " 'finish',\n", + " 'finished',\n", + " 'get',\n", + " 'getDouble',\n", + " 'getInt',\n", + " 'getString',\n", + " 'getStringUnicode',\n", + " 'help',\n", + " 'listNodes',\n", + " 'listNodesJSON',\n", + " 'progress',\n", + " 'read',\n", + " 'save',\n", + " 'set',\n", + " 'subscribe',\n", + " 'trigger',\n", + " 'unsubscribe']" + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dir(my_lockin.daq)" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "id": "4f8fa7d3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 169, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq.finished()" + ] + }, + { + "cell_type": "code", + "execution_count": 205, + "id": "a0b1b2b2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.])" + ] + }, + "execution_count": 205, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq.progress()" + ] + }, + { + "cell_type": "code", + "execution_count": 202, + "id": "6d228524", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.set('forcetrigger', 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "60365fd8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.])" + ] + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq.progress()" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "id": "76255359", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'triggered': array([0], dtype=int64)}" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq.read()" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "822c77dd", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.finish()" + ] + }, + { + "cell_type": "code", + "execution_count": 193, + "id": "9402f8fe", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.execute()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "55677713", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c980ada", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "306b8d9f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "021403d4", + "metadata": {}, + "outputs": [], + "source": [ + "import time" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "8738508f", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.clear()\n", + "my_lockin.daq = my_lockin.api_session.dataAcquisitionModule()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "8ce3ae43", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.api_session.setDebugLevel(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "9b977196", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'forcetrigger': array([0], dtype=int64), 'triggered': array([1], dtype=int64)}\n", + "Progress [0.] %\n", + "{'dev3442': {'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664380454830777], dtype=uint64), 'createdtimestamp': array([1204630954536], dtype=uint64), 'changedtimestamp': array([1204630954536], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '100 17:54:14.8306', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([1000], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1204630942856, 1204630978696, 1204631014536, 1204631050376,\n", + " 1204631086216, 1204631122056, 1204631157896, 1204631193736,\n", + " 1204631229576, 1204631265416, 1204631301256, 1204631337096,\n", + " 1204631372936, 1204631408776, 1204631444616, 1204631480456,\n", + " 1204631516296, 1204631552136, 1204631587976, 1204631623816,\n", + " 1204631659656, 1204631695496, 1204631731336, 1204631767176,\n", + " 1204631803016, 1204631838856, 1204631874696, 1204631910536,\n", + " 1204631946376, 1204631982216, 1204632018056, 1204632053896,\n", + " 1204632089736, 1204632125576, 1204632161416, 1204632197256,\n", + " 1204632233096, 1204632268936, 1204632304776, 1204632340616,\n", + " 1204632376456, 1204632412296, 1204632448136, 1204632483976,\n", + " 1204632519816, 1204632555656, 1204632591496, 1204632627336,\n", + " 1204632663176, 1204632699016, 1204632734856, 1204632770696,\n", + " 1204632806536, 1204632842376, 1204632878216, 1204632914056,\n", + " 1204632949896, 1204632985736, 1204633021576, 1204633057416,\n", + " 1204633093256, 1204633129096, 1204633164936, 1204633200776,\n", + " 1204633236616, 1204633272456, 1204633308296, 1204633344136,\n", + " 1204633379976, 1204633415816, 1204633451656, 1204633487496,\n", + " 1204633523336, 1204633559176, 1204633595016, 1204633630856,\n", + " 1204633666696, 1204633702536, 1204633738376, 1204633774216,\n", + " 1204633810056, 1204633845896, 1204633881736, 1204633917576,\n", + " 1204633953416, 1204633989256, 1204634025096, 1204634060936,\n", + " 1204634096776, 1204634132616, 1204634168456, 1204634204296,\n", + " 1204634240136, 1204634275976, 1204634311816, 1204634347656,\n", + " 1204634383496, 1204634419336, 1204634455176, 1204634491016,\n", + " 1204634526856, 1204634562696, 1204634598536, 1204634634376,\n", + " 1204634670216, 1204634706056, 1204634741896, 1204634777736,\n", + " 1204634813576, 1204634849416, 1204634885256, 1204634921096,\n", + " 1204634956936, 1204634992776, 1204635028616, 1204635064456,\n", + " 1204635100296, 1204635136136, 1204635171976, 1204635207816,\n", + " 1204635243656, 1204635279496, 1204635315336, 1204635351176,\n", + " 1204635387016, 1204635422856, 1204635458696, 1204635494536,\n", + " 1204635530376, 1204635566216, 1204635602056, 1204635637896,\n", + " 1204635673736, 1204635709576, 1204635745416, 1204635781256,\n", + " 1204635817096, 1204635852936, 1204635888776, 1204635924616,\n", + " 1204635960456, 1204635996296, 1204636032136, 1204636067976,\n", + " 1204636103816, 1204636139656, 1204636175496, 1204636211336,\n", + " 1204636247176, 1204636283016, 1204636318856, 1204636354696,\n", + " 1204636390536, 1204636426376, 1204636462216, 1204636498056,\n", + " 1204636533896, 1204636569736, 1204636605576, 1204636641416,\n", + " 1204636677256, 1204636713096, 1204636748936, 1204636784776,\n", + " 1204636820616, 1204636856456, 1204636892296, 1204636928136,\n", + " 1204636963976, 1204636999816, 1204637035656, 1204637071496,\n", + " 1204637107336, 1204637143176, 1204637179016, 1204637214856,\n", + " 1204637250696, 1204637286536, 1204637322376, 1204637358216,\n", + " 1204637394056, 1204637429896, 1204637465736, 1204637501576,\n", + " 1204637537416, 1204637573256, 1204637609096, 1204637644936,\n", + " 1204637680776, 1204637716616, 1204637752456, 1204637788296,\n", + " 1204637824136, 1204637859976, 1204637895816, 1204637931656,\n", + " 1204637967496, 1204638003336, 1204638039176, 1204638075016,\n", + " 1204638110856, 1204638146696, 1204638182536, 1204638218376,\n", + " 1204638254216, 1204638290056, 1204638325896, 1204638361736,\n", + " 1204638397576, 1204638433416, 1204638469256, 1204638505096,\n", + " 1204638540936, 1204638576776, 1204638612616, 1204638648456,\n", + " 1204638684296, 1204638720136, 1204638755976, 1204638791816,\n", + " 1204638827656, 1204638863496, 1204638899336, 1204638935176,\n", + " 1204638971016, 1204639006856, 1204639042696, 1204639078536,\n", + " 1204639114376, 1204639150216, 1204639186056, 1204639221896,\n", + " 1204639257736, 1204639293576, 1204639329416, 1204639365256,\n", + " 1204639401096, 1204639436936, 1204639472776, 1204639508616,\n", + " 1204639544456, 1204639580296, 1204639616136, 1204639651976,\n", + " 1204639687816, 1204639723656, 1204639759496, 1204639795336,\n", + " 1204639831176, 1204639867016, 1204639902856, 1204639938696,\n", + " 1204639974536, 1204640010376, 1204640046216, 1204640082056,\n", + " 1204640117896, 1204640153736, 1204640189576, 1204640225416,\n", + " 1204640261256, 1204640297096, 1204640332936, 1204640368776,\n", + " 1204640404616, 1204640440456, 1204640476296, 1204640512136,\n", + " 1204640547976, 1204640583816, 1204640619656, 1204640655496,\n", + " 1204640691336, 1204640727176, 1204640763016, 1204640798856,\n", + " 1204640834696, 1204640870536, 1204640906376, 1204640942216,\n", + " 1204640978056, 1204641013896, 1204641049736, 1204641085576,\n", + " 1204641121416, 1204641157256, 1204641193096, 1204641228936,\n", + " 1204641264776, 1204641300616, 1204641336456, 1204641372296,\n", + " 1204641408136, 1204641443976, 1204641479816, 1204641515656,\n", + " 1204641551496, 1204641587336, 1204641623176, 1204641659016,\n", + " 1204641694856, 1204641730696, 1204641766536, 1204641802376,\n", + " 1204641838216, 1204641874056, 1204641909896, 1204641945736,\n", + " 1204641981576, 1204642017416, 1204642053256, 1204642089096,\n", + " 1204642124936, 1204642160776, 1204642196616, 1204642232456,\n", + " 1204642268296, 1204642304136, 1204642339976, 1204642375816,\n", + " 1204642411656, 1204642447496, 1204642483336, 1204642519176,\n", + " 1204642555016, 1204642590856, 1204642626696, 1204642662536,\n", + " 1204642698376, 1204642734216, 1204642770056, 1204642805896,\n", + " 1204642841736, 1204642877576, 1204642913416, 1204642949256,\n", + " 1204642985096, 1204643020936, 1204643056776, 1204643092616,\n", + " 1204643128456, 1204643164296, 1204643200136, 1204643235976,\n", + " 1204643271816, 1204643307656, 1204643343496, 1204643379336,\n", + " 1204643415176, 1204643451016, 1204643486856, 1204643522696,\n", + " 1204643558536, 1204643594376, 1204643630216, 1204643666056,\n", + " 1204643701896, 1204643737736, 1204643773576, 1204643809416,\n", + " 1204643845256, 1204643881096, 1204643916936, 1204643952776,\n", + " 1204643988616, 1204644024456, 1204644060296, 1204644096136,\n", + " 1204644131976, 1204644167816, 1204644203656, 1204644239496,\n", + " 1204644275336, 1204644311176, 1204644347016, 1204644382856,\n", + " 1204644418696, 1204644454536, 1204644490376, 1204644526216,\n", + " 1204644562056, 1204644597896, 1204644633736, 1204644669576,\n", + " 1204644705416, 1204644741256, 1204644777096, 1204644812936,\n", + " 1204644848776, 1204644884616, 1204644920456, 1204644956296,\n", + " 1204644992136, 1204645027976, 1204645063816, 1204645099656,\n", + " 1204645135496, 1204645171336, 1204645207176, 1204645243016,\n", + " 1204645278856, 1204645314696, 1204645350536, 1204645386376,\n", + " 1204645422216, 1204645458056, 1204645493896, 1204645529736,\n", + " 1204645565576, 1204645601416, 1204645637256, 1204645673096,\n", + " 1204645708936, 1204645744776, 1204645780616, 1204645816456,\n", + " 1204645852296, 1204645888136, 1204645923976, 1204645959816,\n", + " 1204645995656, 1204646031496, 1204646067336, 1204646103176,\n", + " 1204646139016, 1204646174856, 1204646210696, 1204646246536,\n", + " 1204646282376, 1204646318216, 1204646354056, 1204646389896,\n", + " 1204646425736, 1204646461576, 1204646497416, 1204646533256,\n", + " 1204646569096, 1204646604936, 1204646640776, 1204646676616,\n", + " 1204646712456, 1204646748296, 1204646784136, 1204646819976,\n", + " 1204646855816, 1204646891656, 1204646927496, 1204646963336,\n", + " 1204646999176, 1204647035016, 1204647070856, 1204647106696,\n", + " 1204647142536, 1204647178376, 1204647214216, 1204647250056,\n", + " 1204647285896, 1204647321736, 1204647357576, 1204647393416,\n", + " 1204647429256, 1204647465096, 1204647500936, 1204647536776,\n", + " 1204647572616, 1204647608456, 1204647644296, 1204647680136,\n", + " 1204647715976, 1204647751816, 1204647787656, 1204647823496,\n", + " 1204647859336, 1204647895176, 1204647931016, 1204647966856,\n", + " 1204648002696, 1204648038536, 1204648074376, 1204648110216,\n", + " 1204648146056, 1204648181896, 1204648217736, 1204648253576,\n", + " 1204648289416, 1204648325256, 1204648361096, 1204648396936,\n", + " 1204648432776, 1204648468616, 1204648504456, 1204648540296,\n", + " 1204648576136, 1204648611976, 1204648647816, 1204648683656,\n", + " 1204648719496, 1204648755336, 1204648791176, 1204648827016,\n", + " 1204648862856, 1204648898696, 1204648934536, 1204648970376,\n", + " 1204649006216, 1204649042056, 1204649077896, 1204649113736,\n", + " 1204649149576, 1204649185416, 1204649221256, 1204649257096,\n", + " 1204649292936, 1204649328776, 1204649364616, 1204649400456,\n", + " 1204649436296, 1204649472136, 1204649507976, 1204649543816,\n", + " 1204649579656, 1204649615496, 1204649651336, 1204649687176,\n", + " 1204649723016, 1204649758856, 1204649794696, 1204649830536,\n", + " 1204649866376, 1204649902216, 1204649938056, 1204649973896,\n", + " 1204650009736, 1204650045576, 1204650081416, 1204650117256,\n", + " 1204650153096, 1204650188936, 1204650224776, 1204650260616,\n", + " 1204650296456, 1204650332296, 1204650368136, 1204650403976,\n", + " 1204650439816, 1204650475656, 1204650511496, 1204650547336,\n", + " 1204650583176, 1204650619016, 1204650654856, 1204650690696,\n", + " 1204650726536, 1204650762376, 1204650798216, 1204650834056,\n", + " 1204650869896, 1204650905736, 1204650941576, 1204650977416,\n", + " 1204651013256, 1204651049096, 1204651084936, 1204651120776,\n", + " 1204651156616, 1204651192456, 1204651228296, 1204651264136,\n", + " 1204651299976, 1204651335816, 1204651371656, 1204651407496,\n", + " 1204651443336, 1204651479176, 1204651515016, 1204651550856,\n", + " 1204651586696, 1204651622536, 1204651658376, 1204651694216,\n", + " 1204651730056, 1204651765896, 1204651801736, 1204651837576,\n", + " 1204651873416, 1204651909256, 1204651945096, 1204651980936,\n", + " 1204652016776, 1204652052616, 1204652088456, 1204652124296,\n", + " 1204652160136, 1204652195976, 1204652231816, 1204652267656,\n", + " 1204652303496, 1204652339336, 1204652375176, 1204652411016,\n", + " 1204652446856, 1204652482696, 1204652518536, 1204652554376,\n", + " 1204652590216, 1204652626056, 1204652661896, 1204652697736,\n", + " 1204652733576, 1204652769416, 1204652805256, 1204652841096,\n", + " 1204652876936, 1204652912776, 1204652948616, 1204652984456,\n", + " 1204653020296, 1204653056136, 1204653091976, 1204653127816,\n", + " 1204653163656, 1204653199496, 1204653235336, 1204653271176,\n", + " 1204653307016, 1204653342856, 1204653378696, 1204653414536,\n", + " 1204653450376, 1204653486216, 1204653522056, 1204653557896,\n", + " 1204653593736, 1204653629576, 1204653665416, 1204653701256,\n", + " 1204653737096, 1204653772936, 1204653808776, 1204653844616,\n", + " 1204653880456, 1204653916296, 1204653952136, 1204653987976,\n", + " 1204654023816, 1204654059656, 1204654095496, 1204654131336,\n", + " 1204654167176, 1204654203016, 1204654238856, 1204654274696,\n", + " 1204654310536, 1204654346376, 1204654382216, 1204654418056,\n", + " 1204654453896, 1204654489736, 1204654525576, 1204654561416,\n", + " 1204654597256, 1204654633096, 1204654668936, 1204654704776,\n", + " 1204654740616, 1204654776456, 1204654812296, 1204654848136,\n", + " 1204654883976, 1204654919816, 1204654955656, 1204654991496,\n", + " 1204655027336, 1204655063176, 1204655099016, 1204655134856,\n", + " 1204655170696, 1204655206536, 1204655242376, 1204655278216,\n", + " 1204655314056, 1204655349896, 1204655385736, 1204655421576,\n", + " 1204655457416, 1204655493256, 1204655529096, 1204655564936,\n", + " 1204655600776, 1204655636616, 1204655672456, 1204655708296,\n", + " 1204655744136, 1204655779976, 1204655815816, 1204655851656,\n", + " 1204655887496, 1204655923336, 1204655959176, 1204655995016,\n", + " 1204656030856, 1204656066696, 1204656102536, 1204656138376,\n", + " 1204656174216, 1204656210056, 1204656245896, 1204656281736,\n", + " 1204656317576, 1204656353416, 1204656389256, 1204656425096,\n", + " 1204656460936, 1204656496776, 1204656532616, 1204656568456,\n", + " 1204656604296, 1204656640136, 1204656675976, 1204656711816,\n", + " 1204656747656, 1204656783496, 1204656819336, 1204656855176,\n", + " 1204656891016, 1204656926856, 1204656962696, 1204656998536,\n", + " 1204657034376, 1204657070216, 1204657106056, 1204657141896,\n", + " 1204657177736, 1204657213576, 1204657249416, 1204657285256,\n", + " 1204657321096, 1204657356936, 1204657392776, 1204657428616,\n", + " 1204657464456, 1204657500296, 1204657536136, 1204657571976,\n", + " 1204657607816, 1204657643656, 1204657679496, 1204657715336,\n", + " 1204657751176, 1204657787016, 1204657822856, 1204657858696,\n", + " 1204657894536, 1204657930376, 1204657966216, 1204658002056,\n", + " 1204658037896, 1204658073736, 1204658109576, 1204658145416,\n", + " 1204658181256, 1204658217096, 1204658252936, 1204658288776,\n", + " 1204658324616, 1204658360456, 1204658396296, 1204658432136,\n", + " 1204658467976, 1204658503816, 1204658539656, 1204658575496,\n", + " 1204658611336, 1204658647176, 1204658683016, 1204658718856,\n", + " 1204658754696, 1204658790536, 1204658826376, 1204658862216,\n", + " 1204658898056, 1204658933896, 1204658969736, 1204659005576,\n", + " 1204659041416, 1204659077256, 1204659113096, 1204659148936,\n", + " 1204659184776, 1204659220616, 1204659256456, 1204659292296,\n", + " 1204659328136, 1204659363976, 1204659399816, 1204659435656,\n", + " 1204659471496, 1204659507336, 1204659543176, 1204659579016,\n", + " 1204659614856, 1204659650696, 1204659686536, 1204659722376,\n", + " 1204659758216, 1204659794056, 1204659829896, 1204659865736,\n", + " 1204659901576, 1204659937416, 1204659973256, 1204660009096,\n", + " 1204660044936, 1204660080776, 1204660116616, 1204660152456,\n", + " 1204660188296, 1204660224136, 1204660259976, 1204660295816,\n", + " 1204660331656, 1204660367496, 1204660403336, 1204660439176,\n", + " 1204660475016, 1204660510856, 1204660546696, 1204660582536,\n", + " 1204660618376, 1204660654216, 1204660690056, 1204660725896,\n", + " 1204660761736, 1204660797576, 1204660833416, 1204660869256,\n", + " 1204660905096, 1204660940936, 1204660976776, 1204661012616,\n", + " 1204661048456, 1204661084296, 1204661120136, 1204661155976,\n", + " 1204661191816, 1204661227656, 1204661263496, 1204661299336,\n", + " 1204661335176, 1204661371016, 1204661406856, 1204661442696,\n", + " 1204661478536, 1204661514376, 1204661550216, 1204661586056,\n", + " 1204661621896, 1204661657736, 1204661693576, 1204661729416,\n", + " 1204661765256, 1204661801096, 1204661836936, 1204661872776,\n", + " 1204661908616, 1204661944456, 1204661980296, 1204662016136,\n", + " 1204662051976, 1204662087816, 1204662123656, 1204662159496,\n", + " 1204662195336, 1204662231176, 1204662267016, 1204662302856,\n", + " 1204662338696, 1204662374536, 1204662410376, 1204662446216,\n", + " 1204662482056, 1204662517896, 1204662553736, 1204662589576,\n", + " 1204662625416, 1204662661256, 1204662697096, 1204662732936,\n", + " 1204662768776, 1204662804616, 1204662840456, 1204662876296,\n", + " 1204662912136, 1204662947976, 1204662983816, 1204663019656,\n", + " 1204663055496, 1204663091336, 1204663127176, 1204663163016,\n", + " 1204663198856, 1204663234696, 1204663270536, 1204663306376,\n", + " 1204663342216, 1204663378056, 1204663413896, 1204663449736,\n", + " 1204663485576, 1204663521416, 1204663557256, 1204663593096,\n", + " 1204663628936, 1204663664776, 1204663700616, 1204663736456,\n", + " 1204663772296, 1204663808136, 1204663843976, 1204663879816,\n", + " 1204663915656, 1204663951496, 1204663987336, 1204664023176,\n", + " 1204664059016, 1204664094856, 1204664130696, 1204664166536,\n", + " 1204664202376, 1204664238216, 1204664274056, 1204664309896,\n", + " 1204664345736, 1204664381576, 1204664417416, 1204664453256,\n", + " 1204664489096, 1204664524936, 1204664560776, 1204664596616,\n", + " 1204664632456, 1204664668296, 1204664704136, 1204664739976,\n", + " 1204664775816, 1204664811656, 1204664847496, 1204664883336,\n", + " 1204664919176, 1204664955016, 1204664990856, 1204665026696,\n", + " 1204665062536, 1204665098376, 1204665134216, 1204665170056,\n", + " 1204665205896, 1204665241736, 1204665277576, 1204665313416,\n", + " 1204665349256, 1204665385096, 1204665420936, 1204665456776,\n", + " 1204665492616, 1204665528456, 1204665564296, 1204665600136,\n", + " 1204665635976, 1204665671816, 1204665707656, 1204665743496,\n", + " 1204665779336, 1204665815176, 1204665851016, 1204665886856,\n", + " 1204665922696, 1204665958536, 1204665994376, 1204666030216,\n", + " 1204666066056, 1204666101896, 1204666137736, 1204666173576,\n", + " 1204666209416, 1204666245256, 1204666281096, 1204666316936,\n", + " 1204666352776, 1204666388616, 1204666424456, 1204666460296,\n", + " 1204666496136, 1204666531976, 1204666567816, 1204666603656,\n", + " 1204666639496, 1204666675336, 1204666711176, 1204666747016]],\n", + " dtype=uint64), 'value': array([[1.10172382e-06, 9.00993372e-07, 6.85672291e-07, 5.05722310e-07,\n", + " 2.63556648e-07, 2.84944932e-07, 3.43998598e-07, 3.56673579e-07,\n", + " 4.30376278e-07, 3.80952694e-07, 4.10249181e-07, 4.03857472e-07,\n", + " 3.59043179e-07, 3.51889392e-07, 5.21878583e-07, 6.58856069e-07,\n", + " 6.23421580e-07, 5.82284234e-07, 5.37666393e-07, 2.95894822e-07,\n", + " 1.12301962e-08, 3.05695226e-07, 6.04882662e-07, 9.20686311e-07,\n", + " 1.13660529e-06, 1.19092367e-06, 9.76087500e-07, 6.15055004e-07,\n", + " 3.13769275e-07, 1.81930674e-07, 2.39599186e-07, 2.50579467e-07,\n", + " 2.97543602e-07, 3.24700912e-07, 2.81532788e-07, 3.05032989e-07,\n", + " 5.97171120e-07, 7.96912833e-07, 7.64501338e-07, 6.77978549e-07,\n", + " 6.23856189e-07, 5.55979018e-07, 3.88805118e-07, 2.57782050e-07,\n", + " 1.68561224e-07, 1.32007622e-07, 7.78802425e-08, 1.63811875e-07,\n", + " 3.47639782e-07, 2.50012698e-07, 8.94291151e-08, 8.03697325e-08,\n", + " 1.30349154e-07, 2.19107313e-07, 4.69253203e-07, 6.39894882e-07,\n", + " 6.57779206e-07, 5.09883973e-07, 4.76852062e-07, 5.10156623e-07,\n", + " 6.23915346e-07, 5.94415979e-07, 4.12425406e-07, 2.67075364e-07,\n", + " 9.69192031e-08, 4.97695649e-08, 6.58232731e-08, 1.23616393e-07,\n", + " 2.54326451e-07, 2.70416881e-07, 1.38021070e-07, 8.80823575e-08,\n", + " 5.45155700e-08, 2.21586304e-07, 3.09675449e-07, 2.78693839e-07,\n", + " 2.33244356e-07, 2.13303117e-07, 3.95575820e-07, 5.10217416e-07,\n", + " 5.55577809e-07, 5.54332627e-07, 4.60837489e-07, 3.45195816e-07,\n", + " 4.08619026e-07, 3.29004646e-07, 1.99000774e-07, 6.32831896e-08,\n", + " 1.10443827e-07, 1.25044715e-07, 5.80890342e-08, 6.50742469e-08,\n", + " 3.18526981e-07, 5.52935197e-07, 6.18173192e-07, 6.35119098e-07,\n", + " 6.52850575e-07, 7.50804686e-07, 8.00443590e-07, 7.44553393e-07,\n", + " 5.48159761e-07, 3.03408876e-07, 3.71190485e-07, 4.09963545e-07,\n", + " 2.14933673e-07, 1.25808499e-07, 2.63823650e-07, 3.78668448e-07,\n", + " 4.21149267e-07, 4.30933377e-07, 3.88958810e-07, 3.39340699e-07,\n", + " 2.99199090e-07, 2.38414859e-07, 9.79969920e-08, 1.71532624e-07,\n", + " 4.15741660e-07, 6.09098279e-07, 7.58500603e-07, 8.81326664e-07,\n", + " 9.27644427e-07, 8.78532515e-07, 7.24006467e-07, 5.27521366e-07,\n", + " 3.13078440e-07, 1.78492138e-07, 1.02943885e-07, 9.00787678e-08,\n", + " 2.23117015e-07, 3.52778792e-07, 3.64945691e-07, 2.71476053e-07,\n", + " 1.50592943e-07, 9.85347571e-08, 1.37514951e-07, 2.62132523e-07,\n", + " 5.61961763e-07, 7.62610677e-07, 7.61311804e-07, 7.51694936e-07,\n", + " 6.75334372e-07, 6.38306937e-07, 6.09471814e-07, 5.06948147e-07,\n", + " 3.77760478e-07, 4.62184582e-07, 5.50134840e-07, 5.93225916e-07,\n", + " 5.70856045e-07, 4.45811062e-07, 2.64324269e-07, 1.74873117e-07,\n", + " 1.41081115e-07, 1.34482520e-07, 9.52025471e-08, 5.85520569e-08,\n", + " 1.73440558e-07, 2.22078318e-07, 2.33007683e-07, 3.03478090e-07,\n", + " 4.05284261e-07, 6.13934440e-07, 7.63735737e-07, 6.12481949e-07,\n", + " 3.23829195e-07, 1.47620966e-07, 1.72441448e-07, 3.74744625e-07,\n", + " 2.70861242e-07, 3.20812078e-08, 1.87066335e-07, 3.01109457e-07,\n", + " 4.91104778e-07, 4.33183644e-07, 2.82325730e-07, 2.97699066e-07,\n", + " 5.17974675e-07, 5.91289304e-07, 3.46911982e-07, 1.78438744e-07,\n", + " 1.02194575e-07, 1.57912315e-07, 2.22870560e-07, 3.24817655e-07,\n", + " 3.50475580e-07, 4.29146299e-07, 3.44077590e-07, 1.72237873e-07,\n", + " 9.22907941e-09, 2.21248674e-07, 3.25739808e-07, 2.14661637e-07,\n", + " 1.64524065e-07, 2.52054707e-07, 4.70487339e-07, 4.74727628e-07,\n", + " 3.43503301e-07, 5.03108132e-07, 5.68300504e-07, 4.01165899e-07,\n", + " 2.44321059e-07, 3.00103881e-07, 3.72187270e-07, 3.47736345e-07,\n", + " 3.10355839e-07, 2.75364159e-07, 4.09862560e-07, 5.73371383e-07,\n", + " 6.27081190e-07, 5.77312744e-07, 6.05007397e-07, 7.27155688e-07,\n", + " 5.92057189e-07, 1.91106106e-07, 2.56967975e-07, 2.92111836e-07,\n", + " 3.90146251e-07, 4.82477848e-07, 5.32305439e-07, 3.44347786e-07,\n", + " 1.72010907e-07, 1.73923000e-07, 2.50814343e-07, 3.89090037e-07,\n", + " 4.75643228e-07, 3.88711305e-07, 1.97222847e-07, 2.46780284e-07,\n", + " 2.64668826e-07, 2.89501174e-07, 4.01518224e-07, 6.74135688e-07,\n", + " 6.18645069e-07, 4.37556495e-07, 2.20923047e-07, 1.14419556e-07,\n", + " 1.26856734e-07, 1.00089621e-07, 1.19525727e-07, 2.57526231e-07,\n", + " 2.26675326e-07, 3.10498070e-07, 3.31654109e-07, 2.14005446e-07,\n", + " 1.86077339e-07, 2.48257635e-07, 3.22971276e-07, 2.40623303e-07,\n", + " 1.11573253e-07, 1.79141024e-07, 2.04903808e-07, 1.84530491e-07,\n", + " 2.06834505e-07, 3.85550780e-07, 4.17616354e-07, 4.10810334e-07,\n", + " 4.15976585e-07, 5.94376739e-07, 7.45402668e-07, 7.06737766e-07,\n", + " 5.06713546e-07, 4.63435309e-07, 5.54252429e-07, 6.89894794e-07,\n", + " 7.03826561e-07, 6.46166485e-07, 6.09534471e-07, 6.27221407e-07,\n", + " 6.25122666e-07, 6.02095574e-07, 5.38525279e-07, 4.77109918e-07,\n", + " 4.68633768e-07, 5.49740086e-07, 6.68247982e-07, 6.83298293e-07,\n", + " 5.75904493e-07, 4.71106274e-07, 2.62474890e-07, 2.08783763e-07,\n", + " 8.82209886e-08, 1.15886977e-08, 5.56766077e-08, 2.55647020e-07,\n", + " 4.29921534e-07, 3.63903429e-07, 2.24994979e-07, 6.40724979e-08,\n", + " 2.18174975e-07, 3.90993800e-07, 3.26305621e-07, 7.97413743e-08,\n", + " 2.02468614e-07, 2.89155193e-07, 3.85857853e-07, 5.37231927e-07,\n", + " 7.73238741e-07, 7.68905833e-07, 6.50909665e-07, 6.70089472e-07,\n", + " 6.39205529e-07, 4.08252469e-07, 2.21792694e-07, 1.14801932e-07,\n", + " 1.13725462e-07, 4.44966872e-07, 8.28901844e-07, 1.01473163e-06,\n", + " 9.24568619e-07, 6.14258722e-07, 3.35031847e-07, 1.85673215e-07,\n", + " 1.52792186e-07, 3.15459204e-07, 3.88451031e-07, 4.23969453e-07,\n", + " 4.50853976e-07, 4.95974133e-07, 4.31684977e-07, 1.04238612e-07,\n", + " 2.50071162e-07, 3.77273337e-07, 4.51408268e-07, 5.05259783e-07,\n", + " 5.63401662e-07, 6.04346571e-07, 5.15800601e-07, 4.71134910e-07,\n", + " 6.03224967e-07, 5.31633718e-07, 3.53417994e-07, 1.39320333e-07,\n", + " 1.22904463e-07, 1.90635450e-07, 3.05044716e-07, 3.71255569e-07,\n", + " 4.28827198e-07, 4.35061635e-07, 3.83926620e-07, 2.93598126e-07,\n", + " 3.03978936e-07, 3.76574453e-07, 4.38974518e-07, 3.67454943e-07,\n", + " 1.85178407e-07, 1.62951258e-07, 2.02209877e-07, 1.03071540e-07,\n", + " 8.78383533e-08, 2.79744145e-07, 3.49905868e-07, 3.96674925e-07,\n", + " 5.90938110e-07, 7.02573590e-07, 6.73909212e-07, 5.14048070e-07,\n", + " 3.30404926e-07, 1.62184815e-07, 2.37903294e-07, 4.85346027e-07,\n", + " 4.03753378e-07, 3.27056394e-07, 2.55584118e-07, 3.05960649e-07,\n", + " 3.83446085e-07, 5.74046413e-07, 6.27709939e-07, 4.78470426e-07,\n", + " 4.65230034e-07, 3.58294942e-07, 1.73612183e-07, 1.92023326e-07,\n", + " 2.54248171e-07, 3.19083436e-07, 1.38770681e-07, 5.41525005e-08,\n", + " 2.77540914e-07, 3.61662365e-07, 3.70860352e-07, 4.06588683e-07,\n", + " 3.85190720e-07, 3.84275516e-07, 3.16298031e-07, 2.21499569e-07,\n", + " 1.53273756e-07, 8.76957469e-08, 1.98060853e-07, 3.91326256e-07,\n", + " 4.25993278e-07, 3.35671756e-07, 5.19576302e-08, 1.70884313e-07,\n", + " 2.15189768e-07, 2.79358661e-07, 3.15516474e-07, 3.76591686e-07,\n", + " 3.18433151e-07, 2.40545801e-07, 2.08688055e-07, 2.82018612e-07,\n", + " 4.53363506e-07, 5.80581909e-07, 5.93196116e-07, 5.40983376e-07,\n", + " 5.58967494e-07, 5.55660148e-07, 6.35585684e-07, 6.20240423e-07,\n", + " 6.81962130e-07, 6.74469772e-07, 6.12472606e-07, 5.11543210e-07,\n", + " 5.75453913e-07, 6.05407513e-07, 5.33758830e-07, 4.72757988e-07,\n", + " 3.75739332e-07, 1.62924315e-07, 2.01131427e-07, 9.05138952e-08,\n", + " 7.45520615e-09, 2.17270471e-07, 2.89617935e-07, 1.30100758e-07,\n", + " 1.30095319e-07, 1.64433901e-07, 1.10164649e-07, 2.98595620e-07,\n", + " 3.83649826e-07, 2.78758448e-07, 2.28737139e-07, 1.84545341e-07,\n", + " 1.44420273e-07, 4.57294424e-07, 6.68904526e-07, 7.24629512e-07,\n", + " 6.92990602e-07, 5.50788691e-07, 3.61729826e-07, 1.54338849e-07,\n", + " 9.36556041e-08, 3.84913625e-07, 6.74676961e-07, 7.49737854e-07,\n", + " 7.91698334e-07, 6.41507399e-07, 6.01816832e-07, 7.41940247e-07,\n", + " 8.15793327e-07, 7.48879176e-07, 5.83365556e-07, 4.20656161e-07,\n", + " 3.18818747e-07, 2.04860203e-07, 2.77391239e-07, 3.67076249e-07,\n", + " 4.10224823e-07, 3.07760784e-07, 3.95908324e-07, 5.47137366e-07,\n", + " 6.51749747e-07, 7.29113815e-07, 7.38477703e-07, 7.71924829e-07,\n", + " 8.09991899e-07, 7.31862177e-07, 4.80444342e-07, 3.75488325e-07,\n", + " 2.30663163e-07, 1.25087616e-07, 1.81723196e-07, 1.51660581e-07,\n", + " 1.45726213e-07, 2.56302335e-07, 3.22508638e-07, 2.97016756e-07,\n", + " 2.46639946e-07, 1.80873620e-07, 1.10603196e-07, 4.11544779e-07,\n", + " 7.00062907e-07, 6.97734300e-07, 5.37358877e-07, 4.43892359e-07,\n", + " 4.13851719e-07, 4.61548999e-07, 4.83614804e-07, 5.09572495e-07,\n", + " 4.97111450e-07, 3.07411792e-07, 1.60220721e-07, 2.50309182e-07,\n", + " 3.48249997e-07, 2.60791915e-07, 1.46551304e-08, 2.78461321e-07,\n", + " 3.72349704e-07, 4.30719884e-07, 4.45666767e-07, 3.27599352e-07,\n", + " 1.23808373e-07, 6.23509798e-08, 1.75828335e-07, 3.04169271e-07,\n", + " 2.93007656e-07, 2.23771779e-07, 2.38133733e-07, 2.32698141e-07,\n", + " 3.81322503e-07, 4.33507591e-07, 4.77924413e-07, 4.98704734e-07,\n", + " 5.11102151e-07, 5.30412445e-07, 5.88101932e-07, 5.25820025e-07,\n", + " 3.64397164e-07, 1.28373792e-07, 1.67656421e-07, 3.26175983e-07,\n", + " 3.98572683e-07, 3.18682353e-07, 1.23289791e-07, 2.31347164e-07,\n", + " 4.30995051e-07, 4.94945496e-07, 5.00033328e-07, 2.90503592e-07,\n", + " 2.36491774e-07, 3.29661022e-07, 4.14656961e-07, 4.73994058e-07,\n", + " 3.92556499e-07, 3.58857059e-07, 3.39263702e-07, 1.55860375e-07,\n", + " 1.45640380e-07, 2.38803777e-07, 3.50502161e-07, 3.89760610e-07,\n", + " 2.96614664e-07, 3.38885974e-07, 4.63940538e-07, 4.33276263e-07,\n", + " 2.50469351e-07, 2.37320277e-07, 3.68405627e-07, 6.17641452e-07,\n", + " 8.84763346e-07, 9.17253173e-07, 7.06064935e-07, 4.99665046e-07,\n", + " 2.86683710e-07, 2.30685990e-07, 1.97848786e-07, 1.78313368e-07,\n", + " 2.21611128e-07, 3.62535608e-07, 5.24055643e-07, 5.77170078e-07,\n", + " 4.67761382e-07, 5.22425933e-07, 4.52543367e-07, 3.79985241e-07,\n", + " 2.77172847e-07, 1.49777161e-07, 1.15214658e-07, 3.59981435e-07,\n", + " 6.03369756e-07, 6.67961744e-07, 5.94612510e-07, 4.16769794e-07,\n", + " 2.58266120e-07, 3.39543432e-07, 4.73534940e-07, 4.96254211e-07,\n", + " 3.71374416e-07, 2.92820765e-07, 4.17394871e-07, 6.16769871e-07,\n", + " 6.53420767e-07, 6.01329267e-07, 5.84599318e-07, 5.32087815e-07,\n", + " 5.11893352e-07, 3.93062658e-07, 1.51709865e-07, 2.12522162e-08,\n", + " 8.89926409e-08, 2.71148514e-07, 5.10614147e-07, 5.86233899e-07,\n", + " 4.56926837e-07, 3.34114450e-07, 3.66266238e-07, 4.64055009e-07,\n", + " 4.71204388e-07, 4.68161087e-07, 4.35620452e-07, 4.07623605e-07,\n", + " 4.27871698e-07, 5.59862233e-07, 6.05468102e-07, 6.36568208e-07,\n", + " 6.54980918e-07, 6.15334462e-07, 3.32778868e-07, 2.44608204e-08,\n", + " 1.28116423e-07, 1.21720857e-07, 1.06496458e-07, 2.26547081e-07,\n", + " 3.03950013e-07, 2.72227746e-07, 2.15457545e-07, 2.44805478e-07,\n", + " 4.37398264e-07, 6.24068867e-07, 6.10211264e-07, 5.84822469e-07,\n", + " 5.59034655e-07, 5.62235625e-07, 5.81709446e-07, 5.34074456e-07,\n", + " 4.31861549e-07, 1.99938765e-07, 1.48787174e-07, 1.20190864e-07,\n", + " 2.57822474e-07, 4.45790132e-07, 4.20567341e-07, 3.44484166e-07,\n", + " 2.73959165e-07, 1.71478123e-07, 7.83323773e-08, 9.37151918e-08,\n", + " 2.49811716e-07, 3.09317789e-07, 3.02401749e-07, 2.48652746e-07,\n", + " 2.39160349e-07, 4.73779328e-07, 5.82964207e-07, 5.28841215e-07,\n", + " 5.67864881e-07, 6.37154438e-07, 6.33173841e-07, 4.17288629e-07,\n", + " 5.18028416e-07, 6.47880325e-07, 7.42836657e-07, 7.70841690e-07,\n", + " 6.62514309e-07, 5.13944815e-07, 3.45391554e-07, 1.26703549e-07,\n", + " 4.91374190e-08, 5.58747034e-08, 1.81795476e-07, 5.04145382e-07,\n", + " 6.36718257e-07, 6.19121328e-07, 5.05161528e-07, 4.23852618e-07,\n", + " 4.07100383e-07, 5.52901048e-07, 5.73362020e-07, 4.64448810e-07,\n", + " 4.09242005e-07, 4.58095006e-07, 4.36634270e-07, 3.77672928e-07,\n", + " 3.26387651e-07, 3.19701485e-07, 3.36957607e-07, 2.76393757e-07,\n", + " 2.33877207e-07, 5.99739826e-08, 3.87451598e-07, 5.06846618e-07,\n", + " 2.73912143e-07, 1.69720831e-07, 4.97385909e-07, 4.49638096e-07,\n", + " 2.75734554e-07, 2.83083828e-07, 3.61067130e-07, 2.82104562e-07,\n", + " 7.75347440e-08, 5.64334566e-08, 1.85022021e-07, 3.03871562e-07,\n", + " 3.10899044e-07, 2.72303530e-07, 2.21233625e-07, 2.48180434e-07,\n", + " 2.78723931e-07, 3.22697810e-07, 5.54059670e-07, 6.19390567e-07,\n", + " 5.51157971e-07, 3.76065087e-07, 4.20955015e-08, 1.22463307e-07,\n", + " 7.62915335e-08, 1.76891360e-07, 2.81819575e-07, 3.15055046e-07,\n", + " 3.26917003e-07, 2.59225916e-07, 1.12111201e-07, 3.54231417e-08,\n", + " 1.30066101e-07, 3.77238140e-07, 6.62036199e-07, 7.23178983e-07,\n", + " 6.28532827e-07, 4.20225381e-07, 1.97549962e-07, 3.35634207e-07,\n", + " 3.66089416e-07, 2.72458372e-07, 1.52055798e-07, 2.29626293e-07,\n", + " 2.16658080e-07, 1.38513811e-07, 2.10525809e-07, 2.35135964e-07,\n", + " 3.75240077e-07, 4.43467112e-07, 1.79198796e-07, 2.34808419e-07,\n", + " 5.07529421e-07, 6.96410096e-07, 6.45342656e-07, 4.42581123e-07,\n", + " 3.07838187e-07, 3.22290837e-07, 2.47777651e-07, 3.71568152e-07,\n", + " 4.23185003e-07, 3.48936635e-07, 2.53383478e-07, 3.81561622e-07,\n", + " 5.49555713e-07, 7.35642765e-07, 8.92304125e-07, 9.49032819e-07,\n", + " 8.15547663e-07, 6.47913144e-07, 5.53582472e-07, 5.82332542e-07,\n", + " 5.28295282e-07, 4.83346357e-07, 5.09975635e-07, 3.61859401e-07,\n", + " 1.87085701e-07, 1.00685767e-07, 6.48184726e-08, 2.51909657e-07,\n", + " 3.41402645e-07, 3.61064978e-07, 3.29101330e-07, 3.09282468e-07,\n", + " 3.56624640e-07, 3.56407153e-07, 4.19803216e-07, 5.20763489e-07,\n", + " 5.84085817e-07, 5.51045302e-07, 6.62566213e-07, 6.34141819e-07,\n", + " 4.17268796e-07, 3.84569151e-07, 4.20606084e-07, 3.47259006e-07,\n", + " 3.13524207e-07, 3.00912440e-07, 2.97730333e-07, 1.80344993e-07,\n", + " 5.71022710e-08, 1.61224854e-07, 1.54991875e-07, 2.70976776e-07,\n", + " 4.12883459e-07, 3.49212288e-07, 1.78077072e-07, 8.46431259e-08,\n", + " 2.16470941e-07, 4.71058132e-07, 5.17018370e-07, 4.12778655e-07,\n", + " 3.59922374e-07, 2.88825818e-07, 1.60507626e-07, 2.56569859e-07,\n", + " 3.94164341e-07, 4.51043831e-07, 4.16377396e-07, 3.41116493e-07,\n", + " 1.87434013e-07, 2.73445796e-07, 3.69698843e-07, 3.89326346e-07,\n", + " 2.05621253e-07, 6.39084693e-08, 2.03270487e-08, 2.19618890e-07,\n", + " 4.09822299e-07, 4.53437598e-07, 6.04374490e-07, 6.71124535e-07,\n", + " 5.35008768e-07, 3.31273048e-07, 1.86286264e-07, 7.87992030e-08,\n", + " 7.33899804e-08, 5.46788003e-08, 7.82461988e-08, 2.89594445e-07,\n", + " 4.71009109e-07, 6.25776587e-07, 7.29467199e-07, 7.03004149e-07,\n", + " 7.15162244e-07, 6.40278175e-07, 4.81499008e-07, 3.26249199e-07,\n", + " 2.51090617e-07, 3.26096355e-07, 4.67166693e-07, 4.49483618e-07,\n", + " 4.44373646e-07, 5.33181373e-07, 5.04411615e-07, 2.90559870e-07,\n", + " 1.76062043e-08, 6.63463654e-08, 6.20297987e-08, 1.36291039e-07,\n", + " 1.64785161e-07, 1.32513331e-07, 1.91439409e-07, 2.02623515e-07,\n", + " 2.60582721e-07, 3.29594684e-07, 3.19847083e-07, 4.86802232e-07,\n", + " 5.06645747e-07, 4.63002082e-07, 4.45252041e-07, 3.29432378e-07,\n", + " 1.33060167e-07, 1.12901016e-07, 5.26525262e-08, 2.23240071e-07,\n", + " 2.15720374e-07, 1.78089833e-07, 9.07086483e-08, 1.85874627e-07,\n", + " 3.43056815e-07, 5.23815412e-07, 5.41483621e-07, 5.34903506e-07,\n", + " 6.87934277e-07, 6.35206008e-07, 5.30810105e-07, 5.86690328e-07,\n", + " 5.96205596e-07, 4.76265283e-07, 2.59530478e-07, 1.74668642e-07,\n", + " 2.20707690e-07, 1.48224947e-07, 7.76568209e-08, 1.49773341e-07,\n", + " 1.78680352e-07, 1.50650345e-07, 1.71730188e-07, 1.91727303e-07,\n", + " 2.55737209e-07, 4.01336506e-07, 4.90735809e-07, 6.14103359e-07,\n", + " 7.46771362e-07, 7.70136971e-07, 7.22502224e-07, 6.80766422e-07,\n", + " 4.75239918e-07, 2.77572849e-07, 2.05658903e-07, 2.15890173e-07,\n", + " 3.81961906e-07, 5.64244747e-07, 6.73058541e-07, 6.74224365e-07,\n", + " 5.94286990e-07, 5.01544846e-07, 3.92881635e-07, 3.41382951e-07,\n", + " 3.33890182e-07, 1.99711452e-07, 2.42957717e-07, 3.43601866e-07,\n", + " 3.29441193e-07, 2.52072739e-07, 2.95682939e-07, 3.75249375e-07,\n", + " 3.42851182e-07, 3.24730227e-07, 2.39156456e-07, 1.41895006e-07,\n", + " 2.08806816e-07, 2.25333412e-07, 2.89249900e-07, 4.32962675e-07,\n", + " 3.95274135e-07, 2.61367467e-07, 2.59601271e-07, 3.31315463e-07,\n", + " 4.64020000e-07, 4.42235952e-07, 2.78579548e-07, 4.32860594e-08,\n", + " 1.19422155e-07, 2.20370440e-07, 2.72269130e-07, 1.95321901e-07,\n", + " 2.49038024e-07, 2.20263688e-07, 1.09444566e-07, 1.19985084e-07,\n", + " 1.64712500e-07, 2.54279504e-07, 5.21125581e-07, 5.99847999e-07,\n", + " 5.50143097e-07, 5.38032710e-07, 5.75328278e-07, 5.84995137e-07,\n", + " 5.91818588e-07, 6.61172483e-07, 5.09732156e-07, 3.38181717e-07,\n", + " 1.90165818e-07, 9.16482454e-08, 2.16879324e-07, 2.71869259e-07,\n", + " 2.34202087e-07, 1.64473707e-07, 1.85627516e-07, 4.21186435e-07,\n", + " 7.20099193e-07, 8.49382786e-07, 8.55383445e-07, 8.06922724e-07,\n", + " 8.86273143e-07, 1.09564047e-06, 1.02477921e-06, 7.71886033e-07,\n", + " 4.82086127e-07, 1.55281914e-07, 2.88683618e-07, 4.12018350e-07,\n", + " 3.66836577e-07, 3.69618906e-07, 3.32524375e-07, 2.48514935e-07,\n", + " 1.59734486e-07, 1.87519651e-07, 1.90979404e-07, 1.35212486e-07,\n", + " 1.37459873e-07, 2.72669989e-07, 3.34520602e-07, 4.73230690e-07,\n", + " 7.20279987e-07, 8.29459769e-07, 8.65655251e-07, 6.95763571e-07,\n", + " 3.59860664e-07, 3.39939569e-07, 4.08631101e-07, 4.24498281e-07,\n", + " 4.20614116e-07, 2.52512024e-07, 3.18811094e-07, 4.74561047e-07,\n", + " 5.65069723e-07, 5.56085131e-07, 4.72746776e-07, 2.86232741e-07,\n", + " 2.83763569e-07, 4.50330590e-07, 4.43099713e-07, 2.94279395e-07,\n", + " 1.94999411e-07, 1.30027981e-07, 7.19276390e-08, 7.09954223e-08]])}], 'sample.x': [{'header': {'systemtime': array([1664380454830796], dtype=uint64), 'createdtimestamp': array([1204630954536], dtype=uint64), 'changedtimestamp': array([1204630954536], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '100 17:54:14.8306', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([1000], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1204630942856, 1204630978696, 1204631014536, 1204631050376,\n", + " 1204631086216, 1204631122056, 1204631157896, 1204631193736,\n", + " 1204631229576, 1204631265416, 1204631301256, 1204631337096,\n", + " 1204631372936, 1204631408776, 1204631444616, 1204631480456,\n", + " 1204631516296, 1204631552136, 1204631587976, 1204631623816,\n", + " 1204631659656, 1204631695496, 1204631731336, 1204631767176,\n", + " 1204631803016, 1204631838856, 1204631874696, 1204631910536,\n", + " 1204631946376, 1204631982216, 1204632018056, 1204632053896,\n", + " 1204632089736, 1204632125576, 1204632161416, 1204632197256,\n", + " 1204632233096, 1204632268936, 1204632304776, 1204632340616,\n", + " 1204632376456, 1204632412296, 1204632448136, 1204632483976,\n", + " 1204632519816, 1204632555656, 1204632591496, 1204632627336,\n", + " 1204632663176, 1204632699016, 1204632734856, 1204632770696,\n", + " 1204632806536, 1204632842376, 1204632878216, 1204632914056,\n", + " 1204632949896, 1204632985736, 1204633021576, 1204633057416,\n", + " 1204633093256, 1204633129096, 1204633164936, 1204633200776,\n", + " 1204633236616, 1204633272456, 1204633308296, 1204633344136,\n", + " 1204633379976, 1204633415816, 1204633451656, 1204633487496,\n", + " 1204633523336, 1204633559176, 1204633595016, 1204633630856,\n", + " 1204633666696, 1204633702536, 1204633738376, 1204633774216,\n", + " 1204633810056, 1204633845896, 1204633881736, 1204633917576,\n", + " 1204633953416, 1204633989256, 1204634025096, 1204634060936,\n", + " 1204634096776, 1204634132616, 1204634168456, 1204634204296,\n", + " 1204634240136, 1204634275976, 1204634311816, 1204634347656,\n", + " 1204634383496, 1204634419336, 1204634455176, 1204634491016,\n", + " 1204634526856, 1204634562696, 1204634598536, 1204634634376,\n", + " 1204634670216, 1204634706056, 1204634741896, 1204634777736,\n", + " 1204634813576, 1204634849416, 1204634885256, 1204634921096,\n", + " 1204634956936, 1204634992776, 1204635028616, 1204635064456,\n", + " 1204635100296, 1204635136136, 1204635171976, 1204635207816,\n", + " 1204635243656, 1204635279496, 1204635315336, 1204635351176,\n", + " 1204635387016, 1204635422856, 1204635458696, 1204635494536,\n", + " 1204635530376, 1204635566216, 1204635602056, 1204635637896,\n", + " 1204635673736, 1204635709576, 1204635745416, 1204635781256,\n", + " 1204635817096, 1204635852936, 1204635888776, 1204635924616,\n", + " 1204635960456, 1204635996296, 1204636032136, 1204636067976,\n", + " 1204636103816, 1204636139656, 1204636175496, 1204636211336,\n", + " 1204636247176, 1204636283016, 1204636318856, 1204636354696,\n", + " 1204636390536, 1204636426376, 1204636462216, 1204636498056,\n", + " 1204636533896, 1204636569736, 1204636605576, 1204636641416,\n", + " 1204636677256, 1204636713096, 1204636748936, 1204636784776,\n", + " 1204636820616, 1204636856456, 1204636892296, 1204636928136,\n", + " 1204636963976, 1204636999816, 1204637035656, 1204637071496,\n", + " 1204637107336, 1204637143176, 1204637179016, 1204637214856,\n", + " 1204637250696, 1204637286536, 1204637322376, 1204637358216,\n", + " 1204637394056, 1204637429896, 1204637465736, 1204637501576,\n", + " 1204637537416, 1204637573256, 1204637609096, 1204637644936,\n", + " 1204637680776, 1204637716616, 1204637752456, 1204637788296,\n", + " 1204637824136, 1204637859976, 1204637895816, 1204637931656,\n", + " 1204637967496, 1204638003336, 1204638039176, 1204638075016,\n", + " 1204638110856, 1204638146696, 1204638182536, 1204638218376,\n", + " 1204638254216, 1204638290056, 1204638325896, 1204638361736,\n", + " 1204638397576, 1204638433416, 1204638469256, 1204638505096,\n", + " 1204638540936, 1204638576776, 1204638612616, 1204638648456,\n", + " 1204638684296, 1204638720136, 1204638755976, 1204638791816,\n", + " 1204638827656, 1204638863496, 1204638899336, 1204638935176,\n", + " 1204638971016, 1204639006856, 1204639042696, 1204639078536,\n", + " 1204639114376, 1204639150216, 1204639186056, 1204639221896,\n", + " 1204639257736, 1204639293576, 1204639329416, 1204639365256,\n", + " 1204639401096, 1204639436936, 1204639472776, 1204639508616,\n", + " 1204639544456, 1204639580296, 1204639616136, 1204639651976,\n", + " 1204639687816, 1204639723656, 1204639759496, 1204639795336,\n", + " 1204639831176, 1204639867016, 1204639902856, 1204639938696,\n", + " 1204639974536, 1204640010376, 1204640046216, 1204640082056,\n", + " 1204640117896, 1204640153736, 1204640189576, 1204640225416,\n", + " 1204640261256, 1204640297096, 1204640332936, 1204640368776,\n", + " 1204640404616, 1204640440456, 1204640476296, 1204640512136,\n", + " 1204640547976, 1204640583816, 1204640619656, 1204640655496,\n", + " 1204640691336, 1204640727176, 1204640763016, 1204640798856,\n", + " 1204640834696, 1204640870536, 1204640906376, 1204640942216,\n", + " 1204640978056, 1204641013896, 1204641049736, 1204641085576,\n", + " 1204641121416, 1204641157256, 1204641193096, 1204641228936,\n", + " 1204641264776, 1204641300616, 1204641336456, 1204641372296,\n", + " 1204641408136, 1204641443976, 1204641479816, 1204641515656,\n", + " 1204641551496, 1204641587336, 1204641623176, 1204641659016,\n", + " 1204641694856, 1204641730696, 1204641766536, 1204641802376,\n", + " 1204641838216, 1204641874056, 1204641909896, 1204641945736,\n", + " 1204641981576, 1204642017416, 1204642053256, 1204642089096,\n", + " 1204642124936, 1204642160776, 1204642196616, 1204642232456,\n", + " 1204642268296, 1204642304136, 1204642339976, 1204642375816,\n", + " 1204642411656, 1204642447496, 1204642483336, 1204642519176,\n", + " 1204642555016, 1204642590856, 1204642626696, 1204642662536,\n", + " 1204642698376, 1204642734216, 1204642770056, 1204642805896,\n", + " 1204642841736, 1204642877576, 1204642913416, 1204642949256,\n", + " 1204642985096, 1204643020936, 1204643056776, 1204643092616,\n", + " 1204643128456, 1204643164296, 1204643200136, 1204643235976,\n", + " 1204643271816, 1204643307656, 1204643343496, 1204643379336,\n", + " 1204643415176, 1204643451016, 1204643486856, 1204643522696,\n", + " 1204643558536, 1204643594376, 1204643630216, 1204643666056,\n", + " 1204643701896, 1204643737736, 1204643773576, 1204643809416,\n", + " 1204643845256, 1204643881096, 1204643916936, 1204643952776,\n", + " 1204643988616, 1204644024456, 1204644060296, 1204644096136,\n", + " 1204644131976, 1204644167816, 1204644203656, 1204644239496,\n", + " 1204644275336, 1204644311176, 1204644347016, 1204644382856,\n", + " 1204644418696, 1204644454536, 1204644490376, 1204644526216,\n", + " 1204644562056, 1204644597896, 1204644633736, 1204644669576,\n", + " 1204644705416, 1204644741256, 1204644777096, 1204644812936,\n", + " 1204644848776, 1204644884616, 1204644920456, 1204644956296,\n", + " 1204644992136, 1204645027976, 1204645063816, 1204645099656,\n", + " 1204645135496, 1204645171336, 1204645207176, 1204645243016,\n", + " 1204645278856, 1204645314696, 1204645350536, 1204645386376,\n", + " 1204645422216, 1204645458056, 1204645493896, 1204645529736,\n", + " 1204645565576, 1204645601416, 1204645637256, 1204645673096,\n", + " 1204645708936, 1204645744776, 1204645780616, 1204645816456,\n", + " 1204645852296, 1204645888136, 1204645923976, 1204645959816,\n", + " 1204645995656, 1204646031496, 1204646067336, 1204646103176,\n", + " 1204646139016, 1204646174856, 1204646210696, 1204646246536,\n", + " 1204646282376, 1204646318216, 1204646354056, 1204646389896,\n", + " 1204646425736, 1204646461576, 1204646497416, 1204646533256,\n", + " 1204646569096, 1204646604936, 1204646640776, 1204646676616,\n", + " 1204646712456, 1204646748296, 1204646784136, 1204646819976,\n", + " 1204646855816, 1204646891656, 1204646927496, 1204646963336,\n", + " 1204646999176, 1204647035016, 1204647070856, 1204647106696,\n", + " 1204647142536, 1204647178376, 1204647214216, 1204647250056,\n", + " 1204647285896, 1204647321736, 1204647357576, 1204647393416,\n", + " 1204647429256, 1204647465096, 1204647500936, 1204647536776,\n", + " 1204647572616, 1204647608456, 1204647644296, 1204647680136,\n", + " 1204647715976, 1204647751816, 1204647787656, 1204647823496,\n", + " 1204647859336, 1204647895176, 1204647931016, 1204647966856,\n", + " 1204648002696, 1204648038536, 1204648074376, 1204648110216,\n", + " 1204648146056, 1204648181896, 1204648217736, 1204648253576,\n", + " 1204648289416, 1204648325256, 1204648361096, 1204648396936,\n", + " 1204648432776, 1204648468616, 1204648504456, 1204648540296,\n", + " 1204648576136, 1204648611976, 1204648647816, 1204648683656,\n", + " 1204648719496, 1204648755336, 1204648791176, 1204648827016,\n", + " 1204648862856, 1204648898696, 1204648934536, 1204648970376,\n", + " 1204649006216, 1204649042056, 1204649077896, 1204649113736,\n", + " 1204649149576, 1204649185416, 1204649221256, 1204649257096,\n", + " 1204649292936, 1204649328776, 1204649364616, 1204649400456,\n", + " 1204649436296, 1204649472136, 1204649507976, 1204649543816,\n", + " 1204649579656, 1204649615496, 1204649651336, 1204649687176,\n", + " 1204649723016, 1204649758856, 1204649794696, 1204649830536,\n", + " 1204649866376, 1204649902216, 1204649938056, 1204649973896,\n", + " 1204650009736, 1204650045576, 1204650081416, 1204650117256,\n", + " 1204650153096, 1204650188936, 1204650224776, 1204650260616,\n", + " 1204650296456, 1204650332296, 1204650368136, 1204650403976,\n", + " 1204650439816, 1204650475656, 1204650511496, 1204650547336,\n", + " 1204650583176, 1204650619016, 1204650654856, 1204650690696,\n", + " 1204650726536, 1204650762376, 1204650798216, 1204650834056,\n", + " 1204650869896, 1204650905736, 1204650941576, 1204650977416,\n", + " 1204651013256, 1204651049096, 1204651084936, 1204651120776,\n", + " 1204651156616, 1204651192456, 1204651228296, 1204651264136,\n", + " 1204651299976, 1204651335816, 1204651371656, 1204651407496,\n", + " 1204651443336, 1204651479176, 1204651515016, 1204651550856,\n", + " 1204651586696, 1204651622536, 1204651658376, 1204651694216,\n", + " 1204651730056, 1204651765896, 1204651801736, 1204651837576,\n", + " 1204651873416, 1204651909256, 1204651945096, 1204651980936,\n", + " 1204652016776, 1204652052616, 1204652088456, 1204652124296,\n", + " 1204652160136, 1204652195976, 1204652231816, 1204652267656,\n", + " 1204652303496, 1204652339336, 1204652375176, 1204652411016,\n", + " 1204652446856, 1204652482696, 1204652518536, 1204652554376,\n", + " 1204652590216, 1204652626056, 1204652661896, 1204652697736,\n", + " 1204652733576, 1204652769416, 1204652805256, 1204652841096,\n", + " 1204652876936, 1204652912776, 1204652948616, 1204652984456,\n", + " 1204653020296, 1204653056136, 1204653091976, 1204653127816,\n", + " 1204653163656, 1204653199496, 1204653235336, 1204653271176,\n", + " 1204653307016, 1204653342856, 1204653378696, 1204653414536,\n", + " 1204653450376, 1204653486216, 1204653522056, 1204653557896,\n", + " 1204653593736, 1204653629576, 1204653665416, 1204653701256,\n", + " 1204653737096, 1204653772936, 1204653808776, 1204653844616,\n", + " 1204653880456, 1204653916296, 1204653952136, 1204653987976,\n", + " 1204654023816, 1204654059656, 1204654095496, 1204654131336,\n", + " 1204654167176, 1204654203016, 1204654238856, 1204654274696,\n", + " 1204654310536, 1204654346376, 1204654382216, 1204654418056,\n", + " 1204654453896, 1204654489736, 1204654525576, 1204654561416,\n", + " 1204654597256, 1204654633096, 1204654668936, 1204654704776,\n", + " 1204654740616, 1204654776456, 1204654812296, 1204654848136,\n", + " 1204654883976, 1204654919816, 1204654955656, 1204654991496,\n", + " 1204655027336, 1204655063176, 1204655099016, 1204655134856,\n", + " 1204655170696, 1204655206536, 1204655242376, 1204655278216,\n", + " 1204655314056, 1204655349896, 1204655385736, 1204655421576,\n", + " 1204655457416, 1204655493256, 1204655529096, 1204655564936,\n", + " 1204655600776, 1204655636616, 1204655672456, 1204655708296,\n", + " 1204655744136, 1204655779976, 1204655815816, 1204655851656,\n", + " 1204655887496, 1204655923336, 1204655959176, 1204655995016,\n", + " 1204656030856, 1204656066696, 1204656102536, 1204656138376,\n", + " 1204656174216, 1204656210056, 1204656245896, 1204656281736,\n", + " 1204656317576, 1204656353416, 1204656389256, 1204656425096,\n", + " 1204656460936, 1204656496776, 1204656532616, 1204656568456,\n", + " 1204656604296, 1204656640136, 1204656675976, 1204656711816,\n", + " 1204656747656, 1204656783496, 1204656819336, 1204656855176,\n", + " 1204656891016, 1204656926856, 1204656962696, 1204656998536,\n", + " 1204657034376, 1204657070216, 1204657106056, 1204657141896,\n", + " 1204657177736, 1204657213576, 1204657249416, 1204657285256,\n", + " 1204657321096, 1204657356936, 1204657392776, 1204657428616,\n", + " 1204657464456, 1204657500296, 1204657536136, 1204657571976,\n", + " 1204657607816, 1204657643656, 1204657679496, 1204657715336,\n", + " 1204657751176, 1204657787016, 1204657822856, 1204657858696,\n", + " 1204657894536, 1204657930376, 1204657966216, 1204658002056,\n", + " 1204658037896, 1204658073736, 1204658109576, 1204658145416,\n", + " 1204658181256, 1204658217096, 1204658252936, 1204658288776,\n", + " 1204658324616, 1204658360456, 1204658396296, 1204658432136,\n", + " 1204658467976, 1204658503816, 1204658539656, 1204658575496,\n", + " 1204658611336, 1204658647176, 1204658683016, 1204658718856,\n", + " 1204658754696, 1204658790536, 1204658826376, 1204658862216,\n", + " 1204658898056, 1204658933896, 1204658969736, 1204659005576,\n", + " 1204659041416, 1204659077256, 1204659113096, 1204659148936,\n", + " 1204659184776, 1204659220616, 1204659256456, 1204659292296,\n", + " 1204659328136, 1204659363976, 1204659399816, 1204659435656,\n", + " 1204659471496, 1204659507336, 1204659543176, 1204659579016,\n", + " 1204659614856, 1204659650696, 1204659686536, 1204659722376,\n", + " 1204659758216, 1204659794056, 1204659829896, 1204659865736,\n", + " 1204659901576, 1204659937416, 1204659973256, 1204660009096,\n", + " 1204660044936, 1204660080776, 1204660116616, 1204660152456,\n", + " 1204660188296, 1204660224136, 1204660259976, 1204660295816,\n", + " 1204660331656, 1204660367496, 1204660403336, 1204660439176,\n", + " 1204660475016, 1204660510856, 1204660546696, 1204660582536,\n", + " 1204660618376, 1204660654216, 1204660690056, 1204660725896,\n", + " 1204660761736, 1204660797576, 1204660833416, 1204660869256,\n", + " 1204660905096, 1204660940936, 1204660976776, 1204661012616,\n", + " 1204661048456, 1204661084296, 1204661120136, 1204661155976,\n", + " 1204661191816, 1204661227656, 1204661263496, 1204661299336,\n", + " 1204661335176, 1204661371016, 1204661406856, 1204661442696,\n", + " 1204661478536, 1204661514376, 1204661550216, 1204661586056,\n", + " 1204661621896, 1204661657736, 1204661693576, 1204661729416,\n", + " 1204661765256, 1204661801096, 1204661836936, 1204661872776,\n", + " 1204661908616, 1204661944456, 1204661980296, 1204662016136,\n", + " 1204662051976, 1204662087816, 1204662123656, 1204662159496,\n", + " 1204662195336, 1204662231176, 1204662267016, 1204662302856,\n", + " 1204662338696, 1204662374536, 1204662410376, 1204662446216,\n", + " 1204662482056, 1204662517896, 1204662553736, 1204662589576,\n", + " 1204662625416, 1204662661256, 1204662697096, 1204662732936,\n", + " 1204662768776, 1204662804616, 1204662840456, 1204662876296,\n", + " 1204662912136, 1204662947976, 1204662983816, 1204663019656,\n", + " 1204663055496, 1204663091336, 1204663127176, 1204663163016,\n", + " 1204663198856, 1204663234696, 1204663270536, 1204663306376,\n", + " 1204663342216, 1204663378056, 1204663413896, 1204663449736,\n", + " 1204663485576, 1204663521416, 1204663557256, 1204663593096,\n", + " 1204663628936, 1204663664776, 1204663700616, 1204663736456,\n", + " 1204663772296, 1204663808136, 1204663843976, 1204663879816,\n", + " 1204663915656, 1204663951496, 1204663987336, 1204664023176,\n", + " 1204664059016, 1204664094856, 1204664130696, 1204664166536,\n", + " 1204664202376, 1204664238216, 1204664274056, 1204664309896,\n", + " 1204664345736, 1204664381576, 1204664417416, 1204664453256,\n", + " 1204664489096, 1204664524936, 1204664560776, 1204664596616,\n", + " 1204664632456, 1204664668296, 1204664704136, 1204664739976,\n", + " 1204664775816, 1204664811656, 1204664847496, 1204664883336,\n", + " 1204664919176, 1204664955016, 1204664990856, 1204665026696,\n", + " 1204665062536, 1204665098376, 1204665134216, 1204665170056,\n", + " 1204665205896, 1204665241736, 1204665277576, 1204665313416,\n", + " 1204665349256, 1204665385096, 1204665420936, 1204665456776,\n", + " 1204665492616, 1204665528456, 1204665564296, 1204665600136,\n", + " 1204665635976, 1204665671816, 1204665707656, 1204665743496,\n", + " 1204665779336, 1204665815176, 1204665851016, 1204665886856,\n", + " 1204665922696, 1204665958536, 1204665994376, 1204666030216,\n", + " 1204666066056, 1204666101896, 1204666137736, 1204666173576,\n", + " 1204666209416, 1204666245256, 1204666281096, 1204666316936,\n", + " 1204666352776, 1204666388616, 1204666424456, 1204666460296,\n", + " 1204666496136, 1204666531976, 1204666567816, 1204666603656,\n", + " 1204666639496, 1204666675336, 1204666711176, 1204666747016]],\n", + " dtype=uint64), 'value': array([[ 3.92985139e-07, 3.83420582e-07, 2.70894730e-07,\n", + " 1.59362046e-07, 5.19425521e-09, -1.48426426e-07,\n", + " -1.43519777e-07, 8.15211657e-08, 2.37241792e-07,\n", + " 1.43174769e-07, 1.06832322e-07, 3.03419964e-07,\n", + " 3.53603991e-07, 2.79436221e-07, 2.91986862e-07,\n", + " 3.61741877e-07, 3.62849251e-07, 4.00763667e-07,\n", + " 4.44543818e-07, 2.68402540e-07, 4.07432428e-09,\n", + " -3.04182928e-07, -5.46997467e-07, -7.22909138e-07,\n", + " -8.42683151e-07, -9.57424350e-07, -8.91693433e-07,\n", + " -5.90276549e-07, -3.09874066e-07, 3.15099414e-08,\n", + " 1.17763757e-07, -2.48585203e-08, -5.14343080e-08,\n", + " -7.95461888e-08, 1.09972075e-08, 2.60788444e-07,\n", + " 5.95013983e-07, 7.90452394e-07, 7.46151442e-07,\n", + " 6.50482553e-07, 5.95991605e-07, 5.00587601e-07,\n", + " 3.03236996e-07, 9.30959778e-08, 2.06233517e-08,\n", + " 3.14812406e-09, 4.27014776e-08, 1.62276378e-07,\n", + " 3.45086417e-07, 2.49326044e-07, 8.88291187e-08,\n", + " 7.91114905e-08, 1.02013570e-07, -1.65233163e-08,\n", + " -1.17815179e-07, -2.93111576e-07, -3.76068382e-07,\n", + " -2.22642030e-07, -8.62448467e-08, 2.06532484e-08,\n", + " 7.47423847e-08, 2.17917751e-07, 2.91384742e-07,\n", + " 2.34781890e-07, 8.57551385e-08, -3.07021322e-08,\n", + " -6.35412815e-08, -4.95621757e-08, -8.56349537e-08,\n", + " -1.45087561e-07, -1.32979989e-07, -2.56436081e-08,\n", + " 3.83718354e-08, -2.08320308e-09, -1.47861378e-07,\n", + " -2.48321514e-07, -2.27038641e-07, -2.11037919e-07,\n", + " -3.84853233e-07, -5.05484683e-07, -5.41471956e-07,\n", + " -5.06235688e-07, -4.06738226e-07, -1.02136146e-07,\n", + " 1.07573163e-07, 9.34738723e-08, -4.02792458e-08,\n", + " -3.98182384e-08, -7.42580579e-08, -8.18560090e-08,\n", + " -5.80349046e-08, 4.76930331e-08, 2.96791264e-07,\n", + " 5.32980691e-07, 5.86162761e-07, 5.87198982e-07,\n", + " 6.17966886e-07, 6.79197152e-07, 5.80585828e-07,\n", + " 2.82879127e-07, 2.60759146e-08, -2.61981323e-07,\n", + " -3.43245975e-07, -3.49784985e-07, -2.03524277e-07,\n", + " -4.41544579e-08, 4.10816736e-08, 1.58254074e-07,\n", + " 1.88760681e-07, 1.04991881e-07, -5.24316624e-08,\n", + " -7.14860345e-08, -7.36427835e-08, -6.57321128e-08,\n", + " 4.97774320e-08, 1.71477989e-07, 4.10129111e-07,\n", + " 6.08990697e-07, 7.57704131e-07, 8.73352994e-07,\n", + " 9.14463967e-07, 8.71196843e-07, 7.13427694e-07,\n", + " 4.95935074e-07, 2.12877165e-07, 8.20102760e-08,\n", + " 8.16299898e-08, -8.94497745e-08, -2.09379848e-07,\n", + " -3.49057897e-07, -3.64097140e-07, -2.65484620e-07,\n", + " -1.38712385e-07, -6.69226000e-08, -6.93950583e-08,\n", + " -2.61780417e-07, -5.49814934e-07, -7.53205273e-07,\n", + " -7.45047656e-07, -7.28842440e-07, -6.66364884e-07,\n", + " -6.38251807e-07, -6.08288124e-07, -5.06938859e-07,\n", + " -3.70191884e-07, -4.39671251e-07, -5.18713381e-07,\n", + " -5.92985192e-07, -5.58427579e-07, -4.05719346e-07,\n", + " -2.36963154e-07, -1.26458320e-07, 8.08335413e-08,\n", + " 1.01863488e-07, -2.76203788e-08, -3.17000845e-08,\n", + " 9.74459498e-08, 1.39901676e-07, 7.68734225e-08,\n", + " -1.09082349e-07, -2.89064159e-07, -4.68825929e-07,\n", + " -5.44368350e-07, -4.44860723e-07, -2.66156100e-07,\n", + " -1.47009919e-07, -7.06746377e-08, -8.82742357e-08,\n", + " -1.26150981e-07, -2.56645358e-08, 1.22603437e-07,\n", + " 2.88491936e-07, 4.83080683e-07, 4.14143642e-07,\n", + " 2.74622850e-07, 2.43333546e-07, 2.92212881e-07,\n", + " 1.99867311e-07, -2.50217564e-08, -1.10268651e-07,\n", + " -3.72949557e-08, 6.92772652e-08, 1.26283125e-07,\n", + " 2.10329367e-07, 2.62502722e-07, 3.08120923e-07,\n", + " 3.12027826e-07, 1.65437058e-07, -6.38055685e-09,\n", + " -1.33220957e-07, -8.91950545e-08, 6.40501236e-08,\n", + " 1.19388943e-07, 1.93055643e-07, 3.50974276e-07,\n", + " 3.97211937e-07, 3.25983014e-07, 2.73461064e-07,\n", + " 1.98727648e-07, 1.55330175e-07, 1.90476753e-07,\n", + " 2.61940664e-07, 2.00896954e-07, 4.53180381e-08,\n", + " -1.97603532e-07, -2.75219588e-07, -2.36965546e-07,\n", + " -1.80616218e-07, -1.54334614e-07, -7.63107663e-08,\n", + " 1.61057788e-07, 2.74578005e-07, 1.63907542e-07,\n", + " -6.21654347e-08, -2.49956267e-07, -2.91821234e-07,\n", + " -3.75682715e-07, -4.41552352e-07, -4.87636344e-07,\n", + " -3.21807041e-07, -1.66438000e-07, -1.28596533e-07,\n", + " -1.44966778e-07, -1.12107299e-07, -2.19878378e-08,\n", + " 1.79218846e-08, -1.00522322e-07, -2.46749545e-07,\n", + " -2.60108593e-07, -2.75065919e-07, -2.58524067e-07,\n", + " -3.81742181e-07, -3.48997505e-07, -2.08807026e-07,\n", + " -1.16515868e-07, -1.05323136e-07, -2.41726897e-08,\n", + " 4.29286926e-08, 5.61681538e-08, 3.76722522e-08,\n", + " 1.38363789e-07, 2.03251619e-07, 2.58051101e-07,\n", + " 1.92023609e-07, 1.52896582e-07, 1.02029714e-07,\n", + " 4.03647504e-08, 5.41549090e-08, -5.61274942e-08,\n", + " -1.70893209e-07, -1.95489236e-07, -1.79434102e-07,\n", + " -1.90418753e-07, -3.48402561e-07, -3.33618635e-07,\n", + " -3.26589917e-07, -4.11926502e-07, -5.46374420e-07,\n", + " -6.52977135e-07, -6.32305351e-07, -4.91076260e-07,\n", + " -4.62341930e-07, -5.53354107e-07, -6.67683329e-07,\n", + " -6.31887993e-07, -4.50556645e-07, -2.71762332e-07,\n", + " -1.42126590e-07, 1.25963230e-07, 3.40132531e-07,\n", + " 4.29167339e-07, 4.55697086e-07, 4.59132817e-07,\n", + " 5.23494464e-07, 6.45093969e-07, 6.82350657e-07,\n", + " 5.68289907e-07, 4.45257751e-07, 2.59265506e-07,\n", + " 2.07892785e-07, 7.75227791e-08, 2.10114111e-09,\n", + " -2.04415797e-08, -1.55623761e-07, -1.85535424e-07,\n", + " -1.49825592e-07, -8.89923548e-08, 4.57419735e-09,\n", + " 5.10922895e-08, 1.40718455e-07, 1.43216026e-07,\n", + " 5.61567930e-08, 1.79643379e-08, 3.86223698e-08,\n", + " 1.53206312e-07, 1.79312124e-07, 7.49385071e-08,\n", + " -2.79522324e-08, -9.90639600e-08, -2.59066394e-07,\n", + " -3.46135792e-07, -1.63205568e-07, 1.90346403e-08,\n", + " -4.05100484e-09, -9.41662802e-08, -1.47081073e-07,\n", + " -6.07148461e-08, -3.67191450e-09, -6.38641661e-08,\n", + " -1.07170155e-07, -1.40608435e-07, -8.53814296e-08,\n", + " 9.04961595e-08, 2.52720517e-07, 2.35757719e-07,\n", + " 2.67364526e-07, 3.95856420e-07, 4.95924909e-07,\n", + " 4.23995806e-07, 1.04117103e-07, -2.16378668e-07,\n", + " -3.11306119e-07, -2.60955268e-07, -7.30400657e-08,\n", + " 2.12508838e-07, 3.22259079e-07, 4.08452504e-07,\n", + " 4.70284889e-07, 5.51629066e-07, 4.34274894e-07,\n", + " 2.41514032e-07, 6.07967631e-08, -1.20032320e-07,\n", + " -1.90575412e-07, -2.92648177e-07, -3.14663520e-07,\n", + " -3.62121565e-07, -3.63577535e-07, -3.71738142e-07,\n", + " -2.93161205e-07, -2.25049314e-07, -1.51070491e-07,\n", + " 7.38030299e-09, 6.07818148e-08, -4.18972560e-08,\n", + " -1.33020649e-07, -1.94261677e-07, -8.04209666e-08,\n", + " -8.10990241e-08, -1.87267041e-07, -2.94979523e-07,\n", + " -3.96578127e-07, -5.46681160e-07, -5.69697445e-07,\n", + " -5.55555103e-07, -4.79262275e-07, -3.06220090e-07,\n", + " -1.15504163e-07, 2.28751723e-07, 4.22506351e-07,\n", + " 2.75850409e-07, 7.17802182e-08, -1.52670563e-07,\n", + " -2.67373495e-07, -3.23360474e-07, -4.74308389e-07,\n", + " -4.85272710e-07, -2.15499705e-07, 2.99624875e-09,\n", + " 9.53585612e-09, -1.37725196e-07, -1.88432415e-07,\n", + " -2.43055507e-07, -2.71423304e-07, -1.12316576e-07,\n", + " -5.20812729e-08, -2.77504893e-07, -3.56383787e-07,\n", + " -3.37075293e-07, -3.63530896e-07, -2.98915127e-07,\n", + " -2.23851651e-07, -1.60337875e-07, -1.63355649e-07,\n", + " -1.03609456e-07, -1.25081875e-08, 1.97007989e-07,\n", + " 3.81623192e-07, 4.15189429e-07, 2.83439989e-07,\n", + " 3.52171340e-08, -5.29291437e-09, 2.70027127e-08,\n", + " 8.30094242e-08, 2.37340451e-07, 3.69867804e-07,\n", + " 3.11326449e-07, 2.07639261e-07, 1.38845724e-07,\n", + " 3.49929087e-08, 2.85627233e-08, 1.99058306e-07,\n", + " 3.25536357e-07, 4.24391040e-07, 5.15305754e-07,\n", + " 5.54799314e-07, 6.02066618e-07, 5.56236150e-07,\n", + " 5.88164047e-07, 5.98419816e-07, 5.44714554e-07,\n", + " 4.76758126e-07, 5.39173497e-07, 5.82523733e-07,\n", + " 5.20635740e-07, 4.53664707e-07, 3.73594130e-07,\n", + " 9.79225034e-08, -1.64556301e-07, -6.45308628e-08,\n", + " -2.53225173e-09, -7.11942426e-08, -6.92868322e-08,\n", + " -1.83482117e-08, -5.87386733e-08, -3.65385688e-08,\n", + " 1.03064140e-07, 2.30992781e-07, 2.62640247e-07,\n", + " 7.88806879e-08, -1.76595708e-07, -1.84531492e-07,\n", + " 1.14630581e-07, 4.46794442e-07, 6.63414078e-07,\n", + " 7.22672357e-07, 6.75053467e-07, 5.45177355e-07,\n", + " 3.61184602e-07, 1.39103434e-07, -8.15002380e-08,\n", + " -3.84913624e-07, -6.68408026e-07, -6.90710377e-07,\n", + " -6.50547728e-07, -5.83720200e-07, -5.99011771e-07,\n", + " -6.59074271e-07, -6.13119433e-07, -5.01846851e-07,\n", + " -3.28521843e-07, -3.56619972e-08, 4.30500733e-08,\n", + " -4.95508149e-09, 5.33895531e-08, 1.68351988e-07,\n", + " 1.90788874e-07, 3.30179317e-08, -2.65245447e-07,\n", + " -4.54763113e-07, -5.42195457e-07, -5.84733100e-07,\n", + " -6.18889499e-07, -6.64385124e-07, -6.42400873e-07,\n", + " -5.23666071e-07, -4.33743928e-07, -3.57675923e-07,\n", + " -2.17862143e-07, -5.70602717e-08, 2.77303987e-08,\n", + " 1.37077035e-07, 1.36061144e-07, 2.01107427e-07,\n", + " 2.33071798e-07, 2.38902255e-07, 1.93699021e-07,\n", + " 1.33213781e-07, -2.10454933e-08, -4.07932301e-07,\n", + " -6.97150727e-07, -6.85435400e-07, -4.98341760e-07,\n", + " -3.69193334e-07, -2.30489918e-07, -1.65074112e-07,\n", + " -1.73244286e-07, -3.12409308e-07, -4.17552466e-07,\n", + " -2.76978711e-07, -1.01703840e-07, 4.00203402e-08,\n", + " 7.96801261e-08, 5.91327120e-08, -5.31025446e-09,\n", + " -3.70498026e-08, -1.22080245e-08, -1.04164937e-07,\n", + " -1.12687893e-07, 2.26682870e-08, 7.39250085e-08,\n", + " 3.86630294e-08, -1.57473769e-07, -2.77513264e-07,\n", + " -2.34415954e-07, -9.34774599e-08, 1.13495702e-07,\n", + " 2.30309940e-07, 2.77524625e-07, 2.54816277e-07,\n", + " 1.46039472e-07, 1.39078919e-07, 1.50235177e-07,\n", + " 6.14425322e-08, -6.96551597e-08, -4.93481152e-08,\n", + " -3.38221533e-08, -1.24280643e-08, -1.38384119e-07,\n", + " -1.30164914e-07, -9.61938754e-08, -1.49727531e-07,\n", + " -1.22355295e-07, -7.24708323e-08, -1.90739246e-07,\n", + " -3.05289704e-07, -4.30052282e-07, -2.88965500e-07,\n", + " -1.99357871e-07, -2.45945323e-07, -2.01812391e-07,\n", + " -1.75720332e-07, -2.87410273e-07, -3.58312126e-07,\n", + " -3.25443080e-07, -9.20071395e-08, 1.06721107e-07,\n", + " 2.36255798e-07, 3.48033635e-07, 3.71790162e-07,\n", + " 2.44360200e-07, -3.30041792e-08, -1.65477718e-07,\n", + " -2.09568795e-07, -1.90201105e-07, -2.05444244e-07,\n", + " -2.42772684e-07, -2.99709183e-07, -4.29494409e-07,\n", + " -4.59779183e-07, -4.38130374e-07, -3.70995508e-07,\n", + " -2.59954326e-07, -2.12623043e-07, -1.96560136e-07,\n", + " -9.51660263e-08, -8.87185008e-08, -1.39274443e-07,\n", + " -9.18026459e-08, -1.22325398e-07, -7.09897490e-08,\n", + " -1.93013190e-09, 8.98390297e-08, 2.15450674e-07,\n", + " 1.84958417e-07, 1.07249680e-07, 1.05097715e-07,\n", + " 1.84560193e-07, 1.00563579e-07, 6.71581861e-08,\n", + " 1.28528368e-07, 7.91252430e-08, -1.03254284e-07,\n", + " -3.00204273e-07, -4.21055763e-07, -4.41529033e-07,\n", + " -3.30959621e-07, -2.49891092e-07, -4.16851089e-07,\n", + " -5.84338464e-07, -5.04995573e-07, -2.83871100e-07,\n", + " -1.08966350e-07, 7.49971047e-08, 2.59871811e-07,\n", + " 2.35015085e-07, 5.78046999e-08, 1.89616923e-08,\n", + " 5.20639328e-08, 2.52515425e-07, 5.02891442e-07,\n", + " 5.86196246e-07, 4.50872952e-07, 3.32533982e-07,\n", + " 3.62297358e-07, 4.60746043e-07, 4.70768618e-07,\n", + " 4.65780650e-07, 3.85436219e-07, 3.07193527e-07,\n", + " 1.69756536e-07, -1.12962943e-07, -3.10589196e-07,\n", + " -4.24860419e-07, -4.91873905e-07, -4.46859617e-07,\n", + " -2.48426153e-07, -1.17500068e-08, 8.72451907e-08,\n", + " 8.76894559e-08, 1.03219005e-07, 2.25426610e-07,\n", + " 2.74669489e-07, 1.74889802e-07, 9.11700314e-08,\n", + " 1.26579700e-07, 2.19670895e-07, 2.72036784e-07,\n", + " 1.76660285e-07, 4.93636615e-08, 7.17258061e-08,\n", + " 4.75489309e-08, -1.28243154e-07, -3.22162214e-07,\n", + " -3.43309954e-07, -1.01288276e-07, 6.92969970e-08,\n", + " 9.49148939e-08, 2.00153721e-07, 3.68585833e-07,\n", + " 3.84339607e-07, 3.28500915e-07, 2.73623702e-07,\n", + " 1.64186180e-07, 7.31961266e-08, 6.60735333e-08,\n", + " 9.36717885e-08, 1.02275465e-07, -2.02699726e-10,\n", + " -1.48580095e-07, -2.13070896e-07, -4.68278819e-07,\n", + " -5.81437287e-07, -5.20804358e-07, -5.67430676e-07,\n", + " -6.15038802e-07, -5.96161419e-07, -3.53384549e-07,\n", + " -2.65704062e-07, -1.59498375e-07, -3.02076405e-09,\n", + " 1.15199217e-07, 2.82614242e-07, 1.88842598e-07,\n", + " 6.59521526e-09, -4.59996832e-08, -4.59883224e-08,\n", + " 4.34303595e-08, 1.69507795e-07, 3.57003247e-07,\n", + " 5.25516080e-07, 6.08550019e-07, 4.93009382e-07,\n", + " 4.03527319e-07, 3.93266169e-07, 3.88992134e-07,\n", + " 3.42486599e-07, 2.64011310e-07, 3.28545761e-07,\n", + " 4.39363913e-07, 4.25984535e-07, 3.74664433e-07,\n", + " 2.42144853e-07, 7.68674431e-08, 3.01484450e-08,\n", + " -9.57824966e-08, -1.44516533e-07, 3.92926542e-08,\n", + " 3.85308859e-07, 5.05405158e-07, 2.73567496e-07,\n", + " -1.47725647e-07, -3.63148218e-07, -2.02561005e-07,\n", + " -8.18243184e-08, -1.13539351e-07, -2.34597128e-07,\n", + " -2.11553339e-07, -5.91261347e-08, 5.44197939e-08,\n", + " -6.64006033e-08, -2.31789229e-07, -3.09711428e-07,\n", + " -2.70477970e-07, -2.18363810e-07, -2.43894409e-07,\n", + " -2.57952442e-07, -1.65912416e-07, 8.97977722e-08,\n", + " 2.25512115e-07, 2.48212092e-07, 1.24256726e-07,\n", + " 4.20180387e-08, 5.78292152e-08, 5.49848418e-08,\n", + " -1.33292709e-07, -2.81195344e-07, -2.61471883e-07,\n", + " -9.86579626e-08, 1.99112120e-09, -6.98746016e-09,\n", + " 2.15441705e-08, 3.71580288e-08, -1.20388091e-07,\n", + " -4.02575408e-07, -5.37950123e-07, -5.66455445e-07,\n", + " -4.17524363e-07, -8.54322540e-08, 8.19755958e-08,\n", + " 1.78326728e-07, 2.05387440e-07, 1.44143422e-07,\n", + " 1.79644575e-07, 1.47876326e-07, 4.88093764e-08,\n", + " -8.83184828e-08, 2.13462543e-10, 2.12627229e-07,\n", + " 2.80647038e-07, 1.25450800e-07, -5.96834095e-08,\n", + " -3.59005729e-07, -6.50030515e-07, -6.45321185e-07,\n", + " -3.91315707e-07, -9.13422365e-08, 4.67758019e-08,\n", + " -1.67632673e-07, -3.60025805e-07, -3.91212264e-07,\n", + " -3.39129198e-07, -2.34033276e-07, -1.98976389e-07,\n", + " 9.53663343e-08, 3.86565119e-07, 6.78102334e-07,\n", + " 7.94773067e-07, 6.75312971e-07, 5.18205137e-07,\n", + " 3.61853690e-07, 3.49845376e-07, 4.18397945e-07,\n", + " 4.49034902e-07, 5.09952448e-07, 3.28503307e-07,\n", + " 7.95724979e-08, -5.88815796e-08, -2.76963165e-09,\n", + " 2.11172455e-08, -8.00992780e-09, -1.54857807e-07,\n", + " -2.87621344e-07, -3.06567490e-07, -3.45380601e-07,\n", + " -3.47566648e-07, -4.19708617e-07, -4.64905274e-07,\n", + " -5.27758333e-07, -5.50948617e-07, -6.16901368e-07,\n", + " -6.01836413e-07, -3.79309784e-07, -1.16091335e-07,\n", + " 8.04855436e-08, 2.60922382e-07, 3.05965968e-07,\n", + " 1.51118326e-07, 1.70321584e-07, 1.11500993e-07,\n", + " 4.55560159e-08, 2.46934905e-08, 1.16256365e-08,\n", + " 7.68345568e-09, 4.35810389e-08, 6.55874127e-08,\n", + " 6.65997154e-08, 7.96059822e-08, 1.25218802e-07,\n", + " 1.69880308e-07, 2.97179323e-07, 3.40381870e-07,\n", + " 3.24701043e-07, 2.83566153e-07, 1.47797399e-07,\n", + " 1.72691197e-07, 2.29566707e-07, 1.78815838e-07,\n", + " 2.06524113e-07, 2.74380089e-07, 1.67206346e-07,\n", + " 2.06466712e-08, -1.03414530e-07, -7.01406823e-08,\n", + " 3.54150503e-08, 5.66315528e-08, 1.05236436e-10,\n", + " -4.27116425e-08, -3.81930530e-08, 1.01061658e-07,\n", + " 2.33339673e-07, 3.38343512e-07, 3.08279376e-07,\n", + " 2.23005574e-07, 1.46063987e-07, 7.48111471e-08,\n", + " 1.67899950e-08, 1.64683063e-08, 6.33337983e-08,\n", + " 2.63583787e-07, 3.62437274e-07, 3.46500532e-07,\n", + " 4.43665452e-07, 5.54326946e-07, 6.36912435e-07,\n", + " 5.88680663e-07, 4.56565287e-07, 3.25703779e-07,\n", + " 1.71597575e-07, -2.70140735e-08, -1.29319435e-07,\n", + " -1.24364354e-07, -1.00961206e-07, -1.60780944e-07,\n", + " -1.77396342e-07, -1.33214379e-07, -3.57684295e-09,\n", + " 6.09462467e-08, 6.19531681e-08, -1.58237332e-08,\n", + " -1.52174278e-09, 8.21759038e-08, 1.54579767e-07,\n", + " 1.52723779e-07, 9.63068850e-08, -2.47652426e-08,\n", + " -2.51300423e-07, -4.81848938e-07, -5.06587274e-07,\n", + " -4.40668008e-07, -3.73317885e-07, -2.15470406e-07,\n", + " 4.91711267e-08, 1.11269593e-07, -4.26937044e-08,\n", + " -1.86128575e-07, -2.14070642e-07, -1.47656884e-07,\n", + " -8.93218165e-08, -9.35886757e-09, 1.35206696e-07,\n", + " 2.87461097e-07, 3.51993156e-07, 2.32537245e-07,\n", + " 1.60774965e-07, 2.04713568e-07, 3.08541869e-07,\n", + " 2.90892642e-07, 2.93433863e-07, 2.42301512e-07,\n", + " 1.02518824e-07, 6.95122534e-08, 1.91951857e-07,\n", + " 1.29419888e-07, -7.00438170e-08, -1.35923620e-07,\n", + " -1.42971471e-07, -1.42289228e-07, -4.13615068e-08,\n", + " 5.64115130e-08, 1.29904813e-07, 2.10795756e-07,\n", + " 1.88795362e-07, 1.14082276e-07, 2.61978931e-08,\n", + " -2.28488632e-08, -1.12846345e-07, -2.38474732e-07,\n", + " -2.81456641e-07, -2.74899096e-07, -9.95267611e-08,\n", + " 1.31155691e-07, 3.42233074e-07, 5.11480170e-07,\n", + " 6.33651899e-07, 6.29492668e-07, 5.71221579e-07,\n", + " 4.80191464e-07, 2.60756754e-07, -8.36031730e-09,\n", + " -1.07722049e-07, -1.67486179e-07, -2.31938713e-07,\n", + " -3.18197312e-07, -3.20214144e-07, -2.18911518e-07,\n", + " -1.07631163e-07, 4.35535340e-09, 9.73634349e-08,\n", + " 9.48682551e-09, -2.62690473e-08, -7.19613923e-08,\n", + " -2.08782511e-07, -2.02599871e-07, -2.28978340e-07,\n", + " -3.80279634e-07, -3.92481081e-07, -2.32316607e-07,\n", + " -2.01331054e-07, -3.21509270e-07, -4.52587230e-07,\n", + " -3.64860104e-07, -1.95073672e-07, -4.32581544e-08,\n", + " 3.76268092e-08, -7.76459536e-08, -1.42308362e-07,\n", + " -4.10481893e-09, 2.16926974e-07, 1.53687649e-07,\n", + " 1.06774921e-07, 6.36459200e-08, 5.98998617e-08,\n", + " -1.60623089e-08, 8.54603569e-08, 1.16995412e-07,\n", + " 1.21679031e-07, 1.92005671e-07, 2.41701784e-07,\n", + " 6.02873231e-08, -2.91312990e-07, -4.71218862e-07,\n", + " -3.52183897e-07, -2.15410015e-07, -1.35076347e-07,\n", + " -8.62358777e-08, -5.95530598e-08, -3.03487530e-08,\n", + " 8.98456070e-09, -3.20104124e-08, -9.66178108e-08,\n", + " -3.88782259e-07, -6.41902196e-07, -6.68480376e-07,\n", + " -5.54219916e-07, -4.27331681e-07, -2.97937504e-07,\n", + " -2.48852480e-07, -1.43612457e-07, 8.00119796e-08,\n", + " 2.20572580e-07, 1.43064749e-07, 3.75084183e-08,\n", + " -1.07341164e-07, -1.40729815e-07, -1.94001575e-07,\n", + " -1.92580884e-07, -9.88289718e-08, -1.16050675e-07,\n", + " -1.86615891e-07, -1.86427542e-07, -4.54729030e-08,\n", + " 7.93171799e-08, 2.37748242e-07, 3.21543352e-07,\n", + " 4.72589328e-07, 7.19963714e-07, 8.07619686e-07,\n", + " 7.82908257e-07, 5.77874794e-07, 1.71552132e-07,\n", + " -2.18546778e-07, -4.07964589e-07, -3.67413283e-07,\n", + " -3.21461435e-07, -2.51965924e-07, -2.42406748e-07,\n", + " -3.32600951e-07, -4.32792615e-07, -4.44281922e-07,\n", + " -3.81532306e-07, -2.55676704e-07, -2.79632344e-07,\n", + " -3.65262514e-07, -2.75049775e-07, -1.84903407e-07,\n", + " -1.84206814e-07, -1.25358121e-07, -7.17850016e-08,\n", + " -6.69752182e-08]])}]}}}, 'triggered': array([0], dtype=int64)}\n", + "Progress [1.] %\n" + ] + } + ], + "source": [ + "my_lockin.daq.set('device', 'dev3442')\n", + "# my_lockin.daq.set('save/directory', 'C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer')\n", + "my_lockin.daq.set('type', 1)\n", + "my_lockin.daq.set('triggernode', '/dev3442/demods/0/sample.AuxIn0')\n", + "my_lockin.daq.set('endless', 0)\n", + "my_lockin.daq.set('grid/cols', 1000)\n", + "# my_lockin.daq.subscribe('/dev3442/demods/0/sample.R.avg')\n", + "my_lockin.daq.subscribe('/dev3442/demods/0/sample.R')\n", + "my_lockin.daq.subscribe('/dev3442/demods/0/sample.X')\n", + "my_lockin.daq.execute()\n", + "my_lockin.daq.set('forcetrigger', 1)\n", + "result = 0\n", + "while not my_lockin.daq.finished():\n", + " time.sleep(1)\n", + " result = my_lockin.daq.read()\n", + " print(result)\n", + " print(f\"Progress {my_lockin.daq.progress()} %\\r\")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c0e526ba", + "metadata": {}, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "Timeout during set in dataAcquisitionModule module.", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_12728\\3516131054.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mwhile\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mmy_lockin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfinished\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmy_lockin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Progress {my_lockin.daq.progress()} %\\r\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mRuntimeError\u001b[0m: Timeout during set in dataAcquisitionModule module." + ] + } + ], + "source": [ + "while not my_lockin.daq.finished():\n", + " time.sleep(1)\n", + " result = my_lockin.daq.read()\n", + " print(result)\n", + " print(f\"Progress {my_lockin.daq.progress()} %\\r\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ae560ada", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "1f6a003a", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.finish()\n", + "my_lockin.daq.unsubscribe('*')" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "c8c91ef7", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.clear()" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "0e75a1ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(270)\u001b[0;36marm_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 268 \u001b[1;33m \u001b[0mdemod\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_get_demod\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 269 \u001b[1;33m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 270 \u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mapi_session\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'/{self.serial}/{demod}/enable'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 271 \u001b[1;33m \u001b[1;32mexcept\u001b[0m \u001b[0mRuntimeError\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 272 \u001b[1;33m \u001b[1;32mraise\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> self.api_session.setInt('/dev3442/demods/0/enable', 0)\n", + "ipdb> r\n" + ] + } + ], + "source": [ + "%debug" + ] }, { "cell_type": "code", "execution_count": null, - "id": "a06c534e", + "id": "dfe07e28", "metadata": {}, "outputs": [], "source": [] @@ -512,7 +2992,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c8c9523b", + "id": "c69299c6", "metadata": {}, "outputs": [], "source": [] @@ -520,7 +3000,7 @@ { "cell_type": "code", "execution_count": null, - "id": "baddb8d5", + "id": "1e70db16", "metadata": {}, "outputs": [], "source": [] @@ -528,7 +3008,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e551db46", + "id": "63957cc1", "metadata": {}, "outputs": [], "source": [] @@ -536,7 +3016,7 @@ { "cell_type": "code", "execution_count": null, - "id": "86907e32", + "id": "a67d911a", "metadata": {}, "outputs": [], "source": [] diff --git a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb index 3b43fd72f..395866d67 100644 --- a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb +++ b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "14133f44", + "id": "fceb835c", "metadata": {}, "source": [ "# Zurich Instruments Lock-In MFLI Data Aquesition" @@ -11,7 +11,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "0a0fdc55", + "id": "55c55e0a", "metadata": {}, "outputs": [], "source": [ @@ -22,7 +22,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "5a98e00c", + "id": "708ad356", "metadata": {}, "outputs": [], "source": [ @@ -31,8 +31,18 @@ }, { "cell_type": "code", - "execution_count": 25, - "id": "03a8c5ae", + "execution_count": 3, + "id": "e69e0618", + "metadata": {}, + "outputs": [], + "source": [ + "import time" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f7cb2ae3", "metadata": {}, "outputs": [], "source": [ @@ -41,8 +51,8 @@ }, { "cell_type": "code", - "execution_count": 3, - "id": "575d35da", + "execution_count": 5, + "id": "12279c39", "metadata": {}, "outputs": [], "source": [ @@ -51,8 +61,8 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "84863030", + "execution_count": 6, + "id": "9eef13eb", "metadata": {}, "outputs": [], "source": [ @@ -61,8 +71,8 @@ }, { "cell_type": "code", - "execution_count": 4, - "id": "5e020984", + "execution_count": 7, + "id": "c1f9c7ec", "metadata": {}, "outputs": [ { @@ -80,8 +90,8 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "33a97342", + "execution_count": 8, + "id": "9a3bf46e", "metadata": {}, "outputs": [], "source": [ @@ -91,57 +101,47 @@ { "cell_type": "code", "execution_count": 9, - "id": "6681f625", + "id": "baf33df9", "metadata": {}, "outputs": [], "source": [ - "my_lockin.register_measurement_channel(program_name=\"test\", channel_path=[\"demods/0/sample.R\", \"auxins/0/sample.AuxIn0.avg\", \"demods/0/sample.X\", \"demods/0/sample.Y\"])" + "my_lockin_channels = {\n", + " \"R\": [\"demods/0/sample.R\"],\n", + " \"X\": [\"demods/0/sample.X\"],\n", + " \"Y\": [\"demods/0/sample.Y\"],\n", + " \"A\": [\"auxins/0/sample.AuxIn0.avg\"],\n", + " \"many\": [\"demods/0/sample.R\", \"auxins/0/sample.AuxIn0.avg\", \"demods/0/sample.X\", \"demods/0/sample.Y\"]\n", + "}" ] }, { "cell_type": "code", "execution_count": 10, - "id": "bc1e47cb", + "id": "dfd7c42e", "metadata": {}, "outputs": [], "source": [ - "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"a\": (np.array([0, 3])*1, np.array([1, 10])*1),\"b\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" + "for k, v in my_lockin_channels.items():\n", + " my_lockin.register_measurement_channel(program_name=None, channel_path=v, window_name=k)" ] }, { "cell_type": "code", "execution_count": 11, - "id": "160c071b", + "id": "62df1451", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'test': {'channels': ['demods/0/sample.R',\n", + "{'channel_mapping': {'R': ['demods/0/sample.R'],\n", + " 'X': ['demods/0/sample.X'],\n", + " 'Y': ['demods/0/sample.Y'],\n", + " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", + " 'many': ['demods/0/sample.R',\n", " 'auxins/0/sample.AuxIn0.avg',\n", " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y'],\n", - " 'windows': {'a': (array([0, 3]), array([ 1, 10])),\n", - " 'b': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))},\n", - " 'masks': {'a': array([[[ 0., nan, 0., 0.],\n", - " [ 5022., nan, 5022., 5022.]],\n", - " \n", - " [[ 1674., nan, 1674., 1674.],\n", - " [16741., nan, 16741., 16741.]],\n", - " \n", - " [[ 1674., nan, 1674., 1674.],\n", - " [21763., nan, 21763., 21763.]]]),\n", - " 'b': array([[[ 0., nan, 0., 0.],\n", - " [ 3., nan, 3., 3.],\n", - " [ 7., nan, 7., 7.]],\n", - " \n", - " [[ 1., nan, 1., 1.],\n", - " [ 6., nan, 6., 6.],\n", - " [10., nan, 10., 10.]],\n", - " \n", - " [[ 1., nan, 1., 1.],\n", - " [ 9., nan, 9., 9.],\n", - " [17., nan, 17., 17.]]])}}}" + " 'demods/0/sample.Y']}}" ] }, "execution_count": 11, @@ -149,29 +149,133 @@ "output_type": "execute_result" } ], + "source": [ + "my_lockin.programs[None]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b9944369", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"A\": (np.array([0, 3])*1, np.array([1, 10])*1),\"many\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "fec2b04e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{None: {'channel_mapping': {'R': ['demods/0/sample.R'],\n", + " 'X': ['demods/0/sample.X'],\n", + " 'Y': ['demods/0/sample.Y'],\n", + " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", + " 'many': ['demods/0/sample.R',\n", + " 'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.X',\n", + " 'demods/0/sample.Y']}},\n", + " 'test': {'windows': {'A': (array([0, 3]), array([ 1, 10])),\n", + " 'many': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))},\n", + " 'masks': {'A': {'mask': array([[[nan],\n", + " [nan]],\n", + " \n", + " [[nan],\n", + " [nan]],\n", + " \n", + " [[nan],\n", + " [nan]]]),\n", + " 'channels': ['auxins/0/sample.AuxIn0.avg'],\n", + " 'sample_rates': [None]},\n", + " 'many': {'mask': array([[[ 0., nan, 0., 0.],\n", + " [ 3., nan, 3., 3.],\n", + " [ 7., nan, 7., 7.]],\n", + " \n", + " [[ 1., nan, 1., 1.],\n", + " [ 6., nan, 6., 6.],\n", + " [10., nan, 10., 10.]],\n", + " \n", + " [[ 1., nan, 1., 1.],\n", + " [ 9., nan, 9., 9.],\n", + " [17., nan, 17., 17.]]]),\n", + " 'channels': ['demods/0/sample.R',\n", + " 'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.X',\n", + " 'demods/0/sample.Y'],\n", + " 'sample_rates': [TimeType(6857143, 4096),\n", + " None,\n", + " TimeType(6857143, 4096),\n", + " TimeType(6857143, 4096)]}},\n", + " 'all_channels': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", + " 'demods/0/sample.X',\n", + " 'demods/0/sample.Y'},\n", + " 'window_hull': [0.0, 17.0]}}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "my_lockin.programs" ] }, { "cell_type": "code", - "execution_count": null, - "id": "83995f77", + "execution_count": 14, + "id": "35b54564", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "my_lockin.delete_program(program_name=\"test\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "26769d32", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{None: {'channel_mapping': {'R': ['demods/0/sample.R'],\n", + " 'X': ['demods/0/sample.X'],\n", + " 'Y': ['demods/0/sample.Y'],\n", + " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", + " 'many': ['demods/0/sample.R',\n", + " 'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.X',\n", + " 'demods/0/sample.Y']}}}" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.programs" + ] }, { "cell_type": "code", "execution_count": null, - "id": "e6e33177", + "id": "6b95f243", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "333ce31c", + "id": "e20ad339", "metadata": {}, "source": [ "## Defining a simple qupulse pulse with a measurement window." @@ -179,8 +283,8 @@ }, { "cell_type": "code", - "execution_count": 111, - "id": "906d5c5a", + "execution_count": 16, + "id": "648f0722", "metadata": {}, "outputs": [], "source": [ @@ -189,8 +293,8 @@ }, { "cell_type": "code", - "execution_count": 21, - "id": "4b0cc17e", + "execution_count": 17, + "id": "823cf456", "metadata": {}, "outputs": [], "source": [ @@ -206,8 +310,8 @@ }, { "cell_type": "code", - "execution_count": 52, - "id": "ab4a8768", + "execution_count": 18, + "id": "715df81e", "metadata": {}, "outputs": [], "source": [ @@ -224,8 +328,8 @@ }, { "cell_type": "code", - "execution_count": 137, - "id": "4268b9d4", + "execution_count": 19, + "id": "86258f61", "metadata": {}, "outputs": [], "source": [ @@ -236,8 +340,8 @@ }, { "cell_type": "code", - "execution_count": 138, - "id": "f082459a", + "execution_count": 20, + "id": "dabc4f0f", "metadata": {}, "outputs": [ { @@ -255,15 +359,15 @@ }, { "cell_type": "code", - "execution_count": 139, - "id": "e0600a11", + "execution_count": 21, + "id": "86ca9d23", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'T', 'R', 'A'}\n", + "{'R', 'A', 'T'}\n", "[]\n", "set()\n" ] @@ -277,8 +381,8 @@ }, { "cell_type": "code", - "execution_count": 140, - "id": "bb0530ec", + "execution_count": 22, + "id": "18693b31", "metadata": {}, "outputs": [ { @@ -287,7 +391,7 @@ "" ] }, - "execution_count": 140, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -298,13 +402,13 @@ }, { "cell_type": "code", - "execution_count": 142, - "id": "3c713b54", + "execution_count": 23, + "id": "d1142301", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -322,8 +426,8 @@ }, { "cell_type": "code", - "execution_count": 143, - "id": "454dab56", + "execution_count": 24, + "id": "56081907", "metadata": {}, "outputs": [], "source": [ @@ -343,8 +447,8 @@ }, { "cell_type": "code", - "execution_count": 144, - "id": "8332701f", + "execution_count": 25, + "id": "8f367858", "metadata": {}, "outputs": [], "source": [ @@ -356,13 +460,13 @@ }, { "cell_type": "code", - "execution_count": 145, - "id": "1c891151", + "execution_count": 26, + "id": "4beacf1c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAEGCAYAAACD7ClEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAByQklEQVR4nO2deZgdVZn/P6fqrr2nO3tCFgghBBIgQAQSdlkFXEAFF0BnRNx1RgeV34zgiCuOiuI6OoggiIqgqIgsAcMaAgEC2SF70p10er37rTq/P6rq9t231L1VMfV9njzdXbfq1jfnPee857zve95XSCnx4MGDBw8HJxSnCXjw4MGDB+fgKQEPHjx4OIjhKQEPHjx4OIjhKQEPHjx4OIjhKQEPHjx4OIjhc5pANsaPHy9nzZqVcy0SiaJpOgCqqtDa2gJANBJFN68rqkKLeT0WjWSux+NxdF2CUAiGQiRicRRVoWd8d83cLB7ZHLJ5lOKQ4SFFhoPUJapfrZlHpbbI5lCuLZA0jAM4J49qOGR42CiPavpEubZopDyq5eDJ48CVx8qVK/dKKSfURDQLrlICs2bN4vnnn8+59rcHn2DixLkA9PWt57zzTwNg+d+eZN7kIwBYu3sdS89bAsCKxx/luDkzAXj6qRfp7p7BK5u3ccRxS3j56RUMDu7gU9dfWzM3i0c2h2wepThYPHYMiwyHOePn8vzGx2rmUaktsjmUa4tEPNAwDuCcPKrhYPGwUx7V9IlybdFIeVTLwZPHgSsPIcSWmkjmwTMHefDgwcNBDE8JePDgwcNBDE8JePDgwcNBDFf5BDx48GAglUqxfft24vF42fsmTGxHUfdmfl+zZg0ArRNa2c1uWie0Zq4B+DvGsX5fBIC22bPRVJU5HbNQ1L3MP3Equj4p5/5qYfEoxsH63bqezcHiMUeS4eBXEpw0c1HNPIpxqKctpGS/OVi/2ymPUCjE9OnT8fv9NXGqBE8JePDgQmzfvp329nZmzZqFEKLkfUNDI/h9IQBS6Tidne0AjAyNEvIHiacStHe2Ze6PjAzTEgwAMDoaxecLEkskCbW0EY1E0LQkk6ZMrJmvxaMYByCHRzYHi0dKExkOIV+ISGK4Zh7FONTTFroU+80B7JWHlJL+/n62b9/O7Nmza+JUCZ45yIMHFyIej9PT01NWAXg4eCCEoKenp+LOsB54SsCDB5fCUwAestGo/uApAQ8ePHg4iOEpAQ8ePFSNq6++mt/97neOvHvz5s0cffTRtn3fh6/9CL+7917bvu9AhacEPHjw8E8DTdOcpnDAwVMCHjx4KIrbb7+dhQsXcswxx/D+978/c/2JJ57glFNO4dBDD83sCkZHR7nwLedx2mmnsmDBAu6//34ANm/ZzIJFC/jEJz/OUUcdxbnnnkssFgPgzHPO5bovXs8Zb34zi086kSefXA4YE/mNX76RE088kYULF/KTn/ykLM9ly5Zx5pln8q//+kEWLz4OTdP43Oc+l3n+F//3CwCklHz84x9n/vz5vOUtb2HPnj22t9mBCC9E1IMHl+PGP73KazuHi36maRpCGGs5KXVUVc1cV4SCnnUNQNc0FEUwf3I7/3ba9JLvfPXVV7npppt48sknGT9+PPv27ct8tmvXLpYvX87atWu55JJLuOyyywiFQtx9128JtwRIpRKcdNJJvPD8iwBs3LiRn//sF9z2y9t417vexf33/5EPXmUolXQ6zbKHH+Yvf3uYr37tK/z2N7/nl3fcRkdHOytWrCCRSLBkyRLOPffcso7R5557jqeeeobD58zjZ//7Izo7OzPPn3zSyVxw7vmsWLmCdevW8corr9Db28v8+fP51w9eXZ0Q/onhKQEPHjwU4NFHH+Wyyy5j/PjxAHR3j2WyfNvb3oaiKMyfP5/e3l7AWGXfcMN/8o/lT+D3+9ixYwd9fX0AzJ41m4ULFwJw/PHHs2Xr1sx3veNtbwXgmIXHsHWrkQft0cce5pVXX+bBvz0IwNDQEBs2bGDu3Lkl+S5evBgrA/Gjjz7KmjWvZXYpgwODbNy4kSefeoorrrgCVVWZOnUqp5126n630z8DGq4EhBAq8DywQ0p5UaPf58HDPxu+dPFRJT/b38NJpSClLLnyDgaDOfcB3HPPPezdu4fHH3+C8eO7mTVrFvF4nKA/QCAwdjBMVVXS6XTBd2Vfl1Jy01e+yuVXvDvnvZs3by7Jt7W1NYfT97//fc4777yctnjgr3/2wm6LoBk+gU8BtZ9D9+DBg2M4++yzueeee+jv7wfIMQcVw/DwEBMmTMTv9/PYY4+xZUv92Y3PPuscfvnL20ilUgCsX7+eSCRS4alc7j/60Y8yz2/YuIFIJMKSU07h7rvvRtM0du3axT/+8Y+6Of4zoaE7ASHEdOAtwE3Av1XzzFAsRUrTGd8WrHxzg6Drkm0DUWb2tFa+uYHYti/KpI4QAZ9z/vvBaBJdQndroPLNDUJK09k9FOeQ7pbKNzcQW/ojTB/Xgqo4t5pMmwVIfGpj+8RRRx3F9ddfz+mnn46qqhx33HHcdtttAOhSkkxrBHxjvoZ3vevdXHHF5Zxxxukcf/wi5s2bV/e7r37/B9j0xnoWLVqElJIJEyZw3333FdyXSGlFx8aVV15Fb+/uzPPd47q59557ufjiS3j62adZsGABc+fOZemSpXVztJDSdBQBqnLgxtg02hz0XeA/gPZSNwghrgGuAZgxYwanfO0RIkmNzV9/S4OplcaPHt/Et/62joc+cxpzJ5Wk3lCMJtKc+s3HuHTRdL79rmMc4QBw7Jf/DuCoPG768xpue2ozz11/NhPbQ45w2D4Q5fRvLePDpx/KFy440hEOAK/tMhzEC6d3NfxdV111FVdddVXOtdtuu42t/RHW7h7h6GmdjI6OAtDT08Njj/6jqElq1fOriKcSAHz2s58lMmL8Hx77+0OAYZbq6elhzWsbiEYiKIrCF79wPd+75Xs57+7s7GT16tUAxJJpNvSNMqUzzBlnnMEZZ5zB0NAIAIqi8NWvfpWvfvWrOTziqQQ/+MEPMt+Xn8OoHqzZNYxPUZg/tWO/vsdJNEx9CSEuAvqklCvL3Sel/KmU8gQp5QkTJkwgknQ+zvfFrQMAbOkvbTNtNKwV38Nreh3j4BY887phktgzknCMw1DMMC08sX6vYxzcgpGEYbvXTX+AE0hqxrsjiXSFOxuPtK5XvsnFaOQeZglwiRBiM3A3cJYQ4o4Gvs82BM1tbiLtnEKyTA5OcnALgn5LHs4NNjf0CbdAYPRNB3UAlkXOSUX0z4KGKQEp5ReklNOllLOAy4FHpZTva9T77ETQtDMORJKOcbCiGOKpA3uVYQcseYzEnVv1WRy27XNud+gWZCZg3bkJ2BofKc1TAvuLA9eb0UBYqwsvnMwdsExjTk46PtXoCx0hewt6HIiwxODk9GspogPYH+saNOWwmJRyGbCsGe+yA10thrMo6aD5wcMYesxIMSfNQRa8PgF+VZDWx84IOAE3mKT+WeBaPWqt/pyAtfV3w6TjIVseztvjvT4xtkN2cGOGtUn3lMD+w7VKIO7gYLO2/r3D9lfxOVDh5KrPcpLvHXXOR2Mh6eDixA24+uqr+euf7gNAa7IWKJZKOumChcGBDtcqASe33S0Bw0oW8qsV7jx4kHZw2WfJw8lDcx7G4OBZuQLUckjLSzNdHK4dVU5u/S3zg2f/HYOTZpCwFSKa8gaxhWbszEqlkl7x9JNc+bZzWTh/ruOppHUp0XWdj370o5x00mIuvextvPOdl2Z4zZo1i69/4+uc8eYz+MN9f+Chhx7i5JNPZtGiRbzvyiszh91eXLWKcy88j7PefCbvfPel7N69C4AzzjiD6667jsWLFzN37tx/ylQTrs0i6mRopKUE9kWcO5zkNiRSGm1BZ7qLtQOwDmwddPjr52H3KwAcah2OCqqAoFVLZ1JJB6QOqiGjsKahCEFYSshKJR3S0kZIzaSj4OQvlnxluVTSe/p6ue3eB4n2bePKyy91NJW0LiX33nsvmzdv5qmnnmFgYJhFixZyzTXXjP2fQ0GWPbyMHbt3cOXVV/Lwww/T2trKf3/5Rv7ne7fwhf/4HJ/7/Of57d330Nbeye//8AduvOkGbr75WxmOzz33HH/5y1+48cYbefjhh2uVoKvhWiXg5ElANxxOchuiSY0eh95tKYGYC06THywol0r6vAsvQlEU5s6b54pU0suXL+ed73wniqIwedJkTj01N0X0O95+KQDPrVjBa6+9xpIlSwCIx+OccvJJrFu/njVr1nDR2y5B6hJN05gyeerY8+94R4Z7qUym5bKuuh2uUwIBVSGp6Y6eBPSZRk8nE4W5DU76BCxzkKoepPK44OuZX1/fPgjAkVM68KsKkRKppGMlUknHs/Pl7GcqaYE7UklXMo21trZYN3LOOedw1113AWO5g15ZvZp58+bx+CPLiCWS6FIQ8oWIJIZLcizgYLbHgQjX+QTcFJ7pBg5ugZM+GmsnkPBOT2fQ6DVSuVTSxUJEnUwlvXTpUn7/+9+j6zq9vb0sX17cbn/iiSfy5JNPsnHjRgCi0Sjr12/giLlz2dvfz7PPPQtAKpVizdrXauLsZPTc/sJ1O4GgX2EkAf0uCAf0UgSMYTjmnHnO2pl58hhDo3fK5VJJWxvkVFa4rBOppC1ceumlPPLII5x88ps4/PC5nHDCCXR2dhbcN378BG677TauuOIKEokEuq5z0403MHfu4fzq//6P6774RQYHh0hrGh+79hPMmH1Z1Zx1CQdqLKHrlIAFN5hiOsJeigALbkjU5cljDM1YeZZKJd07HKd3OI4ihGOppLOhKAo333wzmiYZHopw2ukns2DBAsAwIY0MjWbuPeuss1ixYgWQm0p64YIF/P2vDxWYg5YtW5Z5dvz48XWbpNwM1ymBjpCfvaNJV4RnuoGD0wj6FBJpPWfV5xQ8eYzBDVOOdAULAxdddBH9/ftIp1J87nPXMXny5Ka+38nT0/sL1ymBgJcioABORh4ETCXgBnu8G/qEW+CGScdNi99ly5Zl6i2n0s0/6e+mtqgVrnMMW0pg15DzKRs2762+rmkj4WS63IBZxrB3xHl5vOESebgBmgt2Zm5ZJLkBzU6hYSdcpwSsVA2tAefdLE7W1c2Gk/lqLHmEfM7Lo6fVubrT2XCD/dcNMek+F/jtXIMDuClcqwTcsMpwAwdwNl1CyO+mkF13mIOc3JkpmfBM5xWRGzi4BW5YGNQL1ykBy/zgZBUpCwNR58NUwR1lFd1Qy3Ug6o60EU4qI2sD4Abrg1tMIG6YgA9kheg6JWBtMd0wAbulkzubQsPoIv0Oltq0MBJ3hxKIObgzs4qpuKG4uVvGhxvm3/QBXObSdUrAQthL45yBkykbrBPcbpCHW1J7O2oOMkes4pAR+uqrr+ZP991rcGiyX6JYPQGANza/wa9//euSz+3atYt3v/fdJT/fH1hK2U4fzf98939s+65q4Fol4AYbtFvgZHy8dWjPDfZ4t5wTcNJHY006ugti9N1yTuCNNzaXVALpdJopU6bwmzt/05B3W3O/leLCDnz3u9+x7buqgevOCVjY6qUIyGDQBSmUtw3EnKbgCpMUQCTRXCXwjee+wdp9awEjk6ouJT5VIehTSKc1FDOVtC51fKYPR0trKIqCruuoWZFdmqahKoIjuubysSM+Uva9t99+OzfffDNCCBYuXMivfvUrAJ55ajk/uOW79O/p4zvfvpnLLruM0dFR3vvetzIwsA9d1/jKV77CWWeczeYtm7n47Rdz0ptOYsXzK5g2bRq/vuNXtAQDnHnOuSw+8UQeefQxhoaG+dGPfsZxxx6XqSew4vnnSCQSfOxjH+PDH/5wSZ7Xf/ELrF27lqVLl/C+911Je3sbjz32CPF4nEgkwi3f/T7vvvxdPPP0s0SjUa6++mrWrl3L4YfPYfu2bfzge99l3hFHctvtv+Tb3/kfJk2ezOGHzUVRBb/4v5+zZ88err32Wraa2U+/+93vsmTJEm644QZe3biZ7Vu3MmXSBO79baGiicfjfOQjH+G5557D7/Nz01e+ylsuvpDbbruN559/nm987asAXPy2d/DRa6/l0cceJxaPcdLJJzD38Lnc+oNbq+0mdcO1SqAt5FpqTYcbnE5O1RJwI5IuqFDVaENMuXoCvbt3c9u9D7L9jY18+l/e42g9AYD/vumr3PLd73DnnXfh94W47Zc/5+mnn+bll1+mu7ub1S+/mrn3hz/8IePGjePll1/muWef4ZQlSwHDZPT1b32DR//+GC2t7Vx62dsy+Y8+9alP8ZnPfIalS5eydetWzjvvPNasWQPAay+v4v9+/1dmTRpXlNuttxqT+DNPPcvm19/gwksuZMM5G0q2+3/f+GV+/NOf8MzTzxONRNC0xi98XDuynSw0nw035Al3g9PJLfJwA5rtE7hu8XWZ3zf0jhBLaYxvCzK1K5w5JQsUzduTn0o6O1/OaJlU0uXqCVxw0cUoisJhc91RT6DYGumcc87J4Wxh+fLlfOpTnwLgqPnzWWjmGFr5wgucumQp48aNQ5eCt1/yDtasNzKJPvzww7z22lhW0eHhYUZGRgA467wLCYXDJQ1jy5cv5xOf+AQA846YxyGHHML69etL3O0MXKsE3GL/TesSv8N57N1gj/d8NGNwQ99sdFhkucVPIBA073FLPYHCa62trSX/X7VcB9B1naeffppwOFzwWbjFqFVQarde6nt9Ph96VoRXPO7ciXzXOobdkiLAyXBAC7vdkEKj3x3ycENMeN+I82VHG62Uy9UTsJAdpupkPYFwa1tmZV4JS5cu5Z577gFgzdq1vGJmJT1+0SL+8eRyBgcHSafT3P/AfZlnzj33XH7wgx9k/l61alXB95ZaGJx22mnceeedxv9jw3q2b9vOEUccwaxZs1i1ahW6rrNt2zaee/75zDM+v89WR3MluHYnMM4tKRtcsOprCTgvJrek0EhpkoDP2Z2ZFTbrJHxKYzmUqydQDE7WE1iwcAE+n48lS07h/e+/ivb2tpL3fvSjH+Wqq65i4cKFLDj6aBYuWEBnRydTpkzlc//2Wc49/xwmTZ7MkXPn09ZhrPJvueUWPvaxj7Fw4ULS6TSnnXYaP/7xj3O+t1Tq+49+9KNce+21nHTKm/D7/Pzohz8mGAyyZMkSZs+ezeKTTmbh0Uex6LhjM89c+f6reNObFnH00QsObsewGyZfcIcZxBXmIBdkEQWjLQIOT8Ju6BPNCBaoVE8AyKzAnawnoPr8PPLIIzlZRC0OADNnzsxwCIVC3HHHHYRCIV55aRUXv/WtzJw5g2Qyzbvf+S7e8573kUxpfOCDV/GuU98JGHUEfvObwsifG264gXW7h0mk9ZIH1kKhELfddluOjwaMcwV33nlnUR/NDf91A1//+s2eYzjqkqLiTsaEW4i7YAKOJJ1PGwHGBNxe+bYGc3C+T7ghYgzcUVu3FhNhNBrlzDPPJJVKoWkaP7zlFgKBAMlkmpu+9lUeeexR4okEbz7zzVxw/gVVf69b5FEPXKsEdg46H5cO7shhtGPQ+TMTOwed90sARBMalN7tNwVu6JtOnlrOhq5LFIcDJ2ppi/b2dp437e/Zq3CAr9301aKF5qvBow8/xPe+diOapmcc6jNmzOCBB/5U9Xc4BdcqgfaQO0oJukHDu6EtOsLu6CopF+TMaXXBmQk3lF8Fd1Q4c0NTnH7WOXzg3W8vCNk9EOC8h6sE3FDOENzhm/A4jMENvgk3tIUboqTAHTzckMfOBRTqhmuVwJALUiUADLvAHOQG88MOF3AAiLrAN+GGkF0nCw1lww0TsBsyqqZcsDCoF65VAuCOVYYbVn1+1XkxuYEDuOPchs9hGzi4o7IYuMNc6ga4RR71wHnjZhm4wfnlhkyJzjNwD9yw8nRi3nvmmZUMDUbYMRgjmdZRhMK2njCjkRg+1XBuprUkba3GqdZoJEbAFyCZTtLSOnbSNR6LEfT76Oxs4eijjqj43j/84Q+84x3vYM2aNUVj/z0dcODD1UrADaF4brBBuyFMNZnWXbEzc0NbOHFOYGgwwsSJc0n4IsTTOqoQTJzQRstoBJ9qpF5Iawna2ox0CdHR6JgSaGvJfE8sOkrI76dvz8aq3nvXXXexdOlS7r77bm644YaCz13QJVzCwQUk6oQ79vglEHPBWYFdQ87bwt2SssENduheF6Rs2OyClCZaEyad0dFRnnzySX7+859z9913F73HDfZ4N5hs3TA26oWrlYAbGtYNKRvGtbgjZYMbDq2FXJCywS0pTRq9+rzvvvs4//zzmTt3Lt3d3bzwwgsF97jBFu6GcNlmV1mzE86PqDJwg4Z3Q4oANyhDcIc83NAWbugTzcBdd93F5ZdfDsDll1/OXXfdVXCPG8wgruDgNIH9QMOWuUKIEPAEEDTf8zsp5Zdq+Q43DDY3THxuWIGD56MZ4+B8O0BjS0z29/fz6KOPsnr1aoQQaJqGEIJvfvObuRxcMPu5gYOU0hXKqB40cieQAM6SUh4DHAucL4Q4qZYvcMNZgS37nLf/bnGJT6DZZRWLYbsLyly6xUfTyDnnd7/7HVdeeSVbtmxh8+bNbNu2jdmzZ7N8+fKc+9xwqNMNi0Vwh4O6HjRsJyANtThq/uk3/x1wzdQVdt7+6xafgBucgO0uKDvqhDw6u1rp61vPXjNEFKBFayERj+eEiEajRUJEo8VDRMvhrrvu4vOf/3zOtUsvvZRf//rX3HDMiZlrbrCFu+HcBhy4ZyYaOqKEECqwEpgD3CqlfLbIPdcA14CRcCkbbtDwbjCBuMEODm6Rh/McnJDHSScdD4yVlwSYO6mdRDTakPKSy5YtK7j2yU9+EiCTRhpcYo93ngJwAK5wTTTUMSyl1KSUxwLTgcVCiKOL3PNTKeUJUsoTJkyYkPNZJOF8ioDeYedDEve4ICwS3BGy64a26HVB2ghwxwScdoFB3g0mKXCHPOpBU6KDpJSDwDLg/FqeG3VB3p4DVbCNgBvSamsuMEm5pUe4Ye5zS1u4AW6QRz1omBIQQkwQQnSZv4eBNwNrq3k27FcNcg7H/wZUxfEY5JDfEJGTyigjD4dNr4Y8nI1qDvoUx+3gTr/fghDC8YIybjinMCaPA1MlNnJETQEeE0K8DKwA/i6lfKCaB4PmxOe0Pb41qDpug7YmYCf9AmPycLYtWoKq432iJaA67qOxlLHTea1U4bwzVBHO+wQsebjAMlYXGhkd9DJwXD3PWoW8dw7GGG8nqZp5qI6HZwZ9KpBy9KyAJY/dQ3FmVLi3kQioClv6na2yFvSpDERTju7MjNWvJKVJVMdYGDycPkejCOG4T8CSh3aAagFXnhg2Jj7nUzbsiyTpdDg803KOO3lAySrsHgo4OeXAQDRJV4uzVdaG48bZFSeVsmV8cNo8l9al4+bSA3XidROcD7ouAmvl6fQqY9b4Fsc5TOkKMdI76qgpJmOScrgtZo9vddwkNX1cmPW9o01vixeefYHoYCxTbzqZ1tnRFkTRUjnnBFpbjfj/WCRGwOcnmU4RzkolnYhFCPp9tHS2cPj8uWXfqaoqCxYsIJ1OM3v2bH71q1/R1dWV+TzoUxw3xQR8CvGU5ujOTFUEKc1581y9cKUSUITArwrHba8Bn+J4WKS1K3Jy8rN2Ak7b4wM+xXFFlGkLrbltER2MMW/yEbQEDCWQSGtMbA+h5imBNjNtdGQ0RtDnJ5FO0do2pgRi0Qghv591vZVjNMLhMKtWrQLgqquu4tZbb+X666/PfC5w3ieQcck6SCObg/Nu6trhSnMQGIpgq8P2X5+i8LrDaYOt05AjcedSaATMqmLb9jmbssGnKLzhtDzM6KSogyk0rIiYZtrCTz75ZHbs2FHAw+mFmtUWTioji4PTbVEvXKsEEmndcftvJJGm2yUpG5xcb1khcJ1hZ+UxmkjT43AaZ2uycTKFhjVomxUqqmkajzzyCJdccknudV3ic9gnYJmBnB0fxk/VBeGq9cC1SmBaV9hx++8h3S2Oa3dLCTmdPbM95HPcHDSju8XxPjG+zaji5Whm10yIaGMRi8U49thj6enpYd++fZxzzjk5nwd9iuNhkVbtayd9AkpmN+IYhf2Ca5VAwKcwEEk6yiHoUxw/JWvZoONO2+NVhcGos1ldgz6FgajzfQKc9dEIQCDQGzzrWD6BLVu2kEwmufXWW3N5COejc4QLYvQtDs2o9tYIuFYJxFMaIw7nDrISdTV6sJWDtcrYN+rs5JdI6476JcCQR9RhR71lDhp0WBlJZNPs4J2dndxyyy3cfPPNpFJjfUCXzisBqwmc5GGdm3a6LepFxeggIcQJwKnAVCAGrAYellLuaySxtqCPkN84KOUULFOMkyYhK3Wy3+GyimPycA6dYb/jcelWavFmpzRp6Qqzdvc6dgxG8SkK8VSa1qCPsNBzQ0RHi4SIjhYPEa0Fxx13HMcccwx333035771nYARGul0Cgun+wOQMc+5gUo9KKkEhBBXA58E3sBIB70OCAFLgeuEEKuB/5RSbm0EsXGtAZIOm0DazAnYFeGZKY2gYywMeThtj+8M+9F0Zys4ZVJopPSmhgMuetMiwEgl7VeN2PjWoI8OVWtIKmnj89Gcv//0pz8BY6mkVUU4nmDRUsZO8zDaggMyRrTcTqAVWCKlLBoXKIQ4FjgcaIgSCPoUNvWNwgznIlKCLoiPtzj0DsfpcIyFoYy29kdhonMc3GCPtzjsGU042RRjKRsc3Jwpwnk7uLU/TuvS0flXYMij1dkAurpQUglIKW8t9Zn5+Srb2WRhIJqkPeRsi1r253jSyUnHGOUBnwIOmqEHIkkmtgcB5/w0o6aPKO5gCg0rGsXv8N4/resEfD6cDI60bOCOrsJdsvLWdOl41uN6UZehWQhxkd1E8jGzp5WUw7njp3Qa22wnfQJWKumU5uyKa9b4VlIOO76mdhq2bSdPDbeY+ZOcbougT3XcBBLIhGc6x8Fpn4SFgE9xXB71ol5v44mVb9k/BH2K47HxYykbnE/e5nS6hKALUja4IaV1pk84uBsBIyzR6SnHDad13ZLG2Q0pretFXUpASvklu4nkI+hT2DHobJoCawIecjA+XiBQFcHWfc6m0Aj4FF7fM1r5xkZyMFeeTp7dsPrE9gFn+6YihOOOenfE6Dc/hUYpHk7Lo15UEyJ6ZbHrUsrb7aczhqFYilaHUxdn4n4d3nFqunQ8ZcNQNEW3wykbLJOYkytPSwl0hHzg4JhP67qLUjY4vxNQHN4aabpu5pU68LYD1WQRzTb9hICzgReAhiqBGd2tpPS+Rr6iIqxJz2kzyPi2oOPpK2b0tLB297CjHCa0G0GyTp/WDfoUEpre1MXByytXkBgdYcdgDJ8iMtFBOwPgU40FQlpL0WqmjY5mnRNoyUolHY9FCfr9BFvbOHTukSXf19/fz9lnnw3A7t27UVWVCRMmAPCnh58AwOcCn4C1E3DaHh/wqa6of10PKioBKeUnsv8WQnQCv2oYIxOWDdrRmHAXhCRaPCKJNIQr39tIDkZ0jnOnFdwQsguGWSqa0IwlUZOQGB3huDkz6emP4lMFqhBEUxoTQqJoKunoaJYSyE4lHYkQCvh5cVP5yO6enp5MGukbbriBtrY2PvvZzwLmOYF4PGNLdrTKmvnTDT4BB4MI9wv1+ASiGOcDGgrLFOOkb9g6jdhnHo5xCpou2TXoPAdHk6YxZoPudziFhi4lOx32VwGkHd4dWvNu2ukZGOd9AlI6z6FeVOMT+BNj8laA+cA9jSQFY6s+J+ed1qDRPEGH0yWoiqAj7MfJFBqWU9ZJe3xb0DB7+FVnbeGKEKaPxnnnsJOwFkluCNJ0Q4y+K1JY1IFqfAI3Z/2eBrZIKbc3iE8G40x7vJOrDLeYgyZ2BB03gfSYKZSdbIpQVohoEy0xBZjYETR8Ag5CVYXjLki3pFD2q2aMvoNzsF8VOJxTsG5U4xN4vBlE8hFwwU7AignfMxx3NEVAQDXDZac5l0TODfKwOOwdTTLdORoEfCo7BmLQ7RwHIZzP25NJoaxLR9MRC8zgDQeD14QQZqEhZ60G9aDeE8M/tZtIPqzVd8LBk7LW4SSnt5oD0SQhn7OdK2qmbEg6uOwLOJxJ1cJgNJnZJToFPZOywTkOVgplp3ckaV06bho7UNNIQ/2F5n9iK4simGiGAzqZLWHMDu4cBzBSaGxz+LDYlC4jwsRJK0jY9M04vQKe2dNCs6MBg23tvLhxSyZENBxQ2TuaZFdIIeCrL0R0f6G4Qyc7rpDBPQuUelCXEpBSrrSbSD7c4BgWwowJT2uO2htDftU8q+BcRxuTh5M+GiuNh7P2+JBfbXrVu4XHG8d1usxU0u0hHzsGY0xvUwn5G5NK2sINN9xQ9Lrikhh9IYSjAQsGB+PngZg6ouKsIoSYIIS4WQjxFyHEo9a/RhOzNOtoytlW9atmCmUHEVAVXt8bcZaDKY+og8XerKggp3dFAVXhDYflIVzglLXWRU4fZBTC+QOdiktMY/WgmqXlncAaYDZwI7AZWNFATsCYvdHpqKvRRJquFmdTNgxGk4xzmEPa4SymMDbxdTicQmMgmsxErzmFsdW386VPVRfY450Oz7R2Iv+UOwGgR0r5cyAlpXxcSvlB4KQG88rkynH6IMr0cWHHzQ8ze1odn4R72oxJz+kUyp1hv+Orvlk9raSawKGcmcXvgpQN1lbAaZ9Z0Kc4vgLPyKOB72iU2a0aJWCdUNolhHiLEOI4aHyEnhtCEi0eTiuBoF8h7vA5Acsn4HSiRL+qOH5mIuBTiDe4IUKhEP39/SUHfsYG3VAW5SEwdgNOJpAzeLgnXLZRbSGlpL+/n1DI/hMy1TiGv2LmC/p34PtAB/AZ25nkwYrMGUw4XL5OCDbvjTgaE64II4Omk84va7s9lHRaHrB5bxRmOMlBsC+SpJF5lKZPn8727dvZs2dPzvW+4TiqIhgI+tg7miTqF4QDxq5Z01KEw8YkEY8l8Ks+UlqaUHiMZyIeJ2A52BMpVFUlmdbwB4IkEwl0XWPfYH9ZbsPxFMOxNL7hEL1DcQZ9Ci2qRFX9RTkAOTyyOVg8NEmGg1/xk0jHy/JIaTq9wwnS/QFiKY1oUiMSEgUc6mkLKamKA8DuoTgBn0LYr9IfSRIPCIL+xsgjFAoxfbr96++KOwEp5QNSyiEp5Wop5ZlSyuOllH+0nUkewmYa6aDDZy8Sac3xFMqW383JVbiVQsPvcCRcUtMdl0e6CfGhfr+f2bNnc+SRR+b8u/m5CL94NYXeOY0P/XEXy9cPoGvj0bXx7OkbydwX2RNhMpOJ7InkPJ8aHmBudytzu1sZfeMN1H1JNr68GV0bz2srdvLMIy8UvDP/33P7wnzoj7uYe8Q8rvnTbh7YqrCnb6Qkh3we2RwsHtkcIpuCFXmEJszgQ3/cxS7Rw53r0nzu4b1FOdTTFtVyOPLII7nxH4Pcs1FnIDCBD/1xFys2Nk4es2fPxu+33x9WckgLIf6fEKLk+lcIcVYjy0xaB7WcNgdN6wo7XuHMOjPh7OlpF8nDYXPQ5A4j7t7JnZlbylxO7Qo5bi6d0hluio+mHKx66E6Pj3pQzhz0CvAnIUQco37AHozkuYcDxwIPA19tFLFMFSmHQ0QDPpUt/RGcPA4eyNjjnY/RH3W4lwd8CruH4zDJWQ7g7M5sLGTX+TrDu4fi0Okch6BPIZJ03k8EEHdBFF2tKKkEpJT3A/cLIQ4HlgBTgGHgDuAaKWVDUygGXTDxgVHhzOmwr7hZzzbuYD93y85sKJbKnBx2ChErhYaDA95aJDk89zEcTzOh3dkBYpUbdTJ1gxUm6+QYrRfVJJDbAGxoApccCCHwKcLxnCDTu8IMx5xL4QwwudNwLmkOaiMrd5HT5zamdYUZiqVwMi5mqplCw8lFuGUOcnh4MLUrbJZVdA7Txjkvj/aQMZU6PT7qgasTXrQEVMd3AuGA6nhcurXqc5KGXxUI4XyIaIsL5OEG/4gbTFIArQHVcR9NyEXycNpHUw8apgSEEIcIIR4TQqwRQrwqhPhUrd8R8Cn0xZwf8DscriJlFbWJOLjUEULgVxT2OC4P1fGUDZZpLO6gPCwfzd640/JQeGOvs2k8rPHhpHnOWhjsi3tKIBtp4N+llEdinDD+mBBifi1fMBBN0ep3dn81GEtlipk4hUwUisP9K6nptPicT6vtdBoPayfipA/QyqMUdrjK2r6I8ylNoqZjxA07gaDD8qgH1ZSXnAv8CJgkpTxaCLEQuERK+ZVyz0kpdwG7zN9HhBBrgGnAa9WSm9XTQlpPZP6+7/UE992xknGtAc4NNWcEzuxuyXE4rdqb4r47VqIqgk+e3fBSywCMazGrrJk0+iIJ/ve1GPftXcm5R01iQlNYGKGqaWmMNCkl92yMc98dK5nUEeKsQJPk0dPCqzuHM38/12vIw68qnB7WmNcEDuOtKmumct4d0fj4r19A0yVvPXYq+5+kuTKEEIT9Y+ZSTZf8en2c+/auZGZPK0ubtG6ZNb6VVdsGsaLnlu9Mct8dKwn6FM5qac6sPLnD8JlZbbF1RONjv34BXZe8+8RD6s6XXwtC5m7E4pDUdG5fa8hj3uQOjm8Ch3pRTfv8DPgcZg0BKeXLQohfA2WVQDaEELOA44Bni3x2DXANwIwZucdAgz6VVHKsk/91axLYDcCxb2qv9vX7hYBPyTmtu3xXilf6DQ5HTe1kQTM4qLn2xpd7R1jRl4a+3ewejvPvhzWBBEZbpHVj1TWS1Hhkewq2G21xwikdTeEQ9OX6BB7fmWLjkMGhZ26Y02c3g0OuDfqVfRoPbNoFQCSpcc20xnMAs2+aundPNMnjO1Ow02iLxac1J2YzoCqmPIxJ8JEdKXZGDA5T57dwyszGc8hEEpptsWpvmj9v2UVAVVAUwRU9jedgBLGM9Yntw3Ge3J2C3bt5ZE0fvzitOeOjHlSzXmiRUj6Xd63qhMJCiDbg98CnpZTD+Z9LKX8qpTxBSnnChAm5a1q/KuiL5a4wD5/YjHVWNodCp9OcJnMImCaYobwUGs3m4VcVeqO5q7tmy8OnCkYTud2v+RzMMyxJZ+XhU0SBj6bpHFSFXUPxzN8CZ/oEQCTrTJEQcEh3uNQjtkMII5Ix30fTbHnUg2qUwF4hxGGYFmkhxGWYZp5KEEL4MRTAnVLKe2slNxJP01aLT6D3VRY9cQXs21Trq0oiYcbo1xKFcdRzn0Ssus02DtZWM1CLvfHRr3Dk8/9hGwcw5RGogcPWZwx5jO62jUPctP9WHROupVj49IcRa35nGwdr5VlTMam/XsfcVTfYxgGMNOc1jY8NDxvySBSsxepGNJmurbJXYpRjnvwgYtPfbONg5bWqyRr/h2s5bPW3bOMAhimotRaf2at/4Lgn3guasyHo1UjvYximoHlCiB3Ap4GPVHpIGMnffw6skVL+Tz3kZvS01BYi+uKdqFocsbPA6lQ3Jncaq4mqQ790nZbINtQVt9jGwVICNYWfPfEt2kbsPd4xoztcW0ji0z8w5LF3rW0cao7RT44SjPehPGefPKw8SjU5Ip/9MZ0DL9nGAWBGd0ttHB77CqoWh5GdtnGYPi5c2xjd9zqB5ADKql/YxqGjnpQNL91F956nbOMAhm+iJg5/+Rw+LQopZ6Pdqjks9jrwZiFEK6BIKUeq/O4lwPuBV4QQq8xrX5RS/qVacgFVqa2ymG6/Rq05pXUDOFgrrZjDKQKCPpU9NcnD/vjxmuPjNftLoWVSBDidssGnMBqpgUMD2iLoU9F0Wf3OrAGn26yQ3aTDMfoBn8JoqoY21swSpbqD5fqoLjro3/L+BhgCVkopV5V6Tkq5nP2szBtLacTqah/7OprlhKx6wGv21561YsIjDudRiqa02hRRA044x01tnKg2PjMjD/v6hOWod7r0aSyl1VhsyH6+NYdnNqBP+ExzUL6PptmIpTTCah0cHFYC1ZiDTgCuxQjvnIYRyXMG8DMhhL1G5zx0hv21pS5uQAezKmpVvctrgH3Pign3OxyD3Bn2E3D4XPx4Ux5V7wQasDOz0pz7HW6LjpC/Tg72jZMxeVT7nfaPUcs8V5OPpgHoCPlqnK/MnweAEugBFkkp/11K+e8YSmECcBpwdQO50Rn213YgJ2oWgLBxNR7OxP9W+UADdgJCCEJ+xfEj6V1hfyY2viqM9ho/pX1mIWsCrppHyjjtLZLVWjErYywk0Vl5jGvx19YnRkwHvY0LlZr9I4lR46eN8nBDWhUwzvPUxCExZPw8AJTADCB7ZksBM80soonij9iDoE+tLZV0yIyNtrFRrQFf9da/QQL1qwr9Mad9Agp7auEQMmOjbZx0LNNY1WbCBpof+h1OERD0qbWljQi0AiDS9qVBscZHsloawpxybFwsWWkj9jlchTDorzOtio3yqAfVHBb7NfCMEOJ+8++LgbtMR3HVp3/rwVCt2TtV8/i6v8V+MtVCNmY5MhJPE+pqxtnH0hiIpgjVksXZZ8Zp++yri6rpVsqGKge8dcI5YF+8tukXc7zq3b5osra0EUFDKUvFvn5kFZSp2ilrjY+wfSe4rARyAYfNQf2jScK1hIiGuiA+CMLZjlRNecn/xvADDGI4hK+VUn5ZShmRUr63keRmdBuTuZN5wjvCZr3QGicduzGju6W+XDU2roRn9bRU7xvJJWEbh+5WI2WDVrUjsjHy6GrxV8+hQZjd01pXnxA2tolV9c5JefhUBVURjuZyApg9vj552GkurQdVLQmklM8LIbZiVBZDCDFDSrm1ocwYC/1K6zKzBS+PBoSf1RqS2KBJJ+BT6kyQJbGrXYL+GjlY4YA2tkl+ioCKaJA8gj4lk0fJKdTdJ2zkXXPVu0bKw2GfWd0cHPYtVdwJCCEuEUJsAN4AHjd//rXRxGDM4ZNwcMlldfJ9iSo5NEigAVWhL1pHO9g54FUVXdaxM7OxTSx5DFUtj8b0nWIpNJqNgE+pLb24tRawUx61loFtkDx8SmGKmWYj4FPYU4ufqAGLpHpQjRXtvzFSQa+XUs4G3gw82VBWJmJmyoZUzUrAvs5gOSKD1YbiNUigg9FkbSkCLNg44EcTho8mWas8bNzuWmGy1e0MGfv/2zw/DEVT9cnDRozE63S429hHFVMOVVcAbND4GK41xUwDMBRLEa7HvH8AKIGUlLIfUIQQipTyMYxC8w2HlSLWydBIq5aA0+aHWeNb6yufZ+MEPK2rxhQa1tLTRkXUEjAsmFWHZzbI3jpzfI0pTRqAQ8bV6TOzsY9aKRuqNwdZ99nbdjN7WhwPoa7fb+esEqjGJzBoZgJ9ArhTCNFHDVlE9weZ4uYOmoOsnUDVVYsaaPOsK02BjROwFYqX0vRMdtXqONg3EWfSOFf7lQ2Th8qww0XFM+kSqh4fjfPRVH9iuEE+M1Uh4bQ8fGr1obLZOAB2Am8FosBngAeBTcBFjSRlwVrhRKod8Q3IS2KZH6qOQW6QQNO6ZKCeOGgb+VirvVi1XnJh/05gLCbcWZ+AIQ9nB68lj9p9ZvbJw28qgarbokHy0KR75FH7DtHljmHgv6SUupQyLaX8pZTyFuC6RhODsfDMmpvIxknHigmv2tbXgKRpYNhcw/WEd9s46NrN06HVh8tmzsXbxsFaeYaqjY9v0KSjCuortWlj3wznVbOqGjb2UYtD1WUVrV2hzfOeKkRtMfoNQKhOy4Vo0JxRLapRAucUuXaB3USKodW0/1bVqPdcCc/+2Pjd5gidrhY/VQU/rPwl3P5WW99tYVJHsDp74+A2+J+sUs42ToJtphJIVyOPX70d1v3Z+F23j0N+BaeyeOoH8Jv3mX/Y2ycmdYSqCxvesx6+c/TY3zbKw6q1XHF8SAk/Oxt2v2xdsI1DTSHUj30N/lAxC31dmNgRrE4Z7lgJ3zumIRy6W408ShXNc1oKfngKxAbMC87uBEquLYUQHwE+ChwqhHg566N2mhQdZIUDjiSr0JSv3T/2u83OQL+qsC9ehRvkT5+09b3ZCPiU6sxBT34PhndkXbBxFW6udKKVRryUsOnRrL/tk4cQAp+qVLf1f+j6sd9tTiQX8Cn0V5Oy4cHrYGhb1oWxUoz7zUE1vieh6YR8Zb4zGYEdz2dRsN9HM1iNMfzxr4/9Lu11KwZ9anVpPH73LzCw2dZ3W8gvA1sSI7ug79Wxv13sGP41xnmArwGfz7o+IqXc11BWJlTTFKPXuLIX0b226tbBaJIZNeVLsB9DsXR1R77C43L/tjGHvNW3K610RP6kH7O3uyTTOj6lNnkImxP7DURT1WV1bZuU+7eugeK3hUNat9KcV1AC6bwUX/GB4vfVAavUZs3JTGP2cQDYF0lWl8GzYyoMvGHruy3ETd9lLF1ByebnF7Ox0ls9KNdsKjCMUVlsJOsfQojuxlODtpCho2pVAjJ/ItxPzOppdXjDZlT1qg6NYzrOND9UkofIX+VZif1swqSOYM0WPynszbs0q6cFWZfZ0T759JgpNCqOj3wFGGy3jQNAS0Ct3QIb6rKVw6yelupaVtQQ1VYjJpkh7RWtn/kJFZ3MdUb5ncBKxnpsvp6XwKENYZSFsXDACuLN307ZvL0K+hVSLsgYKXE2JtwKl60kDyHzOrnN8gj5VVK1mjR8QVs5GCkC6njQ1kgpK0S0RiVg9/ioJ32FjUnswOgTVcmjgSkaxiqc6RkrRlE0WB61oqQkzNPBjsLyCeyJlt/KF5gfbBZ0QFXYEXX+SDpU4XTK3/rb6BOwOPTHystDaYI8+upJ2WsnB59CQqfybiAVzf3b1jQepj0+kWJyWxkll29+sFkeflVhT30lAG1DwKcwWE1lMRvrGBRwMH00w4k040JlTH7pfCXgUsdwNoQQl2AUkQFYJqV8oHGUxmDtBMIVSgYp+U4/mzXrgAtSBEQSxiCrqARSebnJbexglg08WOGgmKI3dqUzEE0yOVCrPOwdaCNmoEDFiK0GDnjVNMT7lQomjuRoHgd75TEYTTGzx9k8zkOxFFVFiOb7yKS07XyRNPtY2V0AFPoA3H5YTAjxdeBTGLUDXgM+JYT4WqOJgbHFg8re9vydgLBx9QuGvdHpI+lVp2zIt/c2ImVDJQ4FndretpvV0+p4Fanp40x5VFLKZiGXDOw8txGqNoS6mDXXPswe77w8rJQNFXdm/rzaFnaG7IarDBFV83cJ7t8JXAgcK6XRWkKIXwIvAl9oJDEwYsIF1XTyfJ+AvY0a9FVpb2wgAr4qD6IUrELsNwdVjg5qsDz8CgOOpw2uboFCQRST/fKoyKHB5qCATyFVSwXABnAI+hTDZ1bpawsKHNkXsptJc1OzPFy+EzDRlfW7vaEeZWCd1t0dKV/FstE+ASFw3AZtze1VxeiX+3s/YJnneiMVfDTky8PethM4nzbYkke8UjhggTzs42D5BPZUGB8F5wLslocrxochkIqr8IIFin0cMmVHK/gwG62Ua0U1O4GvAS8KIR7D2FeeRhN2ARYk0BYoT7NACdhsDkppOq0O+wQsp1PlsMT8Sce+trCSxrUGyq+cGq2Uk2ndcR+NlTq58inVxskjbMrBSt1QmsI/vzwsVFYCjZOHZS4NVfBhFsaQujR3kBDiB0KIU6SUd2HUE7jX/HeylPLuZhHsCoiKJpBGmx+mdIYdNwd1mnmUKoYDNrCTAwSVyiapwvKF9nKY2hWq3Udjc5+wUgRUDl/O/9z+6KCKHPJXnjbLY1pXuM6qd/ZhfFuV8iiYcO3Pa1VxjLrMHFRuib0B+LYQYgrwG+AuKeWqprDKgqrAvgoF5wtXnvbHQddUwakBsOy/FU8jNnhVoSowUKmYSaNDRH0KQ9WEAzYQ1oCvnMGzceY567RuRXkUmIMaII96MtzazAGMGP2yaKS51PQJDCdqHR8u9QlIKb8npTwZOB3YB/yfEGKNEOK/hBBzm0UwlpYVp7WCE6o2d/Lheis42YiqbdCR/ty/be5gsXTl5lUKDovZLI9Yuo6vtJeDdWgvWinN+WhfHg37B3zFE8MFZxXsbYuhCou04rDfJAVj1QhLYrQ3j4b9hykrmgjj+SGiLjUHWZBSbpFSfkNKeRzwHuDtwJqGMzPRHVQqlq4rnHTsHWjT663gZCOsCk6iUgahQN4RdJvbojskKsujIFmb3fKoNoVG42CZgyoi0Jb7t83yaPFVUdoxP01BI+ThsEtgYruZsqHSEA125P5t87kNQTWlNhtnkqoH1ZwT8AshLhZC3ImRUG49cGnDmZkIqs7WGIaxPOE119a1EcFqt7sFx/FtDsVTBKkKHGRetyr0EewfQn61jjJ+9s5SYyGilWLC7U2PUMBDrSyPgjBVm+UR9quOLpAgO1y2VnnYfZq9ijEq8uXh0p2AEOIcIcQvgO3ANcBfgMOklO+WUt7XJH74FMGu0QohcHmdWuxcgdjyuG0cxkpM1lgs4qVf2jbgLHtj5fCz3O2w8sqdhVvg/YBPgV0jFUJ280JExbanENufsY2DFRNeSzEVkY4hVv/atgFnyWOgRlOIsur/bM2g6ROV5VHQJzY/BrtesI1D0K8SqZQ1In8cDG1FrPmdfRx8lj2+tvQVyos/LzxRvR/wCdhdcb7KGx+bHoQ9r5a4ufEotxP4IvA0cKSU8mIp5Z1SykiTeGUQSUnaK4Yk5imBfRtQH/qMfRySVsqG2iYQ9bnvwV57LGdWJEhQrRAOmBd5oGx4AOWJG23hADCakpniMqVQII89q1H/+lHbOIyYAz1RY8iW+vTNELFHIVopG3yVai3nKR1l7e9Rnv2uLRzAkEd7BXkUTDq7X8T3wL/axmEoaijCcuHLBX1CaqjLv2rbBGxZYCqaYvLl8cqvUFb9whYOAJF05ZD2AqW841l8973fNg61olwCuTObSaQUJoYV9lSIBCk4nGQzpnQa9saKW80iEMkIsP/548dSaOiEyunuIgVcxODm3ON++4GJYaViZbHCcxv2IpOyoZ6KZTblbreq3lWsslZkYhTD22C8LTSY2KJUNpc2uHzhIWaa8/I7sxIcbZKH5TOrXGWtyOejvZB/kLhOTAxXDmkvDNl1Fs5mfaoCPqWa3EElGt2mrb91UKuu/EGxvbZwGCvjVykGuYgSiOy2hQOAX4FkxXZorO/E2hXVXtDbKDhkC4dqUzYUW5mO2ikPUUWagsYqgWpSaJQco/FBWzhULY8isHN8+KqRh8MhoflwvRJQq7CxlepgBaGjdcJnZs+0zEI1Id8JVDcHQ1QV7Y1FBrwM2FdERFUEO0fiZe9p9E7AaouK4YBFYZNPwJx0+iqlbCi2EAl32cIBjPFRSR52l1vNhzU+ypnnSvYJm8p+WqfZ91bymRWBDPfYwgGqlIfDheXz4XolkNCgrYJPoNTKU5X2lBSsHPJVBukKHaJGVGyLYoOtxlKM5RBLSzpr9AlkYNMKyIqLL7vgKvUum+RhmedaKqZsKMbDvkilWFrSUckn0OBJxzJ/lNuZlVyo2SSPFiuFRrkym0DRRYCNSjJexfhotFKuFa5XAj0hUXHb70sXLxShavZ0sK6WKlM2FIEY3WULB4A2v6jMYWBLIQebttwAE8JKxe2uPzVU9HpBnYE6YaUIKBeKV3LlaaNjWBFVpCkoVtR8ZKctHADGVyGPktFhNplLrbKK5eVRYhdtk3mu6pDdga0Fl8SIfWN0fFipbC4dtk/+dsD1SsCnCOIVokB0pfjBnYJDZHWi+hQBhZAFqWvrh0/AaCWTVPukgku2clAqh+FpavGaqXbtzKoJ2S2pBNQqD3lVAVXASB3yIGxfiW5/FfIoVePZLnNpsIoU4yVrfNhUZtLyCYwmK6yyO6YUXLKzJrlfGYteKwmba6DvLxqmBIQQvxBC9AkhVu/P91hatdRuwN+3nCPX3VT0M7uUgGUOKjXYRHKQ+Wu+VPzhgnKP9SOpSyJl7OCzN/8UXru/8AMboxGSmiy7MwvsfIgjNn6r6Gd27QSsBWypwSbifRy15v8Vf9hGeaT18mkj5my6BV5fVviBjeaZhFbeNzJhz6Pwl88W/cwupWzthiIlJmAlspWjXislD3t261bIbslFkpTM3fAt2LO28DO75VEmtcvk3r/Ao/9d/EOHHMaN3AncBpy/v1/SbqaoLbXNa33pyyglVjT+EmaimjmYFZysfOH5COxeRvfgiqKfieHC7We9aPGJTGRMAdIxpu26rzgHG5VApZTBbS+UzjLu0+w5ZtIRNuRRylcT2nY/nSOvFf1MDG+3hQMYKRtKyUPE9zK578HiDw5vs41Dm19kyn4WwxEbby75marFSn5WCyql0Ai9fgetsUIzJYAYtc80Iihd+lQZ3czEvY8Vf25kh20cWv2ibLnPOa//oORnqm7fAqUWNOxMu5TyCSHErFqeGUwM0ieXEw0kuH+jcapyr+9VfJ1plg/04evcRiwYxNeZYE0siVz3W0LshrbWot+XHriNUWU9/ck0kU3L2aCGSYfKa9sVu1ewamA1vs5tPLItQs9AkMFYEl/nGtYmNjMaGiCp+PF1Jlg/vAVlcCV9QytQS3Bg9xPsaxtkQHYR3fgEW4SgX9uNJkqvwraNbOOpHSvwda5mzcgu7t/4CgBqx8v0qyE2pVrwdfYTCwaRPpWX+reye+dW/KU4AMN7bmFj4nAGkhHitLFHO5GIr/TJ1Vg6xmNbH2OfWEtaldy/cQ8AgwFDHk8P5spj9WicyLp7CAVTECzOI7nvp0RZRX8yRWTTk2xQW9CD5e2nT+18itXDa/B17uDBzXFagz52D8fxda5jdXwrsXA/wm/IY5uERzY8QGDHX1FKtcXWB+hv386g3kF04xNsVlQGtD40UXrX+MbQGzyx9Xl8nWt4ebCX8EYjmiTY9TK9SgsxJYGvM00sGKRfBHh570Z6t2/CV0YeQ3t+wMbEHAaSo0TpYI92PHG1dMz8aHKUZduXMepfg8DP/RuNyXM0tBq9Tef5kV34Ordn5LFqOMqekbsIleEQ33srcW0R/ckEo68/xQa1BVHBWvbE9idYH1mLr3M3f9yUQlUEm/sj+Do38lJ0O8nWPkQwgK8zwRZN8sj6+wn2/h5Risf6X7O3fS1DehvRjU/wuuJnUNuLVubsz/qB9Ty240V8netY2b+X9MYuANq6X2Y7rShqHF+HIY/dWohX9qyhd8u60vKQgwzu+SEbE4cykBwlIsaxR9tJUi19kG0oMcQT258gHnqVXVoL9280Fnvx8GqSUrIqsgVf505iwSBKR5IXBkfYMTBcVh7Rvu+QTB5DfzLG6OtPs15twRdovMVeVC5Ssh9fbiiBB6SUR5e55xqMtBSEZoWOn3PDnIbxsfDQpQ8xpa3QNpjSUxz/q+OpnLd0/3HS4FJ+9qkfFf3sk49+kse2FV+12Ikp8Wk89OHiq9X7Nt7Hfz75nw3nAPDkFU/SEegouD6UGGLp3UubwuG0fWdz62e+W/SzD/7tg6zYXXynZydmxmbzwLV/LPrZHa/dwTdWfKPhHIRUeOHKlfiK2Op3ju7kvN+f13AOAOfsvYD/+fdvFv3snX96J2v3FTHr2IzDI/O496O/LfrZj176ET9c9cOGcwjoAVZ+YGXZe4QQK6WUJ9T7jsZmt6oCUsqfAj8FWLhooVwkvsm2gSi//OBiAL7xmyd5YEuS/zptDl9+YiOzelrY3B/lzx3fok1GGDn+23Q+/cGS3//Ggm+zefcuztxzM7d3ncxd7VtJlrBNSymRSI4fdz6Pr1jI3decxLSuMPGUxjnfeYK3HTGJNb17SahBNvdHuWXOSo7bdjtDJ/0voZXXEUz1F/3eTZPfwxb9EN6UfJDh0QE+OEVDL7PSSepJekLj2bL6g3zsjDlcvvgQAN5+y+O0BYOcOqObX72yg1k9LUzyx7h54JPEZ13BQHSIKX1/Kfqde9sXMTLrvSQ2/515Iw/yiUNOY1iUNs8kNaONDktfh57q4IfvXQTAl+5czqM7UgXy+Hvblwn4Qowe/QU6Vny85Pe+seDbbN+5mVP7v88Pu5fwp9bNpEuYq1JmDPmJ497BYyvm8MAnltIZ9tM3HOfSHz/Ne46aylNbeyFgyON73Q+wKPJ3hk67h84n3lWSw/qpH2B7eiKnxP7AlqTk0xOj6KK0PBJagmmth7DupSu47rwjuOiYqQBc8J1lzOhsZWZLkr9uTTKrp4WjWgb4fN9/EJtzDSODG5m499Gi39nbuZTojLejvf4n5kSW8aEZJ5Vd/Vp9durofzK+tY1vXLoQgP/45T94ujfNl06bw41Z8lgW/jy0HcLrE97C4Zu+U/J731jwbXbvWMfJ+37KzT1LeaTljZLpH6w+cULHe1j2wnSWffZ0VEVhY98oH7htBf9y7CH8ed0OQi0hNvdH+Vn3PcyLPMngmX+m67G3lOSwZvq17Ep2smTkTl6iky+NH0SrII/DOubx0guX8OVLjuLMeRMBOOvmx1g4sZMONcqynSlmjAtzesdOPrTrBqLz/43YrqfpGXi66Hfu7D6bxLQLEZt+x4zos1w545iyfSJlZmbt2vsljpzawX9dNB+Aj//8CV7Zp/GFJXO4abkhjx0DcR71f4JU9yK2dizmsM0/Lvm9byz4Nnu3vcSJg7fz5Qmn8lywuBnNTjiuBLIRUAKExAR8eoTp7dMBmBocj0zF6VAmIVP78OltyNQo3WIcE6TGYNs8eko4YlJKC0NtR7FLbWF6WqNDry59Q1dgMjLVzeSWqUxvb0XTJTLVTUhOwK/rpEUYmRql0zeR6WmNcMd8wjJASwkeW9sWE4i0Mllpo0WrLnnYpJbJbE510+mflGmLyYEeIukA7cpEZCqGqrfRog8xPa0RCU5FTfqZXoJDPDgXf9tRRHiR6WmNQJWpLAJyPLrsyJNHokAe40UnbYqf4dbD6S7BIRaYyFDbUexVYXpao71KeXT6JiFT3UxpnUZ3a4A2NYlMrSPEBFQthdANebTSw/S0RqjtSLo1pWRgwObWEwiMBphMiFgVjmKBYFLLVNamuukKTM60xST/eITWQgtJZCqBqrfRJnWmpzVGwocQGtlXUh4j4SMJtR1FiieZntbw4SdNZd+NTx9PkPYseUxAphK0m/JQLXm0dhJQOhgITC/JYTh8GN1tRzGkxJie1miV1cmjwzcRmepmWtt0fKqCnowiU5sIiwkoWgyf3oJMjdKekcfhjC/jLH2j5TgCmsJUAuzQKp9pEQgmtkxFprrpDk5heruxq5/oG4+qdxBWwshUElVvpR3j/zYcns2o8hpTS/DY13IMrW1HAQ8zPa2hVlF83id8qHoPYdGVkce04ARWJZN0+cbkQTrKJH8rutrFqH9qSXn0tx9Dd9tRRNV+Y16pUh77C1cpgWLwlSggrcg0engq0lc8HFGOP5LV7e/AjoBAKyY8Pw5atVawwl/0rIL0t6Kf/Fm0/uIca4VfEaRSuas0nzlx6MEelKHiDi594ZX0Jt9kS/ogv1LcUS+khhaeCSXCUeWkY3it7e22pGgplTZYtVbSir+oApChcegnfw7ZZ8/g8hcptamaQQrS34VS4pyKdsLH6I8swI5AQTOZaUFbKDKNFp6CLor/X/WpJ7K+5W3YUZnByqian0dJQUP3tRV7BADZOgn95M/BLnsOz/kseWTNahl5+NpKOl61xZ9iaPRw7AjctcoLp/MDWaSOHp4MoriNXz9kKZtCF1PaY9A4NDJE9C6MLKRHCCG2CyH+pZ7vsRo1Px5bkRpS8YFafFrR517MaMuh9byyKFQBvXkpG6yoJKn4SPm7Cp6RE+Yjj3irbRx8RY6k+6zIKOEjGZxQ9Dn9uA+hl2inejhAYTigkGlQfEi1eDfWj7yUaOgQWzhY5wR6I4XykCggFNJK4fQmJx+HnLPfAWsZ+JQy8lB8JIITiz4nj/sXpGKPIrLGR/5ZGqGnQfGXPLMhj34PseBkWzhYEVJ9eSkbVJkGUXqdKae9CTn7LFs4gBG9tzNvjKpYY9RPIlB8fMhjrrItvYu1SMpPoSGkBsJP2lc8hYt+zFUkAjZlFawRjYwOusLO78sPB1RkChR/Sc1qd6a+lG6kiB3KqtSXWW0qfnQlWPCMnaGZANEiKQKs1a9UfGhFOBj87EsbYR2QzbcaKxklUIKDjW1hxYS3+vPaQhoTH5gHCPW8EEib5RFJSTqCAbJbI3vS0WxSvOVgFXjPP7uhSA1N+NCbIA8rhUZ+ygarT5REI+QR8gFju0A1o5SbI4+EOUDyT3ErMmX0iRJjVOgaTp3ddf2J4VbrnEDeVrM12YsssdU1YG8lqXHBwgpObXHzOL7w49OKhJPZnDeoWIqAkDTfofhL5+yx6VQmQHuguDxaEqY8SpzeLrcirAchtdAE0qntySwKip5J0Ow5HGVhYlgp2Pa36OZ7FV+RMpv2o9OUR74SCKQHjYmv1MKglHKoA2MZbvPkke5DlpO7ze0zIVw4Rls1I+xWCp9thxXLYVyweIZbSyGWym5g56n+WuF6JTBm88xt1ISvAyVRJu9Ifm3X/YRPQCyV28ESfjOsUQhSRbZ50sb0AGC0Rf7pUOs4vtASJAMlrMw2bXUtDlAoj6Sv3ZBHqWR7fnvrAquiMJ1IXGlDmAegippBbMwWCYb5If/EsG4NKV0j2YTtvWV+yPeZ6cKHktxXdIcK2Jo+QzFr6+bLI6a0oySKR8wBELJ7fAhieRy0LCVUylxqLwfzXVnysHbrIjmIppYYBzYu1GqF65WAak4q+WUVhdTR2maWftDGiQ+MPKX9sVwOip4eW2kVNUvZuxvRpWGOyZ5+fWaOHD3YjaaUWE3sTxbU/K8y/0+D8VTedR2ttYw8bO7kElmQNliRGlrIyNWjF7O5lznJWQ90KRnJ841kzHOBzqaYHywUptCQaC2HlDSXShtNhBYK5IFWfozazEGThfOEYo4P6Wsr6SS3E9baKHtx4LeCN1qmoZcaow2QR7VwvRKwMidbW04LikyVNzHY3KgK0OovtHlaJim90lFLG2Ct+rKLeufYoH2Njy0wMzYUpNBQ9Ar231K+mzqhCFEoD8Y4FJWHzSYpnxAF7ZCJRhG+0qtwGxE2myDXZyaNya+c89nmRZIQhWm1sx3DerH32cxBLcIh21HfDITNyInsoxa+jN/ObwSzFIPNbVELXK8EMiGJWqGNzYqwiISLrDZsnnQ6g4UpYlWZQjeF2t99chEO9u4ErLw92VvNseggP0m/vdvrYqhGHkl/EbOU3fIIFFZwMiYdg8OeCUWqo9rMoT0gchQyZE86fhIBe81PxRBQC/uEP2vSMbgUmXhsbouuQGHK9+w+sXvShQ3n0FmEg5oVvBEN2xOdVg4hcy7P9k1YO4HyStm5qdj1SsAKSdwXyzU/hE3HF8Dq+TfBmz6S+6DNmtWvwJ68kMT22A6keahk96QL4F2/svWd+fBl7PFjHaxDmo4vaydwzePgs9f+XoxDvjlIlcmMPFYt+B4cl1c42+aVmE8prOo1Lt2XmXS2T30nvC0vLYfN5iCfYpjmshVBp74PMEMSQ5PhQ8VPDNvJAXIz3AYYm/gA+MRKOPrS3Adt3ikXk0dXui8j980zroYL85LZNYBDfpbdzrThk5CKn0jbHPjXR2x9ZyEHY8LKNhMGMUxUmUCWT7wAR+QpRW8nUBqWOSh//GrCj5IwBlwq0A3ds3NvsFmzjqZkQcbIuL8Lf3oQMFdd0xblPWXvTsAqKJPtgEubUb7C8hRMPRZ8jTNDWDsBkbXLyXZ8ASSD46FrRu6DDZBHfsbIqNKeCRbQ1SBMOSbvKXvlETfn3WSWLzIpLB+R2XGnHW/rO/Nh+cyy17+WEhBJs7jPuFnQnpcrqxHyyDPZZjuGdTUMk/JSiNk88cVMeWRvBhLWeRErKmd63Sl2qoJlHcxeGFg7AZE2I8d6DoPWvKABmxcotcD1SkARAlUUK4Ik0VqzJpr8Tm3zKmNCWCkoZ6jINPHQ1NIcbDYHWeFnxXwCeolDKHbDSmqYnV9mzPE1fezGvP+7tHnATwwrBWVKVNJobbOyOOTLw97u3h2yTk9ncbAckaWiQGyGZX7Ilodlg9ZbyvXNBsgjf3xUkIfdzukeUx6aLOYza7zPDorLwzLP6eGsw4MNlkctcL0SAKOIdG5cukSV6fKCtTlGP6AUxkGreiov4iB34hORPls5WAutbN9Etg06gwbWlC3GIVBsoOV1cmFzTHjJlA1lONhVynCMQ2GMvk/mmWIaDMv8UFke+QsSezPl+hVRVB5SlOkTseryaNXCAXKVctHx0UD4i8gj4xPICVbIk4fnEygPnyLYnWVvDBRztOQ3YqjLdg69kfxj8cncwzD5K532qdgJf5HqSb5ibdHAraUijCDR3VnH84s6vvLbwu5zG4pgV36KgCxHZDEOtBYp9bhfHIyfcS17FW4oAbvSQlSCFZeebY/3iyrGh83hqz6FwpQNWSe4i3GQbY2RR3bUripTRmRSkyZZi0N2uGxAjEXwZVAgj+bsVIrhgFACo0mNtsDYZJtxfGU3ZIO3/pGUpMWf+50dsW3IchwacE4g/1vHa0axl9xJx9735kMC7YGx7WvYKpCT8//PX+nYu92NpCTtgVxnc3d6V9578znY2y6WaybbDDI+bZ4ib9pOwPiZHS7birELLts3bTbFjKYkHXnyGJfaldvm+c1vc8iuNflnm4N6UrsQDayZkg9roRbO8o+0Y/oCmjhf1YIDQglMaQvmhCRmdgJa1sojf5Vh86QzIVwYfhbzd+emJ2iwEmjLlNoc4xETxsnYkjl7GoCOoC/jpIas3Uh2LpgGTzrFUjZE1E5EOit9R/6kb7MSsFI2ZJsfIorpm2mSElDMswrZfUKxTD3Zk18T5JGfsiGqdow5Q5vAYVywiDzUztJF7hsAy2eWLQ9pzQPZc1KD26IWHBBKwK+KnDhoayegh7IdLXkD3PbwM2FMfFnjSpUp4tmZGAsmGXs7X7Ej6WPmoOztZGNXPn5F5MVBm46vUFbEQ4MdXz6FHEUEhvlBy3FON7Z7j6UNHrvml6nS+XoaBL8i8s4JmOaHnDQijd2Z+YvIQ5FaeXnYrJSLycMnkySacH7GglpkjGZ8NP6s4I2CBYqXNqIsBLn2X8vGlmNHa/CkY4ksna0E9GRueoKCTm33KVnj50DWmQm/5YhsYidSRJ48Mua5MjbPBsgjPybcJ1PlHcM260ZL2sNZS0+fTFVIbGg/hCBHHkFRxDndBHnsyUvZ4LMy/ZbiYDMseUTSuY76kqd0GwDr5PbuIuOjXOCEZw6qgJSu05mVQjlj8yzXqA3aXmVvNTti23MHfIMFGTRPh2afV5io7TZz6JexhduMlK7n2H87hJFfW5ZTyjbLQy9i8ejU9pbvEzYjZJ5kVLPafmJ6V/EUCQ1EWs+1x3djFDhq5vjQJITyzgkEZbSp8rBOT2djQnJn+UymDUK2v2q8GDR+cWC+qgYHhBKY0BLIqeqlZGXOzKDBK52OIil7E/5O/Omh0hxsD8Mzfma3xajS3lSbJ8D4PHlkkB2a2uCVTlewMCY8IUIo5oG14u+0Vx6BjPlh7HtH1Q786WFb31MJ+fJIW6URc5yyjR0fXUElL4WG8buSKjM+bHbYWoukXHl04k81Vx5dIV+OPOLSmPxzzkUUmIOcUwKuLy8J4FcUNu4bK98YNLdXP1gX5+XX1zKajLB6/etcm/XMfy7rZfVoN37/IPGon3cBWxKm4yhd+6RpLXI2j+jMMc8BxeIxntfGc/tjBodfbnuBn2U9s277br56/zYGBwMk0nC4EkE158lRWbvQrciDjfvGKtsMj4wy4OvkEyaHn+54jh8l0jll6j5gcvD7Bzk1qrIY2BZPZlJe1IqAovDa3jEHrGXzvHn1MBvXGjw2BbdwVdYzn/l7H5tHDA5q1M/bgc0JoB30/FNGVcCKj9+SJQ90jQf7W7nbbIvfbnmJ72U9s3zDTn7WOyaPY0ScXnPXFNFrV1IWh80jRn+SUjIwPMIO3xQ+lyWP2/Oey5bHBVGVY4Hd8RRhWd9wNMbHWJ+wzA///cIe1ms9/HTHc1w8tJ13Zj3z4b/20jdkcOiI+rkIc3y0UrLQfHkOhjN0b0wyo3WsT9y3O8T9Zls8sHknX8965r6Xt3PfpjF5nEKCXaoRShyTtcvDnzVGhXnAdGB4lE3+ydxQpTwuiyjMA/Yl06DXNz58isiRh5W/6Ppnd7E9HeSnO57j8oHdZCeO+MAft2c4TIn6OA/YmgA92NhdPRwgSuDkQ8YxnEijpWN8+PTDeO3JNbAPhjWFEdLE0hKRyK3xuzcVIKoJfEKSlNYBDuOz3pE4c2r0Fc3pUJk/oY1oPMqli6azbvcw4XUaMd3PSMrgMBTPtVH3MY7hhEZUEyR10ABhjq/BKousZyPsg6WHjKM3kqBFJLn05JlMWqaQTIxxUGMpWmVugRuLg09IUmZbxDQdvc7zBEtnjCOtS3QtzrWnH8br/3geBmEorTAiDR5+BnOe2ZdUMxwCljzMthiKpRhfYxnmI7pUjhzfRjwR5b1vmsEzm/oJvp4ioquZthjOl4fsypGHrkg0UwkM6LUPhXFBweKpnfSNjLDg0MksmNbBhOWCRMqXI4985MrDuBbXdbQ6FgYAp8/s5untAwgtwTWnH8auxwMwDINphahmcAglcw9m7UuILHlYHIyfKU0SqLE55nerbBptJZGMcfWSWTz1qg5bYTRLHtF4rs+gT2vPlYcYq1xXjzwmtSgsmtzBvsgoi4+YyrSuFnqelSTSNcgDgZSQlJKROuVx5sweVvUOo+gJ/vW0Qxla5oNRGEgLoiaHlmTuwcVsDglzfMR1u0NLiuOAUAJnzerhrFk99PWt57zjp0NwAvwOrlt8OOmeo1m7ex1Lp50Ivxt75kcXz+bpl3bQ3T2JV98YhO0w0V//9nNyq8pNZ841OJxxmHHxhgiLJ4c57SSTw9knwlfGnjl1ZhtLzpzF00+9yI5hwRGJVgb37aubgyIE/37yoQAGj5NnwWsjxPp83HauyeG8JfCNboiNvef37zI4dHdPIrI6DQMQVgWROpvjgjkTuWDOxDF56J3wZ7hxyRFoHUcYPMafCH+6I/PMLy+dw9Mr1tLdPYn1m3bCTujZj943o13lq2eZ8lgym6sXT4Gb4K1zpnLuPLMtlh4B3xp75h1HdvK2E8fkMXM0TDIv6Vkt8CmCLyydY3A4/zjj4isDjEQDufK4Ife5bHmkXtZgCAKKoFRhuEp4+7zJvH3e5DF5jLbAY/Ct04/itaFhg8OTz8Pf788889t3H5bh8MaGTbAbun31j485nT6+drYpjzfN5L3zg/BtuHzedN52mNkWJxwO3x975poTJvChI8fkMWkwyMT9qDgZVAX/edrhpjzMvFEv7WVQTOC2s6uTBy9pKMPUuUc28J4F03jPgmkGjxMOgb0+eAZ+cPYxrN27zeDw94fgyceKcti+PgW90OWDbfvBo1ocED6BAmRS5JZztDQ4QsO0f6t61iSS79xJ2Zu6oihaevBp0dxrNofeVYRZGk9mV/MqOBHZ4PVG2qgoJvQyfiLN3pq2RVFMHs1GwDo7ki2PJtuc04YcctKFFPgEGpfeJIOWHlSn5RE0Q0OzT2k3e4yWwYGpBMwOlpM0Lb+DNTCTZjaHeLBMUiibU1cU5xEnFrI3PUU9HCAvaVqBI7LRSsDsE+GsbJn5SewCjS+6QzpOPDil8n0N5gAgcyadJg91Ux5aOCs1hBOpEtJx4qHS8pDNqP6WjqMLn6NhoOVwQJiDCjCyy/iZfUrWbGCJQD/pM+Cv0chcK6yBVuKcgH7sB9EXXtlYDgD73kBXimcQ3TvpdLoWN4HD0A7jZxF5JAPjUE+8tvErn5QZpqoUcgDQj/0AcsH785+yH/veQA/NLfrRnilvZtybrm48h0HTiFBkpxxtnUnwhA80noPloyspjw8i57yl8TwG3kDvmVnUvNM77Xx6TvqXxnMY3FKytOXQuIW0HXdF4zmUgTtVUyWoRoPmxKWbpph4yzTkgvc1nkPSOA6v6MVtyvqJH4dgR+N5BNuKhCQaE+7eyWfB5OMazyFjDsoe8IY8om2zkPPfWewpe5E0lECuOWhs6OsnfsL2YvdFEWzDlx4p+lHf1PNgwvzGc7B2PEVCREc7j0DOvaTxHKzwbVk8bFg/8eOZcdxQBFpLyqN3+sXQfVhzOOixoh+NdC1AHnZe4zmUwYGpBMytZlkbdJM4JAITK9zYYGgpYqHpxT9rlt1RSxgH1pp4MKgYBwAtlJ3Gw4HuraWIhacV/6xZ8kgnSPnyFiDNtkFb5rlgmVQizYCWV/MjG02TR5JYdnoZ4+Xmz+YltyuFA1MJDJnb3aI2zyY1asJYfetNKlZREvteL+SQshxhTerkA1ty02dAZoA1beqxctP7HLSDA4zsKlNgvlnyeKOIPMy2aFZGzYiZ3TZ7jDb7VKyUkIqUyeXUTHk0N59ULTgwlYBldshJzWqmVEjUH4JZEzJFa5p7WrcA/jBqdiZT8xpgeyGX0hxCuVFSkJGN3ywv2HBo1v+1zCnZJsGXjpT4pEkTsL8FX3o076Lxbn/2iepGwlI2TcwdVABzjKpacVOMbNb0V9QkZbSPr8mnmYvhwFQC6XiR7a6xykhmbz8bzAEg1cQMhUWhpYiFipsftAYWnM9BOkEsPyJGseTR0yQOhjz0QJY8mr3yNENQY+Hi5oem7RrTCWLhQ4p+lAo2qb9agRP+rHHabCVg+onioXxTjAG7y1uWRDpBLFzcZJsOdDWHQxkcmEqgf0PhgLKig5plfxg2IpSanTY4B7oOqWjhVjOz5W+SePeuLymPpm25h7YDDodFJo3Vt66UCjtsUlvsXV/YL5tYWAWAwS3Ga3PChpvsl8iYbIuP0abtBPauLzlGnfcIHKhKINiBouUdxGr2pGO+T29GnHEpmJOOIpN5H5gdrFmTYLADVXdYHmakmPRnlbFs9qRjykPI4ofSmiaPUEdJE0jT5GFFjOXIo8nTTcpqgxJTrZPjI8PJ+UNjB6YSSI4WbndNgar5yqGBHADSahMOIFXgUPIwTLM6eXKUaP5213y3oucrqAbBjEuXPntrGdfGwZRHsETt3GbJIzFa0vzQlFO6AIkRIzbeSZ+AOT4SgQlFP26aUk6OEi0VweeCvcCBqQTiw6R9eYfBTCeo1qwyi3EjRW7a56ASiBvb3QJFZEbKNK2TJ0bQ8jmY5ygKolQaxmHYmHSaWGazGAcATS1+ULF58hgu7BPxQeNns3ZHieHCsdGsvmDBHB9aqTHaLHnEh9Hy56tokwImqsABqgSG0NS8FZ+Zn6NpRaXjQ+AL5RbNaDYyiiivLVoM53jTJp3YYOGAD3UCIJq10okPFbZDs5GRR/ET3E2xQUtZvC3CTQ5giA8VKqJmHA7L4TAIlN6tN0UeqThoiUJ5tBq7k6bNV2VwYCqBaD+p/IGWKSHXpEaN7oPwuMr3NZSDsZoomHQyq70miFfXITZAOj9ay7J1NquTF+sTzYYpj5I8mqGUk6OgJQsnHdF8eRT0iWabg6zx4S9xcr8ZfDJ9olRbeEqgdqQTEB8klR9aZW01m3YYpi+jzR1DpA+AlL8r7wNjwDdlJxDbB1Ijmc8hY3VokjxG9xRphyZjtJQ8DDRFHhkO+QsU6/Ceg/JotqN+tA+EWlIpN0UemTHamfeBe04MuyuB3OBW3t/3TSLxJNx7B0idhTt3E9rSgkAyNT4Emw2Pfzw4Kad6lhUTbkcnn7br73zLt4yeh+41aghKjWN27ia4pc3gMPAj2PAQzLtov99VFJF+lOEdfNP3E459rR32tGS1RStC6kxLDMMzz4JQSQTyYvEz9t/96OQx4zveO/gTOtIK3HtbcXlsMA7nJQqcoTZ0cvPRQ3c9wLd8Kq1/vg9UCVLPlce+H8K2Z0hMOGe/8sCXRGwAX3SYb/l+zAkvdcG2UI48psaHjT6x7i8Q7Cxpg96vSSdqtPNHIz+gM67CveNA11i4qzdXHq8ZyfwKndMy72cdMAsezN/1B5b6BMp99wN6Rh6Ztth3K+xZQ3zK22iIhyYxTGjkJb7le51jnh8HG4Kl5dE1o2Qa7f0yB0X3gtT4j8T36dnpg3u7isvj5U0G5Xx5mD5MN5iD3KUEEsMcGV1JUhewNQyKSkc0gZIIgVBQtZSRlG3mEgY7j6PYMaT9OoFn5jsZN/gqJ6sBQrveMPLgC4W2aAI1FcanpWAoAlOOhWPfC1vqf11JDG5DxPexRN1Nx2AAEkEQKu3ROGoqDCgoWgqmHAOzTqWgBEaoEyJ7kPuTQ75vDQAnxJ7CLzuKyENF1ZLQ0QGzT2Oo42hysiiZE4YvlX9ytQaYW+mJgy9xshrCt2OzoewVlTazLXxaCoYjMHURfV1n0pAkziO7UOPDnKLuoGtfEKKBHHn4tDQMjhrymHsBlAiIkiUySVaFvtcAOCG5AlWEYWuohDy6YeI8RtuKZzJVS55mrgLmWYzpQys5Rm1BbNtsTLBZ8lAteUw7nr3jTqNEFqX9Q6Qff2yUU1QYtzcEI/7S8jj6MijVBfdHKfetBalzgrYKNerLyKM9mkDNkcdUOORNRMMzc583zddKyVDe5sFdSmDS0Xxx1k94Y2+Ev336NACWP/gEEycaHdqoGGRcT/3tydxnzbQBuhLYbxvX7olLWNr7fh6/6gxm9hiruidNHtkcANjyZIlv2R9IZKCVJYmvcP3ZR/Kh0w7N4QC5bUF+W5gnJffvhKqxQvnSxO8yqM/kdx85BSgtDy2fQ7FU23VyeGPy+Vy35x28cM05dLca/6di8hj625ONUQIS9NA4liRu4OtvWcDli2eU5AAUysOEvj/5880F40e6fkJXxwR+cfWJQGl56PkczJj5/cphY65aX57yLj62+lw2fuICfKox2oq1xUiJdrAD6bapLNn2BW69dBFvWTilJAegpDz2zzxltMW7Wn7OMYd08b3Lj8vhALnykKXGqJPRbCYaqgSEEOcD38NYqv6vlPLrFR6pHxOOgFmnsn7825nXsJdUgSWfZvOeKKWigpuCd98OL95B2u+go/Sws2HGybw+5X00IXlyaSy+hteHg8xwksM7b4MNDze/ulc2jrkCXruf7Ye8ny7nWMCx72NjagqznOTw1lth9ytOMoBTPg67VtE7/S2UOFXSNDRMCQghVOBW4BxgO7BCCPFHKeVrpZ7RdElKqzMhm+qHqx8g9vijJW8JYJh7evu3sK1IJe1kyoxt1/fDTnfOjex5/NGSSiAoo0AQXRlh264NRe9JSn3//Ntz3mz8K9MWKhpCiZTkMBw3D8PV2xaBFvjggySqkMfOPW8QSBbmfB8c2rp/HAAu/Bb9jz9aUgkEsc4zlJZHCp1gnUXHATjq7ca/Mm2hoKGVkceouXKsuy1auuFfHiJVVh6GHWt730ZafIW7lt7BnSaH/Uia+LZbGXj80RJKQBKUxo5FE6XloSHR92eAHGfWGynRFgo6itCQZeQRMUvHavXy6JwOH3wQrYw8/KQQSrokB7vQyJ3AYmCjlPJ1ACHE3cBbgZJK4LVdwwys7eOoqfYWY7HEtEBbBYznS698DsosBDb0GgPO2uraxkPx0aX3AYewe9zzXPjQO4rfKGBOUpgc7I2osPwER+vrWN4SLs3BxKrtMebNtJeDbnI4TnuRP9HDR5+9puz9r+005KEqNreF4mdyehswna09T5duCwXmR4y+YHefsNpintzMqnCwrDyElKzrjTC5uzHyOF5/kccZx2WPXl72/pe3R1AVgbA52kcKPzPSG4CpbJjwOBc+9HjxG1XoHDHMv3aPD930r82SvWxqHSgrj6CEbftiLJ5lb5JEaXI4QX+RF+msOEb3F41UAtOAbVl/bwfelH+TEOIa4BqA8dNm86WL53PsIV22EpHCx6bFPyK4+h+cv2c7XZNLH5xRhMqEY6/isvFzmNppb16gXUf+O8Mj0/jQcJTXk71MmFQ642n31KW845ijuPgYe+sHbwsfj94mOV+D4N4NZTmE/RMZd+FZLJ5t70GjlNLK6yfcwrg1T3Penu2Mm1x6ECnCz8QT/5UrJ86kM2zvYaMdR3+Boefv5QPDEbYm+8q2xfgZb+biRUdz3lH2bt43t5xCMh3kkpSkZ/T1shxaA4fQedGJnHq4vZlyo2oPmxd9m8nrVnDO3h30TCotD1UEmHDKR7h20jTblfK2Y25k4IU/8t6REXYn+su2xYRD38JFixdw+lx7w7Q3tZ1BVO/kXQmN54a3lOXQ3jqH9ovnc9Y8ewtLDfqns+XYrzN74wucs3dXWXkA/D9W79f7GqkEivWQgr2TlPKnwE8BTjjhBPmBJbMbQmZ48llsfaOd6YM7+NT7rm3IOyoh3j6HtS3ncfz4uciNjznCI62EWR8+mznj5zLbIQ4AQ1PPY8eWbg5xUB6xzvmsbYnwpvFzUR1qi6TaxrrwOc7KQwgGpl9E37ZJzHRQHtFxx7CuJcmp4+fyvENtEVc7WRs+lznj57LHMXko7JvxdvbtmF6VPP7f+2/fr9c18rTEdiA7y9t0YGcD3+fBgwcPHmpEI5XACuBwIcRsIUQAuBz4YwPf58GDBw8eakTDzEFSyrQQ4uPA3zBCRH8hpXy1Ue/z4MGDBw+1o6HnBKSUfwH+0sh3ePDgwYOH+nHgJZDz4MGDBw+2wVMCHjx48HAQw1MCHjx48HAQw1MCHjx48HAQw1MCHjx48HAQw1MCHjx48HAQw1MCHjx48HAQw1MCHjx48HAQw1MCHjx48HAQw1MCHjx48HAQw1MCHjx48HAQw1MCHjx48HAQQ8j9KmZrL4QQI8A6p3lUgfHAXqdJVIEDgeeBwBE8nnbiQOAIBw7PI6SU7fU+3NAsonVgnZTyBKdJVIIQ4nmPpz04EDiCx9NOHAgc4cDiuT/Pe+YgDx48eDiI4SkBDx48eDiI4TYl8FOnCVQJj6d9OBA4gsfTThwIHOEg4ekqx7AHDx48eGgu3LYT8ODBgwcPTYSnBDx48ODhIIZrlIAQ4nwhxDohxEYhxOed5gMghDhECPGYEGKNEOJVIcSnzOs3CCF2CCFWmf8udAHXzUKIV0w+z5vXuoUQfxdCbDB/jnOY4xFZbbZKCDEshPi0G9pTCPELIUSfEGJ11rWS7SeE+ILZV9cJIc5zkOO3hBBrhRAvCyH+IIToMq/PEkLEstr0x83gWIZnSRm7qC1/k8VvsxBilXndybYsNQfZ1zellI7/A1RgE3AoEABeAua7gNcUYJH5ezuwHpgP3AB81ml+eVw3A+Pzrn0T+Lz5++eBbzjNM0/mu4GZbmhP4DRgEbC6UvuZfeAlIAjMNvuu6hDHcwGf+fs3sjjOyr7PBW1ZVMZuasu8z78N/JcL2rLUHGRb33TLTmAxsFFK+bqUMgncDbzVYU5IKXdJKV8wfx8B1gDTnGVVE94K/NL8/ZfA25yjUoCzgU1Syi1OEwGQUj4B7Mu7XKr93grcLaVMSCnfADZi9OGmc5RSPiSlTJt/PgNMbzSPSijRlqXgmra0IIQQwLuAuxrNoxLKzEG29U23KIFpwLasv7fjsslWCDELOA541rz0cXML/gunzSwmJPCQEGKlEOIa89okKeUuMDoTMNExdoW4nNxB5rb2hNLt59b++kHgr1l/zxZCvCiEeFwIcapTpLJQTMZubMtTgV4p5Yasa463Zd4cZFvfdIsSEEWuuSZ2VQjRBvwe+LSUchj4EXAYcCywC2Pr6DSWSCkXARcAHxNCnOY0oVIQQgSAS4Dfmpfc2J7l4Lr+KoS4HkgDd5qXdgEzpJTHAf8G/FoI0eEUP0rL2HVtCVxB7gLF8bYsMgeVvLXItbLt6RYlsB04JOvv6cBOh7jkQAjhx2j8O6WU9wJIKXullJqUUgd+RhO2r5Ugpdxp/uwD/oDBqVcIMQXA/NnnHMMcXAC8IKXsBXe2p4lS7eeq/iqEuAq4CHivNA3Dpjmg3/x9JYZteK5THMvI2G1t6QPeAfzGuuZ0Wxabg7Cxb7pFCawADhdCzDZXiZcDf3SYk2Ub/DmwRkr5P1nXp2Td9nZgdf6zzYQQolUI0W79juEsXI3RhleZt10F3O8MwwLkrLTc1p5ZKNV+fwQuF0IEhRCzgcOB5xzghxDifOA64BIpZTTr+gQhhGr+fqjJ8XUnOJocSsnYNW1p4s3AWinlduuCk21Zag7Czr7phMe7hBf8QgzP9ybgeqf5mJyWYmylXgZWmf8uBH4FvGJe/yMwxWGeh2JEBLwEvGq1H9ADPAJsMH92u6BNW4B+oDPrmuPtiaGUdgEpjNXUv5RrP+B6s6+uAy5wkONGDBuw1T9/bN57qdkXXgJeAC52uC1LytgtbWlevw24Nu9eJ9uy1BxkW9/00kZ48ODBw0EMt5iDPHjw4MGDA/CUgAcPHjwcxPCUgAcPHjwcxPCUgAcPHjwcxPCUgAcPHjwcxPCUgId/CggherKyPO7Oylg5KoT4YYPe+WkhxJV1PBcQQjxhHkzy4MFReCGiHv7pIIS4ARiVUt7cwHf4MGLGF8mxBG61PP8ljKSJd1a82YOHBsLbCXj4p4YQ4gwhxAPm7zcIIX4phHjIzBf/DiHEN4VRh+FB83g+QojjzURhK4UQf8s77WrhLIzUF2nzmWVCiG8IIZ4TQqy3kowJIY4yr60yk6cdbj5/H/DehjeABw8V4CkBDwcbDgPegpFy9w7gMSnlAiAGvMVUBN8HLpNSHg/8AripyPcsAVbmXfNJKRcDnwa+ZF67FvielPJY4ASM06lgpE040ab/kwcPdcOzSXo42PBXKWVKCPEKRmGbB83rr2AUDzkCOBr4u5G2BRUjvUA+pmDkds+GldxrpfldAE8D1wshpgP3SjM9sZRSE0IkhRDt0sgT78GDI/CUgIeDDQkAKaUuhEjJMaeYjjEeBPCqlPLkCt8TA0LFvhvQzO9CSvlrIcSzGLuPvwkh/lVK+ah5XxCI79f/xoOH/YRnDvLgIRfrgAlCiJPBSOMrhDiqyH1rgDmVvszMOvm6lPIWjMRpC83rPcAeKWXKNuYePNQBTwl48JAFaZQ3vQz4hhDiJYysjacUufWvGHVqK+HdwGphFC2fB9xuXj8T+Mv+8vXgYX/hhYh68FAnhBB/AP5D5pYhrPbZe4EvSCnX2c/Mg4fq4e0EPHioH5/HcBDXBLNw0n2eAvDgBng7AQ8ePHg4iOHtBDx48ODhIIanBDx48ODhIIanBDx48ODhIIanBDx48ODhIIanBDx48ODhIMb/B9GV1DYHgbuqAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -381,14 +485,14 @@ { "cell_type": "code", "execution_count": null, - "id": "69244a9c", + "id": "a443878d", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "ada25926", + "id": "ca0ab7e8", "metadata": {}, "source": [ "## Execution\n", @@ -399,18 +503,38 @@ }, { "cell_type": "code", - "execution_count": 146, - "id": "4ef8f47f", + "execution_count": 27, + "id": "a94273c9", + "metadata": {}, + "outputs": [], + "source": [ + "from qupulse.hardware.awgs.virtual import VirtualAWG" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "4f2f2591", + "metadata": {}, + "outputs": [], + "source": [ + "from qupulse.hardware.setup import HardwareSetup, MeasurementMask, PlaybackChannel" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "00a9186d", "metadata": {}, "outputs": [], "source": [ - "from qupulse.hardware.setup import HardwareSetup, MeasurementMask" + "my_awg = VirtualAWG(\"awg\", channels=3)" ] }, { "cell_type": "code", - "execution_count": 150, - "id": "4d6b9acc", + "execution_count": 30, + "id": "ffdc6396", "metadata": {}, "outputs": [], "source": [ @@ -419,92 +543,2448 @@ }, { "cell_type": "code", - "execution_count": 151, - "id": "a4731c70", + "execution_count": 31, + "id": "4e756118", "metadata": {}, "outputs": [], "source": [ - "for n in [\"R\", \"T\", \"A\"]:\n", - " setup.set_measurement(f\"{n}_lockin\", MeasurementMask(my_lockin, n))" + "for n in my_lockin.programs[None][\"channel_mapping\"].keys():\n", + " setup.set_measurement(f\"{n}\", MeasurementMask(my_lockin, n))" ] }, { "cell_type": "code", - "execution_count": 156, - "id": "c885518e", + "execution_count": 32, + "id": "847713ee", "metadata": {}, "outputs": [], "source": [ - "# for c in [\"red\", \"green\", \"trigger_out\"]:\n", - "# setup.set_channel(f\"{n}\", None)" + "for i, c in enumerate([\"red\", \"green\", \"trigger_out\"]):\n", + " setup.set_channel(f\"{c}\", PlaybackChannel(my_awg, i))" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "4f7e7867", + "metadata": {}, + "outputs": [], + "source": [ + "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "d240e903", + "metadata": {}, + "outputs": [], + "source": [ + "setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(None), update=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "72862ec2", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{None: {'channel_mapping': {'R': ['demods/0/sample.R'],\n", + " 'X': ['demods/0/sample.X'],\n", + " 'Y': ['demods/0/sample.Y'],\n", + " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", + " 'many': ['demods/0/sample.R',\n", + " 'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.X',\n", + " 'demods/0/sample.Y']}},\n", + " 'test': {'windows': {'X': (array([10.]), array([3.])),\n", + " 'R': (array([ 6.5, 14. ]), array([1.4, 1. ])),\n", + " 'A': (array([ 3., 12.]), array([1.5, 3. ]))},\n", + " 'masks': {'X': {'mask': array([[[16741.]],\n", + " \n", + " [[ 5022.]],\n", + " \n", + " [[21763.]]]),\n", + " 'channels': ['demods/0/sample.X'],\n", + " 'sample_rates': [TimeType(6857143, 4096)]},\n", + " 'R': {'mask': array([[[10882.],\n", + " [23438.]],\n", + " \n", + " [[ 2343.],\n", + " [ 1674.]],\n", + " \n", + " [[13225.],\n", + " [25112.]]]),\n", + " 'channels': ['demods/0/sample.R'],\n", + " 'sample_rates': [TimeType(6857143, 4096)]},\n", + " 'A': {'mask': array([[[nan],\n", + " [nan]],\n", + " \n", + " [[nan],\n", + " [nan]],\n", + " \n", + " [[nan],\n", + " [nan]]]),\n", + " 'channels': ['auxins/0/sample.AuxIn0.avg'],\n", + " 'sample_rates': [None]}},\n", + " 'all_channels': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", + " 'demods/0/sample.X'},\n", + " 'window_hull': [10882.0, 21763.0]}}" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.programs" ] }, { "cell_type": "code", - "execution_count": 158, - "id": "a8ae5cdf", + "execution_count": null, + "id": "2a211ced", "metadata": {}, "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "56298e79", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:283: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + " warnings.warn(f\"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.\")\n" + ] + } + ], + "source": [ + "setup.run_program(\"test\")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "5761973b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "waiting for device dev3442 to finish the acquisition.\n", + "{'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664383619736669], dtype=uint64), 'createdtimestamp': array([1393721038376], dtype=uint64), 'changedtimestamp': array([1393721038376], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '001 18:46:59.7359', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 1394500905096,\n", + " 1394500940936, 1394500976776]], dtype=uint64), 'value': array([[ nan, nan, nan, ..., -0.00060027,\n", + " -0.00061161, -0.00062295]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664383619737528], dtype=uint64), 'createdtimestamp': array([1393721038376], dtype=uint64), 'changedtimestamp': array([1393721038376], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '001 18:46:59.7359', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1393721026696, 1393721062536, 1393721098376, ..., 1394500905096,\n", + " 1394500940936, 1394500976776]], dtype=uint64), 'value': array([[1.28582697e-07, 2.34376326e-07, 2.38996428e-07, ...,\n", + " 5.87560559e-07, 5.32019319e-07, 4.14106693e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664383619737107], dtype=uint64), 'createdtimestamp': array([1393721038376], dtype=uint64), 'changedtimestamp': array([1393721038376], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '001 18:46:59.7359', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1393721026696, 1393721062536, 1393721098376, ..., 1394500905096,\n", + " 1394500940936, 1394500976776]], dtype=uint64), 'value': array([[ 3.39232042e-08, -8.97284119e-08, 9.67278307e-09, ...,\n", + " -5.81247741e-07, -5.16688776e-07, -4.03478886e-07]])}]}}}, 'forcetrigger': array([0], dtype=int64), 'triggered': array([0], dtype=int64)}\n" + ] + } + ], + "source": [ + "data = my_lockin.measure_program([\"\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "b8de12f0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "test_program = combined_pulse.create_program(parameters={})" + "data" ] }, { "cell_type": "code", - "execution_count": 159, - "id": "6a404a7a", + "execution_count": 39, + "id": "9907a87f", "metadata": {}, "outputs": [ { "ename": "KeyError", - "evalue": "\"The following channels are unknown to the HardwareSetup: {'green', 'trigger_out', 'red'}\"", + "evalue": "0", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_14832\\3018318824.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msetup\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mregister_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'puls_test'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtest_program\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrun_callback\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mlambda\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mupdate\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\setup.py\u001b[0m in \u001b[0;36mregister_program\u001b[1;34m(self, name, program, run_callback, update)\u001b[0m\n\u001b[0;32m 100\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mchannels\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_channel_map\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 101\u001b[0m raise KeyError('The following channels are unknown to the HardwareSetup: {}'.format(\n\u001b[1;32m--> 102\u001b[1;33m channels - set(self._channel_map.keys())))\n\u001b[0m\u001b[0;32m 103\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 104\u001b[0m \u001b[0mtemp_measurement_windows\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdefaultdict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mKeyError\u001b[0m: \"The following channels are unknown to the HardwareSetup: {'green', 'trigger_out', 'red'}\"" + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_32508\\1360584380.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mKeyError\u001b[0m: 0" ] } ], "source": [ - "setup.register_program('puls_test', test_program, run_callback=lambda *a, **b: None, update=True)" + "data[0][0].values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "89113a7c", + "metadata": {}, + "outputs": [], + "source": [ + "data[0][0].timestamp.values" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "8641d7d5", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "b0693faf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray '/dev3442/demods/0/sample.r' (col: 1, row: 21763)>\n",
+       "array([[1.28582697e-07, 2.34376326e-07, 2.38996428e-07, ...,\n",
+       "        5.87560559e-07, 5.32019319e-07, 4.14106693e-07]])\n",
+       "Coordinates:\n",
+       "    timestamp  (col, row) uint64 1393721026696 1393721062536 ... 1394500976776\n",
+       "Dimensions without coordinates: col, row\n",
+       "Attributes:\n",
+       "    systemtime:        [1664383619737528]\n",
+       "    createdtimestamp:  [1393721038376]\n",
+       "    changedtimestamp:  [1393721038376]\n",
+       "    flags:             [1849]\n",
+       "    moduleflags:       [0]\n",
+       "    chunksizebytes:    [0]\n",
+       "    name:              001 18:46:59.7359\n",
+       "    status:            [0]\n",
+       "    groupindex:        [0]\n",
+       "    color:             [0]\n",
+       "    activerow:         [0]\n",
+       "    triggernumber:     [0]\n",
+       "    gridrows:          [1]\n",
+       "    gridcols:          [21763]\n",
+       "    gridmode:          [4]\n",
+       "    gridoperation:     [1]\n",
+       "    griddirection:     [0]\n",
+       "    gridrepetitions:   [1]\n",
+       "    gridcoldelta:      [0.00059733]\n",
+       "    gridcoloffset:     [-0.001]\n",
+       "    gridrowdelta:      [1.]\n",
+       "    gridrowoffset:     [0.]\n",
+       "    bandwidth:         [nan]\n",
+       "    center:            [0.]\n",
+       "    nenbw:             [nan]
" + ], + "text/plain": [ + "\n", + "array([[1.28582697e-07, 2.34376326e-07, 2.38996428e-07, ...,\n", + " 5.87560559e-07, 5.32019319e-07, 4.14106693e-07]])\n", + "Coordinates:\n", + " timestamp (col, row) uint64 1393721026696 1393721062536 ... 1394500976776\n", + "Dimensions without coordinates: col, row\n", + "Attributes:\n", + " systemtime: [1664383619737528]\n", + " createdtimestamp: [1393721038376]\n", + " changedtimestamp: [1393721038376]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 18:46:59.7359\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [21763]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data['/dev3442/demods/0/sample.r'][0]" ] }, { "cell_type": "code", - "execution_count": 152, - "id": "6b0dfe3c", + "execution_count": 48, + "id": "b0864fca", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{}" + "13.000597371565114" ] }, - "execution_count": 152, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "setup.run_program()" + "21763/1.674e3" ] }, { "cell_type": "code", - "execution_count": null, - "id": "986388ed", + "execution_count": 44, + "id": "cd038089", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for name, d in data.items():\n", + " plt.plot(d[0].timestamp.values.reshape((-1)), d[0].values.reshape((-1)), label=d[0].name)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "a0dbfbd2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(385)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 383 \u001b[1;33m \u001b[0mchannel_name\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34mf\"/{device_name}/{input_name}/{signal_name}/{final_level_name}\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 384 \u001b[1;33m\t\t\t\t\t\t\tchannel_data = xr.DataArray(\n", + "\u001b[0m\u001b[1;32m--> 385 \u001b[1;33m \u001b[0mdata\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mfinal_level_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"value\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 386 \u001b[1;33m \u001b[0mcords\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m'timestamp'\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mfinal_level_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'timestamp'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 387 \u001b[1;33m \u001b[0mdims\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'col'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'row'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> final_level_data\n", + "[{'header': {'systemtime': array([1664382261279112], dtype=uint64), 'createdtimestamp': array([1312194966056], dtype=uint64), 'changedtimestamp': array([1312194966056], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '007 18:24:21.2784', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1312194954376, 1312194990216, 1312195026056, ..., 1312974832776,\n", + " 1312974868616, 1312974904456]], dtype=uint64), 'value': array([[-0.00083702, -0.00081435, -0.00079167, ..., -0.00066342,\n", + " -0.00066342, -0.00066342]])}]\n", + "ipdb> final_level_data['values']\n", + "*** TypeError: list indices must be integers or slices, not str\n", + "ipdb> final_level_data['value']\n", + "*** TypeError: list indices must be integers or slices, not str\n", + "ipdb> r\n" + ] + } + ], + "source": [ + "%debug" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "96606726", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'forcetrigger': array([0], dtype=int64), 'triggered': array([1], dtype=int64)}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{}\n", + "Progress [0.]\n", + "{'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664381184448982], dtype=uint64), 'createdtimestamp': array([1247600892456], dtype=uint64), 'changedtimestamp': array([1247600892456], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 18:06:24.4482', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1247600880776, 1247600916616, 1247600952456, ..., 1248380759176,\n", + " 1248380795016, 1248380830856]], dtype=uint64), 'value': array([[-2.43316761e-05, -5.26761886e-05, -8.10207011e-05, ...,\n", + " 4.80435375e-04, 5.08779887e-04, 5.37124400e-04]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664381184449458], dtype=uint64), 'createdtimestamp': array([1247600892456], dtype=uint64), 'changedtimestamp': array([1247600892456], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 18:06:24.4482', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1247600880776, 1247600916616, 1247600952456, ..., 1248380759176,\n", + " 1248380795016, 1248380830856]], dtype=uint64), 'value': array([[1.78793064e-07, 2.95350018e-07, 3.64539359e-07, ...,\n", + " 3.68635535e-07, 4.18934422e-07, 6.62816282e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664381184449892], dtype=uint64), 'createdtimestamp': array([1247600892456], dtype=uint64), 'changedtimestamp': array([1247600892456], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 18:06:24.4482', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1247600880776, 1247600916616, 1247600952456, ..., 1248380759176,\n", + " 1248380795016, 1248380830856]], dtype=uint64), 'value': array([[1.52127041e-07, 2.01588166e-07, 1.77798752e-07, ...,\n", + " 3.64727363e-07, 3.53522672e-07, 3.08946072e-07]])}]}}}, 'triggered': array([0], dtype=int64)}\n", + "Progress [1.]\n" + ] + } + ], + "source": [ + "while not my_lockin.daq.finished():\n", + " time.sleep(1)\n", + " result = my_lockin.daq.read()\n", + " print(result)\n", + " print(f\"Progress {my_lockin.daq.progress()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "838d961b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(376)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 374 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 375 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mdevice_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdevice_data\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 376 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0minput_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput_data\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdevice_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 377 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0msignal_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msignal_data\u001b[0m \u001b[1;32min\u001b[0m \u001b[0minput_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 378 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msignal_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> device_data\n", + "array([0], dtype=int64)\n", + "ipdb> data\n", + "{'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664381558471132], dtype=uint64), 'createdtimestamp': array([1270042036776], dtype=uint64), 'changedtimestamp': array([1270042036776], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '005 18:12:38.4705', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1270042025096, 1270042060936, 1270042096776, ..., 1270821903496,\n", + " 1270821939336, 1270821975176]], dtype=uint64), 'value': array([[-0.00225105, -0.00225672, -0.00226239, ..., -0.00142828,\n", + " -0.00145662, -0.00148496]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664381558471577], dtype=uint64), 'createdtimestamp': array([1270042036776], dtype=uint64), 'changedtimestamp': array([1270042036776], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '005 18:12:38.4705', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1270042025096, 1270042060936, 1270042096776, ..., 1270821903496,\n", + " 1270821939336, 1270821975176]], dtype=uint64), 'value': array([[7.96188229e-07, 1.00931080e-06, 9.46633590e-07, ...,\n", + " 4.39649550e-07, 4.78960669e-07, 5.21563402e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664381558471999], dtype=uint64), 'createdtimestamp': array([1270042036776], dtype=uint64), 'changedtimestamp': array([1270042036776], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '005 18:12:38.4705', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1270042025096, 1270042060936, 1270042096776, ..., 1270821903496,\n", + " 1270821939336, 1270821975176]], dtype=uint64), 'value': array([[-7.14710861e-08, -1.44757501e-07, -2.49910226e-07, ...,\n", + " 5.42141045e-08, 1.21691587e-08, -4.78550733e-08]])}]}}}, 'forcetrigger': array([0], dtype=int64), 'triggered': array([0], dtype=int64)}\n", + "ipdb> r\n" + ] + } + ], + "source": [ + "%debug" + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "id": "339755e2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'awgcontrol': array([0], dtype=int64),\n", + " 'bandwidth': array([0.]),\n", + " 'bitmask': array([1], dtype=int64),\n", + " 'bits': array([1], dtype=int64),\n", + " 'buffercount': array([2], dtype=int64),\n", + " 'buffersize': array([0.2]),\n", + " 'clearhistory': array([0], dtype=int64),\n", + " 'count': array([1], dtype=int64),\n", + " 'delay': array([-0.001]),\n", + " 'device': [''],\n", + " 'duration': array([0.]),\n", + " 'edge': array([1], dtype=int64),\n", + " 'enable': array([1], dtype=int64),\n", + " 'endless': array([0], dtype=int64),\n", + " 'eventcount': {'mode': array([1], dtype=int64)},\n", + " 'fft': {'absolute': array([0], dtype=int64),\n", + " 'window': array([1], dtype=int64)},\n", + " 'findlevel': array([0], dtype=int64),\n", + " 'flags': array([8], dtype=int64),\n", + " 'forcetrigger': array([0], dtype=int64),\n", + " 'grid': {'cols': array([21763], dtype=int64),\n", + " 'direction': array([0], dtype=int64),\n", + " 'mode': array([4], dtype=int64),\n", + " 'overwrite': array([0], dtype=int64),\n", + " 'repetitions': array([1], dtype=int64),\n", + " 'rowrepetition': array([0], dtype=int64),\n", + " 'rows': array([1], dtype=int64),\n", + " 'waterfall': array([0], dtype=int64)},\n", + " 'historylength': array([100000], dtype=int64),\n", + " 'holdoff': {'count': array([0], dtype=int64), 'time': array([0.2])},\n", + " 'hysteresis': array([0.]),\n", + " 'level': array([0.]),\n", + " 'preview': array([0], dtype=int64),\n", + " 'pulse': {'max': array([0.001]), 'min': array([0.])},\n", + " 'refreshrate': array([5.]),\n", + " 'save': {'csvlocale': ['C'],\n", + " 'csvseparator': [';'],\n", + " 'directory': ['C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer'],\n", + " 'fileformat': array([0], dtype=int64),\n", + " 'filename': ['dataAcquisitionModule'],\n", + " 'save': array([0], dtype=int64),\n", + " 'saveonread': array([0], dtype=int64)},\n", + " 'spectrum': {'autobandwidth': array([0], dtype=int64),\n", + " 'enable': array([0], dtype=int64),\n", + " 'frequencyspan': array([13000.]),\n", + " 'overlapped': array([1], dtype=int64)},\n", + " 'triggered': array([1], dtype=int64),\n", + " 'triggernode': [''],\n", + " 'type': array([1], dtype=int64)}" + ] + }, + "execution_count": 192, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq_read_return" + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "id": "c5240cf0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(357)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 355 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 356 \u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 357 \u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq_read_return\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 358 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 359 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> data\n", + "{'forcetrigger': array([0], dtype=int64), 'triggered': array([1], dtype=int64)}\n", + "ipdb> r\n" + ] + } + ], + "source": [ + "%debug" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "id": "cb7d26b3", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.clear()" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "id": "36774f10", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 145, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq.read(flat=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "614316d1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 119, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq.read()" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "id": "a9dfa502", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.force_trigger(None)" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "263575fe", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['__class__',\n", + " '__delattr__',\n", + " '__dir__',\n", + " '__doc__',\n", + " '__eq__',\n", + " '__format__',\n", + " '__ge__',\n", + " '__getattribute__',\n", + " '__gt__',\n", + " '__hash__',\n", + " '__init__',\n", + " '__init_subclass__',\n", + " '__le__',\n", + " '__lt__',\n", + " '__module__',\n", + " '__ne__',\n", + " '__new__',\n", + " '__reduce__',\n", + " '__reduce_ex__',\n", + " '__repr__',\n", + " '__setattr__',\n", + " '__sizeof__',\n", + " '__str__',\n", + " '__subclasshook__',\n", + " 'clear',\n", + " 'execute',\n", + " 'finish',\n", + " 'finished',\n", + " 'get',\n", + " 'getDouble',\n", + " 'getInt',\n", + " 'getString',\n", + " 'getStringUnicode',\n", + " 'help',\n", + " 'listNodes',\n", + " 'listNodesJSON',\n", + " 'progress',\n", + " 'read',\n", + " 'save',\n", + " 'set',\n", + " 'subscribe',\n", + " 'trigger',\n", + " 'unsubscribe']" + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dir(my_lockin.daq)" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "id": "4f8fa7d3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 169, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq.finished()" + ] + }, + { + "cell_type": "code", + "execution_count": 205, + "id": "a0b1b2b2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.])" + ] + }, + "execution_count": 205, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq.progress()" + ] + }, + { + "cell_type": "code", + "execution_count": 202, + "id": "6d228524", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.set('forcetrigger', 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "60365fd8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.])" + ] + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq.progress()" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "id": "76255359", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'triggered': array([0], dtype=int64)}" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq.read()" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "822c77dd", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.finish()" + ] + }, + { + "cell_type": "code", + "execution_count": 193, + "id": "9402f8fe", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.execute()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "55677713", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c980ada", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "306b8d9f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "021403d4", + "metadata": {}, + "outputs": [], + "source": [ + "import time" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "8738508f", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.clear()\n", + "my_lockin.daq = my_lockin.api_session.dataAcquisitionModule()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "8ce3ae43", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.api_session.setDebugLevel(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "9b977196", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'forcetrigger': array([0], dtype=int64), 'triggered': array([1], dtype=int64)}\n", + "Progress [0.] %\n", + "{'dev3442': {'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664380454830777], dtype=uint64), 'createdtimestamp': array([1204630954536], dtype=uint64), 'changedtimestamp': array([1204630954536], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '100 17:54:14.8306', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([1000], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1204630942856, 1204630978696, 1204631014536, 1204631050376,\n", + " 1204631086216, 1204631122056, 1204631157896, 1204631193736,\n", + " 1204631229576, 1204631265416, 1204631301256, 1204631337096,\n", + " 1204631372936, 1204631408776, 1204631444616, 1204631480456,\n", + " 1204631516296, 1204631552136, 1204631587976, 1204631623816,\n", + " 1204631659656, 1204631695496, 1204631731336, 1204631767176,\n", + " 1204631803016, 1204631838856, 1204631874696, 1204631910536,\n", + " 1204631946376, 1204631982216, 1204632018056, 1204632053896,\n", + " 1204632089736, 1204632125576, 1204632161416, 1204632197256,\n", + " 1204632233096, 1204632268936, 1204632304776, 1204632340616,\n", + " 1204632376456, 1204632412296, 1204632448136, 1204632483976,\n", + " 1204632519816, 1204632555656, 1204632591496, 1204632627336,\n", + " 1204632663176, 1204632699016, 1204632734856, 1204632770696,\n", + " 1204632806536, 1204632842376, 1204632878216, 1204632914056,\n", + " 1204632949896, 1204632985736, 1204633021576, 1204633057416,\n", + " 1204633093256, 1204633129096, 1204633164936, 1204633200776,\n", + " 1204633236616, 1204633272456, 1204633308296, 1204633344136,\n", + " 1204633379976, 1204633415816, 1204633451656, 1204633487496,\n", + " 1204633523336, 1204633559176, 1204633595016, 1204633630856,\n", + " 1204633666696, 1204633702536, 1204633738376, 1204633774216,\n", + " 1204633810056, 1204633845896, 1204633881736, 1204633917576,\n", + " 1204633953416, 1204633989256, 1204634025096, 1204634060936,\n", + " 1204634096776, 1204634132616, 1204634168456, 1204634204296,\n", + " 1204634240136, 1204634275976, 1204634311816, 1204634347656,\n", + " 1204634383496, 1204634419336, 1204634455176, 1204634491016,\n", + " 1204634526856, 1204634562696, 1204634598536, 1204634634376,\n", + " 1204634670216, 1204634706056, 1204634741896, 1204634777736,\n", + " 1204634813576, 1204634849416, 1204634885256, 1204634921096,\n", + " 1204634956936, 1204634992776, 1204635028616, 1204635064456,\n", + " 1204635100296, 1204635136136, 1204635171976, 1204635207816,\n", + " 1204635243656, 1204635279496, 1204635315336, 1204635351176,\n", + " 1204635387016, 1204635422856, 1204635458696, 1204635494536,\n", + " 1204635530376, 1204635566216, 1204635602056, 1204635637896,\n", + " 1204635673736, 1204635709576, 1204635745416, 1204635781256,\n", + " 1204635817096, 1204635852936, 1204635888776, 1204635924616,\n", + " 1204635960456, 1204635996296, 1204636032136, 1204636067976,\n", + " 1204636103816, 1204636139656, 1204636175496, 1204636211336,\n", + " 1204636247176, 1204636283016, 1204636318856, 1204636354696,\n", + " 1204636390536, 1204636426376, 1204636462216, 1204636498056,\n", + " 1204636533896, 1204636569736, 1204636605576, 1204636641416,\n", + " 1204636677256, 1204636713096, 1204636748936, 1204636784776,\n", + " 1204636820616, 1204636856456, 1204636892296, 1204636928136,\n", + " 1204636963976, 1204636999816, 1204637035656, 1204637071496,\n", + " 1204637107336, 1204637143176, 1204637179016, 1204637214856,\n", + " 1204637250696, 1204637286536, 1204637322376, 1204637358216,\n", + " 1204637394056, 1204637429896, 1204637465736, 1204637501576,\n", + " 1204637537416, 1204637573256, 1204637609096, 1204637644936,\n", + " 1204637680776, 1204637716616, 1204637752456, 1204637788296,\n", + " 1204637824136, 1204637859976, 1204637895816, 1204637931656,\n", + " 1204637967496, 1204638003336, 1204638039176, 1204638075016,\n", + " 1204638110856, 1204638146696, 1204638182536, 1204638218376,\n", + " 1204638254216, 1204638290056, 1204638325896, 1204638361736,\n", + " 1204638397576, 1204638433416, 1204638469256, 1204638505096,\n", + " 1204638540936, 1204638576776, 1204638612616, 1204638648456,\n", + " 1204638684296, 1204638720136, 1204638755976, 1204638791816,\n", + " 1204638827656, 1204638863496, 1204638899336, 1204638935176,\n", + " 1204638971016, 1204639006856, 1204639042696, 1204639078536,\n", + " 1204639114376, 1204639150216, 1204639186056, 1204639221896,\n", + " 1204639257736, 1204639293576, 1204639329416, 1204639365256,\n", + " 1204639401096, 1204639436936, 1204639472776, 1204639508616,\n", + " 1204639544456, 1204639580296, 1204639616136, 1204639651976,\n", + " 1204639687816, 1204639723656, 1204639759496, 1204639795336,\n", + " 1204639831176, 1204639867016, 1204639902856, 1204639938696,\n", + " 1204639974536, 1204640010376, 1204640046216, 1204640082056,\n", + " 1204640117896, 1204640153736, 1204640189576, 1204640225416,\n", + " 1204640261256, 1204640297096, 1204640332936, 1204640368776,\n", + " 1204640404616, 1204640440456, 1204640476296, 1204640512136,\n", + " 1204640547976, 1204640583816, 1204640619656, 1204640655496,\n", + " 1204640691336, 1204640727176, 1204640763016, 1204640798856,\n", + " 1204640834696, 1204640870536, 1204640906376, 1204640942216,\n", + " 1204640978056, 1204641013896, 1204641049736, 1204641085576,\n", + " 1204641121416, 1204641157256, 1204641193096, 1204641228936,\n", + " 1204641264776, 1204641300616, 1204641336456, 1204641372296,\n", + " 1204641408136, 1204641443976, 1204641479816, 1204641515656,\n", + " 1204641551496, 1204641587336, 1204641623176, 1204641659016,\n", + " 1204641694856, 1204641730696, 1204641766536, 1204641802376,\n", + " 1204641838216, 1204641874056, 1204641909896, 1204641945736,\n", + " 1204641981576, 1204642017416, 1204642053256, 1204642089096,\n", + " 1204642124936, 1204642160776, 1204642196616, 1204642232456,\n", + " 1204642268296, 1204642304136, 1204642339976, 1204642375816,\n", + " 1204642411656, 1204642447496, 1204642483336, 1204642519176,\n", + " 1204642555016, 1204642590856, 1204642626696, 1204642662536,\n", + " 1204642698376, 1204642734216, 1204642770056, 1204642805896,\n", + " 1204642841736, 1204642877576, 1204642913416, 1204642949256,\n", + " 1204642985096, 1204643020936, 1204643056776, 1204643092616,\n", + " 1204643128456, 1204643164296, 1204643200136, 1204643235976,\n", + " 1204643271816, 1204643307656, 1204643343496, 1204643379336,\n", + " 1204643415176, 1204643451016, 1204643486856, 1204643522696,\n", + " 1204643558536, 1204643594376, 1204643630216, 1204643666056,\n", + " 1204643701896, 1204643737736, 1204643773576, 1204643809416,\n", + " 1204643845256, 1204643881096, 1204643916936, 1204643952776,\n", + " 1204643988616, 1204644024456, 1204644060296, 1204644096136,\n", + " 1204644131976, 1204644167816, 1204644203656, 1204644239496,\n", + " 1204644275336, 1204644311176, 1204644347016, 1204644382856,\n", + " 1204644418696, 1204644454536, 1204644490376, 1204644526216,\n", + " 1204644562056, 1204644597896, 1204644633736, 1204644669576,\n", + " 1204644705416, 1204644741256, 1204644777096, 1204644812936,\n", + " 1204644848776, 1204644884616, 1204644920456, 1204644956296,\n", + " 1204644992136, 1204645027976, 1204645063816, 1204645099656,\n", + " 1204645135496, 1204645171336, 1204645207176, 1204645243016,\n", + " 1204645278856, 1204645314696, 1204645350536, 1204645386376,\n", + " 1204645422216, 1204645458056, 1204645493896, 1204645529736,\n", + " 1204645565576, 1204645601416, 1204645637256, 1204645673096,\n", + " 1204645708936, 1204645744776, 1204645780616, 1204645816456,\n", + " 1204645852296, 1204645888136, 1204645923976, 1204645959816,\n", + " 1204645995656, 1204646031496, 1204646067336, 1204646103176,\n", + " 1204646139016, 1204646174856, 1204646210696, 1204646246536,\n", + " 1204646282376, 1204646318216, 1204646354056, 1204646389896,\n", + " 1204646425736, 1204646461576, 1204646497416, 1204646533256,\n", + " 1204646569096, 1204646604936, 1204646640776, 1204646676616,\n", + " 1204646712456, 1204646748296, 1204646784136, 1204646819976,\n", + " 1204646855816, 1204646891656, 1204646927496, 1204646963336,\n", + " 1204646999176, 1204647035016, 1204647070856, 1204647106696,\n", + " 1204647142536, 1204647178376, 1204647214216, 1204647250056,\n", + " 1204647285896, 1204647321736, 1204647357576, 1204647393416,\n", + " 1204647429256, 1204647465096, 1204647500936, 1204647536776,\n", + " 1204647572616, 1204647608456, 1204647644296, 1204647680136,\n", + " 1204647715976, 1204647751816, 1204647787656, 1204647823496,\n", + " 1204647859336, 1204647895176, 1204647931016, 1204647966856,\n", + " 1204648002696, 1204648038536, 1204648074376, 1204648110216,\n", + " 1204648146056, 1204648181896, 1204648217736, 1204648253576,\n", + " 1204648289416, 1204648325256, 1204648361096, 1204648396936,\n", + " 1204648432776, 1204648468616, 1204648504456, 1204648540296,\n", + " 1204648576136, 1204648611976, 1204648647816, 1204648683656,\n", + " 1204648719496, 1204648755336, 1204648791176, 1204648827016,\n", + " 1204648862856, 1204648898696, 1204648934536, 1204648970376,\n", + " 1204649006216, 1204649042056, 1204649077896, 1204649113736,\n", + " 1204649149576, 1204649185416, 1204649221256, 1204649257096,\n", + " 1204649292936, 1204649328776, 1204649364616, 1204649400456,\n", + " 1204649436296, 1204649472136, 1204649507976, 1204649543816,\n", + " 1204649579656, 1204649615496, 1204649651336, 1204649687176,\n", + " 1204649723016, 1204649758856, 1204649794696, 1204649830536,\n", + " 1204649866376, 1204649902216, 1204649938056, 1204649973896,\n", + " 1204650009736, 1204650045576, 1204650081416, 1204650117256,\n", + " 1204650153096, 1204650188936, 1204650224776, 1204650260616,\n", + " 1204650296456, 1204650332296, 1204650368136, 1204650403976,\n", + " 1204650439816, 1204650475656, 1204650511496, 1204650547336,\n", + " 1204650583176, 1204650619016, 1204650654856, 1204650690696,\n", + " 1204650726536, 1204650762376, 1204650798216, 1204650834056,\n", + " 1204650869896, 1204650905736, 1204650941576, 1204650977416,\n", + " 1204651013256, 1204651049096, 1204651084936, 1204651120776,\n", + " 1204651156616, 1204651192456, 1204651228296, 1204651264136,\n", + " 1204651299976, 1204651335816, 1204651371656, 1204651407496,\n", + " 1204651443336, 1204651479176, 1204651515016, 1204651550856,\n", + " 1204651586696, 1204651622536, 1204651658376, 1204651694216,\n", + " 1204651730056, 1204651765896, 1204651801736, 1204651837576,\n", + " 1204651873416, 1204651909256, 1204651945096, 1204651980936,\n", + " 1204652016776, 1204652052616, 1204652088456, 1204652124296,\n", + " 1204652160136, 1204652195976, 1204652231816, 1204652267656,\n", + " 1204652303496, 1204652339336, 1204652375176, 1204652411016,\n", + " 1204652446856, 1204652482696, 1204652518536, 1204652554376,\n", + " 1204652590216, 1204652626056, 1204652661896, 1204652697736,\n", + " 1204652733576, 1204652769416, 1204652805256, 1204652841096,\n", + " 1204652876936, 1204652912776, 1204652948616, 1204652984456,\n", + " 1204653020296, 1204653056136, 1204653091976, 1204653127816,\n", + " 1204653163656, 1204653199496, 1204653235336, 1204653271176,\n", + " 1204653307016, 1204653342856, 1204653378696, 1204653414536,\n", + " 1204653450376, 1204653486216, 1204653522056, 1204653557896,\n", + " 1204653593736, 1204653629576, 1204653665416, 1204653701256,\n", + " 1204653737096, 1204653772936, 1204653808776, 1204653844616,\n", + " 1204653880456, 1204653916296, 1204653952136, 1204653987976,\n", + " 1204654023816, 1204654059656, 1204654095496, 1204654131336,\n", + " 1204654167176, 1204654203016, 1204654238856, 1204654274696,\n", + " 1204654310536, 1204654346376, 1204654382216, 1204654418056,\n", + " 1204654453896, 1204654489736, 1204654525576, 1204654561416,\n", + " 1204654597256, 1204654633096, 1204654668936, 1204654704776,\n", + " 1204654740616, 1204654776456, 1204654812296, 1204654848136,\n", + " 1204654883976, 1204654919816, 1204654955656, 1204654991496,\n", + " 1204655027336, 1204655063176, 1204655099016, 1204655134856,\n", + " 1204655170696, 1204655206536, 1204655242376, 1204655278216,\n", + " 1204655314056, 1204655349896, 1204655385736, 1204655421576,\n", + " 1204655457416, 1204655493256, 1204655529096, 1204655564936,\n", + " 1204655600776, 1204655636616, 1204655672456, 1204655708296,\n", + " 1204655744136, 1204655779976, 1204655815816, 1204655851656,\n", + " 1204655887496, 1204655923336, 1204655959176, 1204655995016,\n", + " 1204656030856, 1204656066696, 1204656102536, 1204656138376,\n", + " 1204656174216, 1204656210056, 1204656245896, 1204656281736,\n", + " 1204656317576, 1204656353416, 1204656389256, 1204656425096,\n", + " 1204656460936, 1204656496776, 1204656532616, 1204656568456,\n", + " 1204656604296, 1204656640136, 1204656675976, 1204656711816,\n", + " 1204656747656, 1204656783496, 1204656819336, 1204656855176,\n", + " 1204656891016, 1204656926856, 1204656962696, 1204656998536,\n", + " 1204657034376, 1204657070216, 1204657106056, 1204657141896,\n", + " 1204657177736, 1204657213576, 1204657249416, 1204657285256,\n", + " 1204657321096, 1204657356936, 1204657392776, 1204657428616,\n", + " 1204657464456, 1204657500296, 1204657536136, 1204657571976,\n", + " 1204657607816, 1204657643656, 1204657679496, 1204657715336,\n", + " 1204657751176, 1204657787016, 1204657822856, 1204657858696,\n", + " 1204657894536, 1204657930376, 1204657966216, 1204658002056,\n", + " 1204658037896, 1204658073736, 1204658109576, 1204658145416,\n", + " 1204658181256, 1204658217096, 1204658252936, 1204658288776,\n", + " 1204658324616, 1204658360456, 1204658396296, 1204658432136,\n", + " 1204658467976, 1204658503816, 1204658539656, 1204658575496,\n", + " 1204658611336, 1204658647176, 1204658683016, 1204658718856,\n", + " 1204658754696, 1204658790536, 1204658826376, 1204658862216,\n", + " 1204658898056, 1204658933896, 1204658969736, 1204659005576,\n", + " 1204659041416, 1204659077256, 1204659113096, 1204659148936,\n", + " 1204659184776, 1204659220616, 1204659256456, 1204659292296,\n", + " 1204659328136, 1204659363976, 1204659399816, 1204659435656,\n", + " 1204659471496, 1204659507336, 1204659543176, 1204659579016,\n", + " 1204659614856, 1204659650696, 1204659686536, 1204659722376,\n", + " 1204659758216, 1204659794056, 1204659829896, 1204659865736,\n", + " 1204659901576, 1204659937416, 1204659973256, 1204660009096,\n", + " 1204660044936, 1204660080776, 1204660116616, 1204660152456,\n", + " 1204660188296, 1204660224136, 1204660259976, 1204660295816,\n", + " 1204660331656, 1204660367496, 1204660403336, 1204660439176,\n", + " 1204660475016, 1204660510856, 1204660546696, 1204660582536,\n", + " 1204660618376, 1204660654216, 1204660690056, 1204660725896,\n", + " 1204660761736, 1204660797576, 1204660833416, 1204660869256,\n", + " 1204660905096, 1204660940936, 1204660976776, 1204661012616,\n", + " 1204661048456, 1204661084296, 1204661120136, 1204661155976,\n", + " 1204661191816, 1204661227656, 1204661263496, 1204661299336,\n", + " 1204661335176, 1204661371016, 1204661406856, 1204661442696,\n", + " 1204661478536, 1204661514376, 1204661550216, 1204661586056,\n", + " 1204661621896, 1204661657736, 1204661693576, 1204661729416,\n", + " 1204661765256, 1204661801096, 1204661836936, 1204661872776,\n", + " 1204661908616, 1204661944456, 1204661980296, 1204662016136,\n", + " 1204662051976, 1204662087816, 1204662123656, 1204662159496,\n", + " 1204662195336, 1204662231176, 1204662267016, 1204662302856,\n", + " 1204662338696, 1204662374536, 1204662410376, 1204662446216,\n", + " 1204662482056, 1204662517896, 1204662553736, 1204662589576,\n", + " 1204662625416, 1204662661256, 1204662697096, 1204662732936,\n", + " 1204662768776, 1204662804616, 1204662840456, 1204662876296,\n", + " 1204662912136, 1204662947976, 1204662983816, 1204663019656,\n", + " 1204663055496, 1204663091336, 1204663127176, 1204663163016,\n", + " 1204663198856, 1204663234696, 1204663270536, 1204663306376,\n", + " 1204663342216, 1204663378056, 1204663413896, 1204663449736,\n", + " 1204663485576, 1204663521416, 1204663557256, 1204663593096,\n", + " 1204663628936, 1204663664776, 1204663700616, 1204663736456,\n", + " 1204663772296, 1204663808136, 1204663843976, 1204663879816,\n", + " 1204663915656, 1204663951496, 1204663987336, 1204664023176,\n", + " 1204664059016, 1204664094856, 1204664130696, 1204664166536,\n", + " 1204664202376, 1204664238216, 1204664274056, 1204664309896,\n", + " 1204664345736, 1204664381576, 1204664417416, 1204664453256,\n", + " 1204664489096, 1204664524936, 1204664560776, 1204664596616,\n", + " 1204664632456, 1204664668296, 1204664704136, 1204664739976,\n", + " 1204664775816, 1204664811656, 1204664847496, 1204664883336,\n", + " 1204664919176, 1204664955016, 1204664990856, 1204665026696,\n", + " 1204665062536, 1204665098376, 1204665134216, 1204665170056,\n", + " 1204665205896, 1204665241736, 1204665277576, 1204665313416,\n", + " 1204665349256, 1204665385096, 1204665420936, 1204665456776,\n", + " 1204665492616, 1204665528456, 1204665564296, 1204665600136,\n", + " 1204665635976, 1204665671816, 1204665707656, 1204665743496,\n", + " 1204665779336, 1204665815176, 1204665851016, 1204665886856,\n", + " 1204665922696, 1204665958536, 1204665994376, 1204666030216,\n", + " 1204666066056, 1204666101896, 1204666137736, 1204666173576,\n", + " 1204666209416, 1204666245256, 1204666281096, 1204666316936,\n", + " 1204666352776, 1204666388616, 1204666424456, 1204666460296,\n", + " 1204666496136, 1204666531976, 1204666567816, 1204666603656,\n", + " 1204666639496, 1204666675336, 1204666711176, 1204666747016]],\n", + " dtype=uint64), 'value': array([[1.10172382e-06, 9.00993372e-07, 6.85672291e-07, 5.05722310e-07,\n", + " 2.63556648e-07, 2.84944932e-07, 3.43998598e-07, 3.56673579e-07,\n", + " 4.30376278e-07, 3.80952694e-07, 4.10249181e-07, 4.03857472e-07,\n", + " 3.59043179e-07, 3.51889392e-07, 5.21878583e-07, 6.58856069e-07,\n", + " 6.23421580e-07, 5.82284234e-07, 5.37666393e-07, 2.95894822e-07,\n", + " 1.12301962e-08, 3.05695226e-07, 6.04882662e-07, 9.20686311e-07,\n", + " 1.13660529e-06, 1.19092367e-06, 9.76087500e-07, 6.15055004e-07,\n", + " 3.13769275e-07, 1.81930674e-07, 2.39599186e-07, 2.50579467e-07,\n", + " 2.97543602e-07, 3.24700912e-07, 2.81532788e-07, 3.05032989e-07,\n", + " 5.97171120e-07, 7.96912833e-07, 7.64501338e-07, 6.77978549e-07,\n", + " 6.23856189e-07, 5.55979018e-07, 3.88805118e-07, 2.57782050e-07,\n", + " 1.68561224e-07, 1.32007622e-07, 7.78802425e-08, 1.63811875e-07,\n", + " 3.47639782e-07, 2.50012698e-07, 8.94291151e-08, 8.03697325e-08,\n", + " 1.30349154e-07, 2.19107313e-07, 4.69253203e-07, 6.39894882e-07,\n", + " 6.57779206e-07, 5.09883973e-07, 4.76852062e-07, 5.10156623e-07,\n", + " 6.23915346e-07, 5.94415979e-07, 4.12425406e-07, 2.67075364e-07,\n", + " 9.69192031e-08, 4.97695649e-08, 6.58232731e-08, 1.23616393e-07,\n", + " 2.54326451e-07, 2.70416881e-07, 1.38021070e-07, 8.80823575e-08,\n", + " 5.45155700e-08, 2.21586304e-07, 3.09675449e-07, 2.78693839e-07,\n", + " 2.33244356e-07, 2.13303117e-07, 3.95575820e-07, 5.10217416e-07,\n", + " 5.55577809e-07, 5.54332627e-07, 4.60837489e-07, 3.45195816e-07,\n", + " 4.08619026e-07, 3.29004646e-07, 1.99000774e-07, 6.32831896e-08,\n", + " 1.10443827e-07, 1.25044715e-07, 5.80890342e-08, 6.50742469e-08,\n", + " 3.18526981e-07, 5.52935197e-07, 6.18173192e-07, 6.35119098e-07,\n", + " 6.52850575e-07, 7.50804686e-07, 8.00443590e-07, 7.44553393e-07,\n", + " 5.48159761e-07, 3.03408876e-07, 3.71190485e-07, 4.09963545e-07,\n", + " 2.14933673e-07, 1.25808499e-07, 2.63823650e-07, 3.78668448e-07,\n", + " 4.21149267e-07, 4.30933377e-07, 3.88958810e-07, 3.39340699e-07,\n", + " 2.99199090e-07, 2.38414859e-07, 9.79969920e-08, 1.71532624e-07,\n", + " 4.15741660e-07, 6.09098279e-07, 7.58500603e-07, 8.81326664e-07,\n", + " 9.27644427e-07, 8.78532515e-07, 7.24006467e-07, 5.27521366e-07,\n", + " 3.13078440e-07, 1.78492138e-07, 1.02943885e-07, 9.00787678e-08,\n", + " 2.23117015e-07, 3.52778792e-07, 3.64945691e-07, 2.71476053e-07,\n", + " 1.50592943e-07, 9.85347571e-08, 1.37514951e-07, 2.62132523e-07,\n", + " 5.61961763e-07, 7.62610677e-07, 7.61311804e-07, 7.51694936e-07,\n", + " 6.75334372e-07, 6.38306937e-07, 6.09471814e-07, 5.06948147e-07,\n", + " 3.77760478e-07, 4.62184582e-07, 5.50134840e-07, 5.93225916e-07,\n", + " 5.70856045e-07, 4.45811062e-07, 2.64324269e-07, 1.74873117e-07,\n", + " 1.41081115e-07, 1.34482520e-07, 9.52025471e-08, 5.85520569e-08,\n", + " 1.73440558e-07, 2.22078318e-07, 2.33007683e-07, 3.03478090e-07,\n", + " 4.05284261e-07, 6.13934440e-07, 7.63735737e-07, 6.12481949e-07,\n", + " 3.23829195e-07, 1.47620966e-07, 1.72441448e-07, 3.74744625e-07,\n", + " 2.70861242e-07, 3.20812078e-08, 1.87066335e-07, 3.01109457e-07,\n", + " 4.91104778e-07, 4.33183644e-07, 2.82325730e-07, 2.97699066e-07,\n", + " 5.17974675e-07, 5.91289304e-07, 3.46911982e-07, 1.78438744e-07,\n", + " 1.02194575e-07, 1.57912315e-07, 2.22870560e-07, 3.24817655e-07,\n", + " 3.50475580e-07, 4.29146299e-07, 3.44077590e-07, 1.72237873e-07,\n", + " 9.22907941e-09, 2.21248674e-07, 3.25739808e-07, 2.14661637e-07,\n", + " 1.64524065e-07, 2.52054707e-07, 4.70487339e-07, 4.74727628e-07,\n", + " 3.43503301e-07, 5.03108132e-07, 5.68300504e-07, 4.01165899e-07,\n", + " 2.44321059e-07, 3.00103881e-07, 3.72187270e-07, 3.47736345e-07,\n", + " 3.10355839e-07, 2.75364159e-07, 4.09862560e-07, 5.73371383e-07,\n", + " 6.27081190e-07, 5.77312744e-07, 6.05007397e-07, 7.27155688e-07,\n", + " 5.92057189e-07, 1.91106106e-07, 2.56967975e-07, 2.92111836e-07,\n", + " 3.90146251e-07, 4.82477848e-07, 5.32305439e-07, 3.44347786e-07,\n", + " 1.72010907e-07, 1.73923000e-07, 2.50814343e-07, 3.89090037e-07,\n", + " 4.75643228e-07, 3.88711305e-07, 1.97222847e-07, 2.46780284e-07,\n", + " 2.64668826e-07, 2.89501174e-07, 4.01518224e-07, 6.74135688e-07,\n", + " 6.18645069e-07, 4.37556495e-07, 2.20923047e-07, 1.14419556e-07,\n", + " 1.26856734e-07, 1.00089621e-07, 1.19525727e-07, 2.57526231e-07,\n", + " 2.26675326e-07, 3.10498070e-07, 3.31654109e-07, 2.14005446e-07,\n", + " 1.86077339e-07, 2.48257635e-07, 3.22971276e-07, 2.40623303e-07,\n", + " 1.11573253e-07, 1.79141024e-07, 2.04903808e-07, 1.84530491e-07,\n", + " 2.06834505e-07, 3.85550780e-07, 4.17616354e-07, 4.10810334e-07,\n", + " 4.15976585e-07, 5.94376739e-07, 7.45402668e-07, 7.06737766e-07,\n", + " 5.06713546e-07, 4.63435309e-07, 5.54252429e-07, 6.89894794e-07,\n", + " 7.03826561e-07, 6.46166485e-07, 6.09534471e-07, 6.27221407e-07,\n", + " 6.25122666e-07, 6.02095574e-07, 5.38525279e-07, 4.77109918e-07,\n", + " 4.68633768e-07, 5.49740086e-07, 6.68247982e-07, 6.83298293e-07,\n", + " 5.75904493e-07, 4.71106274e-07, 2.62474890e-07, 2.08783763e-07,\n", + " 8.82209886e-08, 1.15886977e-08, 5.56766077e-08, 2.55647020e-07,\n", + " 4.29921534e-07, 3.63903429e-07, 2.24994979e-07, 6.40724979e-08,\n", + " 2.18174975e-07, 3.90993800e-07, 3.26305621e-07, 7.97413743e-08,\n", + " 2.02468614e-07, 2.89155193e-07, 3.85857853e-07, 5.37231927e-07,\n", + " 7.73238741e-07, 7.68905833e-07, 6.50909665e-07, 6.70089472e-07,\n", + " 6.39205529e-07, 4.08252469e-07, 2.21792694e-07, 1.14801932e-07,\n", + " 1.13725462e-07, 4.44966872e-07, 8.28901844e-07, 1.01473163e-06,\n", + " 9.24568619e-07, 6.14258722e-07, 3.35031847e-07, 1.85673215e-07,\n", + " 1.52792186e-07, 3.15459204e-07, 3.88451031e-07, 4.23969453e-07,\n", + " 4.50853976e-07, 4.95974133e-07, 4.31684977e-07, 1.04238612e-07,\n", + " 2.50071162e-07, 3.77273337e-07, 4.51408268e-07, 5.05259783e-07,\n", + " 5.63401662e-07, 6.04346571e-07, 5.15800601e-07, 4.71134910e-07,\n", + " 6.03224967e-07, 5.31633718e-07, 3.53417994e-07, 1.39320333e-07,\n", + " 1.22904463e-07, 1.90635450e-07, 3.05044716e-07, 3.71255569e-07,\n", + " 4.28827198e-07, 4.35061635e-07, 3.83926620e-07, 2.93598126e-07,\n", + " 3.03978936e-07, 3.76574453e-07, 4.38974518e-07, 3.67454943e-07,\n", + " 1.85178407e-07, 1.62951258e-07, 2.02209877e-07, 1.03071540e-07,\n", + " 8.78383533e-08, 2.79744145e-07, 3.49905868e-07, 3.96674925e-07,\n", + " 5.90938110e-07, 7.02573590e-07, 6.73909212e-07, 5.14048070e-07,\n", + " 3.30404926e-07, 1.62184815e-07, 2.37903294e-07, 4.85346027e-07,\n", + " 4.03753378e-07, 3.27056394e-07, 2.55584118e-07, 3.05960649e-07,\n", + " 3.83446085e-07, 5.74046413e-07, 6.27709939e-07, 4.78470426e-07,\n", + " 4.65230034e-07, 3.58294942e-07, 1.73612183e-07, 1.92023326e-07,\n", + " 2.54248171e-07, 3.19083436e-07, 1.38770681e-07, 5.41525005e-08,\n", + " 2.77540914e-07, 3.61662365e-07, 3.70860352e-07, 4.06588683e-07,\n", + " 3.85190720e-07, 3.84275516e-07, 3.16298031e-07, 2.21499569e-07,\n", + " 1.53273756e-07, 8.76957469e-08, 1.98060853e-07, 3.91326256e-07,\n", + " 4.25993278e-07, 3.35671756e-07, 5.19576302e-08, 1.70884313e-07,\n", + " 2.15189768e-07, 2.79358661e-07, 3.15516474e-07, 3.76591686e-07,\n", + " 3.18433151e-07, 2.40545801e-07, 2.08688055e-07, 2.82018612e-07,\n", + " 4.53363506e-07, 5.80581909e-07, 5.93196116e-07, 5.40983376e-07,\n", + " 5.58967494e-07, 5.55660148e-07, 6.35585684e-07, 6.20240423e-07,\n", + " 6.81962130e-07, 6.74469772e-07, 6.12472606e-07, 5.11543210e-07,\n", + " 5.75453913e-07, 6.05407513e-07, 5.33758830e-07, 4.72757988e-07,\n", + " 3.75739332e-07, 1.62924315e-07, 2.01131427e-07, 9.05138952e-08,\n", + " 7.45520615e-09, 2.17270471e-07, 2.89617935e-07, 1.30100758e-07,\n", + " 1.30095319e-07, 1.64433901e-07, 1.10164649e-07, 2.98595620e-07,\n", + " 3.83649826e-07, 2.78758448e-07, 2.28737139e-07, 1.84545341e-07,\n", + " 1.44420273e-07, 4.57294424e-07, 6.68904526e-07, 7.24629512e-07,\n", + " 6.92990602e-07, 5.50788691e-07, 3.61729826e-07, 1.54338849e-07,\n", + " 9.36556041e-08, 3.84913625e-07, 6.74676961e-07, 7.49737854e-07,\n", + " 7.91698334e-07, 6.41507399e-07, 6.01816832e-07, 7.41940247e-07,\n", + " 8.15793327e-07, 7.48879176e-07, 5.83365556e-07, 4.20656161e-07,\n", + " 3.18818747e-07, 2.04860203e-07, 2.77391239e-07, 3.67076249e-07,\n", + " 4.10224823e-07, 3.07760784e-07, 3.95908324e-07, 5.47137366e-07,\n", + " 6.51749747e-07, 7.29113815e-07, 7.38477703e-07, 7.71924829e-07,\n", + " 8.09991899e-07, 7.31862177e-07, 4.80444342e-07, 3.75488325e-07,\n", + " 2.30663163e-07, 1.25087616e-07, 1.81723196e-07, 1.51660581e-07,\n", + " 1.45726213e-07, 2.56302335e-07, 3.22508638e-07, 2.97016756e-07,\n", + " 2.46639946e-07, 1.80873620e-07, 1.10603196e-07, 4.11544779e-07,\n", + " 7.00062907e-07, 6.97734300e-07, 5.37358877e-07, 4.43892359e-07,\n", + " 4.13851719e-07, 4.61548999e-07, 4.83614804e-07, 5.09572495e-07,\n", + " 4.97111450e-07, 3.07411792e-07, 1.60220721e-07, 2.50309182e-07,\n", + " 3.48249997e-07, 2.60791915e-07, 1.46551304e-08, 2.78461321e-07,\n", + " 3.72349704e-07, 4.30719884e-07, 4.45666767e-07, 3.27599352e-07,\n", + " 1.23808373e-07, 6.23509798e-08, 1.75828335e-07, 3.04169271e-07,\n", + " 2.93007656e-07, 2.23771779e-07, 2.38133733e-07, 2.32698141e-07,\n", + " 3.81322503e-07, 4.33507591e-07, 4.77924413e-07, 4.98704734e-07,\n", + " 5.11102151e-07, 5.30412445e-07, 5.88101932e-07, 5.25820025e-07,\n", + " 3.64397164e-07, 1.28373792e-07, 1.67656421e-07, 3.26175983e-07,\n", + " 3.98572683e-07, 3.18682353e-07, 1.23289791e-07, 2.31347164e-07,\n", + " 4.30995051e-07, 4.94945496e-07, 5.00033328e-07, 2.90503592e-07,\n", + " 2.36491774e-07, 3.29661022e-07, 4.14656961e-07, 4.73994058e-07,\n", + " 3.92556499e-07, 3.58857059e-07, 3.39263702e-07, 1.55860375e-07,\n", + " 1.45640380e-07, 2.38803777e-07, 3.50502161e-07, 3.89760610e-07,\n", + " 2.96614664e-07, 3.38885974e-07, 4.63940538e-07, 4.33276263e-07,\n", + " 2.50469351e-07, 2.37320277e-07, 3.68405627e-07, 6.17641452e-07,\n", + " 8.84763346e-07, 9.17253173e-07, 7.06064935e-07, 4.99665046e-07,\n", + " 2.86683710e-07, 2.30685990e-07, 1.97848786e-07, 1.78313368e-07,\n", + " 2.21611128e-07, 3.62535608e-07, 5.24055643e-07, 5.77170078e-07,\n", + " 4.67761382e-07, 5.22425933e-07, 4.52543367e-07, 3.79985241e-07,\n", + " 2.77172847e-07, 1.49777161e-07, 1.15214658e-07, 3.59981435e-07,\n", + " 6.03369756e-07, 6.67961744e-07, 5.94612510e-07, 4.16769794e-07,\n", + " 2.58266120e-07, 3.39543432e-07, 4.73534940e-07, 4.96254211e-07,\n", + " 3.71374416e-07, 2.92820765e-07, 4.17394871e-07, 6.16769871e-07,\n", + " 6.53420767e-07, 6.01329267e-07, 5.84599318e-07, 5.32087815e-07,\n", + " 5.11893352e-07, 3.93062658e-07, 1.51709865e-07, 2.12522162e-08,\n", + " 8.89926409e-08, 2.71148514e-07, 5.10614147e-07, 5.86233899e-07,\n", + " 4.56926837e-07, 3.34114450e-07, 3.66266238e-07, 4.64055009e-07,\n", + " 4.71204388e-07, 4.68161087e-07, 4.35620452e-07, 4.07623605e-07,\n", + " 4.27871698e-07, 5.59862233e-07, 6.05468102e-07, 6.36568208e-07,\n", + " 6.54980918e-07, 6.15334462e-07, 3.32778868e-07, 2.44608204e-08,\n", + " 1.28116423e-07, 1.21720857e-07, 1.06496458e-07, 2.26547081e-07,\n", + " 3.03950013e-07, 2.72227746e-07, 2.15457545e-07, 2.44805478e-07,\n", + " 4.37398264e-07, 6.24068867e-07, 6.10211264e-07, 5.84822469e-07,\n", + " 5.59034655e-07, 5.62235625e-07, 5.81709446e-07, 5.34074456e-07,\n", + " 4.31861549e-07, 1.99938765e-07, 1.48787174e-07, 1.20190864e-07,\n", + " 2.57822474e-07, 4.45790132e-07, 4.20567341e-07, 3.44484166e-07,\n", + " 2.73959165e-07, 1.71478123e-07, 7.83323773e-08, 9.37151918e-08,\n", + " 2.49811716e-07, 3.09317789e-07, 3.02401749e-07, 2.48652746e-07,\n", + " 2.39160349e-07, 4.73779328e-07, 5.82964207e-07, 5.28841215e-07,\n", + " 5.67864881e-07, 6.37154438e-07, 6.33173841e-07, 4.17288629e-07,\n", + " 5.18028416e-07, 6.47880325e-07, 7.42836657e-07, 7.70841690e-07,\n", + " 6.62514309e-07, 5.13944815e-07, 3.45391554e-07, 1.26703549e-07,\n", + " 4.91374190e-08, 5.58747034e-08, 1.81795476e-07, 5.04145382e-07,\n", + " 6.36718257e-07, 6.19121328e-07, 5.05161528e-07, 4.23852618e-07,\n", + " 4.07100383e-07, 5.52901048e-07, 5.73362020e-07, 4.64448810e-07,\n", + " 4.09242005e-07, 4.58095006e-07, 4.36634270e-07, 3.77672928e-07,\n", + " 3.26387651e-07, 3.19701485e-07, 3.36957607e-07, 2.76393757e-07,\n", + " 2.33877207e-07, 5.99739826e-08, 3.87451598e-07, 5.06846618e-07,\n", + " 2.73912143e-07, 1.69720831e-07, 4.97385909e-07, 4.49638096e-07,\n", + " 2.75734554e-07, 2.83083828e-07, 3.61067130e-07, 2.82104562e-07,\n", + " 7.75347440e-08, 5.64334566e-08, 1.85022021e-07, 3.03871562e-07,\n", + " 3.10899044e-07, 2.72303530e-07, 2.21233625e-07, 2.48180434e-07,\n", + " 2.78723931e-07, 3.22697810e-07, 5.54059670e-07, 6.19390567e-07,\n", + " 5.51157971e-07, 3.76065087e-07, 4.20955015e-08, 1.22463307e-07,\n", + " 7.62915335e-08, 1.76891360e-07, 2.81819575e-07, 3.15055046e-07,\n", + " 3.26917003e-07, 2.59225916e-07, 1.12111201e-07, 3.54231417e-08,\n", + " 1.30066101e-07, 3.77238140e-07, 6.62036199e-07, 7.23178983e-07,\n", + " 6.28532827e-07, 4.20225381e-07, 1.97549962e-07, 3.35634207e-07,\n", + " 3.66089416e-07, 2.72458372e-07, 1.52055798e-07, 2.29626293e-07,\n", + " 2.16658080e-07, 1.38513811e-07, 2.10525809e-07, 2.35135964e-07,\n", + " 3.75240077e-07, 4.43467112e-07, 1.79198796e-07, 2.34808419e-07,\n", + " 5.07529421e-07, 6.96410096e-07, 6.45342656e-07, 4.42581123e-07,\n", + " 3.07838187e-07, 3.22290837e-07, 2.47777651e-07, 3.71568152e-07,\n", + " 4.23185003e-07, 3.48936635e-07, 2.53383478e-07, 3.81561622e-07,\n", + " 5.49555713e-07, 7.35642765e-07, 8.92304125e-07, 9.49032819e-07,\n", + " 8.15547663e-07, 6.47913144e-07, 5.53582472e-07, 5.82332542e-07,\n", + " 5.28295282e-07, 4.83346357e-07, 5.09975635e-07, 3.61859401e-07,\n", + " 1.87085701e-07, 1.00685767e-07, 6.48184726e-08, 2.51909657e-07,\n", + " 3.41402645e-07, 3.61064978e-07, 3.29101330e-07, 3.09282468e-07,\n", + " 3.56624640e-07, 3.56407153e-07, 4.19803216e-07, 5.20763489e-07,\n", + " 5.84085817e-07, 5.51045302e-07, 6.62566213e-07, 6.34141819e-07,\n", + " 4.17268796e-07, 3.84569151e-07, 4.20606084e-07, 3.47259006e-07,\n", + " 3.13524207e-07, 3.00912440e-07, 2.97730333e-07, 1.80344993e-07,\n", + " 5.71022710e-08, 1.61224854e-07, 1.54991875e-07, 2.70976776e-07,\n", + " 4.12883459e-07, 3.49212288e-07, 1.78077072e-07, 8.46431259e-08,\n", + " 2.16470941e-07, 4.71058132e-07, 5.17018370e-07, 4.12778655e-07,\n", + " 3.59922374e-07, 2.88825818e-07, 1.60507626e-07, 2.56569859e-07,\n", + " 3.94164341e-07, 4.51043831e-07, 4.16377396e-07, 3.41116493e-07,\n", + " 1.87434013e-07, 2.73445796e-07, 3.69698843e-07, 3.89326346e-07,\n", + " 2.05621253e-07, 6.39084693e-08, 2.03270487e-08, 2.19618890e-07,\n", + " 4.09822299e-07, 4.53437598e-07, 6.04374490e-07, 6.71124535e-07,\n", + " 5.35008768e-07, 3.31273048e-07, 1.86286264e-07, 7.87992030e-08,\n", + " 7.33899804e-08, 5.46788003e-08, 7.82461988e-08, 2.89594445e-07,\n", + " 4.71009109e-07, 6.25776587e-07, 7.29467199e-07, 7.03004149e-07,\n", + " 7.15162244e-07, 6.40278175e-07, 4.81499008e-07, 3.26249199e-07,\n", + " 2.51090617e-07, 3.26096355e-07, 4.67166693e-07, 4.49483618e-07,\n", + " 4.44373646e-07, 5.33181373e-07, 5.04411615e-07, 2.90559870e-07,\n", + " 1.76062043e-08, 6.63463654e-08, 6.20297987e-08, 1.36291039e-07,\n", + " 1.64785161e-07, 1.32513331e-07, 1.91439409e-07, 2.02623515e-07,\n", + " 2.60582721e-07, 3.29594684e-07, 3.19847083e-07, 4.86802232e-07,\n", + " 5.06645747e-07, 4.63002082e-07, 4.45252041e-07, 3.29432378e-07,\n", + " 1.33060167e-07, 1.12901016e-07, 5.26525262e-08, 2.23240071e-07,\n", + " 2.15720374e-07, 1.78089833e-07, 9.07086483e-08, 1.85874627e-07,\n", + " 3.43056815e-07, 5.23815412e-07, 5.41483621e-07, 5.34903506e-07,\n", + " 6.87934277e-07, 6.35206008e-07, 5.30810105e-07, 5.86690328e-07,\n", + " 5.96205596e-07, 4.76265283e-07, 2.59530478e-07, 1.74668642e-07,\n", + " 2.20707690e-07, 1.48224947e-07, 7.76568209e-08, 1.49773341e-07,\n", + " 1.78680352e-07, 1.50650345e-07, 1.71730188e-07, 1.91727303e-07,\n", + " 2.55737209e-07, 4.01336506e-07, 4.90735809e-07, 6.14103359e-07,\n", + " 7.46771362e-07, 7.70136971e-07, 7.22502224e-07, 6.80766422e-07,\n", + " 4.75239918e-07, 2.77572849e-07, 2.05658903e-07, 2.15890173e-07,\n", + " 3.81961906e-07, 5.64244747e-07, 6.73058541e-07, 6.74224365e-07,\n", + " 5.94286990e-07, 5.01544846e-07, 3.92881635e-07, 3.41382951e-07,\n", + " 3.33890182e-07, 1.99711452e-07, 2.42957717e-07, 3.43601866e-07,\n", + " 3.29441193e-07, 2.52072739e-07, 2.95682939e-07, 3.75249375e-07,\n", + " 3.42851182e-07, 3.24730227e-07, 2.39156456e-07, 1.41895006e-07,\n", + " 2.08806816e-07, 2.25333412e-07, 2.89249900e-07, 4.32962675e-07,\n", + " 3.95274135e-07, 2.61367467e-07, 2.59601271e-07, 3.31315463e-07,\n", + " 4.64020000e-07, 4.42235952e-07, 2.78579548e-07, 4.32860594e-08,\n", + " 1.19422155e-07, 2.20370440e-07, 2.72269130e-07, 1.95321901e-07,\n", + " 2.49038024e-07, 2.20263688e-07, 1.09444566e-07, 1.19985084e-07,\n", + " 1.64712500e-07, 2.54279504e-07, 5.21125581e-07, 5.99847999e-07,\n", + " 5.50143097e-07, 5.38032710e-07, 5.75328278e-07, 5.84995137e-07,\n", + " 5.91818588e-07, 6.61172483e-07, 5.09732156e-07, 3.38181717e-07,\n", + " 1.90165818e-07, 9.16482454e-08, 2.16879324e-07, 2.71869259e-07,\n", + " 2.34202087e-07, 1.64473707e-07, 1.85627516e-07, 4.21186435e-07,\n", + " 7.20099193e-07, 8.49382786e-07, 8.55383445e-07, 8.06922724e-07,\n", + " 8.86273143e-07, 1.09564047e-06, 1.02477921e-06, 7.71886033e-07,\n", + " 4.82086127e-07, 1.55281914e-07, 2.88683618e-07, 4.12018350e-07,\n", + " 3.66836577e-07, 3.69618906e-07, 3.32524375e-07, 2.48514935e-07,\n", + " 1.59734486e-07, 1.87519651e-07, 1.90979404e-07, 1.35212486e-07,\n", + " 1.37459873e-07, 2.72669989e-07, 3.34520602e-07, 4.73230690e-07,\n", + " 7.20279987e-07, 8.29459769e-07, 8.65655251e-07, 6.95763571e-07,\n", + " 3.59860664e-07, 3.39939569e-07, 4.08631101e-07, 4.24498281e-07,\n", + " 4.20614116e-07, 2.52512024e-07, 3.18811094e-07, 4.74561047e-07,\n", + " 5.65069723e-07, 5.56085131e-07, 4.72746776e-07, 2.86232741e-07,\n", + " 2.83763569e-07, 4.50330590e-07, 4.43099713e-07, 2.94279395e-07,\n", + " 1.94999411e-07, 1.30027981e-07, 7.19276390e-08, 7.09954223e-08]])}], 'sample.x': [{'header': {'systemtime': array([1664380454830796], dtype=uint64), 'createdtimestamp': array([1204630954536], dtype=uint64), 'changedtimestamp': array([1204630954536], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '100 17:54:14.8306', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([1000], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1204630942856, 1204630978696, 1204631014536, 1204631050376,\n", + " 1204631086216, 1204631122056, 1204631157896, 1204631193736,\n", + " 1204631229576, 1204631265416, 1204631301256, 1204631337096,\n", + " 1204631372936, 1204631408776, 1204631444616, 1204631480456,\n", + " 1204631516296, 1204631552136, 1204631587976, 1204631623816,\n", + " 1204631659656, 1204631695496, 1204631731336, 1204631767176,\n", + " 1204631803016, 1204631838856, 1204631874696, 1204631910536,\n", + " 1204631946376, 1204631982216, 1204632018056, 1204632053896,\n", + " 1204632089736, 1204632125576, 1204632161416, 1204632197256,\n", + " 1204632233096, 1204632268936, 1204632304776, 1204632340616,\n", + " 1204632376456, 1204632412296, 1204632448136, 1204632483976,\n", + " 1204632519816, 1204632555656, 1204632591496, 1204632627336,\n", + " 1204632663176, 1204632699016, 1204632734856, 1204632770696,\n", + " 1204632806536, 1204632842376, 1204632878216, 1204632914056,\n", + " 1204632949896, 1204632985736, 1204633021576, 1204633057416,\n", + " 1204633093256, 1204633129096, 1204633164936, 1204633200776,\n", + " 1204633236616, 1204633272456, 1204633308296, 1204633344136,\n", + " 1204633379976, 1204633415816, 1204633451656, 1204633487496,\n", + " 1204633523336, 1204633559176, 1204633595016, 1204633630856,\n", + " 1204633666696, 1204633702536, 1204633738376, 1204633774216,\n", + " 1204633810056, 1204633845896, 1204633881736, 1204633917576,\n", + " 1204633953416, 1204633989256, 1204634025096, 1204634060936,\n", + " 1204634096776, 1204634132616, 1204634168456, 1204634204296,\n", + " 1204634240136, 1204634275976, 1204634311816, 1204634347656,\n", + " 1204634383496, 1204634419336, 1204634455176, 1204634491016,\n", + " 1204634526856, 1204634562696, 1204634598536, 1204634634376,\n", + " 1204634670216, 1204634706056, 1204634741896, 1204634777736,\n", + " 1204634813576, 1204634849416, 1204634885256, 1204634921096,\n", + " 1204634956936, 1204634992776, 1204635028616, 1204635064456,\n", + " 1204635100296, 1204635136136, 1204635171976, 1204635207816,\n", + " 1204635243656, 1204635279496, 1204635315336, 1204635351176,\n", + " 1204635387016, 1204635422856, 1204635458696, 1204635494536,\n", + " 1204635530376, 1204635566216, 1204635602056, 1204635637896,\n", + " 1204635673736, 1204635709576, 1204635745416, 1204635781256,\n", + " 1204635817096, 1204635852936, 1204635888776, 1204635924616,\n", + " 1204635960456, 1204635996296, 1204636032136, 1204636067976,\n", + " 1204636103816, 1204636139656, 1204636175496, 1204636211336,\n", + " 1204636247176, 1204636283016, 1204636318856, 1204636354696,\n", + " 1204636390536, 1204636426376, 1204636462216, 1204636498056,\n", + " 1204636533896, 1204636569736, 1204636605576, 1204636641416,\n", + " 1204636677256, 1204636713096, 1204636748936, 1204636784776,\n", + " 1204636820616, 1204636856456, 1204636892296, 1204636928136,\n", + " 1204636963976, 1204636999816, 1204637035656, 1204637071496,\n", + " 1204637107336, 1204637143176, 1204637179016, 1204637214856,\n", + " 1204637250696, 1204637286536, 1204637322376, 1204637358216,\n", + " 1204637394056, 1204637429896, 1204637465736, 1204637501576,\n", + " 1204637537416, 1204637573256, 1204637609096, 1204637644936,\n", + " 1204637680776, 1204637716616, 1204637752456, 1204637788296,\n", + " 1204637824136, 1204637859976, 1204637895816, 1204637931656,\n", + " 1204637967496, 1204638003336, 1204638039176, 1204638075016,\n", + " 1204638110856, 1204638146696, 1204638182536, 1204638218376,\n", + " 1204638254216, 1204638290056, 1204638325896, 1204638361736,\n", + " 1204638397576, 1204638433416, 1204638469256, 1204638505096,\n", + " 1204638540936, 1204638576776, 1204638612616, 1204638648456,\n", + " 1204638684296, 1204638720136, 1204638755976, 1204638791816,\n", + " 1204638827656, 1204638863496, 1204638899336, 1204638935176,\n", + " 1204638971016, 1204639006856, 1204639042696, 1204639078536,\n", + " 1204639114376, 1204639150216, 1204639186056, 1204639221896,\n", + " 1204639257736, 1204639293576, 1204639329416, 1204639365256,\n", + " 1204639401096, 1204639436936, 1204639472776, 1204639508616,\n", + " 1204639544456, 1204639580296, 1204639616136, 1204639651976,\n", + " 1204639687816, 1204639723656, 1204639759496, 1204639795336,\n", + " 1204639831176, 1204639867016, 1204639902856, 1204639938696,\n", + " 1204639974536, 1204640010376, 1204640046216, 1204640082056,\n", + " 1204640117896, 1204640153736, 1204640189576, 1204640225416,\n", + " 1204640261256, 1204640297096, 1204640332936, 1204640368776,\n", + " 1204640404616, 1204640440456, 1204640476296, 1204640512136,\n", + " 1204640547976, 1204640583816, 1204640619656, 1204640655496,\n", + " 1204640691336, 1204640727176, 1204640763016, 1204640798856,\n", + " 1204640834696, 1204640870536, 1204640906376, 1204640942216,\n", + " 1204640978056, 1204641013896, 1204641049736, 1204641085576,\n", + " 1204641121416, 1204641157256, 1204641193096, 1204641228936,\n", + " 1204641264776, 1204641300616, 1204641336456, 1204641372296,\n", + " 1204641408136, 1204641443976, 1204641479816, 1204641515656,\n", + " 1204641551496, 1204641587336, 1204641623176, 1204641659016,\n", + " 1204641694856, 1204641730696, 1204641766536, 1204641802376,\n", + " 1204641838216, 1204641874056, 1204641909896, 1204641945736,\n", + " 1204641981576, 1204642017416, 1204642053256, 1204642089096,\n", + " 1204642124936, 1204642160776, 1204642196616, 1204642232456,\n", + " 1204642268296, 1204642304136, 1204642339976, 1204642375816,\n", + " 1204642411656, 1204642447496, 1204642483336, 1204642519176,\n", + " 1204642555016, 1204642590856, 1204642626696, 1204642662536,\n", + " 1204642698376, 1204642734216, 1204642770056, 1204642805896,\n", + " 1204642841736, 1204642877576, 1204642913416, 1204642949256,\n", + " 1204642985096, 1204643020936, 1204643056776, 1204643092616,\n", + " 1204643128456, 1204643164296, 1204643200136, 1204643235976,\n", + " 1204643271816, 1204643307656, 1204643343496, 1204643379336,\n", + " 1204643415176, 1204643451016, 1204643486856, 1204643522696,\n", + " 1204643558536, 1204643594376, 1204643630216, 1204643666056,\n", + " 1204643701896, 1204643737736, 1204643773576, 1204643809416,\n", + " 1204643845256, 1204643881096, 1204643916936, 1204643952776,\n", + " 1204643988616, 1204644024456, 1204644060296, 1204644096136,\n", + " 1204644131976, 1204644167816, 1204644203656, 1204644239496,\n", + " 1204644275336, 1204644311176, 1204644347016, 1204644382856,\n", + " 1204644418696, 1204644454536, 1204644490376, 1204644526216,\n", + " 1204644562056, 1204644597896, 1204644633736, 1204644669576,\n", + " 1204644705416, 1204644741256, 1204644777096, 1204644812936,\n", + " 1204644848776, 1204644884616, 1204644920456, 1204644956296,\n", + " 1204644992136, 1204645027976, 1204645063816, 1204645099656,\n", + " 1204645135496, 1204645171336, 1204645207176, 1204645243016,\n", + " 1204645278856, 1204645314696, 1204645350536, 1204645386376,\n", + " 1204645422216, 1204645458056, 1204645493896, 1204645529736,\n", + " 1204645565576, 1204645601416, 1204645637256, 1204645673096,\n", + " 1204645708936, 1204645744776, 1204645780616, 1204645816456,\n", + " 1204645852296, 1204645888136, 1204645923976, 1204645959816,\n", + " 1204645995656, 1204646031496, 1204646067336, 1204646103176,\n", + " 1204646139016, 1204646174856, 1204646210696, 1204646246536,\n", + " 1204646282376, 1204646318216, 1204646354056, 1204646389896,\n", + " 1204646425736, 1204646461576, 1204646497416, 1204646533256,\n", + " 1204646569096, 1204646604936, 1204646640776, 1204646676616,\n", + " 1204646712456, 1204646748296, 1204646784136, 1204646819976,\n", + " 1204646855816, 1204646891656, 1204646927496, 1204646963336,\n", + " 1204646999176, 1204647035016, 1204647070856, 1204647106696,\n", + " 1204647142536, 1204647178376, 1204647214216, 1204647250056,\n", + " 1204647285896, 1204647321736, 1204647357576, 1204647393416,\n", + " 1204647429256, 1204647465096, 1204647500936, 1204647536776,\n", + " 1204647572616, 1204647608456, 1204647644296, 1204647680136,\n", + " 1204647715976, 1204647751816, 1204647787656, 1204647823496,\n", + " 1204647859336, 1204647895176, 1204647931016, 1204647966856,\n", + " 1204648002696, 1204648038536, 1204648074376, 1204648110216,\n", + " 1204648146056, 1204648181896, 1204648217736, 1204648253576,\n", + " 1204648289416, 1204648325256, 1204648361096, 1204648396936,\n", + " 1204648432776, 1204648468616, 1204648504456, 1204648540296,\n", + " 1204648576136, 1204648611976, 1204648647816, 1204648683656,\n", + " 1204648719496, 1204648755336, 1204648791176, 1204648827016,\n", + " 1204648862856, 1204648898696, 1204648934536, 1204648970376,\n", + " 1204649006216, 1204649042056, 1204649077896, 1204649113736,\n", + " 1204649149576, 1204649185416, 1204649221256, 1204649257096,\n", + " 1204649292936, 1204649328776, 1204649364616, 1204649400456,\n", + " 1204649436296, 1204649472136, 1204649507976, 1204649543816,\n", + " 1204649579656, 1204649615496, 1204649651336, 1204649687176,\n", + " 1204649723016, 1204649758856, 1204649794696, 1204649830536,\n", + " 1204649866376, 1204649902216, 1204649938056, 1204649973896,\n", + " 1204650009736, 1204650045576, 1204650081416, 1204650117256,\n", + " 1204650153096, 1204650188936, 1204650224776, 1204650260616,\n", + " 1204650296456, 1204650332296, 1204650368136, 1204650403976,\n", + " 1204650439816, 1204650475656, 1204650511496, 1204650547336,\n", + " 1204650583176, 1204650619016, 1204650654856, 1204650690696,\n", + " 1204650726536, 1204650762376, 1204650798216, 1204650834056,\n", + " 1204650869896, 1204650905736, 1204650941576, 1204650977416,\n", + " 1204651013256, 1204651049096, 1204651084936, 1204651120776,\n", + " 1204651156616, 1204651192456, 1204651228296, 1204651264136,\n", + " 1204651299976, 1204651335816, 1204651371656, 1204651407496,\n", + " 1204651443336, 1204651479176, 1204651515016, 1204651550856,\n", + " 1204651586696, 1204651622536, 1204651658376, 1204651694216,\n", + " 1204651730056, 1204651765896, 1204651801736, 1204651837576,\n", + " 1204651873416, 1204651909256, 1204651945096, 1204651980936,\n", + " 1204652016776, 1204652052616, 1204652088456, 1204652124296,\n", + " 1204652160136, 1204652195976, 1204652231816, 1204652267656,\n", + " 1204652303496, 1204652339336, 1204652375176, 1204652411016,\n", + " 1204652446856, 1204652482696, 1204652518536, 1204652554376,\n", + " 1204652590216, 1204652626056, 1204652661896, 1204652697736,\n", + " 1204652733576, 1204652769416, 1204652805256, 1204652841096,\n", + " 1204652876936, 1204652912776, 1204652948616, 1204652984456,\n", + " 1204653020296, 1204653056136, 1204653091976, 1204653127816,\n", + " 1204653163656, 1204653199496, 1204653235336, 1204653271176,\n", + " 1204653307016, 1204653342856, 1204653378696, 1204653414536,\n", + " 1204653450376, 1204653486216, 1204653522056, 1204653557896,\n", + " 1204653593736, 1204653629576, 1204653665416, 1204653701256,\n", + " 1204653737096, 1204653772936, 1204653808776, 1204653844616,\n", + " 1204653880456, 1204653916296, 1204653952136, 1204653987976,\n", + " 1204654023816, 1204654059656, 1204654095496, 1204654131336,\n", + " 1204654167176, 1204654203016, 1204654238856, 1204654274696,\n", + " 1204654310536, 1204654346376, 1204654382216, 1204654418056,\n", + " 1204654453896, 1204654489736, 1204654525576, 1204654561416,\n", + " 1204654597256, 1204654633096, 1204654668936, 1204654704776,\n", + " 1204654740616, 1204654776456, 1204654812296, 1204654848136,\n", + " 1204654883976, 1204654919816, 1204654955656, 1204654991496,\n", + " 1204655027336, 1204655063176, 1204655099016, 1204655134856,\n", + " 1204655170696, 1204655206536, 1204655242376, 1204655278216,\n", + " 1204655314056, 1204655349896, 1204655385736, 1204655421576,\n", + " 1204655457416, 1204655493256, 1204655529096, 1204655564936,\n", + " 1204655600776, 1204655636616, 1204655672456, 1204655708296,\n", + " 1204655744136, 1204655779976, 1204655815816, 1204655851656,\n", + " 1204655887496, 1204655923336, 1204655959176, 1204655995016,\n", + " 1204656030856, 1204656066696, 1204656102536, 1204656138376,\n", + " 1204656174216, 1204656210056, 1204656245896, 1204656281736,\n", + " 1204656317576, 1204656353416, 1204656389256, 1204656425096,\n", + " 1204656460936, 1204656496776, 1204656532616, 1204656568456,\n", + " 1204656604296, 1204656640136, 1204656675976, 1204656711816,\n", + " 1204656747656, 1204656783496, 1204656819336, 1204656855176,\n", + " 1204656891016, 1204656926856, 1204656962696, 1204656998536,\n", + " 1204657034376, 1204657070216, 1204657106056, 1204657141896,\n", + " 1204657177736, 1204657213576, 1204657249416, 1204657285256,\n", + " 1204657321096, 1204657356936, 1204657392776, 1204657428616,\n", + " 1204657464456, 1204657500296, 1204657536136, 1204657571976,\n", + " 1204657607816, 1204657643656, 1204657679496, 1204657715336,\n", + " 1204657751176, 1204657787016, 1204657822856, 1204657858696,\n", + " 1204657894536, 1204657930376, 1204657966216, 1204658002056,\n", + " 1204658037896, 1204658073736, 1204658109576, 1204658145416,\n", + " 1204658181256, 1204658217096, 1204658252936, 1204658288776,\n", + " 1204658324616, 1204658360456, 1204658396296, 1204658432136,\n", + " 1204658467976, 1204658503816, 1204658539656, 1204658575496,\n", + " 1204658611336, 1204658647176, 1204658683016, 1204658718856,\n", + " 1204658754696, 1204658790536, 1204658826376, 1204658862216,\n", + " 1204658898056, 1204658933896, 1204658969736, 1204659005576,\n", + " 1204659041416, 1204659077256, 1204659113096, 1204659148936,\n", + " 1204659184776, 1204659220616, 1204659256456, 1204659292296,\n", + " 1204659328136, 1204659363976, 1204659399816, 1204659435656,\n", + " 1204659471496, 1204659507336, 1204659543176, 1204659579016,\n", + " 1204659614856, 1204659650696, 1204659686536, 1204659722376,\n", + " 1204659758216, 1204659794056, 1204659829896, 1204659865736,\n", + " 1204659901576, 1204659937416, 1204659973256, 1204660009096,\n", + " 1204660044936, 1204660080776, 1204660116616, 1204660152456,\n", + " 1204660188296, 1204660224136, 1204660259976, 1204660295816,\n", + " 1204660331656, 1204660367496, 1204660403336, 1204660439176,\n", + " 1204660475016, 1204660510856, 1204660546696, 1204660582536,\n", + " 1204660618376, 1204660654216, 1204660690056, 1204660725896,\n", + " 1204660761736, 1204660797576, 1204660833416, 1204660869256,\n", + " 1204660905096, 1204660940936, 1204660976776, 1204661012616,\n", + " 1204661048456, 1204661084296, 1204661120136, 1204661155976,\n", + " 1204661191816, 1204661227656, 1204661263496, 1204661299336,\n", + " 1204661335176, 1204661371016, 1204661406856, 1204661442696,\n", + " 1204661478536, 1204661514376, 1204661550216, 1204661586056,\n", + " 1204661621896, 1204661657736, 1204661693576, 1204661729416,\n", + " 1204661765256, 1204661801096, 1204661836936, 1204661872776,\n", + " 1204661908616, 1204661944456, 1204661980296, 1204662016136,\n", + " 1204662051976, 1204662087816, 1204662123656, 1204662159496,\n", + " 1204662195336, 1204662231176, 1204662267016, 1204662302856,\n", + " 1204662338696, 1204662374536, 1204662410376, 1204662446216,\n", + " 1204662482056, 1204662517896, 1204662553736, 1204662589576,\n", + " 1204662625416, 1204662661256, 1204662697096, 1204662732936,\n", + " 1204662768776, 1204662804616, 1204662840456, 1204662876296,\n", + " 1204662912136, 1204662947976, 1204662983816, 1204663019656,\n", + " 1204663055496, 1204663091336, 1204663127176, 1204663163016,\n", + " 1204663198856, 1204663234696, 1204663270536, 1204663306376,\n", + " 1204663342216, 1204663378056, 1204663413896, 1204663449736,\n", + " 1204663485576, 1204663521416, 1204663557256, 1204663593096,\n", + " 1204663628936, 1204663664776, 1204663700616, 1204663736456,\n", + " 1204663772296, 1204663808136, 1204663843976, 1204663879816,\n", + " 1204663915656, 1204663951496, 1204663987336, 1204664023176,\n", + " 1204664059016, 1204664094856, 1204664130696, 1204664166536,\n", + " 1204664202376, 1204664238216, 1204664274056, 1204664309896,\n", + " 1204664345736, 1204664381576, 1204664417416, 1204664453256,\n", + " 1204664489096, 1204664524936, 1204664560776, 1204664596616,\n", + " 1204664632456, 1204664668296, 1204664704136, 1204664739976,\n", + " 1204664775816, 1204664811656, 1204664847496, 1204664883336,\n", + " 1204664919176, 1204664955016, 1204664990856, 1204665026696,\n", + " 1204665062536, 1204665098376, 1204665134216, 1204665170056,\n", + " 1204665205896, 1204665241736, 1204665277576, 1204665313416,\n", + " 1204665349256, 1204665385096, 1204665420936, 1204665456776,\n", + " 1204665492616, 1204665528456, 1204665564296, 1204665600136,\n", + " 1204665635976, 1204665671816, 1204665707656, 1204665743496,\n", + " 1204665779336, 1204665815176, 1204665851016, 1204665886856,\n", + " 1204665922696, 1204665958536, 1204665994376, 1204666030216,\n", + " 1204666066056, 1204666101896, 1204666137736, 1204666173576,\n", + " 1204666209416, 1204666245256, 1204666281096, 1204666316936,\n", + " 1204666352776, 1204666388616, 1204666424456, 1204666460296,\n", + " 1204666496136, 1204666531976, 1204666567816, 1204666603656,\n", + " 1204666639496, 1204666675336, 1204666711176, 1204666747016]],\n", + " dtype=uint64), 'value': array([[ 3.92985139e-07, 3.83420582e-07, 2.70894730e-07,\n", + " 1.59362046e-07, 5.19425521e-09, -1.48426426e-07,\n", + " -1.43519777e-07, 8.15211657e-08, 2.37241792e-07,\n", + " 1.43174769e-07, 1.06832322e-07, 3.03419964e-07,\n", + " 3.53603991e-07, 2.79436221e-07, 2.91986862e-07,\n", + " 3.61741877e-07, 3.62849251e-07, 4.00763667e-07,\n", + " 4.44543818e-07, 2.68402540e-07, 4.07432428e-09,\n", + " -3.04182928e-07, -5.46997467e-07, -7.22909138e-07,\n", + " -8.42683151e-07, -9.57424350e-07, -8.91693433e-07,\n", + " -5.90276549e-07, -3.09874066e-07, 3.15099414e-08,\n", + " 1.17763757e-07, -2.48585203e-08, -5.14343080e-08,\n", + " -7.95461888e-08, 1.09972075e-08, 2.60788444e-07,\n", + " 5.95013983e-07, 7.90452394e-07, 7.46151442e-07,\n", + " 6.50482553e-07, 5.95991605e-07, 5.00587601e-07,\n", + " 3.03236996e-07, 9.30959778e-08, 2.06233517e-08,\n", + " 3.14812406e-09, 4.27014776e-08, 1.62276378e-07,\n", + " 3.45086417e-07, 2.49326044e-07, 8.88291187e-08,\n", + " 7.91114905e-08, 1.02013570e-07, -1.65233163e-08,\n", + " -1.17815179e-07, -2.93111576e-07, -3.76068382e-07,\n", + " -2.22642030e-07, -8.62448467e-08, 2.06532484e-08,\n", + " 7.47423847e-08, 2.17917751e-07, 2.91384742e-07,\n", + " 2.34781890e-07, 8.57551385e-08, -3.07021322e-08,\n", + " -6.35412815e-08, -4.95621757e-08, -8.56349537e-08,\n", + " -1.45087561e-07, -1.32979989e-07, -2.56436081e-08,\n", + " 3.83718354e-08, -2.08320308e-09, -1.47861378e-07,\n", + " -2.48321514e-07, -2.27038641e-07, -2.11037919e-07,\n", + " -3.84853233e-07, -5.05484683e-07, -5.41471956e-07,\n", + " -5.06235688e-07, -4.06738226e-07, -1.02136146e-07,\n", + " 1.07573163e-07, 9.34738723e-08, -4.02792458e-08,\n", + " -3.98182384e-08, -7.42580579e-08, -8.18560090e-08,\n", + " -5.80349046e-08, 4.76930331e-08, 2.96791264e-07,\n", + " 5.32980691e-07, 5.86162761e-07, 5.87198982e-07,\n", + " 6.17966886e-07, 6.79197152e-07, 5.80585828e-07,\n", + " 2.82879127e-07, 2.60759146e-08, -2.61981323e-07,\n", + " -3.43245975e-07, -3.49784985e-07, -2.03524277e-07,\n", + " -4.41544579e-08, 4.10816736e-08, 1.58254074e-07,\n", + " 1.88760681e-07, 1.04991881e-07, -5.24316624e-08,\n", + " -7.14860345e-08, -7.36427835e-08, -6.57321128e-08,\n", + " 4.97774320e-08, 1.71477989e-07, 4.10129111e-07,\n", + " 6.08990697e-07, 7.57704131e-07, 8.73352994e-07,\n", + " 9.14463967e-07, 8.71196843e-07, 7.13427694e-07,\n", + " 4.95935074e-07, 2.12877165e-07, 8.20102760e-08,\n", + " 8.16299898e-08, -8.94497745e-08, -2.09379848e-07,\n", + " -3.49057897e-07, -3.64097140e-07, -2.65484620e-07,\n", + " -1.38712385e-07, -6.69226000e-08, -6.93950583e-08,\n", + " -2.61780417e-07, -5.49814934e-07, -7.53205273e-07,\n", + " -7.45047656e-07, -7.28842440e-07, -6.66364884e-07,\n", + " -6.38251807e-07, -6.08288124e-07, -5.06938859e-07,\n", + " -3.70191884e-07, -4.39671251e-07, -5.18713381e-07,\n", + " -5.92985192e-07, -5.58427579e-07, -4.05719346e-07,\n", + " -2.36963154e-07, -1.26458320e-07, 8.08335413e-08,\n", + " 1.01863488e-07, -2.76203788e-08, -3.17000845e-08,\n", + " 9.74459498e-08, 1.39901676e-07, 7.68734225e-08,\n", + " -1.09082349e-07, -2.89064159e-07, -4.68825929e-07,\n", + " -5.44368350e-07, -4.44860723e-07, -2.66156100e-07,\n", + " -1.47009919e-07, -7.06746377e-08, -8.82742357e-08,\n", + " -1.26150981e-07, -2.56645358e-08, 1.22603437e-07,\n", + " 2.88491936e-07, 4.83080683e-07, 4.14143642e-07,\n", + " 2.74622850e-07, 2.43333546e-07, 2.92212881e-07,\n", + " 1.99867311e-07, -2.50217564e-08, -1.10268651e-07,\n", + " -3.72949557e-08, 6.92772652e-08, 1.26283125e-07,\n", + " 2.10329367e-07, 2.62502722e-07, 3.08120923e-07,\n", + " 3.12027826e-07, 1.65437058e-07, -6.38055685e-09,\n", + " -1.33220957e-07, -8.91950545e-08, 6.40501236e-08,\n", + " 1.19388943e-07, 1.93055643e-07, 3.50974276e-07,\n", + " 3.97211937e-07, 3.25983014e-07, 2.73461064e-07,\n", + " 1.98727648e-07, 1.55330175e-07, 1.90476753e-07,\n", + " 2.61940664e-07, 2.00896954e-07, 4.53180381e-08,\n", + " -1.97603532e-07, -2.75219588e-07, -2.36965546e-07,\n", + " -1.80616218e-07, -1.54334614e-07, -7.63107663e-08,\n", + " 1.61057788e-07, 2.74578005e-07, 1.63907542e-07,\n", + " -6.21654347e-08, -2.49956267e-07, -2.91821234e-07,\n", + " -3.75682715e-07, -4.41552352e-07, -4.87636344e-07,\n", + " -3.21807041e-07, -1.66438000e-07, -1.28596533e-07,\n", + " -1.44966778e-07, -1.12107299e-07, -2.19878378e-08,\n", + " 1.79218846e-08, -1.00522322e-07, -2.46749545e-07,\n", + " -2.60108593e-07, -2.75065919e-07, -2.58524067e-07,\n", + " -3.81742181e-07, -3.48997505e-07, -2.08807026e-07,\n", + " -1.16515868e-07, -1.05323136e-07, -2.41726897e-08,\n", + " 4.29286926e-08, 5.61681538e-08, 3.76722522e-08,\n", + " 1.38363789e-07, 2.03251619e-07, 2.58051101e-07,\n", + " 1.92023609e-07, 1.52896582e-07, 1.02029714e-07,\n", + " 4.03647504e-08, 5.41549090e-08, -5.61274942e-08,\n", + " -1.70893209e-07, -1.95489236e-07, -1.79434102e-07,\n", + " -1.90418753e-07, -3.48402561e-07, -3.33618635e-07,\n", + " -3.26589917e-07, -4.11926502e-07, -5.46374420e-07,\n", + " -6.52977135e-07, -6.32305351e-07, -4.91076260e-07,\n", + " -4.62341930e-07, -5.53354107e-07, -6.67683329e-07,\n", + " -6.31887993e-07, -4.50556645e-07, -2.71762332e-07,\n", + " -1.42126590e-07, 1.25963230e-07, 3.40132531e-07,\n", + " 4.29167339e-07, 4.55697086e-07, 4.59132817e-07,\n", + " 5.23494464e-07, 6.45093969e-07, 6.82350657e-07,\n", + " 5.68289907e-07, 4.45257751e-07, 2.59265506e-07,\n", + " 2.07892785e-07, 7.75227791e-08, 2.10114111e-09,\n", + " -2.04415797e-08, -1.55623761e-07, -1.85535424e-07,\n", + " -1.49825592e-07, -8.89923548e-08, 4.57419735e-09,\n", + " 5.10922895e-08, 1.40718455e-07, 1.43216026e-07,\n", + " 5.61567930e-08, 1.79643379e-08, 3.86223698e-08,\n", + " 1.53206312e-07, 1.79312124e-07, 7.49385071e-08,\n", + " -2.79522324e-08, -9.90639600e-08, -2.59066394e-07,\n", + " -3.46135792e-07, -1.63205568e-07, 1.90346403e-08,\n", + " -4.05100484e-09, -9.41662802e-08, -1.47081073e-07,\n", + " -6.07148461e-08, -3.67191450e-09, -6.38641661e-08,\n", + " -1.07170155e-07, -1.40608435e-07, -8.53814296e-08,\n", + " 9.04961595e-08, 2.52720517e-07, 2.35757719e-07,\n", + " 2.67364526e-07, 3.95856420e-07, 4.95924909e-07,\n", + " 4.23995806e-07, 1.04117103e-07, -2.16378668e-07,\n", + " -3.11306119e-07, -2.60955268e-07, -7.30400657e-08,\n", + " 2.12508838e-07, 3.22259079e-07, 4.08452504e-07,\n", + " 4.70284889e-07, 5.51629066e-07, 4.34274894e-07,\n", + " 2.41514032e-07, 6.07967631e-08, -1.20032320e-07,\n", + " -1.90575412e-07, -2.92648177e-07, -3.14663520e-07,\n", + " -3.62121565e-07, -3.63577535e-07, -3.71738142e-07,\n", + " -2.93161205e-07, -2.25049314e-07, -1.51070491e-07,\n", + " 7.38030299e-09, 6.07818148e-08, -4.18972560e-08,\n", + " -1.33020649e-07, -1.94261677e-07, -8.04209666e-08,\n", + " -8.10990241e-08, -1.87267041e-07, -2.94979523e-07,\n", + " -3.96578127e-07, -5.46681160e-07, -5.69697445e-07,\n", + " -5.55555103e-07, -4.79262275e-07, -3.06220090e-07,\n", + " -1.15504163e-07, 2.28751723e-07, 4.22506351e-07,\n", + " 2.75850409e-07, 7.17802182e-08, -1.52670563e-07,\n", + " -2.67373495e-07, -3.23360474e-07, -4.74308389e-07,\n", + " -4.85272710e-07, -2.15499705e-07, 2.99624875e-09,\n", + " 9.53585612e-09, -1.37725196e-07, -1.88432415e-07,\n", + " -2.43055507e-07, -2.71423304e-07, -1.12316576e-07,\n", + " -5.20812729e-08, -2.77504893e-07, -3.56383787e-07,\n", + " -3.37075293e-07, -3.63530896e-07, -2.98915127e-07,\n", + " -2.23851651e-07, -1.60337875e-07, -1.63355649e-07,\n", + " -1.03609456e-07, -1.25081875e-08, 1.97007989e-07,\n", + " 3.81623192e-07, 4.15189429e-07, 2.83439989e-07,\n", + " 3.52171340e-08, -5.29291437e-09, 2.70027127e-08,\n", + " 8.30094242e-08, 2.37340451e-07, 3.69867804e-07,\n", + " 3.11326449e-07, 2.07639261e-07, 1.38845724e-07,\n", + " 3.49929087e-08, 2.85627233e-08, 1.99058306e-07,\n", + " 3.25536357e-07, 4.24391040e-07, 5.15305754e-07,\n", + " 5.54799314e-07, 6.02066618e-07, 5.56236150e-07,\n", + " 5.88164047e-07, 5.98419816e-07, 5.44714554e-07,\n", + " 4.76758126e-07, 5.39173497e-07, 5.82523733e-07,\n", + " 5.20635740e-07, 4.53664707e-07, 3.73594130e-07,\n", + " 9.79225034e-08, -1.64556301e-07, -6.45308628e-08,\n", + " -2.53225173e-09, -7.11942426e-08, -6.92868322e-08,\n", + " -1.83482117e-08, -5.87386733e-08, -3.65385688e-08,\n", + " 1.03064140e-07, 2.30992781e-07, 2.62640247e-07,\n", + " 7.88806879e-08, -1.76595708e-07, -1.84531492e-07,\n", + " 1.14630581e-07, 4.46794442e-07, 6.63414078e-07,\n", + " 7.22672357e-07, 6.75053467e-07, 5.45177355e-07,\n", + " 3.61184602e-07, 1.39103434e-07, -8.15002380e-08,\n", + " -3.84913624e-07, -6.68408026e-07, -6.90710377e-07,\n", + " -6.50547728e-07, -5.83720200e-07, -5.99011771e-07,\n", + " -6.59074271e-07, -6.13119433e-07, -5.01846851e-07,\n", + " -3.28521843e-07, -3.56619972e-08, 4.30500733e-08,\n", + " -4.95508149e-09, 5.33895531e-08, 1.68351988e-07,\n", + " 1.90788874e-07, 3.30179317e-08, -2.65245447e-07,\n", + " -4.54763113e-07, -5.42195457e-07, -5.84733100e-07,\n", + " -6.18889499e-07, -6.64385124e-07, -6.42400873e-07,\n", + " -5.23666071e-07, -4.33743928e-07, -3.57675923e-07,\n", + " -2.17862143e-07, -5.70602717e-08, 2.77303987e-08,\n", + " 1.37077035e-07, 1.36061144e-07, 2.01107427e-07,\n", + " 2.33071798e-07, 2.38902255e-07, 1.93699021e-07,\n", + " 1.33213781e-07, -2.10454933e-08, -4.07932301e-07,\n", + " -6.97150727e-07, -6.85435400e-07, -4.98341760e-07,\n", + " -3.69193334e-07, -2.30489918e-07, -1.65074112e-07,\n", + " -1.73244286e-07, -3.12409308e-07, -4.17552466e-07,\n", + " -2.76978711e-07, -1.01703840e-07, 4.00203402e-08,\n", + " 7.96801261e-08, 5.91327120e-08, -5.31025446e-09,\n", + " -3.70498026e-08, -1.22080245e-08, -1.04164937e-07,\n", + " -1.12687893e-07, 2.26682870e-08, 7.39250085e-08,\n", + " 3.86630294e-08, -1.57473769e-07, -2.77513264e-07,\n", + " -2.34415954e-07, -9.34774599e-08, 1.13495702e-07,\n", + " 2.30309940e-07, 2.77524625e-07, 2.54816277e-07,\n", + " 1.46039472e-07, 1.39078919e-07, 1.50235177e-07,\n", + " 6.14425322e-08, -6.96551597e-08, -4.93481152e-08,\n", + " -3.38221533e-08, -1.24280643e-08, -1.38384119e-07,\n", + " -1.30164914e-07, -9.61938754e-08, -1.49727531e-07,\n", + " -1.22355295e-07, -7.24708323e-08, -1.90739246e-07,\n", + " -3.05289704e-07, -4.30052282e-07, -2.88965500e-07,\n", + " -1.99357871e-07, -2.45945323e-07, -2.01812391e-07,\n", + " -1.75720332e-07, -2.87410273e-07, -3.58312126e-07,\n", + " -3.25443080e-07, -9.20071395e-08, 1.06721107e-07,\n", + " 2.36255798e-07, 3.48033635e-07, 3.71790162e-07,\n", + " 2.44360200e-07, -3.30041792e-08, -1.65477718e-07,\n", + " -2.09568795e-07, -1.90201105e-07, -2.05444244e-07,\n", + " -2.42772684e-07, -2.99709183e-07, -4.29494409e-07,\n", + " -4.59779183e-07, -4.38130374e-07, -3.70995508e-07,\n", + " -2.59954326e-07, -2.12623043e-07, -1.96560136e-07,\n", + " -9.51660263e-08, -8.87185008e-08, -1.39274443e-07,\n", + " -9.18026459e-08, -1.22325398e-07, -7.09897490e-08,\n", + " -1.93013190e-09, 8.98390297e-08, 2.15450674e-07,\n", + " 1.84958417e-07, 1.07249680e-07, 1.05097715e-07,\n", + " 1.84560193e-07, 1.00563579e-07, 6.71581861e-08,\n", + " 1.28528368e-07, 7.91252430e-08, -1.03254284e-07,\n", + " -3.00204273e-07, -4.21055763e-07, -4.41529033e-07,\n", + " -3.30959621e-07, -2.49891092e-07, -4.16851089e-07,\n", + " -5.84338464e-07, -5.04995573e-07, -2.83871100e-07,\n", + " -1.08966350e-07, 7.49971047e-08, 2.59871811e-07,\n", + " 2.35015085e-07, 5.78046999e-08, 1.89616923e-08,\n", + " 5.20639328e-08, 2.52515425e-07, 5.02891442e-07,\n", + " 5.86196246e-07, 4.50872952e-07, 3.32533982e-07,\n", + " 3.62297358e-07, 4.60746043e-07, 4.70768618e-07,\n", + " 4.65780650e-07, 3.85436219e-07, 3.07193527e-07,\n", + " 1.69756536e-07, -1.12962943e-07, -3.10589196e-07,\n", + " -4.24860419e-07, -4.91873905e-07, -4.46859617e-07,\n", + " -2.48426153e-07, -1.17500068e-08, 8.72451907e-08,\n", + " 8.76894559e-08, 1.03219005e-07, 2.25426610e-07,\n", + " 2.74669489e-07, 1.74889802e-07, 9.11700314e-08,\n", + " 1.26579700e-07, 2.19670895e-07, 2.72036784e-07,\n", + " 1.76660285e-07, 4.93636615e-08, 7.17258061e-08,\n", + " 4.75489309e-08, -1.28243154e-07, -3.22162214e-07,\n", + " -3.43309954e-07, -1.01288276e-07, 6.92969970e-08,\n", + " 9.49148939e-08, 2.00153721e-07, 3.68585833e-07,\n", + " 3.84339607e-07, 3.28500915e-07, 2.73623702e-07,\n", + " 1.64186180e-07, 7.31961266e-08, 6.60735333e-08,\n", + " 9.36717885e-08, 1.02275465e-07, -2.02699726e-10,\n", + " -1.48580095e-07, -2.13070896e-07, -4.68278819e-07,\n", + " -5.81437287e-07, -5.20804358e-07, -5.67430676e-07,\n", + " -6.15038802e-07, -5.96161419e-07, -3.53384549e-07,\n", + " -2.65704062e-07, -1.59498375e-07, -3.02076405e-09,\n", + " 1.15199217e-07, 2.82614242e-07, 1.88842598e-07,\n", + " 6.59521526e-09, -4.59996832e-08, -4.59883224e-08,\n", + " 4.34303595e-08, 1.69507795e-07, 3.57003247e-07,\n", + " 5.25516080e-07, 6.08550019e-07, 4.93009382e-07,\n", + " 4.03527319e-07, 3.93266169e-07, 3.88992134e-07,\n", + " 3.42486599e-07, 2.64011310e-07, 3.28545761e-07,\n", + " 4.39363913e-07, 4.25984535e-07, 3.74664433e-07,\n", + " 2.42144853e-07, 7.68674431e-08, 3.01484450e-08,\n", + " -9.57824966e-08, -1.44516533e-07, 3.92926542e-08,\n", + " 3.85308859e-07, 5.05405158e-07, 2.73567496e-07,\n", + " -1.47725647e-07, -3.63148218e-07, -2.02561005e-07,\n", + " -8.18243184e-08, -1.13539351e-07, -2.34597128e-07,\n", + " -2.11553339e-07, -5.91261347e-08, 5.44197939e-08,\n", + " -6.64006033e-08, -2.31789229e-07, -3.09711428e-07,\n", + " -2.70477970e-07, -2.18363810e-07, -2.43894409e-07,\n", + " -2.57952442e-07, -1.65912416e-07, 8.97977722e-08,\n", + " 2.25512115e-07, 2.48212092e-07, 1.24256726e-07,\n", + " 4.20180387e-08, 5.78292152e-08, 5.49848418e-08,\n", + " -1.33292709e-07, -2.81195344e-07, -2.61471883e-07,\n", + " -9.86579626e-08, 1.99112120e-09, -6.98746016e-09,\n", + " 2.15441705e-08, 3.71580288e-08, -1.20388091e-07,\n", + " -4.02575408e-07, -5.37950123e-07, -5.66455445e-07,\n", + " -4.17524363e-07, -8.54322540e-08, 8.19755958e-08,\n", + " 1.78326728e-07, 2.05387440e-07, 1.44143422e-07,\n", + " 1.79644575e-07, 1.47876326e-07, 4.88093764e-08,\n", + " -8.83184828e-08, 2.13462543e-10, 2.12627229e-07,\n", + " 2.80647038e-07, 1.25450800e-07, -5.96834095e-08,\n", + " -3.59005729e-07, -6.50030515e-07, -6.45321185e-07,\n", + " -3.91315707e-07, -9.13422365e-08, 4.67758019e-08,\n", + " -1.67632673e-07, -3.60025805e-07, -3.91212264e-07,\n", + " -3.39129198e-07, -2.34033276e-07, -1.98976389e-07,\n", + " 9.53663343e-08, 3.86565119e-07, 6.78102334e-07,\n", + " 7.94773067e-07, 6.75312971e-07, 5.18205137e-07,\n", + " 3.61853690e-07, 3.49845376e-07, 4.18397945e-07,\n", + " 4.49034902e-07, 5.09952448e-07, 3.28503307e-07,\n", + " 7.95724979e-08, -5.88815796e-08, -2.76963165e-09,\n", + " 2.11172455e-08, -8.00992780e-09, -1.54857807e-07,\n", + " -2.87621344e-07, -3.06567490e-07, -3.45380601e-07,\n", + " -3.47566648e-07, -4.19708617e-07, -4.64905274e-07,\n", + " -5.27758333e-07, -5.50948617e-07, -6.16901368e-07,\n", + " -6.01836413e-07, -3.79309784e-07, -1.16091335e-07,\n", + " 8.04855436e-08, 2.60922382e-07, 3.05965968e-07,\n", + " 1.51118326e-07, 1.70321584e-07, 1.11500993e-07,\n", + " 4.55560159e-08, 2.46934905e-08, 1.16256365e-08,\n", + " 7.68345568e-09, 4.35810389e-08, 6.55874127e-08,\n", + " 6.65997154e-08, 7.96059822e-08, 1.25218802e-07,\n", + " 1.69880308e-07, 2.97179323e-07, 3.40381870e-07,\n", + " 3.24701043e-07, 2.83566153e-07, 1.47797399e-07,\n", + " 1.72691197e-07, 2.29566707e-07, 1.78815838e-07,\n", + " 2.06524113e-07, 2.74380089e-07, 1.67206346e-07,\n", + " 2.06466712e-08, -1.03414530e-07, -7.01406823e-08,\n", + " 3.54150503e-08, 5.66315528e-08, 1.05236436e-10,\n", + " -4.27116425e-08, -3.81930530e-08, 1.01061658e-07,\n", + " 2.33339673e-07, 3.38343512e-07, 3.08279376e-07,\n", + " 2.23005574e-07, 1.46063987e-07, 7.48111471e-08,\n", + " 1.67899950e-08, 1.64683063e-08, 6.33337983e-08,\n", + " 2.63583787e-07, 3.62437274e-07, 3.46500532e-07,\n", + " 4.43665452e-07, 5.54326946e-07, 6.36912435e-07,\n", + " 5.88680663e-07, 4.56565287e-07, 3.25703779e-07,\n", + " 1.71597575e-07, -2.70140735e-08, -1.29319435e-07,\n", + " -1.24364354e-07, -1.00961206e-07, -1.60780944e-07,\n", + " -1.77396342e-07, -1.33214379e-07, -3.57684295e-09,\n", + " 6.09462467e-08, 6.19531681e-08, -1.58237332e-08,\n", + " -1.52174278e-09, 8.21759038e-08, 1.54579767e-07,\n", + " 1.52723779e-07, 9.63068850e-08, -2.47652426e-08,\n", + " -2.51300423e-07, -4.81848938e-07, -5.06587274e-07,\n", + " -4.40668008e-07, -3.73317885e-07, -2.15470406e-07,\n", + " 4.91711267e-08, 1.11269593e-07, -4.26937044e-08,\n", + " -1.86128575e-07, -2.14070642e-07, -1.47656884e-07,\n", + " -8.93218165e-08, -9.35886757e-09, 1.35206696e-07,\n", + " 2.87461097e-07, 3.51993156e-07, 2.32537245e-07,\n", + " 1.60774965e-07, 2.04713568e-07, 3.08541869e-07,\n", + " 2.90892642e-07, 2.93433863e-07, 2.42301512e-07,\n", + " 1.02518824e-07, 6.95122534e-08, 1.91951857e-07,\n", + " 1.29419888e-07, -7.00438170e-08, -1.35923620e-07,\n", + " -1.42971471e-07, -1.42289228e-07, -4.13615068e-08,\n", + " 5.64115130e-08, 1.29904813e-07, 2.10795756e-07,\n", + " 1.88795362e-07, 1.14082276e-07, 2.61978931e-08,\n", + " -2.28488632e-08, -1.12846345e-07, -2.38474732e-07,\n", + " -2.81456641e-07, -2.74899096e-07, -9.95267611e-08,\n", + " 1.31155691e-07, 3.42233074e-07, 5.11480170e-07,\n", + " 6.33651899e-07, 6.29492668e-07, 5.71221579e-07,\n", + " 4.80191464e-07, 2.60756754e-07, -8.36031730e-09,\n", + " -1.07722049e-07, -1.67486179e-07, -2.31938713e-07,\n", + " -3.18197312e-07, -3.20214144e-07, -2.18911518e-07,\n", + " -1.07631163e-07, 4.35535340e-09, 9.73634349e-08,\n", + " 9.48682551e-09, -2.62690473e-08, -7.19613923e-08,\n", + " -2.08782511e-07, -2.02599871e-07, -2.28978340e-07,\n", + " -3.80279634e-07, -3.92481081e-07, -2.32316607e-07,\n", + " -2.01331054e-07, -3.21509270e-07, -4.52587230e-07,\n", + " -3.64860104e-07, -1.95073672e-07, -4.32581544e-08,\n", + " 3.76268092e-08, -7.76459536e-08, -1.42308362e-07,\n", + " -4.10481893e-09, 2.16926974e-07, 1.53687649e-07,\n", + " 1.06774921e-07, 6.36459200e-08, 5.98998617e-08,\n", + " -1.60623089e-08, 8.54603569e-08, 1.16995412e-07,\n", + " 1.21679031e-07, 1.92005671e-07, 2.41701784e-07,\n", + " 6.02873231e-08, -2.91312990e-07, -4.71218862e-07,\n", + " -3.52183897e-07, -2.15410015e-07, -1.35076347e-07,\n", + " -8.62358777e-08, -5.95530598e-08, -3.03487530e-08,\n", + " 8.98456070e-09, -3.20104124e-08, -9.66178108e-08,\n", + " -3.88782259e-07, -6.41902196e-07, -6.68480376e-07,\n", + " -5.54219916e-07, -4.27331681e-07, -2.97937504e-07,\n", + " -2.48852480e-07, -1.43612457e-07, 8.00119796e-08,\n", + " 2.20572580e-07, 1.43064749e-07, 3.75084183e-08,\n", + " -1.07341164e-07, -1.40729815e-07, -1.94001575e-07,\n", + " -1.92580884e-07, -9.88289718e-08, -1.16050675e-07,\n", + " -1.86615891e-07, -1.86427542e-07, -4.54729030e-08,\n", + " 7.93171799e-08, 2.37748242e-07, 3.21543352e-07,\n", + " 4.72589328e-07, 7.19963714e-07, 8.07619686e-07,\n", + " 7.82908257e-07, 5.77874794e-07, 1.71552132e-07,\n", + " -2.18546778e-07, -4.07964589e-07, -3.67413283e-07,\n", + " -3.21461435e-07, -2.51965924e-07, -2.42406748e-07,\n", + " -3.32600951e-07, -4.32792615e-07, -4.44281922e-07,\n", + " -3.81532306e-07, -2.55676704e-07, -2.79632344e-07,\n", + " -3.65262514e-07, -2.75049775e-07, -1.84903407e-07,\n", + " -1.84206814e-07, -1.25358121e-07, -7.17850016e-08,\n", + " -6.69752182e-08]])}]}}}, 'triggered': array([0], dtype=int64)}\n", + "Progress [1.] %\n" + ] + } + ], + "source": [ + "my_lockin.daq.set('device', 'dev3442')\n", + "# my_lockin.daq.set('save/directory', 'C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer')\n", + "my_lockin.daq.set('type', 1)\n", + "my_lockin.daq.set('triggernode', '/dev3442/demods/0/sample.AuxIn0')\n", + "my_lockin.daq.set('endless', 0)\n", + "my_lockin.daq.set('grid/cols', 1000)\n", + "# my_lockin.daq.subscribe('/dev3442/demods/0/sample.R.avg')\n", + "my_lockin.daq.subscribe('/dev3442/demods/0/sample.R')\n", + "my_lockin.daq.subscribe('/dev3442/demods/0/sample.X')\n", + "my_lockin.daq.execute()\n", + "my_lockin.daq.set('forcetrigger', 1)\n", + "result = 0\n", + "while not my_lockin.daq.finished():\n", + " time.sleep(1)\n", + " result = my_lockin.daq.read()\n", + " print(result)\n", + " print(f\"Progress {my_lockin.daq.progress()} %\\r\")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c0e526ba", + "metadata": {}, + "outputs": [ + { + "ename": "RuntimeError", + "evalue": "Timeout during set in dataAcquisitionModule module.", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_12728\\3516131054.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mwhile\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mmy_lockin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfinished\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmy_lockin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Progress {my_lockin.daq.progress()} %\\r\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mRuntimeError\u001b[0m: Timeout during set in dataAcquisitionModule module." + ] + } + ], + "source": [ + "while not my_lockin.daq.finished():\n", + " time.sleep(1)\n", + " result = my_lockin.daq.read()\n", + " print(result)\n", + " print(f\"Progress {my_lockin.daq.progress()} %\\r\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ae560ada", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "1f6a003a", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.finish()\n", + "my_lockin.daq.unsubscribe('*')" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "c8c91ef7", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.clear()" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "0e75a1ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(270)\u001b[0;36marm_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 268 \u001b[1;33m \u001b[0mdemod\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_get_demod\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 269 \u001b[1;33m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 270 \u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mapi_session\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'/{self.serial}/{demod}/enable'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 271 \u001b[1;33m \u001b[1;32mexcept\u001b[0m \u001b[0mRuntimeError\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 272 \u001b[1;33m \u001b[1;32mraise\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> self.api_session.setInt('/dev3442/demods/0/enable', 0)\n", + "ipdb> r\n" + ] + } + ], + "source": [ + "%debug" + ] }, { "cell_type": "code", "execution_count": null, - "id": "a06c534e", + "id": "dfe07e28", "metadata": {}, "outputs": [], "source": [] @@ -512,7 +2992,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c8c9523b", + "id": "c69299c6", "metadata": {}, "outputs": [], "source": [] @@ -520,7 +3000,7 @@ { "cell_type": "code", "execution_count": null, - "id": "baddb8d5", + "id": "1e70db16", "metadata": {}, "outputs": [], "source": [] @@ -528,7 +3008,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e551db46", + "id": "63957cc1", "metadata": {}, "outputs": [], "source": [] @@ -536,7 +3016,7 @@ { "cell_type": "code", "execution_count": null, - "id": "86907e32", + "id": "a67d911a", "metadata": {}, "outputs": [], "source": [] diff --git a/qupulse/hardware/awgs/virtual.py b/qupulse/hardware/awgs/virtual.py index a96da4a39..6cc3c1751 100644 --- a/qupulse/hardware/awgs/virtual.py +++ b/qupulse/hardware/awgs/virtual.py @@ -1,6 +1,7 @@ """This module contains the tools to setup a virtual AWG i.e. an AWG that forwards the program into a given callback. This is handy to setup a simulation to test qupulse pulses.""" -from typing import Tuple, Optional, Callable, Set +from numbers import Real +from typing import Set, Tuple, Callable, Optional, Mapping, Sequence, List import numpy as np @@ -94,6 +95,9 @@ def set_function_handle_callback(self, duration and following arguments being sampling callbacks as defined above.""" self._function_handle_callback = callback + def set_volatile_parameters(self, program_name: str, parameters: Mapping[str, Real]): + raise NotImplementedError() + def run_current_program(self): (program, channels, voltage_transformations) = self._programs[self._current_program] diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index ab45ddd95..6338e3a32 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -3,9 +3,11 @@ May lines of code have been adapted from the zihdawg driver. """ -from typing import Dict, Tuple, Iterable +from typing import Dict, Tuple, Iterable, Union, List from enum import Enum import warnings +import time +import xarray as xr from qupulse.utils.types import TimeType from qupulse.hardware.dacs.dac_base import DAC @@ -34,18 +36,18 @@ TODO ======== [X] make TriggerMode class an Enum -[ ] setup minimal connection without changing settings other than buffer lengths -[ ] extract window things +[X] setup minimal connection without changing settings other than buffer lengths +[X] extract window things +[ ] cut obtained data to fit into requested windows +[ ] provide interface for changing trigger settings +[ ] print information about how long the measurement is expected to run [ ] implement multiple triggers (using rows) (and check how this actually behaves) [ ] count [ ] endless [ ] change in trigger input port -[ ] make sample rate clean -[ ] implement setting recording channel (could that be already something inside qupulse?) +[X] implement setting recording channel (could that be already something inside qupulse?) => this should be sufficient for operation -[ ] have an interface for setting trigger configurations -[ ] an interface for setting the sample rate based on more convenient parameters -=> this should cover the common use cases +[ ] implement optional operations (averaging, binning, up/down sampling, ...) [ ] implement scope interface for higher sample rates (if i understood the documentation correctly) [ ] implement low level interface (subscribe()) @@ -96,17 +98,26 @@ def __init__(self, device_serial: str = None, """ self.api_session = zhinst_core.ziDAQServer(data_server_addr, data_server_port, api_level_number) # assert zhinst.utils.api_server_version_check(self.api_session) # Check equal data server and api version. + self.device_interface = device_interface self.device = self.api_session.connectDevice(device_serial, device_interface) self.default_timeout = timeout self.serial = device_serial self.daq = self.api_session.dataAcquisitionModule() + self.daq.set('device', device_serial) + + self.daq.set('type', 1) + self.daq.set('triggernode', '/dev3442/demods/0/sample.AuxIn0') + self.daq.set('endless', 0) + + self.daq_read_return = {} if reset: # Create a base configuration: Disable all available outputs, awgs, demods, scopes,... zhinst.utils.disable_everything(self.api_session, self.serial) self.programs = {} + self.currently_set_program = None def reset_device(self): @@ -117,20 +128,19 @@ def reset_device(self): self.clear() - def register_measurement_channel(self, program_name:str, channel_path:str): + def register_measurement_channel(self, program_name:str=None, channel_path:Union[str, List[str]]=[], window_name:str=None): """ This function saves the channel one wants to record with a certain program Args: program_name: Name of the program channel_path: the channel to record in the shape of "demods/0/sample.R.avg". Note that everything but the things behind the last "/" are considered to relate do the demodulator. If this is not given, you might want to check this driver and extend its functionality. + window_name: The windows for that channel. """ if not isinstance(channel_path, list): channel_path = [channel_path] - - self.programs.setdefault(program_name, {}).setdefault("channels", []) - self.programs[program_name]["channels"] = channel_path + self.programs.setdefault(program_name, {}).setdefault("channel_mapping", {}).setdefault(window_name, []).extend(channel_path) def register_measurement_windows(self, program_name: str, windows: Dict[str, Tuple[np.ndarray, np.ndarray]]) -> None: @@ -143,12 +153,21 @@ def register_measurement_windows(self, program_name: str, windows: Dict[str, Tup First array are the start points of measurement windows in nanoseconds. Second array are the corresponding measurement window's lengths in nanoseconds. """ - + self.programs.setdefault(program_name, {}).setdefault("windows", {}).update(windows) for k, v in windows.items(): self.set_measurement_mask(program_name=program_name, mask_name=k, begins=v[0], lengths=v[1]) + def _get_sample_rates(self, channel:str): + try: + timetype_sr = TimeType().from_float(value=self.api_session.getDouble(f"/{self.serial}/{self._get_demod(channel)}/rate"), absolute_error=0) + return timetype_sr + except RuntimeError as e: + if "ZIAPINotFoundException" in e.args[0]: + return None + else: + raise def set_measurement_mask(self, program_name: str, mask_name: str, begins: np.ndarray, @@ -167,17 +186,27 @@ def set_measurement_mask(self, program_name: str, mask_name: str, assert begins.shape == lengths.shape + if program_name not in self.programs: + raise ValueError(f"Program '{program_name}' not known") + + # the channels we want to measure with: + channels_to_measure: List[str] = [] + try: + channels_to_measure = self.programs[program_name]["channel_mapping"][mask_name] + except KeyError: + try: + channels_to_measure = self.programs[None]["channel_mapping"][mask_name] + except KeyError: + channels_to_measure = [] + + if len(channels_to_measure) == 0: + warnings.warn(f"There are no channels defined that should be measured in mask '{mask_name}'.") + # get the sample rates for the requested channels. If no sample rate is found, None will be used. This code is not very nice. currently_set_sample_rates: List[Union[TimeType, None]] = [] - for c in self.programs[program_name]["channels"]: - try: - timetype_sr = TimeType().from_float(value=self.api_session.getDouble(f"/{self.serial}/{self._get_demod(c)}/rate"), absolute_error=0) - currently_set_sample_rates.append(timetype_sr) - except RuntimeError as e: - if "ZIAPINotFoundException" in e.args[0]: - currently_set_sample_rates.append(None) - else: - raise + + for c in channels_to_measure: + currently_set_sample_rates.append(self._get_sample_rates(c)) mask_info = np.full((3, len(begins), len(currently_set_sample_rates)), np.nan) @@ -189,12 +218,32 @@ def set_measurement_mask(self, program_name: str, mask_name: str, mask_info[1, :, i] = np.floor_divide(lengths * float(sr.numerator), float(sr.denominator)).astype(dtype=np.uint64) # the length mask_info[2, :, i] = (mask_info[0, :, i] + mask_info[1, :, i]).astype(dtype=np.uint64) # the end - self.programs.setdefault(program_name, {}).setdefault("masks", {})[mask_name] = mask_info + self.programs.setdefault(program_name, {}).setdefault("masks", {})[mask_name] = {"mask": mask_info, "channels": channels_to_measure, "sample_rates": currently_set_sample_rates} + self.programs.setdefault(program_name, {}).setdefault("all_channels", set()).update(channels_to_measure) + self.programs.setdefault(program_name, {}).setdefault("window_hull", [np.nan, np.nan]) # as the lock-in can measure multiple channels with different sample rates, the return value of this function is not defined correctly. # this could be fixed by only measuring on one channel, or by returning some "summary" value. As of now, there does not to be a use of the return values. - - return (np.min(mask_info[0], axis=-1), np.min(mask_info[2], axis=-1)) + # but there are also used calculations in the following code. + + if len(channels_to_measure) == 0: + return None + else: + + # update the hull of all measurement windows defined for this program to later set the number of samples to record. + # TODO this whole thing could be improved at some point. + # we also only use the max sample value later. The smallest staring point is somewhat ill-defined + if np.sum(np.isnan(mask_info)) == len(mask_info.reshape((-1))): + pass + else: + _start = np.nanmin(mask_info[0]) + _end = np.nanmax(mask_info[2]) + if np.isnan(self.programs[program_name]["window_hull"][0]) or self.programs[program_name]["window_hull"][0] > _start: + self.programs[program_name]["window_hull"][0] = _start + if np.isnan(self.programs[program_name]["window_hull"][1]) or self.programs[program_name]["window_hull"][1] > _end: + self.programs[program_name]["window_hull"][1] = _end + + return (np.min(mask_info[0], axis=-1), np.max(mask_info[2], axis=-1)) def register_operations(self, program_name: str, operations) -> None: """Register operations that are to be applied to the measurement results. @@ -215,38 +264,62 @@ def _get_demod(self, channel:str): return "/".join(elements[:-1]) - def arm_program(self, program_name: str) -> None: + def arm_program(self, program_name: str, force:bool=True) -> None: """Prepare the device for measuring the given program and wait for a trigger event.""" - # TODO check if program_name specified program is selected and important parameter set to the lock-in - - for c in self.programs[program_name].channels: - # select the value to measure - self.daq.subscribe(f'/{self.serial}/{c}') - - # activate corresponding demodulators - demod = self._get_demod(c) - try: - self.daq.set(f'/{self.serial}/{demod}/enable', 1) - except RuntimeError as e: - if "ZIAPINotFoundException" in e.args[0]: - # ok, the channel can not be enabled. Then the user should be caring about that. - warnigns.warn(f"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.") - pass - else: - raise + # check if program_name specified program is selected and important parameter set to the lock-in + if self.currently_set_program is None or self.currently_set_program != program_name or force: + + for c in self.programs[program_name]["all_channels"]: + + # activate corresponding demodulators + demod = self._get_demod(c) + try: + self.api_session.setInt(f'/{self.serial}/{demod}/enable', 1) + except RuntimeError as e: + if "ZIAPINotFoundException" in e.args[0] or f"Path /{self.serial}/{demod}/enable not found." in e.args[0]: + # ok, the channel can not be enabled. Then the user should be caring about that. + warnings.warn(f"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.") + pass + else: + raise + + # select the value to measure + self.daq.subscribe(f'/{self.serial}/{c}') + + # check if sample rates are the same as when register_measurement_windows() was called + for k, v in self.programs[program_name]['masks'].items(): + if len(v["channels"]) != len(v["sample_rates"]): + raise ValueError(f"There is a mismatch between number the channels to be used and the known sample rates.") + for c, r in zip(v["channels"], v["sample_rates"]): + if self._get_sample_rates(c) != r: + raise ValueError(f"The sample rate for channel '{c}' has changed. Please call register_measurement_windows() again.") + + # set daq module settings to standard things + # TODO one might want to extend the driver to support more methods + self.daq.set('grid/mode', 4) # this corresponds to Mode: Exact(on-grid) + self.daq.set('grid/rows', 1) # this corresponds to measuring only for one trigger + # the following two lines set the row repetitions to 1 and off + self.daq.set('grid/repetitions', 1) + self.daq.set('grid/rowrepetition', 0) + # TODO these should be a + + # set the buffer size according to the largest measurement window + # TODO one might be able to implement this a bit more cleverly + self.daq.set('grid/cols', int(self.programs[program_name]["window_hull"][1])) + + self.currently_set_program = program_name # execute daq self.daq.execute() # wait until changes have taken place - self.daq.sync() - - if program_name != None: - self.programs.setdefault(program_name, {}).setdefault('armed', False) - self.programs[program_name]['armed'] = True + self.api_session.sync() - raise NotImplementedError() + # # TODO this should be redundant with self.currently_set_program + # if program_name != None: + # self.programs.setdefault(program_name, {}).setdefault('armed', False) + # self.programs[program_name]['armed'] = True def unarm_program(self, program_name:str): """ unarms the lock-in. This should be program independent. @@ -254,11 +327,14 @@ def unarm_program(self, program_name:str): self.daq.finish() self.daq.unsubscribe('*') - self.daq.sync() + self.api_session.sync() + + self.currently_set_program = None - if program_name != None: - self.programs.setdefault(program_name, {}).setdefault('armed', False) - self.programs[program_name]['armed'] = False + # # TODO this should be redundant with self.currently_set_program + # if program_name != None: + # self.programs.setdefault(program_name, {}).setdefault('armed', False) + # self.programs[program_name]['armed'] = False def force_trigger(self, program_name:str): """ forces a trigger @@ -271,16 +347,72 @@ def delete_program(self, program_name: str) -> None: # this does not have an effect on the current implementation of the lock-in driver. - pass + if self.currently_set_program == program_name: + self.unarm_program(program_name) + + self.programs.pop(program_name) def clear(self) -> None: """Clears all registered programs.""" self.unarm_program(program_name=None) - def measure_program(self, channels: Iterable[str]) -> Dict[str, np.ndarray]: + def measure_program(self, channels: Iterable[str], wait=True) -> Dict[str, np.ndarray]: """Get the last measurement's results of the specified operations/channels""" + # wait until the data acquisition has finished + while not self.daq.finished() and wait: + time.sleep(1) + print(f"waiting for device {self.serial} to finish the acquisition.") + + if not self.daq.finished(): + raise ValueError(f"Device {self.serial} did not finish the acquisition in time.") + data = self.daq.read() + self.daq_read_return.update(data) + + # go through the returned object and extract the data of interest + + recorded_data = {} + + for device_name, device_data in data.items(): + if device_name == self.serial: + for input_name, input_data in device_data.items(): + for signal_name, signal_data in input_data.items(): + for final_level_name, final_level_data in signal_data.items(): + channel_name = f"/{device_name}/{input_name}/{signal_name}/{final_level_name}" + channel_data = [xr.DataArray( + data=d["value"], + coords={'timestamp': (['col', 'row'], d['timestamp'])}, + dims=['col', 'row'], + name=channel_name, + attrs=d['header']) + for i, d in enumerate(final_level_data)] + recorded_data[channel_name] = channel_data + + + return recorded_data + + + # the first dimension of channel_data is expected to be the history of multiple not read data points. This will be handled as multiple entries in a list. This will then not make too much sense, if not every channel as this many entries. If this is the case, they will be stacked, such that for the last elements it fits. + # TODO do this based on the timestamps and not the indices. That might be more sound than just assuming that. + + + # applying measurement windows and optional operations + # TODO implement operations + + # targeted structure: + # results[][] -> [data] + + masked_data = {} + + for mask_name in self.programs.[self.currently_set_program]["masks"]: + pass + + result = xr.Dataset( + {} + ) + # self.programs.setdefault(program_name, {}).setdefault("masks", {})[mask_name] = {"mask": mask_info, "channels": channels_to_measure, "sample_rates": currently_set_sample_rates} + - print(data) \ No newline at end of file + print(data) diff --git a/qupulse/utils/tree.py b/qupulse/utils/tree.py index 5b69a30ca..2585a5f57 100644 --- a/qupulse/utils/tree.py +++ b/qupulse/utils/tree.py @@ -84,9 +84,6 @@ def __getitem__(self: _NodeType, *args, **kwargs) ->Union[_NodeType, List[_NodeT def __len__(self) -> int: return len(self.__children) - def __reversed__(self): - return reversed(self.__children) - def get_depth_first_iterator(self: _NodeType) -> Generator[_NodeType, None, None]: stack = [(self, self.__children)] From b16a8bd56e26dbf9e47a61cef0b1f7ee926fb80b Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Thu, 29 Sep 2022 19:31:56 +0200 Subject: [PATCH 09/25] before switching from sample count to timestamp measurement mask selection --- ...struments_lockin_mfli_daq-checkpoint.ipynb | 663 +++++++++------ .../zurich_instruments_lockin_mfli_daq.ipynb | 759 ++++++++++++------ qupulse/hardware/dacs/mfli.py | 140 +++- 3 files changed, 1069 insertions(+), 493 deletions(-) diff --git a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb index 395866d67..a87757f17 100644 --- a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb +++ b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "fceb835c", + "id": "7c76f99a", "metadata": {}, "source": [ "# Zurich Instruments Lock-In MFLI Data Aquesition" @@ -11,7 +11,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "55c55e0a", + "id": "c2829d09", "metadata": {}, "outputs": [], "source": [ @@ -22,7 +22,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "708ad356", + "id": "46ac7589", "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "e69e0618", + "id": "6982f821", "metadata": {}, "outputs": [], "source": [ @@ -42,7 +42,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "f7cb2ae3", + "id": "ffbc21ac", "metadata": {}, "outputs": [], "source": [ @@ -52,7 +52,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "12279c39", + "id": "50760516", "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "9eef13eb", + "id": "d602f04c", "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "c1f9c7ec", + "id": "64c51001", "metadata": {}, "outputs": [ { @@ -91,7 +91,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "9a3bf46e", + "id": "ab3733db", "metadata": {}, "outputs": [], "source": [ @@ -101,7 +101,17 @@ { "cell_type": "code", "execution_count": 9, - "id": "baf33df9", + "id": "d2fa2e3e", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.assumed_minimal_sample_rate = 1." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6a711d77", "metadata": {}, "outputs": [], "source": [ @@ -116,8 +126,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "dfd7c42e", + "execution_count": 11, + "id": "30f25668", "metadata": {}, "outputs": [], "source": [ @@ -127,24 +137,24 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "62df1451", + "execution_count": 12, + "id": "eaf9ac81", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'channel_mapping': {'R': ['demods/0/sample.R'],\n", - " 'X': ['demods/0/sample.X'],\n", - " 'Y': ['demods/0/sample.Y'],\n", - " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", - " 'many': ['demods/0/sample.R',\n", - " 'auxins/0/sample.AuxIn0.avg',\n", + "{'channel_mapping': {'R': {'demods/0/sample.R'},\n", + " 'X': {'demods/0/sample.X'},\n", + " 'Y': {'demods/0/sample.Y'},\n", + " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", + " 'many': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y']}}" + " 'demods/0/sample.Y'}}}" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -155,70 +165,80 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "b9944369", + "execution_count": 13, + "id": "a9d59028", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1674.107177734375\n", + "1674.107177734375\n", + "1674.107177734375\n" + ] + } + ], "source": [ - "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"A\": (np.array([0, 3])*1, np.array([1, 10])*1),\"many\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" + "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"A\": (np.array([0, 3])*1, np.array([1, 10])*1), \"many\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "fec2b04e", + "execution_count": 14, + "id": "f570a78d", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{None: {'channel_mapping': {'R': ['demods/0/sample.R'],\n", - " 'X': ['demods/0/sample.X'],\n", - " 'Y': ['demods/0/sample.Y'],\n", - " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", - " 'many': ['demods/0/sample.R',\n", - " 'auxins/0/sample.AuxIn0.avg',\n", + "{None: {'channel_mapping': {'R': {'demods/0/sample.R'},\n", + " 'X': {'demods/0/sample.X'},\n", + " 'Y': {'demods/0/sample.Y'},\n", + " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", + " 'many': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y']}},\n", + " 'demods/0/sample.Y'}}},\n", " 'test': {'windows': {'A': (array([0, 3]), array([ 1, 10])),\n", " 'many': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))},\n", - " 'masks': {'A': {'mask': array([[[nan],\n", - " [nan]],\n", + " 'masks': {'A': {'mask': array([[[0.],\n", + " [0.]],\n", " \n", - " [[nan],\n", - " [nan]],\n", + " [[0.],\n", + " [0.]],\n", " \n", - " [[nan],\n", - " [nan]]]),\n", - " 'channels': ['auxins/0/sample.AuxIn0.avg'],\n", + " [[0.],\n", + " [0.]]]),\n", + " 'channels': {'auxins/0/sample.AuxIn0.avg'},\n", " 'sample_rates': [None]},\n", - " 'many': {'mask': array([[[ 0., nan, 0., 0.],\n", - " [ 3., nan, 3., 3.],\n", - " [ 7., nan, 7., 7.]],\n", + " 'many': {'mask': array([[[0., 0., 0., 0.],\n", + " [0., 0., 0., 0.],\n", + " [0., 0., 0., 0.]],\n", " \n", - " [[ 1., nan, 1., 1.],\n", - " [ 6., nan, 6., 6.],\n", - " [10., nan, 10., 10.]],\n", + " [[0., 0., 0., 0.],\n", + " [0., 0., 0., 0.],\n", + " [0., 0., 0., 0.]],\n", " \n", - " [[ 1., nan, 1., 1.],\n", - " [ 9., nan, 9., 9.],\n", - " [17., nan, 17., 17.]]]),\n", - " 'channels': ['demods/0/sample.R',\n", - " 'auxins/0/sample.AuxIn0.avg',\n", + " [[0., 0., 0., 0.],\n", + " [0., 0., 0., 0.],\n", + " [0., 0., 0., 0.]]]),\n", + " 'channels': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y'],\n", - " 'sample_rates': [TimeType(6857143, 4096),\n", - " None,\n", + " 'demods/0/sample.Y'},\n", + " 'sample_rates': [None,\n", + " TimeType(6857143, 4096),\n", " TimeType(6857143, 4096),\n", " TimeType(6857143, 4096)]}},\n", " 'all_channels': {'auxins/0/sample.AuxIn0.avg',\n", " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", " 'demods/0/sample.Y'},\n", - " 'window_hull': [0.0, 17.0]}}" + " 'window_hull': [0.0, 0.0]}}" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -229,8 +249,8 @@ }, { "cell_type": "code", - "execution_count": 14, - "id": "35b54564", + "execution_count": 15, + "id": "2e6045d6", "metadata": {}, "outputs": [], "source": [ @@ -239,24 +259,24 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "26769d32", + "execution_count": 16, + "id": "e91550d2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{None: {'channel_mapping': {'R': ['demods/0/sample.R'],\n", - " 'X': ['demods/0/sample.X'],\n", - " 'Y': ['demods/0/sample.Y'],\n", - " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", - " 'many': ['demods/0/sample.R',\n", - " 'auxins/0/sample.AuxIn0.avg',\n", + "{None: {'channel_mapping': {'R': {'demods/0/sample.R'},\n", + " 'X': {'demods/0/sample.X'},\n", + " 'Y': {'demods/0/sample.Y'},\n", + " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", + " 'many': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y']}}}" + " 'demods/0/sample.Y'}}}}" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -268,14 +288,14 @@ { "cell_type": "code", "execution_count": null, - "id": "6b95f243", + "id": "3158c4db", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "e20ad339", + "id": "145e5ba9", "metadata": {}, "source": [ "## Defining a simple qupulse pulse with a measurement window." @@ -283,8 +303,8 @@ }, { "cell_type": "code", - "execution_count": 16, - "id": "648f0722", + "execution_count": 17, + "id": "0d0ca8bd", "metadata": {}, "outputs": [], "source": [ @@ -293,55 +313,55 @@ }, { "cell_type": "code", - "execution_count": 17, - "id": "823cf456", + "execution_count": 18, + "id": "408f7b42", "metadata": {}, "outputs": [], "source": [ "red_pulse = qupulse.pulses.TablePT({\"red\": [\n", - " (0, 0),\n", - " (1, 4, 'hold'),\n", - " (4, .5, 'linear'),\n", - " (5, 2, 'hold'),\n", - " (6, .5, 'hold'),\n", - " (15, .5, 'jump'),\n", + " (\"0*dt\", 0),\n", + " (\"1*dt\", 4, 'hold'),\n", + " (\"4*dt\", .5, 'linear'),\n", + " (\"5*dt\", 2, 'hold'),\n", + " (\"6*dt\", .5, 'hold'),\n", + " (\"15*dt\", .5, 'jump'),\n", "]})" ] }, { "cell_type": "code", - "execution_count": 18, - "id": "715df81e", + "execution_count": 19, + "id": "e8cba8be", "metadata": {}, "outputs": [], "source": [ "green_pulse = qupulse.pulses.SequencePT(*[\n", - " qupulse.pulses.FunctionPT(\".1\", \"6\", channel=\"green\"),\n", - " qupulse.pulses.FunctionPT(\".1+t**2*.9\", \"1\", channel=\"green\"),\n", - " qupulse.pulses.FunctionPT(\"1\", \"1\", channel=\"green\"),\n", - " qupulse.pulses.FunctionPT(\"1+sin(t*2*pi)*exp(-(t-2)**2)\", \"5\", channel=\"green\"),\n", - " qupulse.pulses.FunctionPT(\"1\", \"1\", channel=\"green\"),\n", - " qupulse.pulses.FunctionPT(\"0\", \"1\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\".1\", \"6*dt\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\".1+t**2*.9\", \"1*dt\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"1\", \"1*dt\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"1+sin(t*2*pi)*exp(-(t-2)**2)\", \"5*dt\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"1\", \"1*dt\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"0\", \"1*dt\", channel=\"green\"),\n", "]\n", ")" ] }, { "cell_type": "code", - "execution_count": 19, - "id": "86258f61", + "execution_count": 20, + "id": "3c473b50", "metadata": {}, "outputs": [], "source": [ - "measured_pt = qupulse.pulses.PointPT([(0, 0), (0, 1), (15, 1), (15, 0)],\n", + "measured_pt = qupulse.pulses.PointPT([(\"0*dt\", 0), (\"0*dt\", 1), (\"15*dt\", 1), (\"15*dt\", 0)],\n", " channel_names=(\"trigger_out\",),\n", - " measurements=[('A', 3, 1.5), ('A', 12, 3), ('R', 6.5, 1.4), ('R', 14, 1), ('T', 10, 3)])" + " measurements=[('A', \"dt*3\", \"dt*1.5\"), ('A', \"dt*12\", \"dt*3\"), ('R', \"dt*6.5\", \"dt*1.4\"), ('R', \"dt*14\", \"dt*1\"), ('T', \"dt*10\", \"dt*3\")])" ] }, { "cell_type": "code", - "execution_count": 20, - "id": "dabc4f0f", + "execution_count": 21, + "id": "980a3d80", "metadata": {}, "outputs": [ { @@ -359,15 +379,15 @@ }, { "cell_type": "code", - "execution_count": 21, - "id": "86ca9d23", + "execution_count": 22, + "id": "154e7c08", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'R', 'A', 'T'}\n", + "{'T', 'A', 'R'}\n", "[]\n", "set()\n" ] @@ -381,8 +401,8 @@ }, { "cell_type": "code", - "execution_count": 22, - "id": "18693b31", + "execution_count": 23, + "id": "b10b7f5e", "metadata": {}, "outputs": [ { @@ -391,7 +411,7 @@ "" ] }, - "execution_count": 22, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -402,13 +422,13 @@ }, { "cell_type": "code", - "execution_count": 23, - "id": "d1142301", + "execution_count": 24, + "id": "35d86b39", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -426,8 +446,8 @@ }, { "cell_type": "code", - "execution_count": 24, - "id": "56081907", + "execution_count": 25, + "id": "3ba81135", "metadata": {}, "outputs": [], "source": [ @@ -447,8 +467,8 @@ }, { "cell_type": "code", - "execution_count": 25, - "id": "8f367858", + "execution_count": 26, + "id": "1e0e993b", "metadata": {}, "outputs": [], "source": [ @@ -460,13 +480,13 @@ }, { "cell_type": "code", - "execution_count": 26, - "id": "4beacf1c", + "execution_count": 27, + "id": "a7d2070f", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -485,14 +505,14 @@ { "cell_type": "code", "execution_count": null, - "id": "a443878d", + "id": "ed72dd2f", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "ca0ab7e8", + "id": "374cfcb2", "metadata": {}, "source": [ "## Execution\n", @@ -503,8 +523,8 @@ }, { "cell_type": "code", - "execution_count": 27, - "id": "a94273c9", + "execution_count": 28, + "id": "1c56f470", "metadata": {}, "outputs": [], "source": [ @@ -513,8 +533,8 @@ }, { "cell_type": "code", - "execution_count": 28, - "id": "4f2f2591", + "execution_count": 29, + "id": "b9419441", "metadata": {}, "outputs": [], "source": [ @@ -523,8 +543,8 @@ }, { "cell_type": "code", - "execution_count": 29, - "id": "00a9186d", + "execution_count": 30, + "id": "7cc18e58", "metadata": {}, "outputs": [], "source": [ @@ -533,8 +553,8 @@ }, { "cell_type": "code", - "execution_count": 30, - "id": "ffdc6396", + "execution_count": 31, + "id": "eb7524b8", "metadata": {}, "outputs": [], "source": [ @@ -543,8 +563,8 @@ }, { "cell_type": "code", - "execution_count": 31, - "id": "4e756118", + "execution_count": 32, + "id": "b8a7559a", "metadata": {}, "outputs": [], "source": [ @@ -554,8 +574,8 @@ }, { "cell_type": "code", - "execution_count": 32, - "id": "847713ee", + "execution_count": 33, + "id": "72e58f1c", "metadata": {}, "outputs": [], "source": [ @@ -565,8 +585,8 @@ }, { "cell_type": "code", - "execution_count": 33, - "id": "4f7e7867", + "execution_count": 34, + "id": "918d8031", "metadata": {}, "outputs": [], "source": [ @@ -575,33 +595,63 @@ }, { "cell_type": "code", - "execution_count": 34, - "id": "d240e903", + "execution_count": 35, + "id": "720142ef", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1674.107177734375\n", + "1674.107177734375\n" + ] + } + ], "source": [ "setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(None), update=True)" ] }, { "cell_type": "code", - "execution_count": 35, - "id": "72862ec2", + "execution_count": 40, + "id": "3305f971", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.5111607666015624e-05" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "15e-9*1674.107177734375" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "970c67d9", "metadata": { - "scrolled": true + "scrolled": false }, "outputs": [ { "data": { "text/plain": [ - "{None: {'channel_mapping': {'R': ['demods/0/sample.R'],\n", - " 'X': ['demods/0/sample.X'],\n", - " 'Y': ['demods/0/sample.Y'],\n", - " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", - " 'many': ['demods/0/sample.R',\n", - " 'auxins/0/sample.AuxIn0.avg',\n", + "{None: {'channel_mapping': {'R': {'demods/0/sample.R'},\n", + " 'X': {'demods/0/sample.X'},\n", + " 'Y': {'demods/0/sample.Y'},\n", + " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", + " 'many': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y']}},\n", + " 'demods/0/sample.Y'}}},\n", " 'test': {'windows': {'X': (array([10.]), array([3.])),\n", " 'R': (array([ 6.5, 14. ]), array([1.4, 1. ])),\n", " 'A': (array([ 3., 12.]), array([1.5, 3. ]))},\n", @@ -610,7 +660,7 @@ " [[ 5022.]],\n", " \n", " [[21763.]]]),\n", - " 'channels': ['demods/0/sample.X'],\n", + " 'channels': {'demods/0/sample.X'},\n", " 'sample_rates': [TimeType(6857143, 4096)]},\n", " 'R': {'mask': array([[[10882.],\n", " [23438.]],\n", @@ -620,25 +670,25 @@ " \n", " [[13225.],\n", " [25112.]]]),\n", - " 'channels': ['demods/0/sample.R'],\n", + " 'channels': {'demods/0/sample.R'},\n", " 'sample_rates': [TimeType(6857143, 4096)]},\n", - " 'A': {'mask': array([[[nan],\n", - " [nan]],\n", + " 'A': {'mask': array([[[ 3.],\n", + " [12.]],\n", " \n", - " [[nan],\n", - " [nan]],\n", + " [[ 1.],\n", + " [ 3.]],\n", " \n", - " [[nan],\n", - " [nan]]]),\n", - " 'channels': ['auxins/0/sample.AuxIn0.avg'],\n", + " [[ 4.],\n", + " [15.]]]),\n", + " 'channels': {'auxins/0/sample.AuxIn0.avg'},\n", " 'sample_rates': [None]}},\n", " 'all_channels': {'auxins/0/sample.AuxIn0.avg',\n", " 'demods/0/sample.R',\n", " 'demods/0/sample.X'},\n", - " 'window_hull': [10882.0, 21763.0]}}" + " 'window_hull': [3.0, 15.0]}}" ] }, - "execution_count": 35, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -650,24 +700,32 @@ { "cell_type": "code", "execution_count": null, - "id": "2a211ced", + "id": "212a4514", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", - "execution_count": 41, - "id": "56298e79", + "execution_count": 37, + "id": "5212bdf8", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:283: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:295: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", " warnings.warn(f\"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.\")\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1674.107177734375\n", + "1674.107177734375\n" + ] } ], "source": [ @@ -676,36 +734,36 @@ }, { "cell_type": "code", - "execution_count": 42, - "id": "5761973b", + "execution_count": 38, + "id": "b913c687", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "{'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664383619736669], dtype=uint64), 'createdtimestamp': array([1393721038376], dtype=uint64), 'changedtimestamp': array([1393721038376], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '001 18:46:59.7359', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 1394500905096,\n", - " 1394500940936, 1394500976776]], dtype=uint64), 'value': array([[ nan, nan, nan, ..., -0.00060027,\n", - " -0.00061161, -0.00062295]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664383619737528], dtype=uint64), 'createdtimestamp': array([1393721038376], dtype=uint64), 'changedtimestamp': array([1393721038376], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '001 18:46:59.7359', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1393721026696, 1393721062536, 1393721098376, ..., 1394500905096,\n", - " 1394500940936, 1394500976776]], dtype=uint64), 'value': array([[1.28582697e-07, 2.34376326e-07, 2.38996428e-07, ...,\n", - " 5.87560559e-07, 5.32019319e-07, 4.14106693e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664383619737107], dtype=uint64), 'createdtimestamp': array([1393721038376], dtype=uint64), 'changedtimestamp': array([1393721038376], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '001 18:46:59.7359', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1393721026696, 1393721062536, 1393721098376, ..., 1394500905096,\n", - " 1394500940936, 1394500976776]], dtype=uint64), 'value': array([[ 3.39232042e-08, -8.97284119e-08, 9.67278307e-09, ...,\n", - " -5.81247741e-07, -5.16688776e-07, -4.03478886e-07]])}]}}}, 'forcetrigger': array([0], dtype=int64), 'triggered': array([0], dtype=int64)}\n" + "{'awgcontrol': array([0], dtype=int64), 'bandwidth': array([0.]), 'bitmask': array([1], dtype=int64), 'bits': array([1], dtype=int64), 'buffercount': array([2], dtype=int64), 'buffersize': array([0.2]), 'clearhistory': array([0], dtype=int64), 'count': array([1], dtype=int64), 'delay': array([-0.001]), 'dev3442': {'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664444033771594], dtype=uint64), 'createdtimestamp': array([351220594233], dtype=uint64), 'changedtimestamp': array([351220594233], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '000 11:33:53.7712', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([15], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[351220582553, 351220618393, 351220654233, 351220690073,\n", + " 351220725913, 351220761753, 351220797593, 351220833433,\n", + " 351220869273, 351220905113, 351220940953, 351220976793,\n", + " 351221012633, 351221048473, 351221084313]], dtype=uint64), 'value': array([[3.91947639e-07, 5.04776395e-07, 6.40830166e-07, 8.50759130e-07,\n", + " 9.48581891e-07, 9.39008711e-07, 7.22044644e-07, 5.14505033e-07,\n", + " 4.61612617e-07, 3.55077975e-07, 2.90122718e-07, 3.95506751e-07,\n", + " 4.36968275e-07, 4.26032845e-07, 2.54789854e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664444033771590], dtype=uint64), 'createdtimestamp': array([351220594233], dtype=uint64), 'changedtimestamp': array([351220594233], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '000 11:33:53.7712', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([15], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[351220582553, 351220618393, 351220654233, 351220690073,\n", + " 351220725913, 351220761753, 351220797593, 351220833433,\n", + " 351220869273, 351220905113, 351220940953, 351220976793,\n", + " 351221012633, 351221048473, 351221084313]], dtype=uint64), 'value': array([[-3.84965645e-07, -5.01921593e-07, -5.24020048e-07,\n", + " -5.05596497e-07, -5.44546535e-07, -4.90243338e-07,\n", + " -3.17540780e-07, -1.17378687e-07, -6.11656886e-08,\n", + " -1.94232976e-08, 1.17480934e-07, 2.11811048e-07,\n", + " 3.18037065e-07, 3.79153125e-07, 2.19639802e-07]])}]}}}, 'device': ['dev3442'], 'duration': array([0.00896]), 'edge': array([1], dtype=int64), 'enable': array([1], dtype=int64), 'endless': array([0], dtype=int64), 'eventcount': {'mode': array([1], dtype=int64)}, 'fft': {'absolute': array([0], dtype=int64), 'window': array([1], dtype=int64)}, 'findlevel': array([0], dtype=int64), 'flags': array([8], dtype=int64), 'forcetrigger': array([0], dtype=int64), 'grid': {'cols': array([15], dtype=int64), 'direction': array([0], dtype=int64), 'mode': array([4], dtype=int64), 'overwrite': array([0], dtype=int64), 'repetitions': array([1], dtype=int64), 'rowrepetition': array([0], dtype=int64), 'rows': array([1], dtype=int64), 'waterfall': array([0], dtype=int64)}, 'historylength': array([100000], dtype=int64), 'holdoff': {'count': array([0], dtype=int64), 'time': array([0.2])}, 'hysteresis': array([0.]), 'level': array([0.]), 'preview': array([0], dtype=int64), 'pulse': {'max': array([0.001]), 'min': array([0.])}, 'refreshrate': array([5.]), 'save': {'csvlocale': ['C'], 'csvseparator': [';'], 'directory': ['C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer'], 'fileformat': array([0], dtype=int64), 'filename': ['dataAcquisitionModule'], 'save': array([0], dtype=int64), 'saveonread': array([0], dtype=int64)}, 'spectrum': {'autobandwidth': array([0], dtype=int64), 'enable': array([0], dtype=int64), 'frequencyspan': array([13000.]), 'overlapped': array([1], dtype=int64)}, 'triggered': array([0], dtype=int64), 'triggernode': ['/dev3442/demods/0/sample.AuxIn0'], 'type': array([1], dtype=int64)}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:467: UserWarning: For at least one received channel entries with different dimensions are present. This might lead to undesired masking! (The code will not raise an exception.) ({'/dev3442/demods/0/sample.r': {(1, 15)}, '/dev3442/demods/0/sample.x': {(1, 15)}})\n", + " warnings.warn(f\"For at least one received channel entries with different dimensions are present. This might lead to undesired masking! (The code will not raise an exception.) ({recorded_shapes})\")\n" ] } ], @@ -715,17 +773,87 @@ }, { "cell_type": "code", - "execution_count": 40, - "id": "b8de12f0", - "metadata": {}, + "execution_count": 39, + "id": "9919ae42", + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { "text/plain": [ - "{}" + "{'/dev3442/demods/0/sample.r': [\n", + " array([[2.83077683e-07, 1.98653388e-07, 1.23254334e-07, 2.35563621e-07,\n", + " 2.59927715e-07, 2.30951769e-07, 1.99951982e-07, 1.27807482e-07,\n", + " 1.46559367e-07, 3.77772093e-07, 5.41456793e-07, 5.09670654e-07,\n", + " 4.31549240e-07, 4.23198107e-07, 5.08910680e-07]])\n", + " Coordinates:\n", + " timestamp (col, row) uint64 335622978713 335623014553 ... 335623480473\n", + " Dimensions without coordinates: col, row\n", + " Attributes:\n", + " systemtime: [1664443773825583]\n", + " createdtimestamp: [335622990393]\n", + " changedtimestamp: [335622990393]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 000 11:29:33.8254\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [15]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.x': [\n", + " array([[ 2.80890995e-07, 1.98361712e-07, -3.30729417e-08,\n", + " -2.13084648e-07, -2.54901781e-07, -2.26618891e-07,\n", + " -1.88342725e-07, -6.13516462e-08, -4.60965485e-08,\n", + " -1.99625745e-07, -3.19756724e-07, -3.09219328e-07,\n", + " -2.26602149e-07, -2.13735799e-07, -1.37713835e-07]])\n", + " Coordinates:\n", + " timestamp (col, row) uint64 335622978713 335623014553 ... 335623480473\n", + " Dimensions without coordinates: col, row\n", + " Attributes:\n", + " systemtime: [1664443773825587]\n", + " createdtimestamp: [335622990393]\n", + " changedtimestamp: [335622990393]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 000 11:29:33.8254\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [15]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}" ] }, - "execution_count": 40, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -736,9 +864,92 @@ }, { "cell_type": "code", - "execution_count": 39, - "id": "9907a87f", + "execution_count": 68, + "id": "9efdcbad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/dev3442/demods/0/sample.x\n", + "[[16741. 16742. 16743. ... 21761. 21762. 21763.]]\n", + "/dev3442/demods/0/sample.r\n", + "[[10882. 10883. 10884. ... 13223. 13224. 13225.]\n", + " [23438. 23439. 23440. ... nan nan nan]]\n", + "/dev3442/auxins/0/sample.auxin0.avg\n" + ] + }, + { + "ename": "ValueError", + "evalue": "There is something wrong with the data for channel /dev3442/auxins/0/sample.auxin0.avg. The later code assumes that the lock-in is linearly interpolating up to the highest sample rate used.", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_28708\\3255017280.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mmy_lockin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mprogram_name\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"test\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m in \u001b[0;36m_parse_data\u001b[1;34m(self, recorded_data, program_name)\u001b[0m\n\u001b[0;32m 394\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 395\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misnan\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 396\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"There is something wrong with the data for channel {cn}. The later code assumes that the lock-in is linearly interpolating up to the highest sample rate used.\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 397\u001b[0m \u001b[1;31m# building the mask to apply to the data now:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 398\u001b[0m \u001b[0mapplicable_mask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnanmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mint\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnan\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mValueError\u001b[0m: There is something wrong with the data for channel /dev3442/auxins/0/sample.auxin0.avg. The later code assumes that the lock-in is linearly interpolating up to the highest sample rate used." + ] + } + ], + "source": [ + "my_lockin._parse_data(data, program_name=\"test\")" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "e16b5714", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\numpy\\core\\numeric.py\u001b[0m(342)\u001b[0;36mfull\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 340 \u001b[1;33m \u001b[0mfill_value\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0masarray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfill_value\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 341 \u001b[1;33m \u001b[0mdtype\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfill_value\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 342 \u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mempty\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0morder\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 343 \u001b[1;33m \u001b[0mmultiarray\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcopyto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfill_value\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcasting\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'unsafe'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 344 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> shape\n", + "(2, -2147483647)\n", + "ipdb> u\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(390)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 388 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 389 \u001b[1;33m \u001b[1;31m# building the mask to apply to the data now:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 390 \u001b[1;33m \u001b[0mapplicable_mask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnanmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mint\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnan\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 391 \u001b[1;33m \u001b[1;31m# the following code could probably be optimized with some numpy magic\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 392 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mwi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mw\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> _mask\n", + "array([[[nan],\n", + " [nan]],\n", + "\n", + " [[nan],\n", + " [nan]],\n", + "\n", + " [[nan],\n", + " [nan]]])\n", + "--KeyboardInterrupt--\n", + "\n", + "KeyboardInterrupt: Interrupted by user\n" + ] + } + ], + "source": [ + "%debug" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "ccbb3117", + "metadata": { + "scrolled": true + }, "outputs": [ { "ename": "KeyError", @@ -759,7 +970,7 @@ { "cell_type": "code", "execution_count": null, - "id": "89113a7c", + "id": "b1977d4b", "metadata": {}, "outputs": [], "source": [ @@ -769,7 +980,7 @@ { "cell_type": "code", "execution_count": 43, - "id": "8641d7d5", + "id": "53e76b94", "metadata": {}, "outputs": [], "source": [ @@ -779,7 +990,7 @@ { "cell_type": "code", "execution_count": 47, - "id": "b0693faf", + "id": "21c43e9b", "metadata": {}, "outputs": [ { @@ -1218,7 +1429,7 @@ { "cell_type": "code", "execution_count": 48, - "id": "b0864fca", + "id": "133629d2", "metadata": {}, "outputs": [ { @@ -1239,7 +1450,7 @@ { "cell_type": "code", "execution_count": 44, - "id": "cd038089", + "id": "0e940f58", "metadata": {}, "outputs": [ { @@ -1265,7 +1476,7 @@ { "cell_type": "code", "execution_count": 68, - "id": "a0dbfbd2", + "id": "df2a0ea7", "metadata": {}, "outputs": [ { @@ -1298,7 +1509,7 @@ { "cell_type": "code", "execution_count": 55, - "id": "96606726", + "id": "551bb968", "metadata": { "scrolled": true }, @@ -1357,7 +1568,7 @@ { "cell_type": "code", "execution_count": 63, - "id": "838d961b", + "id": "eb79c602", "metadata": {}, "outputs": [ { @@ -1392,7 +1603,7 @@ { "cell_type": "code", "execution_count": 192, - "id": "339755e2", + "id": "b4c50e35", "metadata": {}, "outputs": [ { @@ -1461,7 +1672,7 @@ { "cell_type": "code", "execution_count": 174, - "id": "c5240cf0", + "id": "9facd1f5", "metadata": {}, "outputs": [ { @@ -1488,7 +1699,7 @@ { "cell_type": "code", "execution_count": 123, - "id": "cb7d26b3", + "id": "51eb510b", "metadata": {}, "outputs": [], "source": [ @@ -1498,7 +1709,7 @@ { "cell_type": "code", "execution_count": 145, - "id": "36774f10", + "id": "4e16f0f2", "metadata": { "scrolled": false }, @@ -1521,7 +1732,7 @@ { "cell_type": "code", "execution_count": 119, - "id": "614316d1", + "id": "429ab72c", "metadata": {}, "outputs": [ { @@ -1542,7 +1753,7 @@ { "cell_type": "code", "execution_count": 110, - "id": "a9dfa502", + "id": "7d64ad62", "metadata": {}, "outputs": [], "source": [ @@ -1552,7 +1763,7 @@ { "cell_type": "code", "execution_count": 111, - "id": "263575fe", + "id": "b8de6d7b", "metadata": {}, "outputs": [ { @@ -1615,7 +1826,7 @@ { "cell_type": "code", "execution_count": 169, - "id": "4f8fa7d3", + "id": "f75de994", "metadata": {}, "outputs": [ { @@ -1636,7 +1847,7 @@ { "cell_type": "code", "execution_count": 205, - "id": "a0b1b2b2", + "id": "7b99b2eb", "metadata": {}, "outputs": [ { @@ -1657,7 +1868,7 @@ { "cell_type": "code", "execution_count": 202, - "id": "6d228524", + "id": "3ab2e209", "metadata": {}, "outputs": [], "source": [ @@ -1667,7 +1878,7 @@ { "cell_type": "code", "execution_count": 114, - "id": "60365fd8", + "id": "ddaec525", "metadata": {}, "outputs": [ { @@ -1688,7 +1899,7 @@ { "cell_type": "code", "execution_count": 117, - "id": "76255359", + "id": "4b8e5939", "metadata": {}, "outputs": [ { @@ -1709,7 +1920,7 @@ { "cell_type": "code", "execution_count": 116, - "id": "822c77dd", + "id": "2d3370e5", "metadata": {}, "outputs": [], "source": [ @@ -1719,7 +1930,7 @@ { "cell_type": "code", "execution_count": 193, - "id": "9402f8fe", + "id": "09fc6209", "metadata": {}, "outputs": [], "source": [ @@ -1729,7 +1940,7 @@ { "cell_type": "code", "execution_count": null, - "id": "55677713", + "id": "32eedc4f", "metadata": {}, "outputs": [], "source": [] @@ -1737,7 +1948,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2c980ada", + "id": "d939a7bd", "metadata": {}, "outputs": [], "source": [] @@ -1745,7 +1956,7 @@ { "cell_type": "code", "execution_count": null, - "id": "306b8d9f", + "id": "41d2d6d3", "metadata": {}, "outputs": [], "source": [] @@ -1753,7 +1964,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "021403d4", + "id": "5acca51a", "metadata": {}, "outputs": [], "source": [ @@ -1763,7 +1974,7 @@ { "cell_type": "code", "execution_count": 32, - "id": "8738508f", + "id": "e3aa7278", "metadata": {}, "outputs": [], "source": [ @@ -1774,7 +1985,7 @@ { "cell_type": "code", "execution_count": 33, - "id": "8ce3ae43", + "id": "8a7d030a", "metadata": {}, "outputs": [], "source": [ @@ -1784,7 +1995,7 @@ { "cell_type": "code", "execution_count": 37, - "id": "9b977196", + "id": "ddda80e7", "metadata": {}, "outputs": [ { @@ -2903,7 +3114,7 @@ { "cell_type": "code", "execution_count": 29, - "id": "c0e526ba", + "id": "cb68a22d", "metadata": {}, "outputs": [ { @@ -2929,7 +3140,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ae560ada", + "id": "ef14673f", "metadata": {}, "outputs": [], "source": [] @@ -2937,7 +3148,7 @@ { "cell_type": "code", "execution_count": 35, - "id": "1f6a003a", + "id": "f58c1f3a", "metadata": {}, "outputs": [], "source": [ @@ -2948,7 +3159,7 @@ { "cell_type": "code", "execution_count": 31, - "id": "c8c91ef7", + "id": "312b86b6", "metadata": {}, "outputs": [], "source": [ @@ -2958,7 +3169,7 @@ { "cell_type": "code", "execution_count": 78, - "id": "0e75a1ba", + "id": "c02fde6f", "metadata": {}, "outputs": [ { @@ -2984,7 +3195,7 @@ { "cell_type": "code", "execution_count": null, - "id": "dfe07e28", + "id": "b5933588", "metadata": {}, "outputs": [], "source": [] @@ -2992,7 +3203,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c69299c6", + "id": "663d0e35", "metadata": {}, "outputs": [], "source": [] @@ -3000,7 +3211,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1e70db16", + "id": "38d18413", "metadata": {}, "outputs": [], "source": [] @@ -3008,7 +3219,7 @@ { "cell_type": "code", "execution_count": null, - "id": "63957cc1", + "id": "b6850fd2", "metadata": {}, "outputs": [], "source": [] @@ -3016,7 +3227,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a67d911a", + "id": "1ceecd5d", "metadata": {}, "outputs": [], "source": [] diff --git a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb index 395866d67..101702024 100644 --- a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb +++ b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "fceb835c", + "id": "ee52af1c", "metadata": {}, "source": [ "# Zurich Instruments Lock-In MFLI Data Aquesition" @@ -11,7 +11,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "55c55e0a", + "id": "cd26d7f1", "metadata": {}, "outputs": [], "source": [ @@ -22,7 +22,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "708ad356", + "id": "2646f99a", "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "e69e0618", + "id": "41fcd1eb", "metadata": {}, "outputs": [], "source": [ @@ -42,7 +42,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "f7cb2ae3", + "id": "3784c6c8", "metadata": {}, "outputs": [], "source": [ @@ -52,7 +52,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "12279c39", + "id": "4cdccd38", "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "9eef13eb", + "id": "94b6ce7b", "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "c1f9c7ec", + "id": "83cfe729", "metadata": {}, "outputs": [ { @@ -91,7 +91,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "9a3bf46e", + "id": "ce3aa3d7", "metadata": {}, "outputs": [], "source": [ @@ -101,7 +101,17 @@ { "cell_type": "code", "execution_count": 9, - "id": "baf33df9", + "id": "43921bfc", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.assumed_minimal_sample_rate = 1." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b0e8819b", "metadata": {}, "outputs": [], "source": [ @@ -116,8 +126,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "dfd7c42e", + "execution_count": 11, + "id": "13e08f84", "metadata": {}, "outputs": [], "source": [ @@ -127,24 +137,24 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "62df1451", + "execution_count": 12, + "id": "ae0d8112", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'channel_mapping': {'R': ['demods/0/sample.R'],\n", - " 'X': ['demods/0/sample.X'],\n", - " 'Y': ['demods/0/sample.Y'],\n", - " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", - " 'many': ['demods/0/sample.R',\n", - " 'auxins/0/sample.AuxIn0.avg',\n", + "{'channel_mapping': {'R': {'demods/0/sample.R'},\n", + " 'X': {'demods/0/sample.X'},\n", + " 'Y': {'demods/0/sample.Y'},\n", + " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", + " 'many': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y']}}" + " 'demods/0/sample.Y'}}}" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -155,70 +165,80 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "b9944369", + "execution_count": 13, + "id": "468243d5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1674.107177734375\n", + "1674.107177734375\n", + "1674.107177734375\n" + ] + } + ], "source": [ - "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"A\": (np.array([0, 3])*1, np.array([1, 10])*1),\"many\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" + "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"A\": (np.array([0, 3])*1, np.array([1, 10])*1), \"many\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "fec2b04e", + "execution_count": 14, + "id": "d2a3fd49", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{None: {'channel_mapping': {'R': ['demods/0/sample.R'],\n", - " 'X': ['demods/0/sample.X'],\n", - " 'Y': ['demods/0/sample.Y'],\n", - " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", - " 'many': ['demods/0/sample.R',\n", - " 'auxins/0/sample.AuxIn0.avg',\n", + "{None: {'channel_mapping': {'R': {'demods/0/sample.R'},\n", + " 'X': {'demods/0/sample.X'},\n", + " 'Y': {'demods/0/sample.Y'},\n", + " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", + " 'many': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y']}},\n", + " 'demods/0/sample.Y'}}},\n", " 'test': {'windows': {'A': (array([0, 3]), array([ 1, 10])),\n", " 'many': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))},\n", - " 'masks': {'A': {'mask': array([[[nan],\n", - " [nan]],\n", + " 'masks': {'A': {'mask': array([[[0.],\n", + " [0.]],\n", " \n", - " [[nan],\n", - " [nan]],\n", + " [[0.],\n", + " [0.]],\n", " \n", - " [[nan],\n", - " [nan]]]),\n", - " 'channels': ['auxins/0/sample.AuxIn0.avg'],\n", + " [[0.],\n", + " [0.]]]),\n", + " 'channels': {'auxins/0/sample.AuxIn0.avg'},\n", " 'sample_rates': [None]},\n", - " 'many': {'mask': array([[[ 0., nan, 0., 0.],\n", - " [ 3., nan, 3., 3.],\n", - " [ 7., nan, 7., 7.]],\n", + " 'many': {'mask': array([[[0., 0., 0., 0.],\n", + " [0., 0., 0., 0.],\n", + " [0., 0., 0., 0.]],\n", " \n", - " [[ 1., nan, 1., 1.],\n", - " [ 6., nan, 6., 6.],\n", - " [10., nan, 10., 10.]],\n", + " [[0., 0., 0., 0.],\n", + " [0., 0., 0., 0.],\n", + " [0., 0., 0., 0.]],\n", " \n", - " [[ 1., nan, 1., 1.],\n", - " [ 9., nan, 9., 9.],\n", - " [17., nan, 17., 17.]]]),\n", - " 'channels': ['demods/0/sample.R',\n", - " 'auxins/0/sample.AuxIn0.avg',\n", + " [[0., 0., 0., 0.],\n", + " [0., 0., 0., 0.],\n", + " [0., 0., 0., 0.]]]),\n", + " 'channels': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y'],\n", - " 'sample_rates': [TimeType(6857143, 4096),\n", - " None,\n", + " 'demods/0/sample.Y'},\n", + " 'sample_rates': [None,\n", + " TimeType(6857143, 4096),\n", " TimeType(6857143, 4096),\n", " TimeType(6857143, 4096)]}},\n", " 'all_channels': {'auxins/0/sample.AuxIn0.avg',\n", " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", " 'demods/0/sample.Y'},\n", - " 'window_hull': [0.0, 17.0]}}" + " 'window_hull': [0.0, 0.0]}}" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -229,8 +249,8 @@ }, { "cell_type": "code", - "execution_count": 14, - "id": "35b54564", + "execution_count": 15, + "id": "75b9e45c", "metadata": {}, "outputs": [], "source": [ @@ -239,24 +259,24 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "26769d32", + "execution_count": 16, + "id": "56f26163", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{None: {'channel_mapping': {'R': ['demods/0/sample.R'],\n", - " 'X': ['demods/0/sample.X'],\n", - " 'Y': ['demods/0/sample.Y'],\n", - " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", - " 'many': ['demods/0/sample.R',\n", - " 'auxins/0/sample.AuxIn0.avg',\n", + "{None: {'channel_mapping': {'R': {'demods/0/sample.R'},\n", + " 'X': {'demods/0/sample.X'},\n", + " 'Y': {'demods/0/sample.Y'},\n", + " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", + " 'many': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y']}}}" + " 'demods/0/sample.Y'}}}}" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -268,14 +288,14 @@ { "cell_type": "code", "execution_count": null, - "id": "6b95f243", + "id": "39176f52", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "e20ad339", + "id": "b30732e3", "metadata": {}, "source": [ "## Defining a simple qupulse pulse with a measurement window." @@ -283,8 +303,8 @@ }, { "cell_type": "code", - "execution_count": 16, - "id": "648f0722", + "execution_count": 17, + "id": "1c964db6", "metadata": {}, "outputs": [], "source": [ @@ -293,55 +313,55 @@ }, { "cell_type": "code", - "execution_count": 17, - "id": "823cf456", + "execution_count": 18, + "id": "b49ab3e5", "metadata": {}, "outputs": [], "source": [ "red_pulse = qupulse.pulses.TablePT({\"red\": [\n", - " (0, 0),\n", - " (1, 4, 'hold'),\n", - " (4, .5, 'linear'),\n", - " (5, 2, 'hold'),\n", - " (6, .5, 'hold'),\n", - " (15, .5, 'jump'),\n", + " (\"0*dt\", 0),\n", + " (\"1*dt\", 4, 'hold'),\n", + " (\"4*dt\", .5, 'linear'),\n", + " (\"5*dt\", 2, 'hold'),\n", + " (\"6*dt\", .5, 'hold'),\n", + " (\"15*dt\", .5, 'jump'),\n", "]})" ] }, { "cell_type": "code", - "execution_count": 18, - "id": "715df81e", + "execution_count": 40, + "id": "c771c335", "metadata": {}, "outputs": [], "source": [ "green_pulse = qupulse.pulses.SequencePT(*[\n", - " qupulse.pulses.FunctionPT(\".1\", \"6\", channel=\"green\"),\n", - " qupulse.pulses.FunctionPT(\".1+t**2*.9\", \"1\", channel=\"green\"),\n", - " qupulse.pulses.FunctionPT(\"1\", \"1\", channel=\"green\"),\n", - " qupulse.pulses.FunctionPT(\"1+sin(t*2*pi)*exp(-(t-2)**2)\", \"5\", channel=\"green\"),\n", - " qupulse.pulses.FunctionPT(\"1\", \"1\", channel=\"green\"),\n", - " qupulse.pulses.FunctionPT(\"0\", \"1\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\".1\", \"6*dt\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\".1+(t/dt)**2*.9\", \"1*dt\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"1\", \"1*dt\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"1+sin((t/dt)*2*pi)*exp(-((t/dt)-2)**2)\", \"5*dt\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"1\", \"1*dt\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"0\", \"1*dt\", channel=\"green\"),\n", "]\n", ")" ] }, { "cell_type": "code", - "execution_count": 19, - "id": "86258f61", + "execution_count": 41, + "id": "437abe9e", "metadata": {}, "outputs": [], "source": [ - "measured_pt = qupulse.pulses.PointPT([(0, 0), (0, 1), (15, 1), (15, 0)],\n", + "measured_pt = qupulse.pulses.PointPT([(\"0*dt\", 0), (\"0*dt\", 1), (\"15*dt\", 1), (\"15*dt\", 0)],\n", " channel_names=(\"trigger_out\",),\n", - " measurements=[('A', 3, 1.5), ('A', 12, 3), ('R', 6.5, 1.4), ('R', 14, 1), ('T', 10, 3)])" + " measurements=[('A', \"dt*3\", \"dt*1.5\"), ('A', \"dt*12\", \"dt*3\"), ('R', \"dt*6.5\", \"dt*1.4\"), ('R', \"dt*14\", \"dt*1\"), ('T', \"dt*10\", \"dt*3\")])" ] }, { "cell_type": "code", - "execution_count": 20, - "id": "dabc4f0f", + "execution_count": 42, + "id": "590ba4f3", "metadata": {}, "outputs": [ { @@ -359,15 +379,15 @@ }, { "cell_type": "code", - "execution_count": 21, - "id": "86ca9d23", + "execution_count": 43, + "id": "b3497d55", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'R', 'A', 'T'}\n", + "{'A', 'T', 'R'}\n", "[]\n", "set()\n" ] @@ -381,17 +401,17 @@ }, { "cell_type": "code", - "execution_count": 22, - "id": "18693b31", + "execution_count": 44, + "id": "a61460bf", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 22, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } @@ -402,13 +422,13 @@ }, { "cell_type": "code", - "execution_count": 23, - "id": "d1142301", + "execution_count": 48, + "id": "7b5633f3", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -420,35 +440,35 @@ } ], "source": [ - "plot(combined_pulse, sample_rate=300, plot_measurements=combined_pulse.measurement_names) # combined_pulse.measurement_names\n", + "plot(combined_pulse, sample_rate=1e-7, plot_measurements=combined_pulse.measurement_names, parameters={\"dt\": 1e9}) # combined_pulse.measurement_names\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 24, - "id": "56081907", + "execution_count": 49, + "id": "435cabec", "metadata": {}, "outputs": [], "source": [ "idle_pulse = qupulse.pulses.TablePT({\"red\": [\n", - " (0, 0),\n", - " (5, 0),\n", + " (\"0*dt\", 0),\n", + " (\"5*dt\", 0),\n", "],\n", " \"green\": [\n", - " (0, 0),\n", - " (5, 0),\n", + " (\"0*dt\", 0),\n", + " (\"5*dt\", 0),\n", "],\n", " \"trigger_out\": [\n", - " (0, 0),\n", - " (5, 0),\n", + " (\"0*dt\", 0),\n", + " (\"5*dt\", 0),\n", "]})" ] }, { "cell_type": "code", - "execution_count": 25, - "id": "8f367858", + "execution_count": 50, + "id": "a54480cc", "metadata": {}, "outputs": [], "source": [ @@ -460,13 +480,13 @@ }, { "cell_type": "code", - "execution_count": 26, - "id": "4beacf1c", + "execution_count": 51, + "id": "eef3881e", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -478,21 +498,21 @@ } ], "source": [ - "plot(rep, sample_rate=300, plot_measurements=combined_pulse.measurement_names)\n", + "plot(rep, sample_rate=1e-7, plot_measurements=combined_pulse.measurement_names, parameters={\"dt\": 1e9})\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, - "id": "a443878d", + "id": "0e6e1e9f", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "ca0ab7e8", + "id": "156b41c5", "metadata": {}, "source": [ "## Execution\n", @@ -503,8 +523,18 @@ }, { "cell_type": "code", - "execution_count": 27, - "id": "a94273c9", + "execution_count": 67, + "id": "1327a836", + "metadata": {}, + "outputs": [], + "source": [ + "from qupulse.utils.types import TimeType" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "57d49de6", "metadata": {}, "outputs": [], "source": [ @@ -513,8 +543,8 @@ }, { "cell_type": "code", - "execution_count": 28, - "id": "4f2f2591", + "execution_count": 53, + "id": "febb35fb", "metadata": {}, "outputs": [], "source": [ @@ -523,8 +553,8 @@ }, { "cell_type": "code", - "execution_count": 29, - "id": "00a9186d", + "execution_count": 54, + "id": "a28c2ea4", "metadata": {}, "outputs": [], "source": [ @@ -533,8 +563,8 @@ }, { "cell_type": "code", - "execution_count": 30, - "id": "ffdc6396", + "execution_count": 55, + "id": "227668fc", "metadata": {}, "outputs": [], "source": [ @@ -543,8 +573,8 @@ }, { "cell_type": "code", - "execution_count": 31, - "id": "4e756118", + "execution_count": 56, + "id": "c7a22e25", "metadata": {}, "outputs": [], "source": [ @@ -554,8 +584,8 @@ }, { "cell_type": "code", - "execution_count": 32, - "id": "847713ee", + "execution_count": 57, + "id": "a1c121b2", "metadata": {}, "outputs": [], "source": [ @@ -565,19 +595,21 @@ }, { "cell_type": "code", - "execution_count": 33, - "id": "4f7e7867", + "execution_count": 60, + "id": "b0b22b67", "metadata": {}, "outputs": [], "source": [ - "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"})" + "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e9})" ] }, { "cell_type": "code", - "execution_count": 34, - "id": "d240e903", - "metadata": {}, + "execution_count": 83, + "id": "a4c80c41", + "metadata": { + "scrolled": true + }, "outputs": [], "source": [ "setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(None), update=True)" @@ -585,32 +617,53 @@ }, { "cell_type": "code", - "execution_count": 35, - "id": "72862ec2", + "execution_count": 78, + "id": "01a46069", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.5111607666015624e-05" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "15e-9*1674.107177734375" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "d110c090", "metadata": { - "scrolled": true + "scrolled": false }, "outputs": [ { "data": { "text/plain": [ - "{None: {'channel_mapping': {'R': ['demods/0/sample.R'],\n", - " 'X': ['demods/0/sample.X'],\n", - " 'Y': ['demods/0/sample.Y'],\n", - " 'A': ['auxins/0/sample.AuxIn0.avg'],\n", - " 'many': ['demods/0/sample.R',\n", - " 'auxins/0/sample.AuxIn0.avg',\n", + "{None: {'channel_mapping': {'R': {'demods/0/sample.R'},\n", + " 'X': {'demods/0/sample.X'},\n", + " 'Y': {'demods/0/sample.Y'},\n", + " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", + " 'many': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y']}},\n", - " 'test': {'windows': {'X': (array([10.]), array([3.])),\n", - " 'R': (array([ 6.5, 14. ]), array([1.4, 1. ])),\n", - " 'A': (array([ 3., 12.]), array([1.5, 3. ]))},\n", + " 'demods/0/sample.Y'}}},\n", + " 'test': {'windows': {'X': (array([1.e+10]), array([3.e+09])),\n", + " 'R': (array([6.5e+09, 1.4e+10]), array([1.4e+09, 1.0e+09])),\n", + " 'A': (array([3.0e+09, 1.2e+10]), array([1.5e+09, 3.0e+09]))},\n", " 'masks': {'X': {'mask': array([[[16741.]],\n", " \n", " [[ 5022.]],\n", " \n", " [[21763.]]]),\n", - " 'channels': ['demods/0/sample.X'],\n", + " 'channels': {'demods/0/sample.X'},\n", " 'sample_rates': [TimeType(6857143, 4096)]},\n", " 'R': {'mask': array([[[10882.],\n", " [23438.]],\n", @@ -620,25 +673,26 @@ " \n", " [[13225.],\n", " [25112.]]]),\n", - " 'channels': ['demods/0/sample.R'],\n", + " 'channels': {'demods/0/sample.R'},\n", " 'sample_rates': [TimeType(6857143, 4096)]},\n", - " 'A': {'mask': array([[[nan],\n", - " [nan]],\n", + " 'A': {'mask': array([[[ 3.],\n", + " [12.]],\n", " \n", - " [[nan],\n", - " [nan]],\n", + " [[ 1.],\n", + " [ 3.]],\n", " \n", - " [[nan],\n", - " [nan]]]),\n", - " 'channels': ['auxins/0/sample.AuxIn0.avg'],\n", + " [[ 4.],\n", + " [15.]]]),\n", + " 'channels': {'auxins/0/sample.AuxIn0.avg'},\n", " 'sample_rates': [None]}},\n", " 'all_channels': {'auxins/0/sample.AuxIn0.avg',\n", " 'demods/0/sample.R',\n", " 'demods/0/sample.X'},\n", - " 'window_hull': [10882.0, 21763.0]}}" + " 'window_hull': [3.0, 25112.0],\n", + " 'largest_sample_rate': -inf}}" ] }, - "execution_count": 35, + "execution_count": 84, "metadata": {}, "output_type": "execute_result" } @@ -649,24 +703,16 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "2a211ced", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 41, - "id": "56298e79", + "execution_count": 85, + "id": "c95fd655", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:283: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", - " warnings.warn(f\"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.\")\n" + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:301: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + " # select the value to measure\n" ] } ], @@ -676,8 +722,8 @@ }, { "cell_type": "code", - "execution_count": 42, - "id": "5761973b", + "execution_count": 86, + "id": "fa01ab41", "metadata": {}, "outputs": [ { @@ -699,13 +745,22 @@ "waiting for device dev3442 to finish the acquisition.\n", "waiting for device dev3442 to finish the acquisition.\n", "waiting for device dev3442 to finish the acquisition.\n", - "{'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664383619736669], dtype=uint64), 'createdtimestamp': array([1393721038376], dtype=uint64), 'changedtimestamp': array([1393721038376], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '001 18:46:59.7359', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 1394500905096,\n", - " 1394500940936, 1394500976776]], dtype=uint64), 'value': array([[ nan, nan, nan, ..., -0.00060027,\n", - " -0.00061161, -0.00062295]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664383619737528], dtype=uint64), 'createdtimestamp': array([1393721038376], dtype=uint64), 'changedtimestamp': array([1393721038376], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '001 18:46:59.7359', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1393721026696, 1393721062536, 1393721098376, ..., 1394500905096,\n", - " 1394500940936, 1394500976776]], dtype=uint64), 'value': array([[1.28582697e-07, 2.34376326e-07, 2.38996428e-07, ...,\n", - " 5.87560559e-07, 5.32019319e-07, 4.14106693e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664383619737107], dtype=uint64), 'createdtimestamp': array([1393721038376], dtype=uint64), 'changedtimestamp': array([1393721038376], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '001 18:46:59.7359', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1393721026696, 1393721062536, 1393721098376, ..., 1394500905096,\n", - " 1394500940936, 1394500976776]], dtype=uint64), 'value': array([[ 3.39232042e-08, -8.97284119e-08, 9.67278307e-09, ...,\n", - " -5.81247741e-07, -5.16688776e-07, -4.03478886e-07]])}]}}}, 'forcetrigger': array([0], dtype=int64), 'triggered': array([0], dtype=int64)}\n" + "waiting for device dev3442 to finish the acquisition.\n", + "{'buffercount': array([77], dtype=int64), 'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664448415930365], dtype=uint64), 'createdtimestamp': array([613164903993], dtype=uint64), 'changedtimestamp': array([613164903993], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 12:46:55.9296', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 614064798873,\n", + " 614064834713, 614064870553]], dtype=uint64), 'value': array([[ nan, nan, nan, ..., -0.00159835,\n", + " -0.00163236, -0.00166638]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664448415931243], dtype=uint64), 'createdtimestamp': array([613164903993], dtype=uint64), 'changedtimestamp': array([613164903993], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 12:46:55.9296', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 614064798873,\n", + " 614064834713, 614064870553]], dtype=uint64), 'value': array([[ nan, nan, nan, ...,\n", + " 5.57739763e-07, 5.03562022e-07, 2.80091264e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664448415930760], dtype=uint64), 'createdtimestamp': array([613164903993], dtype=uint64), 'changedtimestamp': array([613164903993], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 12:46:55.9296', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 614064798873,\n", + " 614064834713, 614064870553]], dtype=uint64), 'value': array([[ nan, nan, nan, ...,\n", + " -4.14088034e-07, -3.42151755e-07, -2.58497160e-07]])}]}}}, 'duration': array([15.00023467]), 'forcetrigger': array([0], dtype=int64), 'grid': {'cols': array([25112], dtype=int64)}, 'triggered': array([0], dtype=int64)}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:473: UserWarning: For at least one received channel entries with different dimensions are present. This might lead to undesired masking! (The code will not raise an exception.) ({'/dev3442/auxins/0/sample.auxin0.avg': {(1, 25112)}, '/dev3442/demods/0/sample.r': {(1, 25112)}, '/dev3442/demods/0/sample.x': {(1, 25112)}})\n", + " return recorded_data\n" ] } ], @@ -715,17 +770,114 @@ }, { "cell_type": "code", - "execution_count": 40, - "id": "b8de12f0", - "metadata": {}, + "execution_count": 87, + "id": "1739937f", + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { "text/plain": [ - "{}" + "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[ nan, nan, nan, ..., -0.00159835,\n", + " -0.00163236, -0.00166638]])\n", + " Coordinates:\n", + " timestamp (col, row) uint64 0 0 0 ... 614064834713 614064870553\n", + " Dimensions without coordinates: col, row\n", + " Attributes:\n", + " systemtime: [1664448415930365]\n", + " createdtimestamp: [613164903993]\n", + " changedtimestamp: [613164903993]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 002 12:46:55.9296\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.r': [\n", + " array([[ nan, nan, nan, ...,\n", + " 5.57739763e-07, 5.03562022e-07, 2.80091264e-07]])\n", + " Coordinates:\n", + " timestamp (col, row) uint64 0 0 0 ... 614064834713 614064870553\n", + " Dimensions without coordinates: col, row\n", + " Attributes:\n", + " systemtime: [1664448415931243]\n", + " createdtimestamp: [613164903993]\n", + " changedtimestamp: [613164903993]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 002 12:46:55.9296\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.x': [\n", + " array([[ nan, nan, nan, ...,\n", + " -4.14088034e-07, -3.42151755e-07, -2.58497160e-07]])\n", + " Coordinates:\n", + " timestamp (col, row) uint64 0 0 0 ... 614064834713 614064870553\n", + " Dimensions without coordinates: col, row\n", + " Attributes:\n", + " systemtime: [1664448415930760]\n", + " createdtimestamp: [613164903993]\n", + " changedtimestamp: [613164903993]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 002 12:46:55.9296\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}" ] }, - "execution_count": 40, + "execution_count": 87, "metadata": {}, "output_type": "execute_result" } @@ -736,9 +888,148 @@ }, { "cell_type": "code", - "execution_count": 39, - "id": "9907a87f", + "execution_count": 100, + "id": "35db3637", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "nan\n", + "-0.0003317117807455361\n", + "-0.0003317117807455361\n" + ] + } + ], + "source": [ + "for e in data['/dev3442/auxins/0/sample.auxin0.avg'][0].values[0, :40]:\n", + " print(e)" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "cf097c1a", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/dev3442/demods/0/sample.x\n", + "(1, 25112)\n", + "[[16741. 16742. 16743. ... 21761. 21762. 21763.]]\n", + "(1, 5023)\n", + "/dev3442/demods/0/sample.r\n", + "(1, 25112)\n", + "[[10882. 10883. 10884. ... 13223. 13224. 13225.]\n", + " [23438. 23439. 23440. ... nan nan nan]]\n", + "(2, 2344)\n", + "/dev3442/auxins/0/sample.auxin0.avg\n", + "(1, 25112)\n", + "[[ 3. 4. nan nan]\n", + " [12. 13. 14. 15.]]\n", + "(2, 4)\n" + ] + } + ], + "source": [ + "my_lockin._parse_data(data, program_name=\"test\")" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "6f93a669", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\numpy\\core\\numeric.py\u001b[0m(342)\u001b[0;36mfull\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 340 \u001b[1;33m \u001b[0mfill_value\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0masarray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfill_value\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 341 \u001b[1;33m \u001b[0mdtype\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfill_value\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 342 \u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mempty\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0morder\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 343 \u001b[1;33m \u001b[0mmultiarray\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcopyto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfill_value\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcasting\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'unsafe'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 344 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> shape\n", + "(2, -2147483647)\n", + "ipdb> u\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(390)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 388 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 389 \u001b[1;33m \u001b[1;31m# building the mask to apply to the data now:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 390 \u001b[1;33m \u001b[0mapplicable_mask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnanmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mint\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnan\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 391 \u001b[1;33m \u001b[1;31m# the following code could probably be optimized with some numpy magic\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 392 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mwi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mw\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> _mask\n", + "array([[[nan],\n", + " [nan]],\n", + "\n", + " [[nan],\n", + " [nan]],\n", + "\n", + " [[nan],\n", + " [nan]]])\n", + "--KeyboardInterrupt--\n", + "\n", + "KeyboardInterrupt: Interrupted by user\n" + ] + } + ], + "source": [ + "%debug" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "3dff5a12", + "metadata": { + "scrolled": true + }, "outputs": [ { "ename": "KeyError", @@ -759,7 +1050,7 @@ { "cell_type": "code", "execution_count": null, - "id": "89113a7c", + "id": "072e924f", "metadata": {}, "outputs": [], "source": [ @@ -769,7 +1060,7 @@ { "cell_type": "code", "execution_count": 43, - "id": "8641d7d5", + "id": "5d823f5e", "metadata": {}, "outputs": [], "source": [ @@ -779,7 +1070,7 @@ { "cell_type": "code", "execution_count": 47, - "id": "b0693faf", + "id": "01fe9f51", "metadata": {}, "outputs": [ { @@ -1218,7 +1509,7 @@ { "cell_type": "code", "execution_count": 48, - "id": "b0864fca", + "id": "8b542fd5", "metadata": {}, "outputs": [ { @@ -1238,13 +1529,13 @@ }, { "cell_type": "code", - "execution_count": 44, - "id": "cd038089", + "execution_count": 88, + "id": "15491285", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1265,7 +1556,7 @@ { "cell_type": "code", "execution_count": 68, - "id": "a0dbfbd2", + "id": "7326c859", "metadata": {}, "outputs": [ { @@ -1298,7 +1589,7 @@ { "cell_type": "code", "execution_count": 55, - "id": "96606726", + "id": "94e49027", "metadata": { "scrolled": true }, @@ -1357,7 +1648,7 @@ { "cell_type": "code", "execution_count": 63, - "id": "838d961b", + "id": "e6af1c97", "metadata": {}, "outputs": [ { @@ -1392,7 +1683,7 @@ { "cell_type": "code", "execution_count": 192, - "id": "339755e2", + "id": "d54014ef", "metadata": {}, "outputs": [ { @@ -1461,7 +1752,7 @@ { "cell_type": "code", "execution_count": 174, - "id": "c5240cf0", + "id": "31d0bf43", "metadata": {}, "outputs": [ { @@ -1488,7 +1779,7 @@ { "cell_type": "code", "execution_count": 123, - "id": "cb7d26b3", + "id": "8fed7140", "metadata": {}, "outputs": [], "source": [ @@ -1498,7 +1789,7 @@ { "cell_type": "code", "execution_count": 145, - "id": "36774f10", + "id": "1f274e40", "metadata": { "scrolled": false }, @@ -1521,7 +1812,7 @@ { "cell_type": "code", "execution_count": 119, - "id": "614316d1", + "id": "53e15047", "metadata": {}, "outputs": [ { @@ -1542,7 +1833,7 @@ { "cell_type": "code", "execution_count": 110, - "id": "a9dfa502", + "id": "ad042dae", "metadata": {}, "outputs": [], "source": [ @@ -1552,7 +1843,7 @@ { "cell_type": "code", "execution_count": 111, - "id": "263575fe", + "id": "083df80b", "metadata": {}, "outputs": [ { @@ -1615,7 +1906,7 @@ { "cell_type": "code", "execution_count": 169, - "id": "4f8fa7d3", + "id": "efe92e25", "metadata": {}, "outputs": [ { @@ -1636,7 +1927,7 @@ { "cell_type": "code", "execution_count": 205, - "id": "a0b1b2b2", + "id": "588ca0bd", "metadata": {}, "outputs": [ { @@ -1657,7 +1948,7 @@ { "cell_type": "code", "execution_count": 202, - "id": "6d228524", + "id": "1b5bd26c", "metadata": {}, "outputs": [], "source": [ @@ -1667,7 +1958,7 @@ { "cell_type": "code", "execution_count": 114, - "id": "60365fd8", + "id": "fdc5e2a6", "metadata": {}, "outputs": [ { @@ -1688,7 +1979,7 @@ { "cell_type": "code", "execution_count": 117, - "id": "76255359", + "id": "ee2305e6", "metadata": {}, "outputs": [ { @@ -1709,7 +2000,7 @@ { "cell_type": "code", "execution_count": 116, - "id": "822c77dd", + "id": "911919e4", "metadata": {}, "outputs": [], "source": [ @@ -1719,7 +2010,7 @@ { "cell_type": "code", "execution_count": 193, - "id": "9402f8fe", + "id": "65a141ca", "metadata": {}, "outputs": [], "source": [ @@ -1729,7 +2020,7 @@ { "cell_type": "code", "execution_count": null, - "id": "55677713", + "id": "4b418c1a", "metadata": {}, "outputs": [], "source": [] @@ -1737,7 +2028,7 @@ { "cell_type": "code", "execution_count": null, - "id": "2c980ada", + "id": "0ad8c16c", "metadata": {}, "outputs": [], "source": [] @@ -1745,7 +2036,7 @@ { "cell_type": "code", "execution_count": null, - "id": "306b8d9f", + "id": "49dc9d70", "metadata": {}, "outputs": [], "source": [] @@ -1753,7 +2044,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "021403d4", + "id": "7363d67f", "metadata": {}, "outputs": [], "source": [ @@ -1763,7 +2054,7 @@ { "cell_type": "code", "execution_count": 32, - "id": "8738508f", + "id": "d1ad57e2", "metadata": {}, "outputs": [], "source": [ @@ -1774,7 +2065,7 @@ { "cell_type": "code", "execution_count": 33, - "id": "8ce3ae43", + "id": "4754b459", "metadata": {}, "outputs": [], "source": [ @@ -1784,7 +2075,7 @@ { "cell_type": "code", "execution_count": 37, - "id": "9b977196", + "id": "cf413391", "metadata": {}, "outputs": [ { @@ -2903,7 +3194,7 @@ { "cell_type": "code", "execution_count": 29, - "id": "c0e526ba", + "id": "76e6b962", "metadata": {}, "outputs": [ { @@ -2929,7 +3220,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ae560ada", + "id": "9c11cee2", "metadata": {}, "outputs": [], "source": [] @@ -2937,7 +3228,7 @@ { "cell_type": "code", "execution_count": 35, - "id": "1f6a003a", + "id": "e4f71fe6", "metadata": {}, "outputs": [], "source": [ @@ -2948,7 +3239,7 @@ { "cell_type": "code", "execution_count": 31, - "id": "c8c91ef7", + "id": "abd297a8", "metadata": {}, "outputs": [], "source": [ @@ -2958,7 +3249,7 @@ { "cell_type": "code", "execution_count": 78, - "id": "0e75a1ba", + "id": "4f311776", "metadata": {}, "outputs": [ { @@ -2984,7 +3275,7 @@ { "cell_type": "code", "execution_count": null, - "id": "dfe07e28", + "id": "a5c04c1b", "metadata": {}, "outputs": [], "source": [] @@ -2992,7 +3283,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c69299c6", + "id": "1d1373fa", "metadata": {}, "outputs": [], "source": [] @@ -3000,7 +3291,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1e70db16", + "id": "e7be9bae", "metadata": {}, "outputs": [], "source": [] @@ -3008,7 +3299,7 @@ { "cell_type": "code", "execution_count": null, - "id": "63957cc1", + "id": "65e6ee21", "metadata": {}, "outputs": [], "source": [] @@ -3016,7 +3307,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a67d911a", + "id": "22736eb6", "metadata": {}, "outputs": [], "source": [] diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index 6338e3a32..aafd39193 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -38,6 +38,7 @@ [X] make TriggerMode class an Enum [X] setup minimal connection without changing settings other than buffer lengths [X] extract window things +[ ] rethink handling different sample rates! [ ] cut obtained data to fit into requested windows [ ] provide interface for changing trigger settings [ ] print information about how long the measurement is expected to run @@ -110,6 +111,8 @@ def __init__(self, device_serial: str = None, self.daq.set('triggernode', '/dev3442/demods/0/sample.AuxIn0') self.daq.set('endless', 0) + self.assumed_minimal_sample_rate = None + self.daq_read_return = {} if reset: @@ -140,7 +143,7 @@ def register_measurement_channel(self, program_name:str=None, channel_path:Union if not isinstance(channel_path, list): channel_path = [channel_path] - self.programs.setdefault(program_name, {}).setdefault("channel_mapping", {}).setdefault(window_name, []).extend(channel_path) + self.programs.setdefault(program_name, {}).setdefault("channel_mapping", {}).setdefault(window_name, set()).update(channel_path) def register_measurement_windows(self, program_name: str, windows: Dict[str, Tuple[np.ndarray, np.ndarray]]) -> None: @@ -203,24 +206,36 @@ def set_measurement_mask(self, program_name: str, mask_name: str, warnings.warn(f"There are no channels defined that should be measured in mask '{mask_name}'.") # get the sample rates for the requested channels. If no sample rate is found, None will be used. This code is not very nice. - currently_set_sample_rates: List[Union[TimeType, None]] = [] + raw_currently_set_sample_rates: List[Union[TimeType, None]] = [] for c in channels_to_measure: - currently_set_sample_rates.append(self._get_sample_rates(c)) - + raw_currently_set_sample_rates.append(self._get_sample_rates(c)) + + # CAUTION + # The MFLI lock-ins up-sample slower channels to fit the fastest sample rate. + # This is the cased for the Lab One Data Server 21.08.20515 and the MFLi Firmware 67629. + foo = [x for x in raw_currently_set_sample_rates if x is not None] + if len(foo) == 0 and self.assumed_minimal_sample_rate is None: + raise ValueError(f"No information about the sample rate is given, thus we can not calculate the window sizes.") + if self.assumed_minimal_sample_rate is not None: + foo.append(TimeType().from_float(value=self.assumed_minimal_sample_rate, absolute_error=0)) + max_sample_rate = max(foo) + currently_set_sample_rates = [max_sample_rate]*len(raw_currently_set_sample_rates) mask_info = np.full((3, len(begins), len(currently_set_sample_rates)), np.nan) - for i, sr in enumerate(currently_set_sample_rates): - if sr is not None: + for i, _sr in enumerate(currently_set_sample_rates): + if _sr is not None: + sr = _sr*1e-9 # converting the sample rate, which is given in Sa/s, into Sa/ns # this code was taken from the already implemented alazar driver. mask_info[0, :, i] = np.rint(begins * float(sr)).astype(dtype=np.uint64) # the begin mask_info[1, :, i] = np.floor_divide(lengths * float(sr.numerator), float(sr.denominator)).astype(dtype=np.uint64) # the length mask_info[2, :, i] = (mask_info[0, :, i] + mask_info[1, :, i]).astype(dtype=np.uint64) # the end - self.programs.setdefault(program_name, {}).setdefault("masks", {})[mask_name] = {"mask": mask_info, "channels": channels_to_measure, "sample_rates": currently_set_sample_rates} + self.programs.setdefault(program_name, {}).setdefault("masks", {})[mask_name] = {"mask": mask_info, "channels": channels_to_measure, "sample_rates": raw_currently_set_sample_rates} self.programs.setdefault(program_name, {}).setdefault("all_channels", set()).update(channels_to_measure) self.programs.setdefault(program_name, {}).setdefault("window_hull", [np.nan, np.nan]) + # self.programs.setdefault(program_name, {}).setdefault("largest_sample_rate", -1*np.inf) # This will be used to set the window_hull only based on the fastest channel queried. # as the lock-in can measure multiple channels with different sample rates, the return value of this function is not defined correctly. # this could be fixed by only measuring on one channel, or by returning some "summary" value. As of now, there does not to be a use of the return values. @@ -235,12 +250,16 @@ def set_measurement_mask(self, program_name: str, mask_name: str, # we also only use the max sample value later. The smallest staring point is somewhat ill-defined if np.sum(np.isnan(mask_info)) == len(mask_info.reshape((-1))): pass + print(f"will not use mask {mask_name}") else: + # TODO need to do something about the different sample rates!!!! + # maybe have it not this flexible??? + _start = np.nanmin(mask_info[0]) _end = np.nanmax(mask_info[2]) if np.isnan(self.programs[program_name]["window_hull"][0]) or self.programs[program_name]["window_hull"][0] > _start: self.programs[program_name]["window_hull"][0] = _start - if np.isnan(self.programs[program_name]["window_hull"][1]) or self.programs[program_name]["window_hull"][1] > _end: + if np.isnan(self.programs[program_name]["window_hull"][1]) or self.programs[program_name]["window_hull"][1] < _end: self.programs[program_name]["window_hull"][1] = _end return (np.min(mask_info[0], axis=-1), np.max(mask_info[2], axis=-1)) @@ -357,6 +376,77 @@ def clear(self) -> None: self.unarm_program(program_name=None) + def _parse_data(self, recorded_data, program_name): + """ This function parses the recorded data and extracts the measurement masks and applies optional operations + """ + + # the first dimension of channel_data is expected to be the history of multiple not read data points. This will be handled as multiple entries in a list. This will then not make too much sense, if not every channel as this many entries. If this is the case, they will be stacked, such that for the last elements it fits. + # TODO do this based on the timestamps and not the indices. That might be more sound than just assuming that. + + + # applying measurement windows and optional operations + # TODO implement operations + + # targeted structure: + # results[][] -> [data] + + masked_data = {} + + index = 0 + + for mask_name in self.programs[program_name]["masks"]: + data_by_channel = {} + _mask = self.programs[program_name]["masks"][mask_name]["mask"] + for ci, _cn in enumerate(self.programs[program_name]["masks"][mask_name]['channels']): + cn = f"/{self.serial}/{_cn}".lower() + print(cn) + if len(recorded_data[cn]) <= index: + # then we do not have data for this index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save. + warnings.warn(f"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{index}]") + continue + applicable_data = recorded_data[cn][-1-index] + + if np.sum(np.isnan(_mask[1, :, ci])) > 0: + raise ValueError(f"There is something wrong with the data for channel {cn}. The later code assumes that the lock-in is linearly interpolating up to the highest sample rate used.") + # building the mask to apply to the data now: + applicable_mask = np.full((_mask.shape[1], np.nanmax(_mask[1, :, ci]).astype(int)+1), np.nan) + # the following code could probably be optimized with some numpy magic + for wi, w in enumerate(_mask[:, :, ci].T): + applicable_mask[wi, :int(w[2]-w[0]+1)] = np.arange(w[0], w[2]+1) + + print(applicable_data.shape) + print(applicable_mask) + print(applicable_mask.shape) + + # TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO + + temp_mask = applicable_mask.reshape((-1)) + temp_mask = temp_mask.copy() + temp_mask[np.isnan(temp_mask)] = 0 + + masked_data = np.take(applicable_data.reshape((-1)), temp_mask) + + np.put_along_axis(masked_data, np.where(np.isnan(applicable_mask.reshape((-1))))) + + # TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO + + # foo = xr.DataArray( + # data=d["value"], + # coords={'timestamp': (['col', 'row'], d['timestamp'])}, + # dims=['col', 'row'], + # name=cn, + # attrs=d['header'] + # ) + # data_by_channel.update({cn: foo}) + # masked_data[mask_name] = data_by_channel + + # result = xr.Dataset( + # {} + # ) + # self.programs.setdefault(program_name, {}).setdefault("masks", {})[mask_name] = {"mask": mask_info, "channels": channels_to_measure, "sample_rates": currently_set_sample_rates} + + pass + def measure_program(self, channels: Iterable[str], wait=True) -> Dict[str, np.ndarray]: """Get the last measurement's results of the specified operations/channels""" @@ -380,39 +470,23 @@ def measure_program(self, channels: Iterable[str], wait=True) -> Dict[str, np.nd for input_name, input_data in device_data.items(): for signal_name, signal_data in input_data.items(): for final_level_name, final_level_data in signal_data.items(): - channel_name = f"/{device_name}/{input_name}/{signal_name}/{final_level_name}" + channel_name = f"/{device_name}/{input_name}/{signal_name}/{final_level_name}".lower() channel_data = [xr.DataArray( data=d["value"], coords={'timestamp': (['col', 'row'], d['timestamp'])}, dims=['col', 'row'], name=channel_name, - attrs=d['header']) - for i, d in enumerate(final_level_data)] + attrs=d['header']) for i, d in enumerate(final_level_data)] recorded_data[channel_name] = channel_data + # check if the shapes of the received measurements are the same. + # this is needed as the assumption, that the lock-in/data server up-samples slower channels to match the one with the highest rate. - return recorded_data - - - # the first dimension of channel_data is expected to be the history of multiple not read data points. This will be handled as multiple entries in a list. This will then not make too much sense, if not every channel as this many entries. If this is the case, they will be stacked, such that for the last elements it fits. - # TODO do this based on the timestamps and not the indices. That might be more sound than just assuming that. - - - # applying measurement windows and optional operations - # TODO implement operations - - # targeted structure: - # results[][] -> [data] - - masked_data = {} - - for mask_name in self.programs.[self.currently_set_program]["masks"]: - pass - - result = xr.Dataset( - {} - ) - # self.programs.setdefault(program_name, {}).setdefault("masks", {})[mask_name] = {"mask": mask_info, "channels": channels_to_measure, "sample_rates": currently_set_sample_rates} + recorded_shapes = {k:set([e.shape for e in v]) for k, v in recorded_data.items()} + if any([len(v)>1 for v in recorded_shapes.items()]) or len(set([e for a in recorded_data.items() for e in a]))>1: + warnings.warn(f"For at least one received channel entries with different dimensions are present. This might lead to undesired masking! (The code will not raise an exception.) ({recorded_shapes})") print(data) + + return recorded_data \ No newline at end of file From 5a5e4974d28e744188b7aaf5c5cc4c3b5f6a722a Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Fri, 30 Sep 2022 11:20:37 +0200 Subject: [PATCH 10/25] extracting windows now working --- ...struments_lockin_mfli_daq-checkpoint.ipynb | 1101 +++++++++++------ .../zurich_instruments_lockin_mfli_daq.ipynb | 1045 ++++++++++------ qupulse/hardware/dacs/mfli.py | 217 ++-- 3 files changed, 1549 insertions(+), 814 deletions(-) diff --git a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb index a87757f17..707f5b1dd 100644 --- a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb +++ b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "7c76f99a", + "id": "d268d6bc", "metadata": {}, "source": [ "# Zurich Instruments Lock-In MFLI Data Aquesition" @@ -11,7 +11,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "c2829d09", + "id": "3fb2b6b7", "metadata": {}, "outputs": [], "source": [ @@ -22,7 +22,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "46ac7589", + "id": "4d29c6af", "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "6982f821", + "id": "aeef36bd", "metadata": {}, "outputs": [], "source": [ @@ -42,7 +42,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "ffbc21ac", + "id": "58cc9d89", "metadata": {}, "outputs": [], "source": [ @@ -52,7 +52,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "50760516", + "id": "8e8b67dd", "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "d602f04c", + "id": "283b8c79", "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "64c51001", + "id": "120c36d1", "metadata": {}, "outputs": [ { @@ -91,7 +91,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "ab3733db", + "id": "e375875e", "metadata": {}, "outputs": [], "source": [ @@ -101,17 +101,18 @@ { "cell_type": "code", "execution_count": 9, - "id": "d2fa2e3e", + "id": "63b3ef39", "metadata": {}, "outputs": [], "source": [ - "my_lockin.assumed_minimal_sample_rate = 1." + "my_lockin.assumed_minimal_sample_rate = 1.\n", + "my_lockin.assumed_minimal_sample_rate = None" ] }, { "cell_type": "code", "execution_count": 10, - "id": "6a711d77", + "id": "c5c765d6", "metadata": {}, "outputs": [], "source": [ @@ -127,7 +128,7 @@ { "cell_type": "code", "execution_count": 11, - "id": "30f25668", + "id": "3efcb7cd", "metadata": {}, "outputs": [], "source": [ @@ -138,7 +139,7 @@ { "cell_type": "code", "execution_count": 12, - "id": "eaf9ac81", + "id": "856983d1", "metadata": {}, "outputs": [ { @@ -166,19 +167,9 @@ { "cell_type": "code", "execution_count": 13, - "id": "a9d59028", + "id": "555a627a", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1674.107177734375\n", - "1674.107177734375\n", - "1674.107177734375\n" - ] - } - ], + "outputs": [], "source": [ "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"A\": (np.array([0, 3])*1, np.array([1, 10])*1), \"many\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" ] @@ -186,7 +177,7 @@ { "cell_type": "code", "execution_count": 14, - "id": "f570a78d", + "id": "99d4067b", "metadata": {}, "outputs": [ { @@ -202,40 +193,11 @@ " 'demods/0/sample.Y'}}},\n", " 'test': {'windows': {'A': (array([0, 3]), array([ 1, 10])),\n", " 'many': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))},\n", - " 'masks': {'A': {'mask': array([[[0.],\n", - " [0.]],\n", - " \n", - " [[0.],\n", - " [0.]],\n", - " \n", - " [[0.],\n", - " [0.]]]),\n", - " 'channels': {'auxins/0/sample.AuxIn0.avg'},\n", - " 'sample_rates': [None]},\n", - " 'many': {'mask': array([[[0., 0., 0., 0.],\n", - " [0., 0., 0., 0.],\n", - " [0., 0., 0., 0.]],\n", - " \n", - " [[0., 0., 0., 0.],\n", - " [0., 0., 0., 0.],\n", - " [0., 0., 0., 0.]],\n", - " \n", - " [[0., 0., 0., 0.],\n", - " [0., 0., 0., 0.],\n", - " [0., 0., 0., 0.]]]),\n", - " 'channels': {'auxins/0/sample.AuxIn0.avg',\n", - " 'demods/0/sample.R',\n", - " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y'},\n", - " 'sample_rates': [None,\n", - " TimeType(6857143, 4096),\n", - " TimeType(6857143, 4096),\n", - " TimeType(6857143, 4096)]}},\n", - " 'all_channels': {'auxins/0/sample.AuxIn0.avg',\n", - " 'demods/0/sample.R',\n", - " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y'},\n", - " 'window_hull': [0.0, 0.0]}}" + " 'windows_from_start_max': {'A': 13, 'many': 0.0101},\n", + " 'all_channels': {'auxins/0/sample.auxin0.avg',\n", + " 'demods/0/sample.r',\n", + " 'demods/0/sample.x',\n", + " 'demods/0/sample.y'}}}" ] }, "execution_count": 14, @@ -250,7 +212,7 @@ { "cell_type": "code", "execution_count": 15, - "id": "2e6045d6", + "id": "007c1f6e", "metadata": {}, "outputs": [], "source": [ @@ -260,7 +222,7 @@ { "cell_type": "code", "execution_count": 16, - "id": "e91550d2", + "id": "2f8bf03d", "metadata": {}, "outputs": [ { @@ -288,14 +250,14 @@ { "cell_type": "code", "execution_count": null, - "id": "3158c4db", + "id": "6f1780ae", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "145e5ba9", + "id": "bb5dcf8a", "metadata": {}, "source": [ "## Defining a simple qupulse pulse with a measurement window." @@ -304,7 +266,7 @@ { "cell_type": "code", "execution_count": 17, - "id": "0d0ca8bd", + "id": "8e89c64d", "metadata": {}, "outputs": [], "source": [ @@ -314,7 +276,7 @@ { "cell_type": "code", "execution_count": 18, - "id": "408f7b42", + "id": "40d73c34", "metadata": {}, "outputs": [], "source": [ @@ -331,15 +293,15 @@ { "cell_type": "code", "execution_count": 19, - "id": "e8cba8be", + "id": "6e627b13", "metadata": {}, "outputs": [], "source": [ "green_pulse = qupulse.pulses.SequencePT(*[\n", " qupulse.pulses.FunctionPT(\".1\", \"6*dt\", channel=\"green\"),\n", - " qupulse.pulses.FunctionPT(\".1+t**2*.9\", \"1*dt\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\".1+(t/dt)**2*.9\", \"1*dt\", channel=\"green\"),\n", " qupulse.pulses.FunctionPT(\"1\", \"1*dt\", channel=\"green\"),\n", - " qupulse.pulses.FunctionPT(\"1+sin(t*2*pi)*exp(-(t-2)**2)\", \"5*dt\", channel=\"green\"),\n", + " qupulse.pulses.FunctionPT(\"1+sin((t/dt)*2*pi)*exp(-((t/dt)-2)**2)\", \"5*dt\", channel=\"green\"),\n", " qupulse.pulses.FunctionPT(\"1\", \"1*dt\", channel=\"green\"),\n", " qupulse.pulses.FunctionPT(\"0\", \"1*dt\", channel=\"green\"),\n", "]\n", @@ -349,7 +311,7 @@ { "cell_type": "code", "execution_count": 20, - "id": "3c473b50", + "id": "d3dede54", "metadata": {}, "outputs": [], "source": [ @@ -361,7 +323,7 @@ { "cell_type": "code", "execution_count": 21, - "id": "980a3d80", + "id": "f7fc2faa", "metadata": {}, "outputs": [ { @@ -380,14 +342,14 @@ { "cell_type": "code", "execution_count": 22, - "id": "154e7c08", + "id": "f6523430", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'T', 'A', 'R'}\n", + "{'R', 'T', 'A'}\n", "[]\n", "set()\n" ] @@ -402,13 +364,13 @@ { "cell_type": "code", "execution_count": 23, - "id": "b10b7f5e", + "id": "5955fdff", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 23, @@ -423,12 +385,12 @@ { "cell_type": "code", "execution_count": 24, - "id": "35d86b39", + "id": "5142a4ab", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -440,35 +402,35 @@ } ], "source": [ - "plot(combined_pulse, sample_rate=300, plot_measurements=combined_pulse.measurement_names) # combined_pulse.measurement_names\n", + "plot(combined_pulse, sample_rate=1e-7, plot_measurements=combined_pulse.measurement_names, parameters={\"dt\": 1e9}) # combined_pulse.measurement_names\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 25, - "id": "3ba81135", + "id": "7f1e0eb3", "metadata": {}, "outputs": [], "source": [ "idle_pulse = qupulse.pulses.TablePT({\"red\": [\n", - " (0, 0),\n", - " (5, 0),\n", + " (\"0*dt\", 0),\n", + " (\"5*dt\", 0),\n", "],\n", " \"green\": [\n", - " (0, 0),\n", - " (5, 0),\n", + " (\"0*dt\", 0),\n", + " (\"5*dt\", 0),\n", "],\n", " \"trigger_out\": [\n", - " (0, 0),\n", - " (5, 0),\n", + " (\"0*dt\", 0),\n", + " (\"5*dt\", 0),\n", "]})" ] }, { "cell_type": "code", "execution_count": 26, - "id": "1e0e993b", + "id": "2bd8d1c2", "metadata": {}, "outputs": [], "source": [ @@ -481,12 +443,12 @@ { "cell_type": "code", "execution_count": 27, - "id": "a7d2070f", + "id": "89cda79b", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -498,21 +460,21 @@ } ], "source": [ - "plot(rep, sample_rate=300, plot_measurements=combined_pulse.measurement_names)\n", + "plot(rep, sample_rate=1e-7, plot_measurements=combined_pulse.measurement_names, parameters={\"dt\": 1e9})\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, - "id": "ed72dd2f", + "id": "67160184", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "374cfcb2", + "id": "d3aa8c2d", "metadata": {}, "source": [ "## Execution\n", @@ -524,98 +486,101 @@ { "cell_type": "code", "execution_count": 28, - "id": "1c56f470", + "id": "326b7236", "metadata": {}, "outputs": [], "source": [ - "from qupulse.hardware.awgs.virtual import VirtualAWG" + "from qupulse.utils.types import TimeType" ] }, { "cell_type": "code", "execution_count": 29, - "id": "b9419441", + "id": "8d7fdb70", "metadata": {}, "outputs": [], "source": [ - "from qupulse.hardware.setup import HardwareSetup, MeasurementMask, PlaybackChannel" + "from qupulse.hardware.awgs.virtual import VirtualAWG" ] }, { "cell_type": "code", "execution_count": 30, - "id": "7cc18e58", + "id": "4d57aedb", "metadata": {}, "outputs": [], "source": [ - "my_awg = VirtualAWG(\"awg\", channels=3)" + "from qupulse.hardware.setup import HardwareSetup, MeasurementMask, PlaybackChannel" ] }, { "cell_type": "code", "execution_count": 31, - "id": "eb7524b8", + "id": "a26db851", "metadata": {}, "outputs": [], "source": [ - "setup = HardwareSetup()" + "my_awg = VirtualAWG(\"awg\", channels=3)" ] }, { "cell_type": "code", "execution_count": 32, - "id": "b8a7559a", + "id": "ad1ec540", "metadata": {}, "outputs": [], "source": [ - "for n in my_lockin.programs[None][\"channel_mapping\"].keys():\n", - " setup.set_measurement(f\"{n}\", MeasurementMask(my_lockin, n))" + "setup = HardwareSetup()" ] }, { "cell_type": "code", "execution_count": 33, - "id": "72e58f1c", + "id": "06744b93", "metadata": {}, "outputs": [], "source": [ - "for i, c in enumerate([\"red\", \"green\", \"trigger_out\"]):\n", - " setup.set_channel(f\"{c}\", PlaybackChannel(my_awg, i))" + "for n in my_lockin.programs[None][\"channel_mapping\"].keys():\n", + " setup.set_measurement(f\"{n}\", MeasurementMask(my_lockin, n))" ] }, { "cell_type": "code", "execution_count": 34, - "id": "918d8031", + "id": "04c4c840", "metadata": {}, "outputs": [], "source": [ - "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"})" + "for i, c in enumerate([\"red\", \"green\", \"trigger_out\"]):\n", + " setup.set_channel(f\"{c}\", PlaybackChannel(my_awg, i))" ] }, { "cell_type": "code", "execution_count": 35, - "id": "720142ef", + "id": "81b44a4c", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1674.107177734375\n", - "1674.107177734375\n" - ] - } - ], + "outputs": [], + "source": [ + "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e9})" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "433cdc54", + "metadata": { + "scrolled": true + }, + "outputs": [], "source": [ "setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(None), update=True)" ] }, { "cell_type": "code", - "execution_count": 40, - "id": "3305f971", + "execution_count": 37, + "id": "b5464fa3", "metadata": {}, "outputs": [ { @@ -624,7 +589,7 @@ "2.5111607666015624e-05" ] }, - "execution_count": 40, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -635,8 +600,8 @@ }, { "cell_type": "code", - "execution_count": 36, - "id": "970c67d9", + "execution_count": 38, + "id": "3b085324", "metadata": { "scrolled": false }, @@ -652,43 +617,18 @@ " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", " 'demods/0/sample.Y'}}},\n", - " 'test': {'windows': {'X': (array([10.]), array([3.])),\n", - " 'R': (array([ 6.5, 14. ]), array([1.4, 1. ])),\n", - " 'A': (array([ 3., 12.]), array([1.5, 3. ]))},\n", - " 'masks': {'X': {'mask': array([[[16741.]],\n", - " \n", - " [[ 5022.]],\n", - " \n", - " [[21763.]]]),\n", - " 'channels': {'demods/0/sample.X'},\n", - " 'sample_rates': [TimeType(6857143, 4096)]},\n", - " 'R': {'mask': array([[[10882.],\n", - " [23438.]],\n", - " \n", - " [[ 2343.],\n", - " [ 1674.]],\n", - " \n", - " [[13225.],\n", - " [25112.]]]),\n", - " 'channels': {'demods/0/sample.R'},\n", - " 'sample_rates': [TimeType(6857143, 4096)]},\n", - " 'A': {'mask': array([[[ 3.],\n", - " [12.]],\n", - " \n", - " [[ 1.],\n", - " [ 3.]],\n", - " \n", - " [[ 4.],\n", - " [15.]]]),\n", - " 'channels': {'auxins/0/sample.AuxIn0.avg'},\n", - " 'sample_rates': [None]}},\n", - " 'all_channels': {'auxins/0/sample.AuxIn0.avg',\n", - " 'demods/0/sample.R',\n", - " 'demods/0/sample.X'},\n", - " 'window_hull': [3.0, 15.0]}}" + " 'test': {'windows': {'X': (array([1.e+10]), array([3.e+09])),\n", + " 'R': (array([6.5e+09, 1.4e+10]), array([1.4e+09, 1.0e+09])),\n", + " 'A': (array([3.0e+09, 1.2e+10]), array([1.5e+09, 3.0e+09]))},\n", + " 'windows_from_start_max': {'X': 13000000000.0,\n", + " 'R': 15000000000.0,\n", + " 'A': 15000000000.0},\n", + " 'all_channels': {'auxins/0/sample.auxin0.avg',\n", + " 'demods/0/sample.r',\n", + " 'demods/0/sample.x'}}}" ] }, - "execution_count": 36, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -699,23 +639,15 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "212a4514", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "5212bdf8", + "execution_count": 98, + "id": "edacdee2", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:295: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:344: UserWarning: The channel auxins/0/sample.auxin0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", " warnings.warn(f\"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.\")\n" ] }, @@ -723,8 +655,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "1674.107177734375\n", - "1674.107177734375\n" + "Will record 25112 samples in 15.000000000000002s!\n", + "MFLI returns a total record time of {'duration': array([15.00023467])}s\n" ] } ], @@ -734,36 +666,40 @@ }, { "cell_type": "code", - "execution_count": 38, - "id": "b913c687", - "metadata": {}, + "execution_count": 99, + "id": "663a88b5", + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'awgcontrol': array([0], dtype=int64), 'bandwidth': array([0.]), 'bitmask': array([1], dtype=int64), 'bits': array([1], dtype=int64), 'buffercount': array([2], dtype=int64), 'buffersize': array([0.2]), 'clearhistory': array([0], dtype=int64), 'count': array([1], dtype=int64), 'delay': array([-0.001]), 'dev3442': {'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664444033771594], dtype=uint64), 'createdtimestamp': array([351220594233], dtype=uint64), 'changedtimestamp': array([351220594233], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '000 11:33:53.7712', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([15], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[351220582553, 351220618393, 351220654233, 351220690073,\n", - " 351220725913, 351220761753, 351220797593, 351220833433,\n", - " 351220869273, 351220905113, 351220940953, 351220976793,\n", - " 351221012633, 351221048473, 351221084313]], dtype=uint64), 'value': array([[3.91947639e-07, 5.04776395e-07, 6.40830166e-07, 8.50759130e-07,\n", - " 9.48581891e-07, 9.39008711e-07, 7.22044644e-07, 5.14505033e-07,\n", - " 4.61612617e-07, 3.55077975e-07, 2.90122718e-07, 3.95506751e-07,\n", - " 4.36968275e-07, 4.26032845e-07, 2.54789854e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664444033771590], dtype=uint64), 'createdtimestamp': array([351220594233], dtype=uint64), 'changedtimestamp': array([351220594233], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '000 11:33:53.7712', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([15], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[351220582553, 351220618393, 351220654233, 351220690073,\n", - " 351220725913, 351220761753, 351220797593, 351220833433,\n", - " 351220869273, 351220905113, 351220940953, 351220976793,\n", - " 351221012633, 351221048473, 351221084313]], dtype=uint64), 'value': array([[-3.84965645e-07, -5.01921593e-07, -5.24020048e-07,\n", - " -5.05596497e-07, -5.44546535e-07, -4.90243338e-07,\n", - " -3.17540780e-07, -1.17378687e-07, -6.11656886e-08,\n", - " -1.94232976e-08, 1.17480934e-07, 2.11811048e-07,\n", - " 3.18037065e-07, 3.79153125e-07, 2.19639802e-07]])}]}}}, 'device': ['dev3442'], 'duration': array([0.00896]), 'edge': array([1], dtype=int64), 'enable': array([1], dtype=int64), 'endless': array([0], dtype=int64), 'eventcount': {'mode': array([1], dtype=int64)}, 'fft': {'absolute': array([0], dtype=int64), 'window': array([1], dtype=int64)}, 'findlevel': array([0], dtype=int64), 'flags': array([8], dtype=int64), 'forcetrigger': array([0], dtype=int64), 'grid': {'cols': array([15], dtype=int64), 'direction': array([0], dtype=int64), 'mode': array([4], dtype=int64), 'overwrite': array([0], dtype=int64), 'repetitions': array([1], dtype=int64), 'rowrepetition': array([0], dtype=int64), 'rows': array([1], dtype=int64), 'waterfall': array([0], dtype=int64)}, 'historylength': array([100000], dtype=int64), 'holdoff': {'count': array([0], dtype=int64), 'time': array([0.2])}, 'hysteresis': array([0.]), 'level': array([0.]), 'preview': array([0], dtype=int64), 'pulse': {'max': array([0.001]), 'min': array([0.])}, 'refreshrate': array([5.]), 'save': {'csvlocale': ['C'], 'csvseparator': [';'], 'directory': ['C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer'], 'fileformat': array([0], dtype=int64), 'filename': ['dataAcquisitionModule'], 'save': array([0], dtype=int64), 'saveonread': array([0], dtype=int64)}, 'spectrum': {'autobandwidth': array([0], dtype=int64), 'enable': array([0], dtype=int64), 'frequencyspan': array([13000.]), 'overlapped': array([1], dtype=int64)}, 'triggered': array([0], dtype=int64), 'triggernode': ['/dev3442/demods/0/sample.AuxIn0'], 'type': array([1], dtype=int64)}\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:467: UserWarning: For at least one received channel entries with different dimensions are present. This might lead to undesired masking! (The code will not raise an exception.) ({'/dev3442/demods/0/sample.r': {(1, 15)}, '/dev3442/demods/0/sample.x': {(1, 15)}})\n", - " warnings.warn(f\"For at least one received channel entries with different dimensions are present. This might lead to undesired masking! (The code will not raise an exception.) ({recorded_shapes})\")\n" + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "{'buffercount': array([77], dtype=int64), 'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664529215402434], dtype=uint64), 'createdtimestamp': array([316381462056], dtype=uint64), 'changedtimestamp': array([316381462056], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '004 11:13:35.4017', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 317281356936,\n", + " 317281392776, 317281428616]], dtype=uint64), 'value': array([[ nan, nan, nan, ..., -0.00232198,\n", + " -0.00232198, -0.00232198]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664529215402983], dtype=uint64), 'createdtimestamp': array([316381462056], dtype=uint64), 'changedtimestamp': array([316381462056], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '004 11:13:35.4017', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[316381450376, 316381486216, 316381522056, ..., 317281356936,\n", + " 317281392776, 317281428616]], dtype=uint64), 'value': array([[1.59011277e-07, 4.70619023e-07, 6.68435541e-07, ...,\n", + " 5.32911742e-07, 5.30974673e-07, 4.72225932e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664529215403471], dtype=uint64), 'createdtimestamp': array([316381462056], dtype=uint64), 'changedtimestamp': array([316381462056], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '004 11:13:35.4017', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[316381450376, 316381486216, 316381522056, ..., 317281356936,\n", + " 317281392776, 317281428616]], dtype=uint64), 'value': array([[-1.00858959e-07, -6.24829378e-08, 5.21458498e-09, ...,\n", + " -9.96038947e-09, -1.75158872e-07, -3.89508749e-07]])}]}}}, 'duration': array([15.00023467]), 'forcetrigger': array([0], dtype=int64), 'triggered': array([0], dtype=int64)}\n" ] } ], @@ -773,8 +709,8 @@ }, { "cell_type": "code", - "execution_count": 39, - "id": "9919ae42", + "execution_count": 74, + "id": "833f68e5", "metadata": { "scrolled": true }, @@ -782,29 +718,59 @@ { "data": { "text/plain": [ - "{'/dev3442/demods/0/sample.r': [\n", - " array([[2.83077683e-07, 1.98653388e-07, 1.23254334e-07, 2.35563621e-07,\n", - " 2.59927715e-07, 2.30951769e-07, 1.99951982e-07, 1.27807482e-07,\n", - " 1.46559367e-07, 3.77772093e-07, 5.41456793e-07, 5.09670654e-07,\n", - " 4.31549240e-07, 4.23198107e-07, 5.08910680e-07]])\n", + "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[-0.00211383, -0.00209682, -0.00207982, ..., -0.00121121,\n", + " -0.00121688, -0.00122255]])\n", + " Coordinates:\n", + " timestamp (row, col) float64 4.482e+12 4.482e+12 ... 4.497e+12 4.497e+12\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664528424329287]\n", + " createdtimestamp: [268898909736]\n", + " changedtimestamp: [268898909736]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 003 11:00:24.3286\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.r': [\n", + " array([[4.24502350e-08, 3.83220570e-07, 6.39577112e-07, ...,\n", + " 2.91820932e-07, 1.21077468e-07, 1.73901447e-07]])\n", " Coordinates:\n", - " timestamp (col, row) uint64 335622978713 335623014553 ... 335623480473\n", - " Dimensions without coordinates: col, row\n", + " timestamp (row, col) float64 4.482e+12 4.482e+12 ... 4.497e+12 4.497e+12\n", + " Dimensions without coordinates: row, col\n", " Attributes:\n", - " systemtime: [1664443773825583]\n", - " createdtimestamp: [335622990393]\n", - " changedtimestamp: [335622990393]\n", + " systemtime: [1664528424329823]\n", + " createdtimestamp: [268898909736]\n", + " changedtimestamp: [268898909736]\n", " flags: [1849]\n", " moduleflags: [0]\n", " chunksizebytes: [0]\n", - " name: 000 11:29:33.8254\n", + " name: 003 11:00:24.3286\n", " status: [0]\n", " groupindex: [0]\n", " color: [0]\n", " activerow: [0]\n", " triggernumber: [0]\n", " gridrows: [1]\n", - " gridcols: [15]\n", + " gridcols: [25112]\n", " gridmode: [4]\n", " gridoperation: [1]\n", " griddirection: [0]\n", @@ -816,30 +782,27 @@ " bandwidth: [nan]\n", " center: [0.]\n", " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.x': [\n", - " array([[ 2.80890995e-07, 1.98361712e-07, -3.30729417e-08,\n", - " -2.13084648e-07, -2.54901781e-07, -2.26618891e-07,\n", - " -1.88342725e-07, -6.13516462e-08, -4.60965485e-08,\n", - " -1.99625745e-07, -3.19756724e-07, -3.09219328e-07,\n", - " -2.26602149e-07, -2.13735799e-07, -1.37713835e-07]])\n", + " '/dev3442/demods/0/sample.x': [\n", + " array([[-4.11211373e-08, -3.45698104e-07, -5.54790943e-07, ...,\n", + " -2.84726146e-07, -1.17343409e-07, 2.52172809e-08]])\n", " Coordinates:\n", - " timestamp (col, row) uint64 335622978713 335623014553 ... 335623480473\n", - " Dimensions without coordinates: col, row\n", + " timestamp (row, col) float64 4.482e+12 4.482e+12 ... 4.497e+12 4.497e+12\n", + " Dimensions without coordinates: row, col\n", " Attributes:\n", - " systemtime: [1664443773825587]\n", - " createdtimestamp: [335622990393]\n", - " changedtimestamp: [335622990393]\n", + " systemtime: [1664528424330307]\n", + " createdtimestamp: [268898909736]\n", + " changedtimestamp: [268898909736]\n", " flags: [1849]\n", " moduleflags: [0]\n", " chunksizebytes: [0]\n", - " name: 000 11:29:33.8254\n", + " name: 003 11:00:24.3286\n", " status: [0]\n", " groupindex: [0]\n", " color: [0]\n", " activerow: [0]\n", " triggernumber: [0]\n", " gridrows: [1]\n", - " gridcols: [15]\n", + " gridcols: [25112]\n", " gridmode: [4]\n", " gridoperation: [1]\n", " griddirection: [0]\n", @@ -853,7 +816,7 @@ " nenbw: [nan]]}" ] }, - "execution_count": 39, + "execution_count": 74, "metadata": {}, "output_type": "execute_result" } @@ -864,8 +827,151 @@ }, { "cell_type": "code", - "execution_count": 68, - "id": "9efdcbad", + "execution_count": 75, + "id": "c1448b03", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4481648300933.333\n", + "4481648898266.667\n", + "4481649495600.0\n", + "4481650092933.333\n", + "4481650690266.667\n", + "4481651287600.0\n", + "4481651884933.333\n", + "4481652482266.667\n", + "4481653079600.0\n", + "4481653676933.333\n", + "4481654274266.667\n", + "4481654871600.0\n", + "4481655468933.333\n", + "4481656066266.667\n", + "4481656663600.0\n", + "4481657260933.333\n", + "4481657858266.667\n", + "4481658455600.0\n", + "4481659052933.333\n", + "4481659650266.667\n", + "---\n", + "4496636588933.334\n", + "4496637186266.666\n", + "4496637783600.0\n", + "4496638380933.333\n", + "4496638978266.667\n", + "4496639575600.0\n", + "4496640172933.333\n", + "4496640770266.667\n", + "4496641367600.0\n", + "4496641964933.333\n", + "4496642562266.667\n", + "4496643159600.0\n", + "4496643756933.333\n", + "4496644354266.667\n", + "4496644951600.0\n", + "4496645548933.333\n", + "4496646146266.667\n", + "4496646743600.0\n", + "4496647340933.333\n", + "4496647938266.667\n" + ] + } + ], + "source": [ + "for e in data['/dev3442/auxins/0/sample.auxin0.avg'][0][\"timestamp\"].values[0, :20]:\n", + " print(e)\n", + "print(\"---\")\n", + "for e in data['/dev3442/auxins/0/sample.auxin0.avg'][0][\"timestamp\"].values[0, -20:]:\n", + " print(e)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "bca17ff3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.89951232" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(130556892296-129657379976)*1e-9" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "95f3cd94", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.0021138295076801594\n", + "-0.002096822800171233\n", + "-0.0020798160926623066\n", + "-0.00206280938515338\n", + "-0.0020458026776444538\n", + "-0.0020287959701355274\n", + "-0.002011789262626601\n", + "-0.0019947825551176745\n", + "-0.001977775847608748\n", + "-0.0019607691400998217\n", + "-0.0019437624325908953\n", + "-0.001926755725081969\n", + "-0.0019097490175730425\n", + "-0.001892742310064116\n", + "-0.0018757356025551897\n", + "-0.0018587288950462633\n", + "-0.0018417221875373369\n", + "-0.0018247154800284104\n", + "-0.001807708772519484\n", + "-0.0017907020650105576\n", + "-0.0017736953575016312\n", + "-0.0017566886499927048\n", + "-0.0017396819424837784\n", + "-0.001722675234974852\n", + "-0.0017056685274659256\n", + "-0.0016886618199569992\n", + "-0.0016716551124480727\n", + "-0.0016572554041315024\n", + "-0.001651586501628527\n", + "-0.0016459175991255515\n", + "-0.001640248696622576\n", + "-0.0016345797941196005\n", + "-0.001628910891616625\n", + "-0.0016232419891136496\n", + "-0.0016175730866106741\n", + "-0.0016119041841076986\n", + "-0.0016062352816047232\n", + "-0.0016005663791017477\n", + "-0.0015948974765987722\n", + "-0.0015892285740957968\n" + ] + } + ], + "source": [ + "for e in data['/dev3442/auxins/0/sample.auxin0.avg'][0].values[0, :40]:\n", + " print(e)" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "40664f2a", "metadata": {}, "outputs": [ { @@ -873,69 +979,373 @@ "output_type": "stream", "text": [ "/dev3442/demods/0/sample.x\n", - "[[16741. 16742. 16743. ... 21761. 21762. 21763.]]\n", + "time_of_trigger=[5.27302317e+12]\n", + "extracted_data=[\n", + "array([[ 8.20515335e-08, -1.37302456e-07, -2.23006770e-07, ...,\n", + " -2.51220898e-07, -8.52887497e-08, -8.56558814e-08]])\n", + "Coordinates:\n", + " time (row, col) float64 5.283e+12 5.283e+12 ... 5.286e+12 5.286e+12\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664529215403471]\n", + " createdtimestamp: [316381462056]\n", + " changedtimestamp: [316381462056]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 11:13:35.4017\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]\n", "/dev3442/demods/0/sample.r\n", - "[[10882. 10883. 10884. ... 13223. 13224. 13225.]\n", - " [23438. 23439. 23440. ... nan nan nan]]\n", - "/dev3442/auxins/0/sample.auxin0.avg\n" + "time_of_trigger=[5.27302317e+12]\n", + "time_of_trigger=[5.27302317e+12]\n", + "extracted_data=[\n", + "array([[5.09070137e-07, 4.36690684e-07, 4.20131474e-07, ...,\n", + " 5.52220621e-07, 5.07130206e-07, 2.38696738e-07]])\n", + "Coordinates:\n", + " time (row, col) float64 5.28e+12 5.28e+12 ... 5.281e+12 5.281e+12\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664529215402983]\n", + " createdtimestamp: [316381462056]\n", + " changedtimestamp: [316381462056]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 11:13:35.4017\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan], \n", + "array([[4.39980625e-07, 5.04697280e-07, 4.95701644e-07, ...,\n", + " 2.04461446e-07, 3.65230061e-07, 5.32911742e-07]])\n", + "Coordinates:\n", + " time (row, col) float64 5.287e+12 5.287e+12 ... 5.288e+12 5.288e+12\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664529215402983]\n", + " createdtimestamp: [316381462056]\n", + " changedtimestamp: [316381462056]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 11:13:35.4017\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]\n", + "/dev3442/auxins/0/sample.auxin0.avg\n", + "time_of_trigger=[5.27309366e+12]\n", + "time_of_trigger=[5.27309366e+12]\n", + "extracted_data=[\n", + "array([[-0.00120247, -0.00121381, -0.00122515, ..., -0.00054094,\n", + " -0.00051259, -0.00048425]])\n", + "Coordinates:\n", + " time (row, col) float64 5.276e+12 5.276e+12 ... 5.278e+12 5.278e+12\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664529215402434]\n", + " createdtimestamp: [316381462056]\n", + " changedtimestamp: [316381462056]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 11:13:35.4017\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan], \n", + "array([[-0.00106838, -0.00109105, -0.00111373, ..., -0.00232198,\n", + " -0.00232198, -0.00232198]])\n", + "Coordinates:\n", + " time (row, col) float64 5.285e+12 5.285e+12 ... 5.288e+12 5.288e+12\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664529215402434]\n", + " createdtimestamp: [316381462056]\n", + " changedtimestamp: [316381462056]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 11:13:35.4017\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]\n" + ] + } + ], + "source": [ + "extracted_data = my_lockin._parse_data(data, program_name=\"test\")" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "6de3049e", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_windows(data):\n", + " for j, w in enumerate(data.keys()):\n", + " for i, c in enumerate(data[w].keys()):\n", + " for e in data[w][c]:\n", + " print(e[\"time\"].values, e.values)\n", + " plt.plot(e[\"time\"].values.T, e.values.T, color=f\"C{j}\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "id": "5944b2ed", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[5.28302353e+12 5.28302413e+12 5.28302473e+12 ... 5.28602155e+12\n", + " 5.28602215e+12 5.28602274e+12]] [[ 8.20515335e-08 -1.37302456e-07 -2.23006770e-07 ... -2.51220898e-07\n", + " -8.52887497e-08 -8.56558814e-08]]\n" ] }, { - "ename": "ValueError", - "evalue": "There is something wrong with the data for channel /dev3442/auxins/0/sample.auxin0.avg. The later code assumes that the lock-in is linearly interpolating up to the highest sample rate used.", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_28708\\3255017280.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mmy_lockin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mprogram_name\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m\"test\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m in \u001b[0;36m_parse_data\u001b[1;34m(self, recorded_data, program_name)\u001b[0m\n\u001b[0;32m 394\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 395\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misnan\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 396\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"There is something wrong with the data for channel {cn}. The later code assumes that the lock-in is linearly interpolating up to the highest sample rate used.\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 397\u001b[0m \u001b[1;31m# building the mask to apply to the data now:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 398\u001b[0m \u001b[0mapplicable_mask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnanmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mint\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnan\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mValueError\u001b[0m: There is something wrong with the data for channel /dev3442/auxins/0/sample.auxin0.avg. The later code assumes that the lock-in is linearly interpolating up to the highest sample rate used." + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[5.27952376e+12 5.27952435e+12 5.27952495e+12 ... 5.28092152e+12\n", + " 5.28092211e+12 5.28092271e+12]] [[5.09070137e-07 4.36690684e-07 4.20131474e-07 ... 5.52220621e-07\n", + " 5.07130206e-07 2.38696738e-07]]\n", + "[[5.28702328e+12 5.28702387e+12 5.28702447e+12 ... 5.28802142e+12\n", + " 5.28802202e+12 5.28802262e+12]] [[4.39980625e-07 5.04697280e-07 4.95701644e-07 ... 2.04461446e-07\n", + " 3.65230061e-07 5.32911742e-07]]\n" ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[5.27609387e+12 5.27609447e+12 5.27609506e+12 ... 5.27759198e+12\n", + " 5.27759258e+12 5.27759318e+12]] [[-0.00120247 -0.00121381 -0.00122515 ... -0.00054094 -0.00051259\n", + " -0.00048425]]\n", + "[[5.28509389e+12 5.28509449e+12 5.28509508e+12 ... 5.28802262e+12\n", + " 5.28802321e+12 5.28802381e+12]] [[-0.00106838 -0.00109105 -0.00111373 ... -0.00232198 -0.00232198\n", + " -0.00232198]]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "my_lockin._parse_data(data, program_name=\"test\")" + "plot_windows(extracted_data)" ] }, { "cell_type": "code", - "execution_count": 59, - "id": "e16b5714", + "execution_count": 50, + "id": "c0ea856a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\numpy\\core\\numeric.py\u001b[0m(342)\u001b[0;36mfull\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 340 \u001b[1;33m \u001b[0mfill_value\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0masarray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfill_value\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 341 \u001b[1;33m \u001b[0mdtype\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfill_value\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 342 \u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mempty\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0morder\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 343 \u001b[1;33m \u001b[0mmultiarray\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcopyto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfill_value\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcasting\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'unsafe'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 344 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m(83)\u001b[0;36mgroup_indexers_by_index\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 81 \u001b[1;33m \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 82 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mkey\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcoords\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m---> 83 \u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"no index found for coordinate {key}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 84 \u001b[1;33m \u001b[1;32melif\u001b[0m \u001b[0mkey\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdims\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 85 \u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"{key} is not a valid dimension or coordinate\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m(110)\u001b[0;36mremap_label_indexers\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 108 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 109 \u001b[1;33m indexes, grouped_indexers = group_indexers_by_index(\n", + "\u001b[0m\u001b[1;32m--> 110 \u001b[1;33m \u001b[0mdata_obj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 111 \u001b[1;33m )\n", + "\u001b[0m\u001b[1;32m 112 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\coordinates.py\u001b[0m(422)\u001b[0;36mremap_label_indexers\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 420 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 421 \u001b[1;33m pos_indexers, new_indexes = indexing.remap_label_indexers(\n", + "\u001b[0m\u001b[1;32m--> 422 \u001b[1;33m \u001b[0mobj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv_indexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 423 \u001b[1;33m )\n", + "\u001b[0m\u001b[1;32m 424 \u001b[1;33m \u001b[1;31m# attach indexer's coordinate to pos_indexers\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[0m\n", - "ipdb> shape\n", - "(2, -2147483647)\n", "ipdb> u\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(390)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 388 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 389 \u001b[1;33m \u001b[1;31m# building the mask to apply to the data now:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 390 \u001b[1;33m \u001b[0mapplicable_mask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnanmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mint\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnan\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 391 \u001b[1;33m \u001b[1;31m# the following code could probably be optimized with some numpy magic\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 392 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mwi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mw\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataset.py\u001b[0m(2505)\u001b[0;36msel\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 2503 \u001b[1;33m \u001b[0mindexers\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0meither_dict_or_kwargs\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers_kwargs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"sel\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 2504 \u001b[1;33m pos_indexers, new_indexes = remap_label_indexers(\n", + "\u001b[0m\u001b[1;32m-> 2505 \u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 2506 \u001b[1;33m )\n", + "\u001b[0m\u001b[1;32m 2507 \u001b[1;33m \u001b[1;31m# TODO: benbovy - flexible indexes: also use variables returned by Index.query\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[0m\n", - "ipdb> _mask\n", - "array([[[nan],\n", - " [nan]],\n", - "\n", - " [[nan],\n", - " [nan]],\n", - "\n", - " [[nan],\n", - " [nan]]])\n", - "--KeyboardInterrupt--\n", - "\n", - "KeyboardInterrupt: Interrupted by user\n" + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(1337)\u001b[0;36msel\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 1335 \u001b[1;33m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1336 \u001b[1;33m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m-> 1337 \u001b[1;33m \u001b[1;33m**\u001b[0m\u001b[0mindexers_kwargs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1338 \u001b[1;33m )\n", + "\u001b[0m\u001b[1;32m 1339 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_from_temp_dataset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(201)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 199 \u001b[1;33m \u001b[0mlabels\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mindexing\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexpanded_indexer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata_array\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndim\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 200 \u001b[1;33m \u001b[0mkey\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata_array\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 201 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata_array\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 202 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 203 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(488)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 486 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"time_of_trigger={time_of_trigger}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 487 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 488 \u001b[1;33m \u001b[0mextracted_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mapplicable_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m\"row\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mrow_index\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m\"timestamp\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mslice\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtime_of_trigger\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtime_of_trigger\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 489 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 490 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"extracted_data={extracted_data}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> applicable_data.where(~np.isnan(applicable_data), drop=True)\n", + "\n", + "array([[-1.54233563e-07, -1.53747443e-07, -1.63328742e-07, ...,\n", + " 1.12498946e-07, 5.47050085e-08, 5.14905138e-08]])\n", + "Coordinates:\n", + " timestamp (row, col) uint64 129659709576 129659745416 ... 130556892296\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664526103384841]\n", + " createdtimestamp: [129656925736]\n", + " changedtimestamp: [129656925736]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 000 10:21:43.3824\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]\n", + "ipdb> r\n" ] } ], @@ -946,7 +1356,7 @@ { "cell_type": "code", "execution_count": 39, - "id": "ccbb3117", + "id": "0cb4bd38", "metadata": { "scrolled": true }, @@ -970,7 +1380,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b1977d4b", + "id": "a415fdd8", "metadata": {}, "outputs": [], "source": [ @@ -980,7 +1390,7 @@ { "cell_type": "code", "execution_count": 43, - "id": "53e76b94", + "id": "1d6ef3db", "metadata": {}, "outputs": [], "source": [ @@ -989,8 +1399,8 @@ }, { "cell_type": "code", - "execution_count": 47, - "id": "21c43e9b", + "execution_count": 72, + "id": "8afaaede", "metadata": {}, "outputs": [ { @@ -1347,27 +1757,27 @@ " stroke: currentColor;\n", " fill: currentColor;\n", "}\n", - "
<xarray.DataArray '/dev3442/demods/0/sample.r' (col: 1, row: 21763)>\n",
-       "array([[1.28582697e-07, 2.34376326e-07, 2.38996428e-07, ...,\n",
-       "        5.87560559e-07, 5.32019319e-07, 4.14106693e-07]])\n",
+       "
<xarray.DataArray '/dev3442/demods/0/sample.r' (col: 1, row: 25112)>\n",
+       "array([[7.03522854e-07, 6.92340419e-07, 7.21439685e-07, ...,\n",
+       "        3.06968651e-07, 3.77702425e-07, 4.19837064e-07]])\n",
        "Coordinates:\n",
-       "    timestamp  (col, row) uint64 1393721026696 1393721062536 ... 1394500976776\n",
+       "    timestamp  (col, row) uint64 2303061427353 2303061463193 ... 2303961405593\n",
        "Dimensions without coordinates: col, row\n",
        "Attributes:\n",
-       "    systemtime:        [1664383619737528]\n",
-       "    createdtimestamp:  [1393721038376]\n",
-       "    changedtimestamp:  [1393721038376]\n",
+       "    systemtime:        [1664476581306703]\n",
+       "    createdtimestamp:  [2303061439033]\n",
+       "    changedtimestamp:  [2303061439033]\n",
        "    flags:             [1849]\n",
        "    moduleflags:       [0]\n",
        "    chunksizebytes:    [0]\n",
-       "    name:              001 18:46:59.7359\n",
+       "    name:              009 20:36:21.3054\n",
        "    status:            [0]\n",
        "    groupindex:        [0]\n",
        "    color:             [0]\n",
        "    activerow:         [0]\n",
        "    triggernumber:     [0]\n",
        "    gridrows:          [1]\n",
-       "    gridcols:          [21763]\n",
+       "    gridcols:          [25112]\n",
        "    gridmode:          [4]\n",
        "    gridoperation:     [1]\n",
        "    griddirection:     [0]\n",
@@ -1378,32 +1788,32 @@
        "    gridrowoffset:     [0.]\n",
        "    bandwidth:         [nan]\n",
        "    center:            [0.]\n",
-       "    nenbw:             [nan]
"
+       "    nenbw:             [nan]
" ], "text/plain": [ - "\n", - "array([[1.28582697e-07, 2.34376326e-07, 2.38996428e-07, ...,\n", - " 5.87560559e-07, 5.32019319e-07, 4.14106693e-07]])\n", + "\n", + "array([[7.03522854e-07, 6.92340419e-07, 7.21439685e-07, ...,\n", + " 3.06968651e-07, 3.77702425e-07, 4.19837064e-07]])\n", "Coordinates:\n", - " timestamp (col, row) uint64 1393721026696 1393721062536 ... 1394500976776\n", + " timestamp (col, row) uint64 2303061427353 2303061463193 ... 2303961405593\n", "Dimensions without coordinates: col, row\n", "Attributes:\n", - " systemtime: [1664383619737528]\n", - " createdtimestamp: [1393721038376]\n", - " changedtimestamp: [1393721038376]\n", + " systemtime: [1664476581306703]\n", + " createdtimestamp: [2303061439033]\n", + " changedtimestamp: [2303061439033]\n", " flags: [1849]\n", " moduleflags: [0]\n", " chunksizebytes: [0]\n", - " name: 001 18:46:59.7359\n", + " name: 009 20:36:21.3054\n", " status: [0]\n", " groupindex: [0]\n", " color: [0]\n", " activerow: [0]\n", " triggernumber: [0]\n", " gridrows: [1]\n", - " gridcols: [21763]\n", + " gridcols: [25112]\n", " gridmode: [4]\n", " gridoperation: [1]\n", " griddirection: [0]\n", @@ -1417,7 +1827,7 @@ " nenbw: [nan]" ] }, - "execution_count": 47, + "execution_count": 72, "metadata": {}, "output_type": "execute_result" } @@ -1429,7 +1839,7 @@ { "cell_type": "code", "execution_count": 48, - "id": "133629d2", + "id": "b029ede6", "metadata": {}, "outputs": [ { @@ -1449,13 +1859,13 @@ }, { "cell_type": "code", - "execution_count": 44, - "id": "0e940f58", + "execution_count": 71, + "id": "48408b39", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1476,7 +1886,7 @@ { "cell_type": "code", "execution_count": 68, - "id": "df2a0ea7", + "id": "e92a3415", "metadata": {}, "outputs": [ { @@ -1509,7 +1919,7 @@ { "cell_type": "code", "execution_count": 55, - "id": "551bb968", + "id": "1fa62c49", "metadata": { "scrolled": true }, @@ -1568,7 +1978,7 @@ { "cell_type": "code", "execution_count": 63, - "id": "eb79c602", + "id": "d37795e8", "metadata": {}, "outputs": [ { @@ -1603,7 +2013,7 @@ { "cell_type": "code", "execution_count": 192, - "id": "b4c50e35", + "id": "1024edab", "metadata": {}, "outputs": [ { @@ -1672,7 +2082,7 @@ { "cell_type": "code", "execution_count": 174, - "id": "9facd1f5", + "id": "93e43a9f", "metadata": {}, "outputs": [ { @@ -1699,7 +2109,7 @@ { "cell_type": "code", "execution_count": 123, - "id": "51eb510b", + "id": "dda2d6d2", "metadata": {}, "outputs": [], "source": [ @@ -1709,7 +2119,7 @@ { "cell_type": "code", "execution_count": 145, - "id": "4e16f0f2", + "id": "5dc632e0", "metadata": { "scrolled": false }, @@ -1732,7 +2142,7 @@ { "cell_type": "code", "execution_count": 119, - "id": "429ab72c", + "id": "8d06dfab", "metadata": {}, "outputs": [ { @@ -1753,7 +2163,7 @@ { "cell_type": "code", "execution_count": 110, - "id": "7d64ad62", + "id": "2fa8bad0", "metadata": {}, "outputs": [], "source": [ @@ -1763,7 +2173,7 @@ { "cell_type": "code", "execution_count": 111, - "id": "b8de6d7b", + "id": "7c3fb570", "metadata": {}, "outputs": [ { @@ -1825,38 +2235,27 @@ }, { "cell_type": "code", - "execution_count": 169, - "id": "f75de994", + "execution_count": 44, + "id": "82162394", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 169, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "my_lockin.daq.finished()" + "my_lockin.daq.finish()" ] }, { "cell_type": "code", - "execution_count": 205, - "id": "7b99b2eb", + "execution_count": 45, + "id": "836853c2", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0.])" + "array([1.])" ] }, - "execution_count": 205, + "execution_count": 45, "metadata": {}, "output_type": "execute_result" } @@ -1868,7 +2267,7 @@ { "cell_type": "code", "execution_count": 202, - "id": "3ab2e209", + "id": "a9930108", "metadata": {}, "outputs": [], "source": [ @@ -1878,7 +2277,7 @@ { "cell_type": "code", "execution_count": 114, - "id": "ddaec525", + "id": "bee6f9bb", "metadata": {}, "outputs": [ { @@ -1899,7 +2298,7 @@ { "cell_type": "code", "execution_count": 117, - "id": "4b8e5939", + "id": "1c3d0463", "metadata": {}, "outputs": [ { @@ -1920,7 +2319,7 @@ { "cell_type": "code", "execution_count": 116, - "id": "2d3370e5", + "id": "0c3fe8b6", "metadata": {}, "outputs": [], "source": [ @@ -1930,7 +2329,7 @@ { "cell_type": "code", "execution_count": 193, - "id": "09fc6209", + "id": "9d077337", "metadata": {}, "outputs": [], "source": [ @@ -1940,7 +2339,7 @@ { "cell_type": "code", "execution_count": null, - "id": "32eedc4f", + "id": "7629f3e1", "metadata": {}, "outputs": [], "source": [] @@ -1948,7 +2347,7 @@ { "cell_type": "code", "execution_count": null, - "id": "d939a7bd", + "id": "15e43752", "metadata": {}, "outputs": [], "source": [] @@ -1956,7 +2355,7 @@ { "cell_type": "code", "execution_count": null, - "id": "41d2d6d3", + "id": "97ba2adc", "metadata": {}, "outputs": [], "source": [] @@ -1964,7 +2363,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "5acca51a", + "id": "4fdeed1d", "metadata": {}, "outputs": [], "source": [ @@ -1974,7 +2373,7 @@ { "cell_type": "code", "execution_count": 32, - "id": "e3aa7278", + "id": "70403aac", "metadata": {}, "outputs": [], "source": [ @@ -1985,7 +2384,7 @@ { "cell_type": "code", "execution_count": 33, - "id": "8a7d030a", + "id": "5f48c06f", "metadata": {}, "outputs": [], "source": [ @@ -1995,7 +2394,7 @@ { "cell_type": "code", "execution_count": 37, - "id": "ddda80e7", + "id": "5a739e12", "metadata": {}, "outputs": [ { @@ -3114,7 +3513,7 @@ { "cell_type": "code", "execution_count": 29, - "id": "cb68a22d", + "id": "2b4a8887", "metadata": {}, "outputs": [ { @@ -3140,7 +3539,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ef14673f", + "id": "4e18fc22", "metadata": {}, "outputs": [], "source": [] @@ -3148,7 +3547,7 @@ { "cell_type": "code", "execution_count": 35, - "id": "f58c1f3a", + "id": "53b4a8a7", "metadata": {}, "outputs": [], "source": [ @@ -3159,7 +3558,7 @@ { "cell_type": "code", "execution_count": 31, - "id": "312b86b6", + "id": "20fa5a67", "metadata": {}, "outputs": [], "source": [ @@ -3169,7 +3568,7 @@ { "cell_type": "code", "execution_count": 78, - "id": "c02fde6f", + "id": "b3d46f38", "metadata": {}, "outputs": [ { @@ -3195,7 +3594,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b5933588", + "id": "1a0c371f", "metadata": {}, "outputs": [], "source": [] @@ -3203,7 +3602,7 @@ { "cell_type": "code", "execution_count": null, - "id": "663d0e35", + "id": "07f26907", "metadata": {}, "outputs": [], "source": [] @@ -3211,7 +3610,7 @@ { "cell_type": "code", "execution_count": null, - "id": "38d18413", + "id": "07df6e4c", "metadata": {}, "outputs": [], "source": [] @@ -3219,7 +3618,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b6850fd2", + "id": "9fff7bd5", "metadata": {}, "outputs": [], "source": [] @@ -3227,7 +3626,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1ceecd5d", + "id": "4b8d0834", "metadata": {}, "outputs": [], "source": [] diff --git a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb index 101702024..37e2c02c6 100644 --- a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb +++ b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "ee52af1c", + "id": "2f430ac2", "metadata": {}, "source": [ "# Zurich Instruments Lock-In MFLI Data Aquesition" @@ -11,7 +11,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "cd26d7f1", + "id": "d054114e", "metadata": {}, "outputs": [], "source": [ @@ -22,7 +22,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "2646f99a", + "id": "30b7fbc1", "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "41fcd1eb", + "id": "b264f571", "metadata": {}, "outputs": [], "source": [ @@ -42,7 +42,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "3784c6c8", + "id": "7f78c8db", "metadata": {}, "outputs": [], "source": [ @@ -52,7 +52,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "4cdccd38", + "id": "324c3b0d", "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "94b6ce7b", + "id": "d531e09d", "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "83cfe729", + "id": "98aebcef", "metadata": {}, "outputs": [ { @@ -91,7 +91,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "ce3aa3d7", + "id": "9d249f5f", "metadata": {}, "outputs": [], "source": [ @@ -101,17 +101,18 @@ { "cell_type": "code", "execution_count": 9, - "id": "43921bfc", + "id": "cf10fd25", "metadata": {}, "outputs": [], "source": [ - "my_lockin.assumed_minimal_sample_rate = 1." + "my_lockin.assumed_minimal_sample_rate = 1.\n", + "my_lockin.assumed_minimal_sample_rate = None" ] }, { "cell_type": "code", "execution_count": 10, - "id": "b0e8819b", + "id": "89e6b5bc", "metadata": {}, "outputs": [], "source": [ @@ -127,7 +128,7 @@ { "cell_type": "code", "execution_count": 11, - "id": "13e08f84", + "id": "6c2de252", "metadata": {}, "outputs": [], "source": [ @@ -138,7 +139,7 @@ { "cell_type": "code", "execution_count": 12, - "id": "ae0d8112", + "id": "a8b630e8", "metadata": {}, "outputs": [ { @@ -166,19 +167,9 @@ { "cell_type": "code", "execution_count": 13, - "id": "468243d5", + "id": "f48d89f0", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1674.107177734375\n", - "1674.107177734375\n", - "1674.107177734375\n" - ] - } - ], + "outputs": [], "source": [ "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"A\": (np.array([0, 3])*1, np.array([1, 10])*1), \"many\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" ] @@ -186,7 +177,7 @@ { "cell_type": "code", "execution_count": 14, - "id": "d2a3fd49", + "id": "45126b53", "metadata": {}, "outputs": [ { @@ -202,40 +193,11 @@ " 'demods/0/sample.Y'}}},\n", " 'test': {'windows': {'A': (array([0, 3]), array([ 1, 10])),\n", " 'many': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))},\n", - " 'masks': {'A': {'mask': array([[[0.],\n", - " [0.]],\n", - " \n", - " [[0.],\n", - " [0.]],\n", - " \n", - " [[0.],\n", - " [0.]]]),\n", - " 'channels': {'auxins/0/sample.AuxIn0.avg'},\n", - " 'sample_rates': [None]},\n", - " 'many': {'mask': array([[[0., 0., 0., 0.],\n", - " [0., 0., 0., 0.],\n", - " [0., 0., 0., 0.]],\n", - " \n", - " [[0., 0., 0., 0.],\n", - " [0., 0., 0., 0.],\n", - " [0., 0., 0., 0.]],\n", - " \n", - " [[0., 0., 0., 0.],\n", - " [0., 0., 0., 0.],\n", - " [0., 0., 0., 0.]]]),\n", - " 'channels': {'auxins/0/sample.AuxIn0.avg',\n", - " 'demods/0/sample.R',\n", - " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y'},\n", - " 'sample_rates': [None,\n", - " TimeType(6857143, 4096),\n", - " TimeType(6857143, 4096),\n", - " TimeType(6857143, 4096)]}},\n", - " 'all_channels': {'auxins/0/sample.AuxIn0.avg',\n", - " 'demods/0/sample.R',\n", - " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y'},\n", - " 'window_hull': [0.0, 0.0]}}" + " 'windows_from_start_max': {'A': 13, 'many': 0.0101},\n", + " 'all_channels': {'auxins/0/sample.auxin0.avg',\n", + " 'demods/0/sample.r',\n", + " 'demods/0/sample.x',\n", + " 'demods/0/sample.y'}}}" ] }, "execution_count": 14, @@ -250,7 +212,7 @@ { "cell_type": "code", "execution_count": 15, - "id": "75b9e45c", + "id": "def7db5f", "metadata": {}, "outputs": [], "source": [ @@ -260,7 +222,7 @@ { "cell_type": "code", "execution_count": 16, - "id": "56f26163", + "id": "d6dbcd84", "metadata": {}, "outputs": [ { @@ -288,14 +250,14 @@ { "cell_type": "code", "execution_count": null, - "id": "39176f52", + "id": "b414de1c", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "b30732e3", + "id": "043d2313", "metadata": {}, "source": [ "## Defining a simple qupulse pulse with a measurement window." @@ -304,7 +266,7 @@ { "cell_type": "code", "execution_count": 17, - "id": "1c964db6", + "id": "57b97220", "metadata": {}, "outputs": [], "source": [ @@ -314,7 +276,7 @@ { "cell_type": "code", "execution_count": 18, - "id": "b49ab3e5", + "id": "62ddbf08", "metadata": {}, "outputs": [], "source": [ @@ -330,8 +292,8 @@ }, { "cell_type": "code", - "execution_count": 40, - "id": "c771c335", + "execution_count": 19, + "id": "d34532dd", "metadata": {}, "outputs": [], "source": [ @@ -348,8 +310,8 @@ }, { "cell_type": "code", - "execution_count": 41, - "id": "437abe9e", + "execution_count": 20, + "id": "02693549", "metadata": {}, "outputs": [], "source": [ @@ -360,8 +322,8 @@ }, { "cell_type": "code", - "execution_count": 42, - "id": "590ba4f3", + "execution_count": 21, + "id": "0ac68a54", "metadata": {}, "outputs": [ { @@ -379,15 +341,15 @@ }, { "cell_type": "code", - "execution_count": 43, - "id": "b3497d55", + "execution_count": 22, + "id": "418c8705", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'A', 'T', 'R'}\n", + "{'R', 'T', 'A'}\n", "[]\n", "set()\n" ] @@ -401,8 +363,8 @@ }, { "cell_type": "code", - "execution_count": 44, - "id": "a61460bf", + "execution_count": 23, + "id": "aa339b15", "metadata": {}, "outputs": [ { @@ -411,7 +373,7 @@ "" ] }, - "execution_count": 44, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -422,13 +384,13 @@ }, { "cell_type": "code", - "execution_count": 48, - "id": "7b5633f3", + "execution_count": 24, + "id": "71cc7cc4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -446,8 +408,8 @@ }, { "cell_type": "code", - "execution_count": 49, - "id": "435cabec", + "execution_count": 25, + "id": "aece2141", "metadata": {}, "outputs": [], "source": [ @@ -467,8 +429,8 @@ }, { "cell_type": "code", - "execution_count": 50, - "id": "a54480cc", + "execution_count": 26, + "id": "bd7178a5", "metadata": {}, "outputs": [], "source": [ @@ -480,13 +442,13 @@ }, { "cell_type": "code", - "execution_count": 51, - "id": "eef3881e", + "execution_count": 27, + "id": "545549c5", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -505,14 +467,14 @@ { "cell_type": "code", "execution_count": null, - "id": "0e6e1e9f", + "id": "d03958df", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "156b41c5", + "id": "69f7b83b", "metadata": {}, "source": [ "## Execution\n", @@ -523,8 +485,8 @@ }, { "cell_type": "code", - "execution_count": 67, - "id": "1327a836", + "execution_count": 28, + "id": "89add969", "metadata": {}, "outputs": [], "source": [ @@ -533,8 +495,8 @@ }, { "cell_type": "code", - "execution_count": 52, - "id": "57d49de6", + "execution_count": 29, + "id": "085ab02a", "metadata": {}, "outputs": [], "source": [ @@ -543,8 +505,8 @@ }, { "cell_type": "code", - "execution_count": 53, - "id": "febb35fb", + "execution_count": 30, + "id": "e3b31765", "metadata": {}, "outputs": [], "source": [ @@ -553,8 +515,8 @@ }, { "cell_type": "code", - "execution_count": 54, - "id": "a28c2ea4", + "execution_count": 31, + "id": "07d8259d", "metadata": {}, "outputs": [], "source": [ @@ -563,8 +525,8 @@ }, { "cell_type": "code", - "execution_count": 55, - "id": "227668fc", + "execution_count": 32, + "id": "3465b009", "metadata": {}, "outputs": [], "source": [ @@ -573,8 +535,8 @@ }, { "cell_type": "code", - "execution_count": 56, - "id": "c7a22e25", + "execution_count": 33, + "id": "7dc1a8ea", "metadata": {}, "outputs": [], "source": [ @@ -584,8 +546,8 @@ }, { "cell_type": "code", - "execution_count": 57, - "id": "a1c121b2", + "execution_count": 34, + "id": "65bc064c", "metadata": {}, "outputs": [], "source": [ @@ -595,8 +557,8 @@ }, { "cell_type": "code", - "execution_count": 60, - "id": "b0b22b67", + "execution_count": 35, + "id": "75656d82", "metadata": {}, "outputs": [], "source": [ @@ -605,8 +567,8 @@ }, { "cell_type": "code", - "execution_count": 83, - "id": "a4c80c41", + "execution_count": 36, + "id": "fc91e75d", "metadata": { "scrolled": true }, @@ -617,8 +579,8 @@ }, { "cell_type": "code", - "execution_count": 78, - "id": "01a46069", + "execution_count": 37, + "id": "47ad74d2", "metadata": {}, "outputs": [ { @@ -627,7 +589,7 @@ "2.5111607666015624e-05" ] }, - "execution_count": 78, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -638,8 +600,8 @@ }, { "cell_type": "code", - "execution_count": 84, - "id": "d110c090", + "execution_count": 38, + "id": "ac914d69", "metadata": { "scrolled": false }, @@ -658,41 +620,15 @@ " 'test': {'windows': {'X': (array([1.e+10]), array([3.e+09])),\n", " 'R': (array([6.5e+09, 1.4e+10]), array([1.4e+09, 1.0e+09])),\n", " 'A': (array([3.0e+09, 1.2e+10]), array([1.5e+09, 3.0e+09]))},\n", - " 'masks': {'X': {'mask': array([[[16741.]],\n", - " \n", - " [[ 5022.]],\n", - " \n", - " [[21763.]]]),\n", - " 'channels': {'demods/0/sample.X'},\n", - " 'sample_rates': [TimeType(6857143, 4096)]},\n", - " 'R': {'mask': array([[[10882.],\n", - " [23438.]],\n", - " \n", - " [[ 2343.],\n", - " [ 1674.]],\n", - " \n", - " [[13225.],\n", - " [25112.]]]),\n", - " 'channels': {'demods/0/sample.R'},\n", - " 'sample_rates': [TimeType(6857143, 4096)]},\n", - " 'A': {'mask': array([[[ 3.],\n", - " [12.]],\n", - " \n", - " [[ 1.],\n", - " [ 3.]],\n", - " \n", - " [[ 4.],\n", - " [15.]]]),\n", - " 'channels': {'auxins/0/sample.AuxIn0.avg'},\n", - " 'sample_rates': [None]}},\n", - " 'all_channels': {'auxins/0/sample.AuxIn0.avg',\n", - " 'demods/0/sample.R',\n", - " 'demods/0/sample.X'},\n", - " 'window_hull': [3.0, 25112.0],\n", - " 'largest_sample_rate': -inf}}" + " 'windows_from_start_max': {'X': 13000000000.0,\n", + " 'R': 15000000000.0,\n", + " 'A': 15000000000.0},\n", + " 'all_channels': {'auxins/0/sample.auxin0.avg',\n", + " 'demods/0/sample.r',\n", + " 'demods/0/sample.x'}}}" ] }, - "execution_count": 84, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" } @@ -703,16 +639,24 @@ }, { "cell_type": "code", - "execution_count": 85, - "id": "c95fd655", + "execution_count": 98, + "id": "6600a0b3", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:301: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", - " # select the value to measure\n" + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:344: UserWarning: The channel auxins/0/sample.auxin0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + " warnings.warn(f\"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Will record 25112 samples in 15.000000000000002s!\n", + "MFLI returns a total record time of {'duration': array([15.00023467])}s\n" ] } ], @@ -722,45 +666,40 @@ }, { "cell_type": "code", - "execution_count": 86, - "id": "fa01ab41", - "metadata": {}, + "execution_count": 99, + "id": "7fb8a8f3", + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "waiting for device dev3442 to finish the acquisition.\n", - "{'buffercount': array([77], dtype=int64), 'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664448415930365], dtype=uint64), 'createdtimestamp': array([613164903993], dtype=uint64), 'changedtimestamp': array([613164903993], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 12:46:55.9296', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 614064798873,\n", - " 614064834713, 614064870553]], dtype=uint64), 'value': array([[ nan, nan, nan, ..., -0.00159835,\n", - " -0.00163236, -0.00166638]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664448415931243], dtype=uint64), 'createdtimestamp': array([613164903993], dtype=uint64), 'changedtimestamp': array([613164903993], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 12:46:55.9296', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 614064798873,\n", - " 614064834713, 614064870553]], dtype=uint64), 'value': array([[ nan, nan, nan, ...,\n", - " 5.57739763e-07, 5.03562022e-07, 2.80091264e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664448415930760], dtype=uint64), 'createdtimestamp': array([613164903993], dtype=uint64), 'changedtimestamp': array([613164903993], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 12:46:55.9296', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 614064798873,\n", - " 614064834713, 614064870553]], dtype=uint64), 'value': array([[ nan, nan, nan, ...,\n", - " -4.14088034e-07, -3.42151755e-07, -2.58497160e-07]])}]}}}, 'duration': array([15.00023467]), 'forcetrigger': array([0], dtype=int64), 'grid': {'cols': array([25112], dtype=int64)}, 'triggered': array([0], dtype=int64)}\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:473: UserWarning: For at least one received channel entries with different dimensions are present. This might lead to undesired masking! (The code will not raise an exception.) ({'/dev3442/auxins/0/sample.auxin0.avg': {(1, 25112)}, '/dev3442/demods/0/sample.r': {(1, 25112)}, '/dev3442/demods/0/sample.x': {(1, 25112)}})\n", - " return recorded_data\n" + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "Waiting for device dev3442 to finish the acquisition.\n", + "{'buffercount': array([77], dtype=int64), 'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664529215402434], dtype=uint64), 'createdtimestamp': array([316381462056], dtype=uint64), 'changedtimestamp': array([316381462056], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '004 11:13:35.4017', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 317281356936,\n", + " 317281392776, 317281428616]], dtype=uint64), 'value': array([[ nan, nan, nan, ..., -0.00232198,\n", + " -0.00232198, -0.00232198]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664529215402983], dtype=uint64), 'createdtimestamp': array([316381462056], dtype=uint64), 'changedtimestamp': array([316381462056], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '004 11:13:35.4017', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[316381450376, 316381486216, 316381522056, ..., 317281356936,\n", + " 317281392776, 317281428616]], dtype=uint64), 'value': array([[1.59011277e-07, 4.70619023e-07, 6.68435541e-07, ...,\n", + " 5.32911742e-07, 5.30974673e-07, 4.72225932e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664529215403471], dtype=uint64), 'createdtimestamp': array([316381462056], dtype=uint64), 'changedtimestamp': array([316381462056], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '004 11:13:35.4017', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[316381450376, 316381486216, 316381522056, ..., 317281356936,\n", + " 317281392776, 317281428616]], dtype=uint64), 'value': array([[-1.00858959e-07, -6.24829378e-08, 5.21458498e-09, ...,\n", + " -9.96038947e-09, -1.75158872e-07, -3.89508749e-07]])}]}}}, 'duration': array([15.00023467]), 'forcetrigger': array([0], dtype=int64), 'triggered': array([0], dtype=int64)}\n" ] } ], @@ -770,8 +709,8 @@ }, { "cell_type": "code", - "execution_count": 87, - "id": "1739937f", + "execution_count": 74, + "id": "a4e923e8", "metadata": { "scrolled": true }, @@ -779,20 +718,20 @@ { "data": { "text/plain": [ - "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[ nan, nan, nan, ..., -0.00159835,\n", - " -0.00163236, -0.00166638]])\n", + "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[-0.00211383, -0.00209682, -0.00207982, ..., -0.00121121,\n", + " -0.00121688, -0.00122255]])\n", " Coordinates:\n", - " timestamp (col, row) uint64 0 0 0 ... 614064834713 614064870553\n", - " Dimensions without coordinates: col, row\n", + " timestamp (row, col) float64 4.482e+12 4.482e+12 ... 4.497e+12 4.497e+12\n", + " Dimensions without coordinates: row, col\n", " Attributes:\n", - " systemtime: [1664448415930365]\n", - " createdtimestamp: [613164903993]\n", - " changedtimestamp: [613164903993]\n", + " systemtime: [1664528424329287]\n", + " createdtimestamp: [268898909736]\n", + " changedtimestamp: [268898909736]\n", " flags: [825]\n", " moduleflags: [0]\n", " chunksizebytes: [0]\n", - " name: 002 12:46:55.9296\n", + " name: 003 11:00:24.3286\n", " status: [0]\n", " groupindex: [0]\n", " color: [0]\n", @@ -811,20 +750,20 @@ " bandwidth: [nan]\n", " center: [0.]\n", " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.r': [\n", - " array([[ nan, nan, nan, ...,\n", - " 5.57739763e-07, 5.03562022e-07, 2.80091264e-07]])\n", + " '/dev3442/demods/0/sample.r': [\n", + " array([[4.24502350e-08, 3.83220570e-07, 6.39577112e-07, ...,\n", + " 2.91820932e-07, 1.21077468e-07, 1.73901447e-07]])\n", " Coordinates:\n", - " timestamp (col, row) uint64 0 0 0 ... 614064834713 614064870553\n", - " Dimensions without coordinates: col, row\n", + " timestamp (row, col) float64 4.482e+12 4.482e+12 ... 4.497e+12 4.497e+12\n", + " Dimensions without coordinates: row, col\n", " Attributes:\n", - " systemtime: [1664448415931243]\n", - " createdtimestamp: [613164903993]\n", - " changedtimestamp: [613164903993]\n", + " systemtime: [1664528424329823]\n", + " createdtimestamp: [268898909736]\n", + " changedtimestamp: [268898909736]\n", " flags: [1849]\n", " moduleflags: [0]\n", " chunksizebytes: [0]\n", - " name: 002 12:46:55.9296\n", + " name: 003 11:00:24.3286\n", " status: [0]\n", " groupindex: [0]\n", " color: [0]\n", @@ -843,20 +782,20 @@ " bandwidth: [nan]\n", " center: [0.]\n", " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.x': [\n", - " array([[ nan, nan, nan, ...,\n", - " -4.14088034e-07, -3.42151755e-07, -2.58497160e-07]])\n", + " '/dev3442/demods/0/sample.x': [\n", + " array([[-4.11211373e-08, -3.45698104e-07, -5.54790943e-07, ...,\n", + " -2.84726146e-07, -1.17343409e-07, 2.52172809e-08]])\n", " Coordinates:\n", - " timestamp (col, row) uint64 0 0 0 ... 614064834713 614064870553\n", - " Dimensions without coordinates: col, row\n", + " timestamp (row, col) float64 4.482e+12 4.482e+12 ... 4.497e+12 4.497e+12\n", + " Dimensions without coordinates: row, col\n", " Attributes:\n", - " systemtime: [1664448415930760]\n", - " createdtimestamp: [613164903993]\n", - " changedtimestamp: [613164903993]\n", + " systemtime: [1664528424330307]\n", + " createdtimestamp: [268898909736]\n", + " changedtimestamp: [268898909736]\n", " flags: [1849]\n", " moduleflags: [0]\n", " chunksizebytes: [0]\n", - " name: 002 12:46:55.9296\n", + " name: 003 11:00:24.3286\n", " status: [0]\n", " groupindex: [0]\n", " color: [0]\n", @@ -877,7 +816,7 @@ " nenbw: [nan]]}" ] }, - "execution_count": 87, + "execution_count": 74, "metadata": {}, "output_type": "execute_result" } @@ -888,8 +827,91 @@ }, { "cell_type": "code", - "execution_count": 100, - "id": "35db3637", + "execution_count": 75, + "id": "3261c214", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4481648300933.333\n", + "4481648898266.667\n", + "4481649495600.0\n", + "4481650092933.333\n", + "4481650690266.667\n", + "4481651287600.0\n", + "4481651884933.333\n", + "4481652482266.667\n", + "4481653079600.0\n", + "4481653676933.333\n", + "4481654274266.667\n", + "4481654871600.0\n", + "4481655468933.333\n", + "4481656066266.667\n", + "4481656663600.0\n", + "4481657260933.333\n", + "4481657858266.667\n", + "4481658455600.0\n", + "4481659052933.333\n", + "4481659650266.667\n", + "---\n", + "4496636588933.334\n", + "4496637186266.666\n", + "4496637783600.0\n", + "4496638380933.333\n", + "4496638978266.667\n", + "4496639575600.0\n", + "4496640172933.333\n", + "4496640770266.667\n", + "4496641367600.0\n", + "4496641964933.333\n", + "4496642562266.667\n", + "4496643159600.0\n", + "4496643756933.333\n", + "4496644354266.667\n", + "4496644951600.0\n", + "4496645548933.333\n", + "4496646146266.667\n", + "4496646743600.0\n", + "4496647340933.333\n", + "4496647938266.667\n" + ] + } + ], + "source": [ + "for e in data['/dev3442/auxins/0/sample.auxin0.avg'][0][\"timestamp\"].values[0, :20]:\n", + " print(e)\n", + "print(\"---\")\n", + "for e in data['/dev3442/auxins/0/sample.auxin0.avg'][0][\"timestamp\"].values[0, -20:]:\n", + " print(e)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "9b6e205d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.89951232" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(130556892296-129657379976)*1e-9" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "8f7b38e3", "metadata": { "scrolled": true }, @@ -898,46 +920,46 @@ "name": "stdout", "output_type": "stream", "text": [ - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "nan\n", - "-0.0003317117807455361\n", - "-0.0003317117807455361\n" + "-0.0021138295076801594\n", + "-0.002096822800171233\n", + "-0.0020798160926623066\n", + "-0.00206280938515338\n", + "-0.0020458026776444538\n", + "-0.0020287959701355274\n", + "-0.002011789262626601\n", + "-0.0019947825551176745\n", + "-0.001977775847608748\n", + "-0.0019607691400998217\n", + "-0.0019437624325908953\n", + "-0.001926755725081969\n", + "-0.0019097490175730425\n", + "-0.001892742310064116\n", + "-0.0018757356025551897\n", + "-0.0018587288950462633\n", + "-0.0018417221875373369\n", + "-0.0018247154800284104\n", + "-0.001807708772519484\n", + "-0.0017907020650105576\n", + "-0.0017736953575016312\n", + "-0.0017566886499927048\n", + "-0.0017396819424837784\n", + "-0.001722675234974852\n", + "-0.0017056685274659256\n", + "-0.0016886618199569992\n", + "-0.0016716551124480727\n", + "-0.0016572554041315024\n", + "-0.001651586501628527\n", + "-0.0016459175991255515\n", + "-0.001640248696622576\n", + "-0.0016345797941196005\n", + "-0.001628910891616625\n", + "-0.0016232419891136496\n", + "-0.0016175730866106741\n", + "-0.0016119041841076986\n", + "-0.0016062352816047232\n", + "-0.0016005663791017477\n", + "-0.0015948974765987722\n", + "-0.0015892285740957968\n" ] } ], @@ -948,8 +970,8 @@ }, { "cell_type": "code", - "execution_count": 103, - "id": "cf097c1a", + "execution_count": 107, + "id": "ac968e7b", "metadata": {}, "outputs": [ { @@ -957,65 +979,337 @@ "output_type": "stream", "text": [ "/dev3442/demods/0/sample.x\n", - "(1, 25112)\n", - "[[16741. 16742. 16743. ... 21761. 21762. 21763.]]\n", - "(1, 5023)\n", + "time_of_trigger=[5.27302317e+12]\n", + "extracted_data=[\n", + "array([[ 8.20515335e-08, -1.37302456e-07, -2.23006770e-07, ...,\n", + " -2.51220898e-07, -8.52887497e-08, -8.56558814e-08]])\n", + "Coordinates:\n", + " time (row, col) float64 1e+10 1e+10 1e+10 ... 1.3e+10 1.3e+10 1.3e+10\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664529215403471]\n", + " createdtimestamp: [316381462056]\n", + " changedtimestamp: [316381462056]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 11:13:35.4017\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]\n", "/dev3442/demods/0/sample.r\n", - "(1, 25112)\n", - "[[10882. 10883. 10884. ... 13223. 13224. 13225.]\n", - " [23438. 23439. 23440. ... nan nan nan]]\n", - "(2, 2344)\n", + "time_of_trigger=[5.27302317e+12]\n", + "time_of_trigger=[5.27302317e+12]\n", + "extracted_data=[\n", + "array([[5.09070137e-07, 4.36690684e-07, 4.20131474e-07, ...,\n", + " 5.52220621e-07, 5.07130206e-07, 2.38696738e-07]])\n", + "Coordinates:\n", + " time (row, col) float64 6.501e+09 6.501e+09 ... 7.899e+09 7.9e+09\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664529215402983]\n", + " createdtimestamp: [316381462056]\n", + " changedtimestamp: [316381462056]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 11:13:35.4017\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan], \n", + "array([[4.39980625e-07, 5.04697280e-07, 4.95701644e-07, ...,\n", + " 2.04461446e-07, 3.65230061e-07, 5.32911742e-07]])\n", + "Coordinates:\n", + " time (row, col) float64 1.4e+10 1.4e+10 1.4e+10 ... 1.5e+10 1.5e+10\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664529215402983]\n", + " createdtimestamp: [316381462056]\n", + " changedtimestamp: [316381462056]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 11:13:35.4017\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]\n", "/dev3442/auxins/0/sample.auxin0.avg\n", - "(1, 25112)\n", - "[[ 3. 4. nan nan]\n", - " [12. 13. 14. 15.]]\n", - "(2, 4)\n" + "time_of_trigger=[5.27309366e+12]\n", + "time_of_trigger=[5.27309366e+12]\n", + "extracted_data=[\n", + "array([[-0.00120247, -0.00121381, -0.00122515, ..., -0.00054094,\n", + " -0.00051259, -0.00048425]])\n", + "Coordinates:\n", + " time (row, col) float64 3e+09 3.001e+09 3.001e+09 ... 4.499e+09 4.5e+09\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664529215402434]\n", + " createdtimestamp: [316381462056]\n", + " changedtimestamp: [316381462056]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 11:13:35.4017\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan], \n", + "array([[-0.00106838, -0.00109105, -0.00111373, ..., -0.00232198,\n", + " -0.00232198, -0.00232198]])\n", + "Coordinates:\n", + " time (row, col) float64 1.2e+10 1.2e+10 1.2e+10 ... 1.493e+10 1.493e+10\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664529215402434]\n", + " createdtimestamp: [316381462056]\n", + " changedtimestamp: [316381462056]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 11:13:35.4017\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]\n" ] } ], "source": [ - "my_lockin._parse_data(data, program_name=\"test\")" + "extracted_data = my_lockin._parse_data(data, program_name=\"test\")" ] }, { "cell_type": "code", - "execution_count": 59, - "id": "6f93a669", + "execution_count": 105, + "id": "65c30f52", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_windows(data):\n", + " for j, w in enumerate(data.keys()):\n", + " for i, c in enumerate(data[w].keys()):\n", + " for e in data[w][c]:\n", + " print(e[\"time\"].values, e.values)\n", + " plt.plot(e[\"time\"].values.T, e.values.T, color=f\"C{j}\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "id": "e06ffa46", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\numpy\\core\\numeric.py\u001b[0m(342)\u001b[0;36mfull\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 340 \u001b[1;33m \u001b[0mfill_value\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0masarray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfill_value\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 341 \u001b[1;33m \u001b[0mdtype\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfill_value\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 342 \u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mempty\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0morder\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 343 \u001b[1;33m \u001b[0mmultiarray\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcopyto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfill_value\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcasting\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'unsafe'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 344 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "[[1.00003600e+10 1.00009573e+10 1.00015547e+10 ... 1.29983760e+10\n", + " 1.29989733e+10 1.29995707e+10]] [[ 8.20515335e-08 -1.37302456e-07 -2.23006770e-07 ... -2.51220898e-07\n", + " -8.52887497e-08 -8.56558814e-08]]\n", + "[[6.50058400e+09 6.50118133e+09 6.50177867e+09 ... 7.89834400e+09\n", + " 7.89894133e+09 7.89953867e+09]] [[5.09070137e-07 4.36690684e-07 4.20131474e-07 ... 5.52220621e-07\n", + " 5.07130206e-07 2.38696738e-07]]\n", + "[[1.40001040e+10 1.40007013e+10 1.40012987e+10 ... 1.49982480e+10\n", + " 1.49988453e+10 1.49994427e+10]] [[4.39980625e-07 5.04697280e-07 4.95701644e-07 ... 2.04461446e-07\n", + " 3.65230061e-07 5.32911742e-07]]\n", + "[[3.00021067e+09 3.00080800e+09 3.00140533e+09 ... 4.49832267e+09\n", + " 4.49892000e+09 4.49951733e+09]] [[-0.00120247 -0.00121381 -0.00122515 ... -0.00054094 -0.00051259\n", + " -0.00048425]]\n", + "[[1.20002320e+10 1.20008293e+10 1.20014267e+10 ... 1.49289573e+10\n", + " 1.49295547e+10 1.49301520e+10]] [[-0.00106838 -0.00109105 -0.00111373 ... -0.00232198 -0.00232198\n", + " -0.00232198]]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_windows(extracted_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "405f9760", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m(83)\u001b[0;36mgroup_indexers_by_index\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 81 \u001b[1;33m \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 82 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mkey\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcoords\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m---> 83 \u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"no index found for coordinate {key}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 84 \u001b[1;33m \u001b[1;32melif\u001b[0m \u001b[0mkey\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdims\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 85 \u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"{key} is not a valid dimension or coordinate\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m(110)\u001b[0;36mremap_label_indexers\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 108 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 109 \u001b[1;33m indexes, grouped_indexers = group_indexers_by_index(\n", + "\u001b[0m\u001b[1;32m--> 110 \u001b[1;33m \u001b[0mdata_obj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 111 \u001b[1;33m )\n", + "\u001b[0m\u001b[1;32m 112 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\coordinates.py\u001b[0m(422)\u001b[0;36mremap_label_indexers\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 420 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 421 \u001b[1;33m pos_indexers, new_indexes = indexing.remap_label_indexers(\n", + "\u001b[0m\u001b[1;32m--> 422 \u001b[1;33m \u001b[0mobj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv_indexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 423 \u001b[1;33m )\n", + "\u001b[0m\u001b[1;32m 424 \u001b[1;33m \u001b[1;31m# attach indexer's coordinate to pos_indexers\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataset.py\u001b[0m(2505)\u001b[0;36msel\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 2503 \u001b[1;33m \u001b[0mindexers\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0meither_dict_or_kwargs\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers_kwargs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"sel\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 2504 \u001b[1;33m pos_indexers, new_indexes = remap_label_indexers(\n", + "\u001b[0m\u001b[1;32m-> 2505 \u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 2506 \u001b[1;33m )\n", + "\u001b[0m\u001b[1;32m 2507 \u001b[1;33m \u001b[1;31m# TODO: benbovy - flexible indexes: also use variables returned by Index.query\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(1337)\u001b[0;36msel\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 1335 \u001b[1;33m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1336 \u001b[1;33m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m-> 1337 \u001b[1;33m \u001b[1;33m**\u001b[0m\u001b[0mindexers_kwargs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1338 \u001b[1;33m )\n", + "\u001b[0m\u001b[1;32m 1339 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_from_temp_dataset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(201)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 199 \u001b[1;33m \u001b[0mlabels\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mindexing\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexpanded_indexer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata_array\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndim\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 200 \u001b[1;33m \u001b[0mkey\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata_array\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 201 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata_array\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 202 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 203 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[0m\n", - "ipdb> shape\n", - "(2, -2147483647)\n", "ipdb> u\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(390)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 388 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 389 \u001b[1;33m \u001b[1;31m# building the mask to apply to the data now:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 390 \u001b[1;33m \u001b[0mapplicable_mask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfull\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnanmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mint\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnan\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 391 \u001b[1;33m \u001b[1;31m# the following code could probably be optimized with some numpy magic\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 392 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mwi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mw\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m_mask\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mci\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(488)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 486 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"time_of_trigger={time_of_trigger}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 487 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 488 \u001b[1;33m \u001b[0mextracted_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mapplicable_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m\"row\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mrow_index\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m\"timestamp\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mslice\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtime_of_trigger\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtime_of_trigger\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 489 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 490 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"extracted_data={extracted_data}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[0m\n", - "ipdb> _mask\n", - "array([[[nan],\n", - " [nan]],\n", - "\n", - " [[nan],\n", - " [nan]],\n", - "\n", - " [[nan],\n", - " [nan]]])\n", - "--KeyboardInterrupt--\n", - "\n", - "KeyboardInterrupt: Interrupted by user\n" + "ipdb> applicable_data.where(~np.isnan(applicable_data), drop=True)\n", + "\n", + "array([[-1.54233563e-07, -1.53747443e-07, -1.63328742e-07, ...,\n", + " 1.12498946e-07, 5.47050085e-08, 5.14905138e-08]])\n", + "Coordinates:\n", + " timestamp (row, col) uint64 129659709576 129659745416 ... 130556892296\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664526103384841]\n", + " createdtimestamp: [129656925736]\n", + " changedtimestamp: [129656925736]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 000 10:21:43.3824\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [0]\n", + " gridrows: [1]\n", + " gridcols: [25112]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]\n", + "ipdb> r\n" ] } ], @@ -1026,7 +1320,7 @@ { "cell_type": "code", "execution_count": 39, - "id": "3dff5a12", + "id": "baed7050", "metadata": { "scrolled": true }, @@ -1050,7 +1344,7 @@ { "cell_type": "code", "execution_count": null, - "id": "072e924f", + "id": "147a4673", "metadata": {}, "outputs": [], "source": [ @@ -1060,7 +1354,7 @@ { "cell_type": "code", "execution_count": 43, - "id": "5d823f5e", + "id": "8ce05631", "metadata": {}, "outputs": [], "source": [ @@ -1069,8 +1363,8 @@ }, { "cell_type": "code", - "execution_count": 47, - "id": "01fe9f51", + "execution_count": 72, + "id": "1b13babc", "metadata": {}, "outputs": [ { @@ -1427,27 +1721,27 @@ " stroke: currentColor;\n", " fill: currentColor;\n", "}\n", - "
<xarray.DataArray '/dev3442/demods/0/sample.r' (col: 1, row: 21763)>\n",
-       "array([[1.28582697e-07, 2.34376326e-07, 2.38996428e-07, ...,\n",
-       "        5.87560559e-07, 5.32019319e-07, 4.14106693e-07]])\n",
+       "
<xarray.DataArray '/dev3442/demods/0/sample.r' (col: 1, row: 25112)>\n",
+       "array([[7.03522854e-07, 6.92340419e-07, 7.21439685e-07, ...,\n",
+       "        3.06968651e-07, 3.77702425e-07, 4.19837064e-07]])\n",
        "Coordinates:\n",
-       "    timestamp  (col, row) uint64 1393721026696 1393721062536 ... 1394500976776\n",
+       "    timestamp  (col, row) uint64 2303061427353 2303061463193 ... 2303961405593\n",
        "Dimensions without coordinates: col, row\n",
        "Attributes:\n",
-       "    systemtime:        [1664383619737528]\n",
-       "    createdtimestamp:  [1393721038376]\n",
-       "    changedtimestamp:  [1393721038376]\n",
+       "    systemtime:        [1664476581306703]\n",
+       "    createdtimestamp:  [2303061439033]\n",
+       "    changedtimestamp:  [2303061439033]\n",
        "    flags:             [1849]\n",
        "    moduleflags:       [0]\n",
        "    chunksizebytes:    [0]\n",
-       "    name:              001 18:46:59.7359\n",
+       "    name:              009 20:36:21.3054\n",
        "    status:            [0]\n",
        "    groupindex:        [0]\n",
        "    color:             [0]\n",
        "    activerow:         [0]\n",
        "    triggernumber:     [0]\n",
        "    gridrows:          [1]\n",
-       "    gridcols:          [21763]\n",
+       "    gridcols:          [25112]\n",
        "    gridmode:          [4]\n",
        "    gridoperation:     [1]\n",
        "    griddirection:     [0]\n",
@@ -1458,32 +1752,32 @@
        "    gridrowoffset:     [0.]\n",
        "    bandwidth:         [nan]\n",
        "    center:            [0.]\n",
-       "    nenbw:             [nan]
"
+       "    nenbw:             [nan]
" ], "text/plain": [ - "\n", - "array([[1.28582697e-07, 2.34376326e-07, 2.38996428e-07, ...,\n", - " 5.87560559e-07, 5.32019319e-07, 4.14106693e-07]])\n", + "\n", + "array([[7.03522854e-07, 6.92340419e-07, 7.21439685e-07, ...,\n", + " 3.06968651e-07, 3.77702425e-07, 4.19837064e-07]])\n", "Coordinates:\n", - " timestamp (col, row) uint64 1393721026696 1393721062536 ... 1394500976776\n", + " timestamp (col, row) uint64 2303061427353 2303061463193 ... 2303961405593\n", "Dimensions without coordinates: col, row\n", "Attributes:\n", - " systemtime: [1664383619737528]\n", - " createdtimestamp: [1393721038376]\n", - " changedtimestamp: [1393721038376]\n", + " systemtime: [1664476581306703]\n", + " createdtimestamp: [2303061439033]\n", + " changedtimestamp: [2303061439033]\n", " flags: [1849]\n", " moduleflags: [0]\n", " chunksizebytes: [0]\n", - " name: 001 18:46:59.7359\n", + " name: 009 20:36:21.3054\n", " status: [0]\n", " groupindex: [0]\n", " color: [0]\n", " activerow: [0]\n", " triggernumber: [0]\n", " gridrows: [1]\n", - " gridcols: [21763]\n", + " gridcols: [25112]\n", " gridmode: [4]\n", " gridoperation: [1]\n", " griddirection: [0]\n", @@ -1497,7 +1791,7 @@ " nenbw: [nan]" ] }, - "execution_count": 47, + "execution_count": 72, "metadata": {}, "output_type": "execute_result" } @@ -1509,7 +1803,7 @@ { "cell_type": "code", "execution_count": 48, - "id": "8b542fd5", + "id": "1b3b9518", "metadata": {}, "outputs": [ { @@ -1529,13 +1823,13 @@ }, { "cell_type": "code", - "execution_count": 88, - "id": "15491285", + "execution_count": 71, + "id": "b9a1f37a", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1556,7 +1850,7 @@ { "cell_type": "code", "execution_count": 68, - "id": "7326c859", + "id": "4bacd809", "metadata": {}, "outputs": [ { @@ -1589,7 +1883,7 @@ { "cell_type": "code", "execution_count": 55, - "id": "94e49027", + "id": "2b295dca", "metadata": { "scrolled": true }, @@ -1648,7 +1942,7 @@ { "cell_type": "code", "execution_count": 63, - "id": "e6af1c97", + "id": "de5e322a", "metadata": {}, "outputs": [ { @@ -1683,7 +1977,7 @@ { "cell_type": "code", "execution_count": 192, - "id": "d54014ef", + "id": "c277273e", "metadata": {}, "outputs": [ { @@ -1752,7 +2046,7 @@ { "cell_type": "code", "execution_count": 174, - "id": "31d0bf43", + "id": "a71d1807", "metadata": {}, "outputs": [ { @@ -1779,7 +2073,7 @@ { "cell_type": "code", "execution_count": 123, - "id": "8fed7140", + "id": "0fa92ea7", "metadata": {}, "outputs": [], "source": [ @@ -1789,7 +2083,7 @@ { "cell_type": "code", "execution_count": 145, - "id": "1f274e40", + "id": "b8101857", "metadata": { "scrolled": false }, @@ -1812,7 +2106,7 @@ { "cell_type": "code", "execution_count": 119, - "id": "53e15047", + "id": "ae4e4a2e", "metadata": {}, "outputs": [ { @@ -1833,7 +2127,7 @@ { "cell_type": "code", "execution_count": 110, - "id": "ad042dae", + "id": "a8954de7", "metadata": {}, "outputs": [], "source": [ @@ -1843,7 +2137,7 @@ { "cell_type": "code", "execution_count": 111, - "id": "083df80b", + "id": "24b03728", "metadata": {}, "outputs": [ { @@ -1905,38 +2199,27 @@ }, { "cell_type": "code", - "execution_count": 169, - "id": "efe92e25", + "execution_count": 44, + "id": "09d01f1c", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "False" - ] - }, - "execution_count": 169, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "my_lockin.daq.finished()" + "my_lockin.daq.finish()" ] }, { "cell_type": "code", - "execution_count": 205, - "id": "588ca0bd", + "execution_count": 45, + "id": "38658331", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0.])" + "array([1.])" ] }, - "execution_count": 205, + "execution_count": 45, "metadata": {}, "output_type": "execute_result" } @@ -1948,7 +2231,7 @@ { "cell_type": "code", "execution_count": 202, - "id": "1b5bd26c", + "id": "73bb08c9", "metadata": {}, "outputs": [], "source": [ @@ -1958,7 +2241,7 @@ { "cell_type": "code", "execution_count": 114, - "id": "fdc5e2a6", + "id": "0142d680", "metadata": {}, "outputs": [ { @@ -1979,7 +2262,7 @@ { "cell_type": "code", "execution_count": 117, - "id": "ee2305e6", + "id": "b6de4fef", "metadata": {}, "outputs": [ { @@ -2000,7 +2283,7 @@ { "cell_type": "code", "execution_count": 116, - "id": "911919e4", + "id": "949a4afd", "metadata": {}, "outputs": [], "source": [ @@ -2010,7 +2293,7 @@ { "cell_type": "code", "execution_count": 193, - "id": "65a141ca", + "id": "8eb9a8a3", "metadata": {}, "outputs": [], "source": [ @@ -2020,7 +2303,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4b418c1a", + "id": "a98682c4", "metadata": {}, "outputs": [], "source": [] @@ -2028,7 +2311,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0ad8c16c", + "id": "a24964df", "metadata": {}, "outputs": [], "source": [] @@ -2036,7 +2319,7 @@ { "cell_type": "code", "execution_count": null, - "id": "49dc9d70", + "id": "4efc42cd", "metadata": {}, "outputs": [], "source": [] @@ -2044,7 +2327,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "7363d67f", + "id": "20a2271a", "metadata": {}, "outputs": [], "source": [ @@ -2054,7 +2337,7 @@ { "cell_type": "code", "execution_count": 32, - "id": "d1ad57e2", + "id": "076f88d5", "metadata": {}, "outputs": [], "source": [ @@ -2065,7 +2348,7 @@ { "cell_type": "code", "execution_count": 33, - "id": "4754b459", + "id": "9f91dd46", "metadata": {}, "outputs": [], "source": [ @@ -2075,7 +2358,7 @@ { "cell_type": "code", "execution_count": 37, - "id": "cf413391", + "id": "28967643", "metadata": {}, "outputs": [ { @@ -3194,7 +3477,7 @@ { "cell_type": "code", "execution_count": 29, - "id": "76e6b962", + "id": "e15e512d", "metadata": {}, "outputs": [ { @@ -3220,7 +3503,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9c11cee2", + "id": "364be378", "metadata": {}, "outputs": [], "source": [] @@ -3228,7 +3511,7 @@ { "cell_type": "code", "execution_count": 35, - "id": "e4f71fe6", + "id": "3411b4bc", "metadata": {}, "outputs": [], "source": [ @@ -3239,7 +3522,7 @@ { "cell_type": "code", "execution_count": 31, - "id": "abd297a8", + "id": "ac9dfd61", "metadata": {}, "outputs": [], "source": [ @@ -3249,7 +3532,7 @@ { "cell_type": "code", "execution_count": 78, - "id": "4f311776", + "id": "5053c5b5", "metadata": {}, "outputs": [ { @@ -3275,7 +3558,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a5c04c1b", + "id": "bd206f1b", "metadata": {}, "outputs": [], "source": [] @@ -3283,7 +3566,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1d1373fa", + "id": "053b7e08", "metadata": {}, "outputs": [], "source": [] @@ -3291,7 +3574,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e7be9bae", + "id": "b40d3759", "metadata": {}, "outputs": [], "source": [] @@ -3299,7 +3582,7 @@ { "cell_type": "code", "execution_count": null, - "id": "65e6ee21", + "id": "0621bc14", "metadata": {}, "outputs": [], "source": [] @@ -3307,7 +3590,7 @@ { "cell_type": "code", "execution_count": null, - "id": "22736eb6", + "id": "14d169ab", "metadata": {}, "outputs": [], "source": [] diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index aafd39193..a5ed4a78d 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -3,7 +3,7 @@ May lines of code have been adapted from the zihdawg driver. """ -from typing import Dict, Tuple, Iterable, Union, List +from typing import Dict, Tuple, Iterable, Union, List, Set from enum import Enum import warnings import time @@ -38,8 +38,8 @@ [X] make TriggerMode class an Enum [X] setup minimal connection without changing settings other than buffer lengths [X] extract window things -[ ] rethink handling different sample rates! -[ ] cut obtained data to fit into requested windows +[X] rethink handling different sample rates! +[X] cut obtained data to fit into requested windows [ ] provide interface for changing trigger settings [ ] print information about how long the measurement is expected to run [ ] implement multiple triggers (using rows) (and check how this actually behaves) @@ -52,6 +52,26 @@ [ ] implement scope interface for higher sample rates (if i understood the documentation correctly) [ ] implement low level interface (subscribe()) + +Tests to implement: +[ ] connecting to a MFLI Device by querying + [ ] available nodes of the api_session + [ ] creating and reading a DAQ Module +[ ] registering channels + [ ] Demod 0 and 1 + [ ] AUXIN +[ ] defining measurement windows + [ ] consecutive ones + [ ] overlapping + [ ] some windows with names but no begin and length information +[ ] relating channels to windows + [ ] adding one channel to one window + [ ] adding multiple channels to one windows + [ ] adding one channel to multiple windows +[ ] measuring only one AUXIN (some channel without the rate argument) + + + """ @@ -158,9 +178,14 @@ def register_measurement_windows(self, program_name: str, windows: Dict[str, Tup """ self.programs.setdefault(program_name, {}).setdefault("windows", {}).update(windows) + self.programs.setdefault(program_name, {}).setdefault("windows_from_start_max", {}).update({k:np.max(v[0]+v[1]) for k, v in windows.items()}) - for k, v in windows.items(): - self.set_measurement_mask(program_name=program_name, mask_name=k, begins=v[0], lengths=v[1]) + # the channels we want to measure with: + channels_to_measure: Set[str] = self._get_channels_for_window(program_name, list(windows.keys())) + self.programs.setdefault(program_name, {})["all_channels"] = channels_to_measure + + # for k, v in windows.items(): + # self.set_measurement_mask(program_name=program_name, mask_name=k, begins=v[0], lengths=v[1]) def _get_sample_rates(self, channel:str): try: @@ -187,20 +212,15 @@ def set_measurement_mask(self, program_name: str, mask_name: str, Measurement windows in DAC samples (begins, lengths) """ + raise NotImplementedError(f"This function has been abandoned as the MFLI returns timestamps.") + assert begins.shape == lengths.shape if program_name not in self.programs: raise ValueError(f"Program '{program_name}' not known") # the channels we want to measure with: - channels_to_measure: List[str] = [] - try: - channels_to_measure = self.programs[program_name]["channel_mapping"][mask_name] - except KeyError: - try: - channels_to_measure = self.programs[None]["channel_mapping"][mask_name] - except KeyError: - channels_to_measure = [] + channels_to_measure: List[str] = self._get_channels_for_window(program_name, mask_name) if len(channels_to_measure) == 0: warnings.warn(f"There are no channels defined that should be measured in mask '{mask_name}'.") @@ -273,6 +293,29 @@ def register_operations(self, program_name: str, operations) -> None: """ self.programs.setdefault(program_name, {}).setdefault("operations", []).append(operations) + + def _get_channels_for_window(self, program_name, window_name=None): + """ Returns the channels to be measured for a given window + """ + if window_name is None: + window_name = list(self.programs[program_name].keys()) + if not isinstance(window_name, list): + window_name = [window_name] + + channels: Set[str] = set() + + for wn in window_name: + try: + channels.update(self.programs[program_name]["channel_mapping"][wn]) + except KeyError: + try: + channels.update(self.programs[None]["channel_mapping"][wn]) + except KeyError: + pass + + channels = set([e.lower() for e in channels]) + return channels + def _get_demod(self, channel:str): """ This function gets the demodulator corresponding to a channel @@ -295,7 +338,7 @@ def arm_program(self, program_name: str, force:bool=True) -> None: demod = self._get_demod(c) try: self.api_session.setInt(f'/{self.serial}/{demod}/enable', 1) - except RuntimeError as e: + except RuntimeError as e: if "ZIAPINotFoundException" in e.args[0] or f"Path /{self.serial}/{demod}/enable not found." in e.args[0]: # ok, the channel can not be enabled. Then the user should be caring about that. warnings.warn(f"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.") @@ -306,29 +349,57 @@ def arm_program(self, program_name: str, force:bool=True) -> None: # select the value to measure self.daq.subscribe(f'/{self.serial}/{c}') - # check if sample rates are the same as when register_measurement_windows() was called - for k, v in self.programs[program_name]['masks'].items(): - if len(v["channels"]) != len(v["sample_rates"]): - raise ValueError(f"There is a mismatch between number the channels to be used and the known sample rates.") - for c, r in zip(v["channels"], v["sample_rates"]): - if self._get_sample_rates(c) != r: - raise ValueError(f"The sample rate for channel '{c}' has changed. Please call register_measurement_windows() again.") + # # check if sample rates are the same as when register_measurement_windows() was called + # for k, v in self.programs[program_name]['masks'].items(): + # if len(v["channels"]) != len(v["sample_rates"]): + # raise ValueError(f"There is a mismatch between number the channels to be used and the known sample rates.") + # for c, r in zip(v["channels"], v["sample_rates"]): + # if self._get_sample_rates(c) != r: + # raise ValueError(f"The sample rate for channel '{c}' has changed. Please call register_measurement_windows() again.") + + # set the buffer size based on the largest sample rate + # if no sample rate is readable, as for example when only AUXIN channels are used, the first demodulator is activated and the corresponding rate is used + + raw_currently_set_sample_rates: List[Union[TimeType, None]] = [] + for c in self.programs[program_name]["all_channels"]: + raw_currently_set_sample_rates.append(self._get_sample_rates(c)) + + # CAUTION + # The MFLI lock-ins up-sample slower channels to fit the fastest sample rate. + # This is the cased for the Lab One Data Server 21.08.20515 and the MFLi Firmware 67629. + foo = [x for x in raw_currently_set_sample_rates if x is not None] + if len(foo) == 0 and self.assumed_minimal_sample_rate is None: + # Ok, we activate the first demodulator + self.api_session.setInt(f'/{self.serial}/demods/0/enable', 1) + foo.append(self._get_sample_rates(f'/{self.serial}/demods/0/sample.R')) + if self.assumed_minimal_sample_rate is not None: + foo.append(TimeType().from_float(value=self.assumed_minimal_sample_rate, absolute_error=0)) + max_sample_rate = max(foo) + currently_set_sample_rates = [max_sample_rate]*len(raw_currently_set_sample_rates) + # set daq module settings to standard things # TODO one might want to extend the driver to support more methods self.daq.set('grid/mode', 4) # this corresponds to Mode: Exact(on-grid) - self.daq.set('grid/rows', 1) # this corresponds to measuring only for one trigger # the following two lines set the row repetitions to 1 and off self.daq.set('grid/repetitions', 1) self.daq.set('grid/rowrepetition', 0) - # TODO these should be a + rows = 1 + # set the buffer size according to the largest measurement window # TODO one might be able to implement this a bit more cleverly - self.daq.set('grid/cols', int(self.programs[program_name]["window_hull"][1])) + measurement_duration = np.max(list(self.programs[program_name]["windows_from_start_max"].values())) + larges_number_of_samples = 1e-9*max_sample_rate*measurement_duration + larges_number_of_samples = np.ceil(larges_number_of_samples) + self.daq.set('grid/cols', larges_number_of_samples) + self.daq.set('grid/rows', rows) # this corresponds to measuring only for one trigger self.currently_set_program = program_name + print(f"Will record {larges_number_of_samples} samples in {measurement_duration*1e-9}s!") # TODO this will have to change if proper multi triggers with over multiple rows is going to be used. + print(f"MFLI returns a total record time of {self.daq.get('duration')}s") + # execute daq self.daq.execute() @@ -392,75 +463,56 @@ def _parse_data(self, recorded_data, program_name): masked_data = {} - index = 0 + shot_index = 0 - for mask_name in self.programs[program_name]["masks"]: + for window_name in self.programs[program_name]["windows"]: data_by_channel = {} - _mask = self.programs[program_name]["masks"][mask_name]["mask"] - for ci, _cn in enumerate(self.programs[program_name]["masks"][mask_name]['channels']): + _wind = self.programs[program_name]["windows"][window_name] + for ci, _cn in enumerate(self._get_channels_for_window(program_name, window_name)): cn = f"/{self.serial}/{_cn}".lower() print(cn) - if len(recorded_data[cn]) <= index: - # then we do not have data for this index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save. - warnings.warn(f"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{index}]") + if len(recorded_data[cn]) <= shot_index: + # then we do not have data for this shot_index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save. + warnings.warn(f"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{shot_index}]") continue - applicable_data = recorded_data[cn][-1-index] - - if np.sum(np.isnan(_mask[1, :, ci])) > 0: - raise ValueError(f"There is something wrong with the data for channel {cn}. The later code assumes that the lock-in is linearly interpolating up to the highest sample rate used.") - # building the mask to apply to the data now: - applicable_mask = np.full((_mask.shape[1], np.nanmax(_mask[1, :, ci]).astype(int)+1), np.nan) - # the following code could probably be optimized with some numpy magic - for wi, w in enumerate(_mask[:, :, ci].T): - applicable_mask[wi, :int(w[2]-w[0]+1)] = np.arange(w[0], w[2]+1) - - print(applicable_data.shape) - print(applicable_mask) - print(applicable_mask.shape) - - # TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO - - temp_mask = applicable_mask.reshape((-1)) - temp_mask = temp_mask.copy() - temp_mask[np.isnan(temp_mask)] = 0 - - masked_data = np.take(applicable_data.reshape((-1)), temp_mask) - - np.put_along_axis(masked_data, np.where(np.isnan(applicable_mask.reshape((-1))))) - - # TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO - - # foo = xr.DataArray( - # data=d["value"], - # coords={'timestamp': (['col', 'row'], d['timestamp'])}, - # dims=['col', 'row'], - # name=cn, - # attrs=d['header'] - # ) - # data_by_channel.update({cn: foo}) - # masked_data[mask_name] = data_by_channel - - # result = xr.Dataset( - # {} - # ) - # self.programs.setdefault(program_name, {}).setdefault("masks", {})[mask_name] = {"mask": mask_info, "channels": channels_to_measure, "sample_rates": currently_set_sample_rates} - - pass - - def measure_program(self, channels: Iterable[str], wait=True) -> Dict[str, np.ndarray]: + applicable_data = recorded_data[cn][-1-shot_index] + + extracted_data = [] + for b, l in zip(*_wind): + _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)["time"][:, 0].values + + time_of_trigger = applicable_data.attrs["gridcoloffset"][0]*1e9+_time_of_first_not_nan_value + + print(f"time_of_trigger={time_of_trigger}") + foo = applicable_data.where((applicable_data["time"]>=time_of_trigger+b) & (applicable_data["time"]<=time_of_trigger+b+l), drop=True) + foo["time"] -= time_of_trigger + extracted_data.append(foo) + + print(f"extracted_data={extracted_data}") + + data_by_channel.update({cn: extracted_data}) + masked_data[window_name] = data_by_channel + + return masked_data + + def measure_program(self, channels: Iterable[str], wait=True, return_raw=False) -> Dict[str, np.ndarray]: """Get the last measurement's results of the specified operations/channels""" # wait until the data acquisition has finished + # TODO implement timeout while not self.daq.finished() and wait: time.sleep(1) - print(f"waiting for device {self.serial} to finish the acquisition.") + print(f"Waiting for device {self.serial} to finish the acquisition.") #Progress: {self.daq.progress()[0]} if not self.daq.finished(): + self.daq.finish() raise ValueError(f"Device {self.serial} did not finish the acquisition in time.") data = self.daq.read() self.daq_read_return.update(data) + self.clock_base = self.api_session.getDouble(f'/{self.serial}/clockbase') + # go through the returned object and extract the data of interest recorded_data = {} @@ -473,8 +525,8 @@ def measure_program(self, channels: Iterable[str], wait=True) -> Dict[str, np.nd channel_name = f"/{device_name}/{input_name}/{signal_name}/{final_level_name}".lower() channel_data = [xr.DataArray( data=d["value"], - coords={'timestamp': (['col', 'row'], d['timestamp'])}, - dims=['col', 'row'], + coords={'time': (['row', 'col'], d["timestamp"]/self.clock_base*1e9)}, + dims=['row', 'col'], name=channel_name, attrs=d['header']) for i, d in enumerate(final_level_data)] recorded_data[channel_name] = channel_data @@ -483,10 +535,11 @@ def measure_program(self, channels: Iterable[str], wait=True) -> Dict[str, np.nd # this is needed as the assumption, that the lock-in/data server up-samples slower channels to match the one with the highest rate. recorded_shapes = {k:set([e.shape for e in v]) for k, v in recorded_data.items()} - if any([len(v)>1 for v in recorded_shapes.items()]) or len(set([e for a in recorded_data.items() for e in a]))>1: + if any([len(v)>1 for v in recorded_shapes.values()]) or len(set([e for a in recorded_shapes.values() for e in a]))>1: warnings.warn(f"For at least one received channel entries with different dimensions are present. This might lead to undesired masking! (The code will not raise an exception.) ({recorded_shapes})") - - print(data) - return recorded_data \ No newline at end of file + if return_raw: + return recorded_data + else: + return self._parse_data(recorded_data, self.currently_set_program) \ No newline at end of file From 0d4ec72b8ef9b159814500ffe31ec464cc40f729 Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Tue, 4 Oct 2022 10:49:18 +0200 Subject: [PATCH 11/25] trigger working --- ...struments_lockin_mfli_daq-checkpoint.ipynb | 1051 +++++++---------- .../zurich_instruments_lockin_mfli_daq.ipynb | 1016 +++++++--------- qupulse/hardware/dacs/mfli.py | 198 +++- 3 files changed, 992 insertions(+), 1273 deletions(-) diff --git a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb index 707f5b1dd..478be723f 100644 --- a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb +++ b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "d268d6bc", + "id": "43453764", "metadata": {}, "source": [ "# Zurich Instruments Lock-In MFLI Data Aquesition" @@ -11,7 +11,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "3fb2b6b7", + "id": "c69fa628", "metadata": {}, "outputs": [], "source": [ @@ -22,7 +22,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "4d29c6af", + "id": "e855b9bf", "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "aeef36bd", + "id": "9fe04cf3", "metadata": {}, "outputs": [], "source": [ @@ -42,7 +42,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "58cc9d89", + "id": "0b2cdab3", "metadata": {}, "outputs": [], "source": [ @@ -52,7 +52,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "8e8b67dd", + "id": "d6c55de0", "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "283b8c79", + "id": "b32f20c2", "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "120c36d1", + "id": "f25240e4", "metadata": {}, "outputs": [ { @@ -91,7 +91,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "e375875e", + "id": "535354b6", "metadata": {}, "outputs": [], "source": [ @@ -101,7 +101,17 @@ { "cell_type": "code", "execution_count": 9, - "id": "63b3ef39", + "id": "d420284a", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.api_session.setDebugLevel(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "82d030c2", "metadata": {}, "outputs": [], "source": [ @@ -111,8 +121,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "c5c765d6", + "execution_count": 11, + "id": "37577ca4", "metadata": {}, "outputs": [], "source": [ @@ -127,8 +137,8 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "3efcb7cd", + "execution_count": 12, + "id": "9b339ce8", "metadata": {}, "outputs": [], "source": [ @@ -138,8 +148,8 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "856983d1", + "execution_count": 13, + "id": "32c4d432", "metadata": {}, "outputs": [ { @@ -155,7 +165,7 @@ " 'demods/0/sample.Y'}}}" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -166,8 +176,8 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "555a627a", + "execution_count": 14, + "id": "78f39281", "metadata": {}, "outputs": [], "source": [ @@ -176,8 +186,8 @@ }, { "cell_type": "code", - "execution_count": 14, - "id": "99d4067b", + "execution_count": 15, + "id": "b8240692", "metadata": {}, "outputs": [ { @@ -200,7 +210,7 @@ " 'demods/0/sample.y'}}}" ] }, - "execution_count": 14, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -211,8 +221,8 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "007c1f6e", + "execution_count": 16, + "id": "ba83fdae", "metadata": {}, "outputs": [], "source": [ @@ -221,8 +231,8 @@ }, { "cell_type": "code", - "execution_count": 16, - "id": "2f8bf03d", + "execution_count": 17, + "id": "2ee09290", "metadata": {}, "outputs": [ { @@ -238,7 +248,7 @@ " 'demods/0/sample.Y'}}}}" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -250,14 +260,14 @@ { "cell_type": "code", "execution_count": null, - "id": "6f1780ae", + "id": "55ae8542", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "bb5dcf8a", + "id": "1bf4a681", "metadata": {}, "source": [ "## Defining a simple qupulse pulse with a measurement window." @@ -265,8 +275,8 @@ }, { "cell_type": "code", - "execution_count": 17, - "id": "8e89c64d", + "execution_count": 18, + "id": "5d6744c8", "metadata": {}, "outputs": [], "source": [ @@ -275,8 +285,8 @@ }, { "cell_type": "code", - "execution_count": 18, - "id": "40d73c34", + "execution_count": 19, + "id": "8fd2dbdd", "metadata": {}, "outputs": [], "source": [ @@ -292,8 +302,8 @@ }, { "cell_type": "code", - "execution_count": 19, - "id": "6e627b13", + "execution_count": 20, + "id": "d43c43a9", "metadata": {}, "outputs": [], "source": [ @@ -310,8 +320,8 @@ }, { "cell_type": "code", - "execution_count": 20, - "id": "d3dede54", + "execution_count": 21, + "id": "bac63dff", "metadata": {}, "outputs": [], "source": [ @@ -322,8 +332,8 @@ }, { "cell_type": "code", - "execution_count": 21, - "id": "f7fc2faa", + "execution_count": 22, + "id": "db319070", "metadata": {}, "outputs": [ { @@ -341,15 +351,15 @@ }, { "cell_type": "code", - "execution_count": 22, - "id": "f6523430", + "execution_count": 23, + "id": "42750aa0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'R', 'T', 'A'}\n", + "{'A', 'T', 'R'}\n", "[]\n", "set()\n" ] @@ -363,8 +373,8 @@ }, { "cell_type": "code", - "execution_count": 23, - "id": "5955fdff", + "execution_count": 24, + "id": "e20696d6", "metadata": {}, "outputs": [ { @@ -373,7 +383,7 @@ "" ] }, - "execution_count": 23, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -384,13 +394,13 @@ }, { "cell_type": "code", - "execution_count": 24, - "id": "5142a4ab", + "execution_count": 25, + "id": "1a62c45a", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEGCAYAAABvtY4XAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA8P0lEQVR4nO3dd3hUVfrA8e87kwahhJDQxaB06QSQIjawV8C1rgu2dVf9WdZdy65lXevad3Xt2BWxoqtrR0CKdOkllNA7AdKTmfP7405CgExLZuZOeT/Pk2du5t4592VgXu6ce857xBiDUkqp+OOwOwCllFLhoQleKaXilCZ4pZSKU5rglVIqTmmCV0qpOJVkdwA1ZWVlmZycHLvDiApFRcW4XG5bY3A6HaSnN7Q1hmAVFxXjtul9czgdNIyx96tKSXGRbe9bXZSWluJ2h2kEoDhITUsLebNlJaWYMMS8ccuGXcaY7Nr2RVWCz8nJYe7cuXaHERW++XoqLVp0tjWGHTtWcfoZw22NIVg/fzOdrq262HLuFdtWMuz0obacu77mTPmRvh2PtjuMgM2csYDMzPZhaXvx+o106Rv6v8dFM+fQMSv0n+lhl3TN97ZPu2iUUipOaYJXSqk4pQleKaXiVFT1wSulLBUVFWzatInS0tKInC+5STNW7SmKyLlCoVGHDriczrC03bFJDg7nrpC3231AG5IdZXV6rQHcZULp1iRwBX5drgleqSi0adMmGjduTE5ODiIS9vMVHdhPw9SUsJ8nVAoLi0lKSg1L2yVl5aQ1bBTydouLikhLqtvoHGMMBQf2soPdlG4K/O9Ju2iUikKlpaU0b948IsldRT8RIaNxMxypwQ2z1ASvVJTS5K5qEhGC/RehCV4ppeKUJnilVMDGXXMtH33yiS3nXr8+n559+4esvev+8Hs+/ezTkLUXjTTBK6XihsvlsjuEqKIJXilVq7feeZfe/QfQJ3cgV467qvr5qdN+ZuiJJ3Fsl27VV/OFhYWMOP1M+g8aTK9+uUz6/AvAuuru3qsP1/7hj/To04/TzzqHkpISAE4eeRp33P1XBg0dRpfjejLt558BK0n/+c67GDhkKL37D+ClV171GefUaVM545wzGXv1OAYMHojL5eLuv/2VYScNZ+CQQbw6/jXAGoly6+230W9gfy68aDQ7du4M+XsWbXSYpFJR7u9fLGXZlv0hbbN7mybcd+5xXvcvXbaMhx99jJ9/+pGsrCz27NlTvW/btm1Mm/wjK1au5PxRYxgzahRpaWl88uEHNGnShF27djH4hBM579xzAFidl8d7b7/JKy/8h4svu5yPP/2MKy67FIDKykp+mf4zX/3vax548GG++/orXnv9DZo2bcrsGdMpKytj2EmncNqIET5vOs+dN4+5M2eTk5PDa6+Pp0nTJvz801TKyso45bQRjDjlVBYu+pXVq1czZ+Zstu/YQf9Bufzuit+G6B2NTprglVJH+HHyT4wedSFZWVkAZGZmVu87/7xzcTgcdO/Wje07dgDW1fHd99zLtJ+n43A42LxlC9u3bwegQ04OfXr3BqBfv76szz9YG2vUBecD0L/G8999/z2LFi/h40+s/vF9+/axOi+Pzp06eY03t39/qirR/vDjDyxZupRPJ30GwP59+8lbs4bpM6Zz0ZiLcDqdtGndmhNPiK1CenUR9gQvIk5gLrDZGHNOuM+nVLzxdaUdLsYYr1fMqamphxwH8O77E9i1axdzZ80gOTmZDp27UFpadsTxToeTksrSI9pyOp1Uuiqr2/zX009x+mkjDznv+vVeiybSsGH6ITE9+c8nGDlixCHHfPPdNwk39DQSffA3A8sjcB6lVIicesrJfPjRx+zevRvgkC6a2uzbt4/s7GySk5OZ/NMU8vM31Pncp40cyYsvv0xFRQUAq1atpqgo8DIKI04dwSvjX61+/eo86/VDhwzlo48/wuVysXXbNqZOm1bnGGNFWK/gRaQdcDbwEHBbOM/lzeYC64ZO24wGdpxeqZh0XPfu3H3nHZw04jScTid9+/Tm9Vdf8Xr85ZdewnmjRjNg8FB69+5F1y51r8l/zVXjWJ+fT/9BgzHGkJ2dxacfTgz49eN+N5b8DRsYMnwoxhiysrL44N0JnH/ueUyZOoUBgwfSsWMnhg0bVucYY4VUfcUKS+MiHwGPAI2B22vrohGR64DrANq3b98/P9/717C66HHfNxSWVbLm4bNwOmLn65ku+FE38bLgx/Lly+nWrVtI2gqE1qI5KBpr0VTJW7uKojWH/rmHXdJ1njEmt7bjw9ZFIyLnADuMMfN8HWeMedkYk2uMyc3OrnXVqXopLLP69Z7+blXI21ZKqWgWzj74ocB5IrIemACcIiLvhPF8tWraIBmA5ybnRfrUSillq7AleGPMXcaYdsaYHOAS4EdjzBXhOp83zRomV2/PWe/7RpFSSsWThJjJmplu9S2OHT/b5kiUUipyIpLgjTE/2TkG/oRO1mSNonIXe4rK7QpDKaUiKiGu4AF+P/wYAG6esMDmSJRSKjISJsH/+XRr6Ny01bsI59BQpeJZPJULTgQJk+CTnA66tmoMwBsz1tsbjFIq4hKxlHDCJHiA18YOAODvXyyzORKlol+slAt2u93cfNst9B+Uy6jfjOGCMaOqF/Lo2rM7Dz/2CKeePpJPPv2E73/4gZNGnMLgE4Zy+ZVXUFhYCMD8BQs47azTGTJ8GGN+M5qt27YCcMYZI/jbPXcx/MQh9O7TnenTfw7hOxx+CVVNsma5guVb99OtdRMbo1EqQP+7E7YtDm2brXrCmY963R1L5YInfT6J/A0bmDNzNjt27qTfgP6HlAFOS03jh2++Y9fuXVx6xWV8OekL0tPTefLpp/jX8//mz7fdzp/+cjsT359AdlY2730wgb///V5efOEVT4wupk6Zwdff/I+HH3mQL//7db3f/khJqAQP8O9L+3LT+wsY+/psfrl7hP8XKJWAYqlc8IxZMxl1wYU4HA5atWzJ8BNOOGT/mFGjAZg9Zw4rVqzglNOtz31FeTkDBwxi1epVLFu+jHMuOA+w/tNp3bptjT/vBQD07dOPDRtCW0ol3BIuwZ/buw03vb+A7fvLKK1wkZbstDskpXzzcaUdLrFULtjfoImG6Q2rjzvl5FN4c/wbh+xfsnQJ3bp246fvfwSOrEVzSIyVlT7PFW0Sqg++yuh+7QC4+5MQf+1VKk7EUrngIccP5rPPJ+F2u9m+Y3t1X/7hBg4YwMxfZrFmzRoAiouLWZ23ms6dOrNr1y5+mf0LABUVFSxbtrTO8UeThLuCB3jwgh58PH8TnyzYzFMX97E7HKWiTiyVC77g/AuYPOUnco8fQMeOncjNzaVJk6ZHHJedlc3L/3mR3109jvJy69vFvX+7l04dO/HuW+9w+x23s3//fsorKrjpxlvo3j3yC62EWljLBQcrNzfXzJ07N6RtnvT4ZHoflcGzl/Q95Pmhj/7I5oISnvpNb0Z5ruijiZYLrhstF1w3sV4uuLCwkEaNGrF7z26Gn3wSP3z7Pa1atqxT21ouOA6M9wyZvG3irzZHopSqr9EXj2HQsMGMPOM07vzLHXVO7vEmIbtoALp4Jj0BbNxTzFGZDW2MRilVH998GTtDFyMpYa/gweqLBxj3xhybI1FKqdBL6AR/+aD2AOTtKKTS5bY5GqWUCq2ETvAiwsldrGUCH/5qhc3RKKVUaCV0ggd4xjO6Zvz0dTZHopRSoZXwCb5pg2TSU6zZrFNX7bQ5GqWUCp2ET/AAb141EICxr+uSfkr5Eo314PPz8/nAx0SoLVu3ctlvLw9naCH1+FP/DFlbmuCB3ByrkJLbwI79pX6OVkpFk/wN3hN8ZWUlbVq35r233w1rDKGsUfPkM6FL8Ak7Dv5wt47ozNPfr+KP787noz8MsTscpao9NvsxVuwJ7SCArplduWPgHT6Peeudd3ny6WcQEXr17MFbr48HrHrwTz/7L7Zt285jjzzEmFGjKCws5ILRF7G3oICKigr+cf99nH/euaxfn89Z553P0KFDmDlzFm3btOGzjz+kQYMGnDzyNAYOGMBPU6ZQULCPV196gROGDcPlcnHnX//GlKlTKSsr54/X/57fX3uN1zjvuf8+Vq5ayaBhg7ni0svJyMjg62++prSsjOKiIl58/gVGXzyGubPmUFxczHV/+D2rVq+iS+cu5G/YwNNPPEX/fv144603eeqZp2nZsiWdOnchNSWVp556lp07d3LzzTewcdNGAP752JMMHjyEhx56gK1bt5K/IZ/mzZvzxutvHxFbaWkpN99yI/Pnz8PhcPDYg48z/IQTeee9t1mwcB5P/vMZAMZcOoqbb7iF7374lpKSEoacOIhuXbvx2ktv1O0v2EMTvMdNp3Tk6e9XMTd/Ly63wemovZKeUokglurB/+P+v/PMv//FJxM/AuDtd9/hlzmzmT19FpmZmeTXKE/88quvkJGRwewZv7B02VKOH2ZdzG3ZupVHH3+MGVN+JikllVFjRtGzZy8A/vyX27jxxpsZMmQoGzdu4Pzzz2b+fKtQ4YKF8/n+u59o0KABtXnp5RcAmDN7Ab8uXMBvLh7Ngtneixw+cN+DvPzai8yY8ov/v6QAaIL3cDiEvu0zWLChgBenrOGGkzvaHZJSAH6vtMMhlurB1+aUk085JOYqM2bN5Ibr/wDAcd2Po8dx1mTHufPmcsLQYWRmZlJSVs6FF44mL281AJMn/8iKFcur29h/4AAHDhwA4OyzzvGa3AFmzpjO9dffAECnTp056qj25K1ZHfCfo740wdfwypW55D74PY9/s1ITvEposVQPvjbpDWsvPeKtuKKvoovG7Wbyj9NqTeQN09N9xmGovd2kpCTc7oP7ykrDc+9Pb7LWkNXo4D/EhRsL7AtEKZvFUj34Ro0aU1h4IKC2hxw/mI8/tUYBLV+xnKWeuu+5/XOZNv1n9u7dS2VlJZMmfVr9mlNOHcGLL/2n+vdfFy0M+M8ydOgJfDDxfQDWrMlj06aNdOrYmfbt27Noya+43W42bd7IvPkHq+gmJyVX/9nrSxP8YV690qq6+bvxOmRSJa6a9eD75A7kT3/x3U10+aWXMG/+fAYMHsq7EybUux58t27d6D9oMD379uf6G2/0OUqlZ48eJDmTGDT0eP79/HM+277ummvZtWsXA4cM4qlnnqbHcT1o2rQJbdu04c+33c6Jp57MqDEX0rVrN5o0sdZsfuLxp1kwfx4DB/Wjf/9evOajLv4R57v2elwuFwMG9uWa667ixedeITU1lcGDhpBzdA6DhuXy13vvonfvPtWvGXvlVRx/wgCu/v3YgM/jTcLWg/cl584vAVh8/2k0TksOaTyB0nrwdaP14Osm1uvBB8rlclFRUUFaWhpr167lrPPPYdG8haSkpFTXlD9QVMzYq8dy5W/Hcp5nPdZQ0HrwUeJ3g48G4PYPtVa8UvGkuLiYU08fyaChx3PJFZfy7FPPkJJi/cf20CMPM2jYYIYOH0rO0R0499zzbY62/vQmay3+enZ33pyZzzdLt/u82aSUii2NGzdm+pRpte575KGHgbqt6PTd999yzz13H/JcztE5TJjwUd0CDRFN8LVISXLQsUUj8nYU8u4vG7ji+KPtDkkpFcVGjjiNkSNOszuMI2gXjReveG62/u2zJTZHopRSdaMJ3osOWQfHt+btCGwIllJKRRNN8D48fbE1+27s67qkn1Iq9mgfvA8X9GnLrR/8yqa9JZRXuklJ0v8PlT1mzZrHvgLvk32C1TQjneOPP7L07uE+nTSJ0b+5hGW/LqRrV3uGn6q60wTvg4hwds/WfLl4K/dOWsKjo3vZHZJKUPsKikI6L2LHjlUBHTfhg4kMGzqECR9+yP33/C1k51eRoZekfjw2xkrqE+ZstDkSpSKrsLCQ6TNn8uqLL/LBxA/tDkfVgSZ4PxqlJpHVyJoI8b/FW22ORqnI+ezzLzj9tNPo3LkTmZnNmL9ggd0hqSBpgg9A1ZJ+f3h3vs2RKBU5Ez6YyCUXXQTAxRddxPsfeF8WT0WnsPXBi0gaMBVI9ZznI2PMfeE6Xzgd16Zp9faWghLaZHiv/6xUPNi9ezc//vQTS5YtRURwuVyICP985GGd2R1DwnkFXwacYozpDfQBzhCR48N4vrD661lW4adr3wptMTSlotFHn3zKby+/nPWrV7Fu1Uo2rMmjQ04OP0+fbndoKghhu4I3VpnKQs+vyZ6f6CldGaRrTujAQ18tZ+mW/VS43CQ7tXdLRU7TjPSAR74E2p4vEyZO5I7bbz/kuVEXXMB7EyZywrBhIYtDhVdYh0mKiBOYB3QEnjfGHLHQoIhcB1wH0L59+3CGUy8iwpBjmzNjzW6e/m4Vfzmjq90hqQQSyJj1UJr83bdHPPd/N94Q0RhU/YX1MtQY4zLG9AHaAQNFpEctx7xsjMk1xuRmZ2eHM5x6e+EK60P2n5/W2ByJUkr5F5F+BmNMAfATcEYkzhcuTRskk+Lpmpm1drfN0SillG9hS/Aiki0iGZ7tBsAIYEW4zhcp48cOAGDs67qkn1IquoWzD7418KanH94BTDTG/DeM54uIYZ2yACitcLO3qJxm6bGzzJlSKrGE7QreGLPIGNPXGNPLGNPDGPNAuM4VadefeCwA/zdBZ/YppaKXjvWrg9tPs4o+TVu9i2hatFwppWrSapJ1kOR00KNtE5Zs3s+r09Zx7fBj7A5Jxbn5v8ynuKAkZO01zGhAv0H9fB6T1CCdnj16UFlZSYecHN56/TUyMjJCFoMKP03wdfTSb3MZ+uiPPPTVck3wKuyKC0ro2ip09dhXbFvp95gGDRqwYI41dWXs1dfw/Isv8dc77whZDCr8tIumjtrWqEezZPM+GyNRKvyOHzSIzZu32B2GCpIm+Hp48QrrK+64N3RJPxW/XC4XP06ezHnnnG13KCpImuDr4YwerQHYeaCM0gqXzdEoFVolJSX0HTCIrNZt2bNnLyNHnGp3SCpImuDraUz/dgDc8fEimyNRKrSq+uDXr15JeUU5z7/wot0hqSBpgq+nf5xvldeZtHCLDplUcalp06Y8+9STPPnMM1RUVNgdjgqC31E0IpILnAC0AUqAJcD3xpg9YY4tJjRIcdI2owGbC0r4eP7m6it6pUKpYUaDgEa+BNNeMPr26UPvnr2YMPFDfnv5ZSGLQ4WX1wQvImOB/wPWYZX8XQmkAcOAO0RkCXCPMWZDBOKMam+MG8DIp6dy+4e/aoJXYeFvzHo4HNiz65DfP//044jHoOrH1xV8OjDUGFPr7AoR6QN0AhI+wXdq2bh6e8PuYto3b2hjNEopZfHaB2+Med5bcvfsX2iM+SE8YcWehy60+uLHvqFVJpVS0aFON1lF5JxQBxLrLhtorUa1dmcR5ZVum6NRSqm6j6IZENIo4oCIcGrXFgA8/NVym6NRSqk6JnhjzH2hDiQePHtpXwDemLHe3kCUUorAhkleWdvzxpi3Qh9ObGuUmkTj1CQOlFUyZdVOTuwc3WvMKqXiWyDVJGt2x6QBpwLzAU3wtXjjqgGMfmEm416fzdpHtHaHCo1F8+ZQVnggZO2lNmpMr/7ee1p3797NiDPOAmDb9u04nQ6ys6wLll+mTyMlRVcyiwV+E7wx5qaav4tIU+DtsEUU4/ofnQmA28CO/aW0aJJmc0QqHpQVHqBvx6ND1t6CvHyf+5s3b15dKvj+fzxIo/R0br/t1pCdX0VGXfrgi7HGvysvbh1hrfj0h3fn2xyJUiqRBdIH/wVQVWTFAXQHJoYzqFh30ykdefr7VczL34vbbXA4xO6QlFIJKJA++CdqbFcC+caYTWGKJy44HELu0c2Ym7+X5yfncdOp+oVHKRV5frtojDFTavxM1+QemBeu6A/Ak9+tsjkSpVSiqutM1pdDHUi8yW6cWr09L18LbyqlIq+ui26/FNIo4tTr4wYw7vU5jH19DovvP93ucFQMS23U2O/Il2DbU/GvTgneGDMv1IHEo5O7WKULDpRWUlRWSXpqXf8/VYnO15j1cLv/nr/Zdm5VP367aEQkW0SeEJGvROTHqp9IBBcPfjfYGrt86wcL7Q1EKZVwAumDfxdYDnQA/g6sB+aEMaa4cvfZ3QD4dtl2XdJPKRVRgST45saY14AKz0iaq4DjwxxX3EhNctKxRSMA3pkVuj5UFf/0gkDVZIwh2H8RgST4qlV2t4rI2SLSF9B16YLw6pW5ANwzaanNkahYkZaWxu7duzXJK8BK7gUH9uIuC27SZCB3/R701J/5E/BvoAmgRSmCkJOVXr29evuBQ5b4U6o27dq1Y9OmTezcuTMi5ysrLSUlyRmRc4VCWVkFTmd44i2vdJGckur/wGDbLSsj2ZFcp9cawF0mlG4NbqBGIMXG/uvZ3AecHHxoCuDZS/pw84SF/G78bGbcdard4agol5ycTIcOHSJ2vjlTfqRHCIuZhdvMGQvIzGwflrbz1m+kS9+hIW932Zw5dMzqHPJ2ffHaRSMifxORTB/7T9Gl+wJ3Xu82AGzZV0pphcvmaJRSicBXH/xi4AsR+UFEHheRv4jIvSLytogsBs4FfolMmLFPRDjXk+TvnbTE5miUUonAa4I3xkwyxgwFrgeWAk5gP/AOMNAYc6sxJjIdhHHisdE9AZg4V8v5KKXCL5A++NXA6gjEEvcapiSR1SiVXYVlfL1kK2f0aG13SEqpOFanYmOq7t68yppyfv07uhiIUiq8wpbgReQoEZksIstFZKmI3Byuc8WS49o0rd7etLfYxkiUUvEunFfwlcCfjDHdsGa+3iAi3cN4vpjxN0/5gmvf0pptSqnwCWTJvs7AC0BLY0wPEekFnGeMedDX64wxW4Gtnu0DIrIcaAssq3/Yse3qYR148MvlLN+6nwqXm2RnbPeUzV2/h/HT1xGOSZfpqUncd253GqfVbYKIUokskGlRrwB/xlMD3hizSETeA3wm+JpEJAfoSy3DKkXkOuA6gPbtwzNxIdqICCd0ymLa6l088e1K7jqzm90h1csXv27h6yXbqmvuhEpRmYvNBSWM6d+O449pHtK2lUoEgST4hsaY2SKH1ECoDPQEItII+Bi4xRiz//D9xpiXgZcBcnNzE6bwxnOX9aP337/lpSlrYz7BAzRpkMy3t54Y0jZnrNnFZa/oVAul6iqQvoFdInIsVjkERGQMnq4Xf0QkGSu5v2uM+aTOUcahpg2SSUu23v4Za3bZHI1SNbgqSHqlH0mv9ENWfmZ3NKoeAknwN2B1z3QVkc3ALcAf/L1IrEv+14Dlxpin6hNkvBo/1hoyOXa8ltdX0UMWvVW97Zz6gI2RqPoKZKLTWmCEiKQDDmPMgQDbHgr8FlgsIgs9z91tjPmqTpHGoSHHZgFQ7nJTUFxORsMUmyNSChx5Xx76RHkRpKTXfrCKaoEs2XebiNwG/B641vP71SLSx9frjDE/G2PEGNPLGNPH86PJ/TB/POlYAG56f4HNkShlkYL1ALhyb7B+X/udjdGo+gikiyYXqx5NW8/PdcBJwCsi8pfwhZYYbhtplQ+dtnqXLu6g7FdaAIC77fGYY0YCIJtn2RiQqo+AluwD+hlj/mSM+RNWws8GhgNjwxhbQkhyOujZ1prd+tLUtTZHoxKdbP8VANNmADRuaz23d42dIal6CCTBtwfKa/xeARxtjCkBysISVYJ58bf9AXj0fytsjkQlvP1WpVPTqi84nJiURlC0w+agVF0FkuDfA2aJyH0ich8wHXjfc9M14WelhkLbjAbV24s37bMxEpXoZLNn3kGzYwAw7YYg5QegosTGqFRd+U3wxph/YPW7F2At23e9MeYBY0yRMebyMMeXMKoW5v7d67NtjkQlMilYZ22kNrEe01taj0Xb7AlI1UtAK7gaY+aKyAYgDUBE2htjNoQ1sgQzorv1QdpTVE5JuS7pp+xjnAcXnDaZ1igv2bUSkxG5NWJVaAQyTPI8EVkNrAOmeB7/F+7AEtFvctsBcPtHv9ociUpI7krkwGZMzknVT5nsHgDIzqU2BaXqI5A++H9glftdZYzpAIzA6odXIfbA+daH6ctFW3XIpIq88kLrUZwHn2vSzrPhjng4qv4CSfAVxpjdgENEHMaYyUCf8IaVmNKSnbRrZt1wnbU94HpuSoXG/o0AmKwaxe+cKRhJQtb9YFNQqj4CSfAFnoqQU4F3ReRZgqgmqYLz5lUDAXhjRanNkahEIyV7rQ3P+PdqqY0hqWHkA1L1FkiCPx8oBm4FvgbWAOeEM6hEdmz2wZrqWw5okleRIzs8k5zSWxy6o2l7ZN96wrKiiwqrQBL8vcYYtzGm0hjzpjHmX8Ad4Q4skT10odUX/+C0PJsjUYnFs+ZDZsdDnjWeMfGeiuEqhgSS4EfW8tyZoQ5EHXTZQGtlq62FZZS79OaW8mH9dLi/KfzzGNi/pV5NyRZP2WrnYVVNUxpbj1qyIOZ4TfAi8gcRWQx0EZFFNX7WAYsiF2LiERH6ZFlTFF5fuMnmaFRUe+Ms67F4Nzw/qF5N1Rz/fsjzLftYG1WjbFTM8HUF/x5wLvC557Hqp78x5ooIxJbQruqWBsDXa3baHImKWlsOKzFdth9cdR//ILtXHkzmNXlqwVdf4auY4SvBO4H9WCs6Hajxg4hkhj+0xJbqFNKTrfHI87ZqfRpVi+nPWo+/eRt6jLa2V3xR5+ak/ACUHLl8pMnqam14ucJX0ctXgp8HzPX8zDvsZ274Q1P3DLdudunNVlWrpZ9aj13PgeGepRmWfFzn5gyCyTn5yB2OZOshf0qd21b28FqLxjNrVdmoS/ODQyb3lFSQ2SDZxmhUVCkvth7TW4DDAVnWwjFsrFuxuuSyPQgG466liyfJ6i40DfSLe6wJZBRNVT2aJzw/OgY+gi7r0QaAx2fqCAZVwzrP1XSv31iPDgc0yITC7XVqLqnc6gY0TY+udb/J6IDk/1SntpV9Aik29ihwM1bt92XAzSLySLgDU5bR3VoBsGJXEW6daKKqLPf0tfetMd7hmBOtxwPBJ/mU8j3WRsNsL0cYSMsIul1lr0Cu4M8CRhpjxhtjxgNnAGeHNyxVxSFCd8/s1olLt9ocjYoaGzzrpLaoUTcmZ5j1uHle0M2lllj13o2XJG5a9UVK9oBbS1nHkoC6aICMGttNwxCH8uHPg62ZhB8s0wSvPPasgQbNDn2uVS/rcWvw5aaNeFKBly4aqvrmi+rWBaTsEUiCfwRYICJviMibWKNoHg5vWKqmjLRkHJ5Z5Mt2HrA3GGW/Qs/ciKMOm9hUdaO1MPjVlzJ2z7c2RGrdb1r1szZcugxzLPE1k/U5ERlijHkfqx78J56fwcaYCZEKUFnuOaEToEMmFbB+qvVY1SVTpUEGJKfDqm+CbrIyyZrMRFqz2g/w1IiXnboMcyzxtWTfauBJEWkNfAC8b4xZGJGo1BH6tLLWyCypdFNS4aJBstPPK1TcWusZQdNh+JH7klKhojjoJtNKtmEatfG637SwCuAhgfbqqmjg9W/LGPOsMWYwcCKwB3hdRJaLyL0i0jliEapqZ3eyyrg+OWudzZEoW21daD1mdztyX7McKN0Hroqgmkwt2Qole7wf4JnsJBt1MbdY4ve/Y2NMvjHmMWNMX+Ay4EJgedgjU0f4XS9rIYZ5W/fpkn6JbLdnTkRSypH7Oo6wHsuLgmrS5WyAaeejWFljz9V9apOg2lX2CmQcfLKInCsi72Ittr0KGB32yNQRkp0O2jWxZhX+L0+LkCWkihKrqmOHE2vfn2wt+ci2xYG3aQxppdsh2ceqTSKY5IbIxhmBt6ts5+sm60gRGQ9sAq4DvgKONcZcbIz5LELxqcP8dZhVn+aVBRttjkTZYofnJmfb/rXvbzfAety5IvA2i3dbj5V+VhCrLK+uLFkXjjnP4Zj5OI6ZT9S5DRUcXzdZ78YqGXy7McZH55yKpFaNDlb027ivhKOaNrAxGhVxa3+yHr0l+ExPCanS4CuQmjYDfe9vdzyOjT8H3S6A8/NxyPaD4/MdS96j8tr5dWpLBc7XTdaTjTGvaHKPPrcOsj7Ef5+62uZIVMRt8hRyPXyIZJV0T6mB9dMCb7Mg37Ph+76OVN2Era0gmS8le6qTe+XFk6qfdsz+d3DtqKDpmKcYNPxoq6rf7pIKyip1Sb+EssMzvqFBRu37q5bbSwrim11V7RqvdWgs7qNPCrzNGhw/3Gm9vucV0OQoKn/zmfX8r68HPdpHBUcTfIwa3t5K8i/N32BzJCqi9q6D5h297xeBVj1h9bdBN20aex8HDyCVJZ4Y1gbVrmOr9a3DPegW64mm7THZ1rh65+fjgmpLBUcTfIy6YYBVM2Ty+t02R6IipupKu00/38dVlEBqI9/H1FRVelh8T54zLXpaG8GszeqZ+WqadTxkkpTr3NesU+5aBuVafiNcNMHHqBSng2Zp1uSTmZv22hyNioh1nhIFbf0k+GNOCm6yU9XQykwf3wxqHCe7Ai9X4Fj2AQDu3D8eusOZjPvYM63NSWMDbk8FRxN8DKta0u+fM4L7yqxiVNUIGm83WKtUTYIrCLD7rnS/9einDIFpdqy1EcRNVln9lfXao48sq+A++R/WMQXr6jTqR/kXtgQvIuNFZIeILAnXORJdh4yDE1N2FGmVv6hVsAE+HAf/GQKvnQ7vXgRvnhd8bfWNnhrw2V19H1dVZbI4wO679QEOffSMgQ+44JgxiHFhktJq/89DHLi7XwSA8/2zAmtTBSWcV/BvYC0OosJoXO92ADw6XZf0izqrv4OnjoNnesLST2DHUti2yLoBum4KPJAJRUHcQ9mdB44kcPpZmze1sfW4K8BhtOnZlKa19H+c0zMHwx1g18/2hQCYY72nAfcQa4SNVJbAtoWBtasC5muiU70YY6aKSE4wrykoK2BS3iT/BwahNG05W10NmZQXW6NNFpespMne9X6Pa5ZtSGqaz0YDU/ZsxOGlnndd7C/ZRmme//79/PJNuNMLmJRXErJzA+TtOEBS07XM2F7AdndgNw1Xlaxm/R7/xdichRtwlO6o8YzhkHHgR9T68bbPVD/uL9nP7m8mwqY5UPPvLrsd9BwDbfoCYl25f36jte+FnnDec+DwUx20vAgapUN2F/D3GSnbaR27bSbkBfC+FeZR0qQpKVt+9Huoo2UHKFmPO5Bj875CGqXjym4HPo6X/lfgWPkpTL4J14n3A37+DRduoWDPbBrsKcVZuR+3syHgxDgcGJw43KVUpjQHU4krqSmIE7fDicNdjtvhb/ioYU95IUVrfq7+3Z9ao62lVlS+wE7XFr/thZKEs2iVJ8H/1xjTw8cx12GVQiAtJ61/x/v93OhRSilVbcnYJfOMMbm17QvbFXygjDEvAy8D9OrXy3w16quQtn/py7Po1qYJ957TPaTthtvUqbPJat4hoGOLyl3c9p01Aeals73+Xxq0XbvXMXy47+nrAM98t4rvVmzny5tOCNm5AeZv2MvNExbyr0v70veojIBeM3fqPI7NPsbnMUk7Z9J4wZ1UNB9Acfc/1VjFqOa1mNT43Xo0IhxxvSYH96/bvYG+Q/pa3SiB1Gxxu+Dffa3t0eOhXa2fUcsXN8PayTD2S2h6lP+2nxsAXc6EkQ/4P/bZXuxsPZLME2/2e6jMehrJn4L74s/8HuuccA7GkYz7N5/6j8FVgfPDCw/+et6bkNII2bkUWfQ2svdgd5O7ZV9WJeXibD3M+41hY3C4y8BUIO5KxF2Bw12OOWIo6JHX32u376R9x+MONlXbNfoR35R9f+tos/xJKvbvYE3O8z6Pq4sL8FJ4jihI8DWlOFJo17hdSNt0upvTQDJC3m64NXeuJTuldUDHZqdAinsnZS43m/ekVy8OUl/GeSCg9y3dWYBUVob8Pd6Qloap2EB2WmvaNW4e0GvWJ+XTOtX3+9Zkw1ekVLoo6HIbjTP8DDkMQkGRk3bZx/k/sKbzXoJProEPfgf3+xhJsmYquFzQbnBg7bqBvJ9glJ+/E1clVLpwSDotGvjvh3cYJ46KMiolxfvqTwDlB0iqdOFu3Rd3AO0CcOn3JL19srX9yRWH7DKOZNwD/w/T41IQB/kzFpCZHGC7QUrZvZGmzQaEtM1WjsZUunayzxGemL3RYZJx4l7PkMmHftYl/fxJ2T4ZgMrM0CX3Out10cHt+W/VfoyrElzlkN4i8HabtIXGAVwg7FgKgMMENvTRZHu+CfupNy/bF1nHtwkiUaY1pfLa+bhOfhh3v+twDfg/XANuonL0RFxX/4LpebmuKBWkcA6TfB+YCXQRkU0icnW4zqWge7Y1cqLSbSgsD7IYVAKRUquOviuthdcFpiPuj79Yj5/fVPv+lV9ajz2CWIYhqxNsXwJuP7WKjLV/f0aA3zyqhkruXunzMNk002o+mARfFVLHM3D3vx7TZyymzzj/E7CUV2FL8MaYS40xrY0xycaYdsaY18J1LmUZ060VAI/pxCev0ta9D0BJ5+ttjqSGFjXGtc964cj9Mz39tr0vCbzNqitdl5/5EbuDG15rMjsH1K5sW2BttAiyy0qFlH7fiSOXHGcVi1qy4wBuXdKvVg1XWQm09OiL/BwZYTd5aqN/feehzxsDGz1X+K17B95e1Q3bCj9DVz2ToSpSA7vHUTXGXjbP9n3cHs9NUYefMfsqrDTBxxGnQ+jYzJrd+tmK7TZHE4XcFYi73NpO8rE8nR2aHwvJnpE3k244+Pzyz63HVj2D61KquoL3u3Sf1WZ5alZg7Ta21gUmKc37McYg7kqMdq3YThN8nLljqFUv5O3Fm22OJPqkbraG4JbkBNHVEUm3eJLxgncOVo6ceKX1eF6Qi2O09VzB+ys45qlvYwL9v0Mc1tqs6yd7P8ZTTti08bGIt4oITfBxJqthSvX2mj2+RzokmoZLrbVASzteZXMkXqQ3P3gj9cnO8Hing/va9A2uraoKkfl+6sykWN9kXEmNA2/bkexziKRs9txgbe1lWUEVMZrg49Bdnqv4+3VJv4OMG2eJNU3c1fhYm4PxYcz4g9tFnlIKN8wJvp2Wnglv/iZcVZRAs5ygun9MVjdkz6rqETiHk63WDVbTInST7lTdRNVEJxUaA9tmAFBY7qKkwkWDZD91ThJA8g5rjdLylt5n/UWN+/dZa68W74GjBnpfns+XqoS96lsY/mfvx636BhoGeIO1SgPP1bvbBc4jrxFlV9WygkG2q0JOr+Dj1GnHWDfN/j1nvb2BRImGy58BoLir/+n4UaFdLnQ+rW7JHQ5WnGzgY7YpWJOhmvhequ8IjTwTqPbWPqlOirZhUhpFzzyDBKYJPk5d09eqVzJzUwHhLCgXE4whea81s7IyM4ihhrGudW9YP833Mfs2QFbnoJo1LXoBIAdqqYxYWmAdo/3vUUETfJxKdjpomW7dcE30dVurumcqMnraHEmElez1PbW/eI/ncVdQzZpG1oQ69hx5BV9doqC1j8JpKmI0wcexe4ZbozD+PSff5kjs1ejX+wEo6n2/rXFEXOczfC+QXbX0Xucg1+Vpai34Ltt/PWKXbLYmZZmWvYJrU4WFJvg41rbxwckomw+U2hiJjYwbZ5H1H1xlZh97Y4m0Es9iLQUba9+/3zNXIti+cqf1zVBq+c9Dts6zNrK6BdemCgtN8HHu+v7tAXhoWmJWmUzN/wiIkdEzodZxpPVY6eU/932eBN8gM7h2RTCNWiM7j1xuWfassjYcOkAvGmiCj3NVo2m2FpZR7vJTWTAOVXXPFPa6195A7LR5fu3PG8+i382DLylgsjwF0iprFB3zzJo1wdbEV2GjCT7OiQhD2llD5cYv9PJVPV5VFiNuKwG5G+XYG4sdqoqTub2Uj877wXpM9rdOaS3SPTdaCw5WLpUtVgEy01ZLFEQLTfAJ4KaB1k2xb9YEN1oi1jVa9A8ASo4dZ3MkNqkuVzCj9v1pTa3HulzBt7JKJ9S80SprvwXAnXNy0O2p8NAEnwDSkpw0TrFms/6yucDeYCIoLX8iAEXdb7U5Eps09SzX5/TSH54/HcRZpwlJplUf4OCoGQDZ4Kl70zy4cfUqfPROSIK4Z3gn/vL9Ch6dvoa+Aa7ZWlZWzLtb/NT9BvK2H6hveD498tVymtYooubL3l2FNFq+gh4VC/grUCiNuGlaZLqmCsuLeNlfnfQIe86RQfGv3/KXnUfG9bddpXQ2Lq4cP5t9e8posjS49+ltwJ3/M+MmbUSMm7dK91IiaVz3xbYQRe9dQUEKyckFYWm7sCSZ9AOhreN0V2ERzSqFx/JqmRwWRprgE0SnzHROOjqTzQdKKSp3BfSaikrD/hI/5WaBFk3S6Nfez5T4OujcsjHDOmZRWFYZUBwAxZUGI5XcXvQAAP9IvZsDFZFZwrCk0uAMMM5Iaeg+wF5pWuv716xiB4uSe7O/pILiCgNlgf27qLJLMskyeyguLeW4Smtt15lJx7M/yHbqotglJEl4ZmiXuAUC/IwEymUMbgNFrvC/NzVpgk8gNw/qENTxO3as4vQzhoYpGv+yGqXyzjXB3bD7+ZvpdGvWgtSvrIU9/nzmxeEIrVYrtq1k2On2vV+1mnAmR6/4L5/dUEtc9+8ku3kWn90wlDlTfqRvx6ODatrx8ymw/CMm9lmKY9FbUAzDz7iS4a1yQhO7DzNnLCAzs2VY2l68fiNd+nb1f2AQjvmlEZW7d/BAp6NC2i7Ajz72aR+8ijtNZlr13oujad1Vu5Tusx7Li2vff0zd5we4+1jvs3PqA0jBeutJT9+8ig6a4FVcEXdFdWGx4u632RxNFOjkmex0+NqsVZOcklLr3nZVTRoPd8ez696WCgvtolFxpXOetWpTefYQa4RIwvOMkNm2CI6tMXyx0HMjNKN9vVqvvPRLHIvfw6Q2wfS9pl5tqdDTBK/ih9tF9m6rcuT+wa/aHEyUaDfAety7/tDnt1s3RWnSrn7tN2qNe/Cf6teGChvtolHx44PfAlDRrBc469H1EE+atrUeDxw2dLGqTz6rEyp+aYJX8aG8CFZ+CcC+Ye/YHEwUaeJJ8BtnHfp81WLc/lZ8UjFNE7yKD89ZXRF7m/aBJD8LTSeSqgU/Dr8f4Sn5qwk+vmmCV7Fv+9Lq2uZLuz1oczBRRsQqOrbmh0OfX/ElNOug66bGOU3wKva9MMR6PO0h30vUJSpnLWUe6jM8UsUM/TSo2PbGOQe3h9xoXxzRrKpaZMEG67F0vzUBqlWCrVGbgDTBq9i14itYbw2L5I71toYS1Y7xjH/f5lmB6cBW67FlD3viURGjCV7FpoINMOFSa/usJ/RmoS9Vk5l2eMa+71jmeT70dVFUdNEEr2LPge3wjKd74ahBMPBae+OJdi08C2BvtUo4sGay9Vg1CUrFLU3wKras/h6e9CwokZwOV39rbzyxoEEGOJJh7RTr901zrMc6rOSkYouWKlCxobwY/nkMVHqKZjVuA39abm9MsSTjKNiz1loYu6qLRodIxr3oSvAFG+Dzmw59ztRW1L+W52qt/W+4o2wrmVtT4LPmPtrz1mag5w7wuCCO7bV1B2kbGgfQZqDx1E58vL5NWSEUvOT9xZF6L/O+B1NjoYST7oKT7vQelzpS21wrwa/zXMVr90xCiK4EX7YfVn9Xy45arjRqvfo48rm+rjJSihywLsXncd6frvu5vV8h+T+2SVEJzrLalqk78rWmvuf28n44XeWwZ7+fNiPwXrbqCcV7IHcsDL0VHNqzGLS+V8DiifDOaOv3zmfYG4+KiOhK8C17wJ/mhrTJSx6fTO+jMnj2kr4hbTfcfv56Ki1a2Lt4sbWi03BbY1Ah0uGwv8fcq+yJQ0VUWC+FROQMEVkpInkiot+plbKLCJx6n1We4Pg/QsNMuyNSERC2K3gRcQLPAyOBTcAcEfncGLPM22tcbkNBcXlI43AF0R+tVFw74TbrR9lCjJsk176InjOcXTQDgTxjzFoAEZkAnA94TfDLtu6nzwO19cHXM5Cc5iFvUymlAmUcyWS6NjJo1ciInjecCb4tsLHG75uAQYcfJCLXAdcBZLXtwH3ndg95IKd0bRHyNpVSKlBbut7Cyv0tyW4Ujlx0n9c94UzwtQ2POKK/xBjzMvAyQG5urhk3tEMYQ1JKqcgra3wsKxqeTmVmOAZOeE/w4bzJugmoWeyiHbAljOdTSilVQzgT/Bygk4h0EJEU4BLg8zCeTymlVA1h66IxxlSKyI3AN4ATGG+MWRqu8ymllDpUWCc6GWO+Ar4K5zmUUkrVTud8K6VUnNIEr5RScUoTvFJKxSlN8EopFac0wSulVJzSBK+UUnFKE7xSSsUpTfBKKRWnNMErpVSc0gSvlFJxShO8UkrFKU3wSikVp8RE0ZqlInIAWGl3HEHIAnbZHUSQYi3mWIsXNOZIiLV4IXwxH22Mya5tR1irSdbBSmNMrt1BBEpE5sZSvBB7McdavKAxR0KsxQv2xKxdNEopFac0wSulVJyKtgT/st0BBCnW4oXYiznW4gWNORJiLV6wIeaousmqlFIqdKLtCl4ppVSIaIJXSqk4FfEELyJniMhKEckTkTtr2S8i8i/P/kUi0i/SMdYSk7+YL/fEukhEZohIbzvirBGPz3hrHDdARFwiMiaS8XmJxW/MInKSiCwUkaUiMiXSMdYSj79/F01F5AsR+dUT8zg74qwRz3gR2SEiS7zsj8bPnr+Yo+2z5zPeGsdF5rNnjInYD+AE1gDHACnAr0D3w445C/gfIMDxwC+RjLGOMQ8Bmnm2z7Qz5kDirXHcj8BXwJgYeI8zgGVAe8/vLWIg5ruBxzzb2cAeIMXGmIcD/YAlXvZH1WcvwJij5rMXSLw1/u1E5LMX6Sv4gUCeMWatMaYcmACcf9gx5wNvGcssIENEWkc4zpr8xmyMmWGM2ev5dRbQLsIx1hTIewxwE/AxsCOSwXkRSMyXAZ8YYzYAGGPsjjuQmA3QWEQEaISV4CsjG2aNYIyZ6onBm2j77PmNOco+e4G8xxDBz16kE3xbYGON3zd5ngv2mEgKNp6rsa6C7OI3XhFpC1wIvBjBuHwJ5D3uDDQTkZ9EZJ6IXBmx6GoXSMzPAd2ALcBi4GZjjDsy4dVJtH32gmX3Z8+vSH/2Il2qQGp57vBxmoEcE0kBxyMiJ2P9IxsW1oh8CyTeZ4A7jDEu6+LSdoHEnAT0B04FGgAzRWSWMWZVuIPzIpCYTwcWAqcAxwLficg0Y8z+MMdWV9H22QtYlHz2AvEMEfzsRTrBbwKOqvF7O6yrm2CPiaSA4hGRXsCrwJnGmN0Riq02gcSbC0zw/APLAs4SkUpjzGcRifBIgf672GWMKQKKRGQq0BuwK8EHEvM44FFjdbzmicg6oCswOzIhBi3aPnsBiaLPXiAi+9mL8A2IJGAt0IGDN6aOO+yYszn0Rs/sSMZYx5jbA3nAEDtjDTTew45/A/tvsgbyHncDfvAc2xBYAvSI8phfAO73bLcENgNZNr/XOXi/YRlVn70AY46az14g8R52XNg/exG9gjfGVIrIjcA3WHeSxxtjlorI9Z79L2LdWT7L85dWjHUVZJsAY74XaA78x/M/c6WxqdJdgPFGlUBiNsYsF5GvgUWAG3jVGONzKJrdMQP/AN4QkcVYSfMOY4xtJW5F5H3gJCBLRDYB9wHJEJ2fPQgo5qj57EFA8UY2Hs//JEoppeKMzmRVSqk4pQleKaXilCZ4pZSKU5rglVIqTmmCV0opmwRanMxz7NEi8oOnsNpPIuK3LIMmeBUXRKS5p9LkQhHZJiKbPduFIvKfMJ3zlrqUTBCRFBGZKiLRtui9irw3gDMCPPYJrFpBvYAHgEf8vUCHSaq4IyL3A4XGmCfCeI4kYD7QzxgTdAExEbkPq1jZuyEPTsUUEckB/muM6eH5/VjgeawKpMXAtcaYFSKyFDjdGLPJU8BunzGmia+29QpexTVPDfn/erbvF5E3ReRbEVkvIqNE5J8islhEvhaRZM9x/UVkiqeo2TdeKiqeAsyvSu6er8yPichsEVklIid4nj/O89xCz1frTp7XfwZcHvY3QMWil4GbjDH9gduBqm+gvwKjPdsXYlUqbe6rIU3wKtEcizUl/3zgHWCyMaYnUAKc7Uny/8aaQt4fGA88VEs7Q4F5hz2XZIwZCNyCNYMR4HrgWWNMH6w6JJs8zy8BBoToz6TihIg0wqpx/6GILAReAqouMG4HThSRBcCJWKUvfH571D5AlWj+Z4yp8JQPcAJfe55fjFVDpAvQA6vyI55jttbSTmtg+WHPfeJ5nOdpC2Am8FfPDbFPjDGrAYxVTbBcRBobYw6E4g+m4oIDKPBcEBzCGLMFGAXV/xGMNsbs89eYUomkDMBYddkrzMGbUG6sCx4Blhpj+nh+ehpjTqulnRIgrba2AZenLYwx7wHneY7/RkROqXF8KlAagj+TihPGKiW9TkQuguplFHt7trNEpCpn34X17dInTfBKHWolkC0igwFEJFlEjqvluOVAR3+NicgxwFpjzL+Az4FenuebAzuNMRUhi1zFHE9xsplAFxHZJCJXY92buVpEfgWWcnClsJOAlSKyCqs6aW1dh4fQLhqlajDGlIu1EPK/RKQp1mfkGawPWk3/A94OoMmLgStEpALYhjW8DeBkrOqNKoEZYy71suuIoZPGmI+Aj4JpX4dJKlVHIvIp8JeqfvUgX/sJcJcxZmXoI1PKol00StXdnRwc4RAwEUkBPtPkrsJNr+CVUipO6RW8UkrFKU3wSikVpzTBK6VUnNIEr5RScUoTvFJKxan/BzNYPwEhcmjjAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -402,14 +412,14 @@ } ], "source": [ - "plot(combined_pulse, sample_rate=1e-7, plot_measurements=combined_pulse.measurement_names, parameters={\"dt\": 1e9}) # combined_pulse.measurement_names\n", + "plot(combined_pulse, sample_rate=1e-6, plot_measurements=combined_pulse.measurement_names, parameters={\"dt\": 1e8}) # combined_pulse.measurement_names\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 25, - "id": "7f1e0eb3", + "execution_count": 26, + "id": "5971d8d4", "metadata": {}, "outputs": [], "source": [ @@ -429,8 +439,8 @@ }, { "cell_type": "code", - "execution_count": 26, - "id": "2bd8d1c2", + "execution_count": 27, + "id": "95354416", "metadata": {}, "outputs": [], "source": [ @@ -442,13 +452,13 @@ }, { "cell_type": "code", - "execution_count": 27, - "id": "89cda79b", + "execution_count": 28, + "id": "da09966f", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -460,21 +470,21 @@ } ], "source": [ - "plot(rep, sample_rate=1e-7, plot_measurements=combined_pulse.measurement_names, parameters={\"dt\": 1e9})\n", + "plot(rep, sample_rate=1e-6, plot_measurements=combined_pulse.measurement_names, parameters={\"dt\": 1e8})\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, - "id": "67160184", + "id": "67d7f4ba", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "d3aa8c2d", + "id": "2ed484d1", "metadata": {}, "source": [ "## Execution\n", @@ -485,8 +495,8 @@ }, { "cell_type": "code", - "execution_count": 28, - "id": "326b7236", + "execution_count": 29, + "id": "c8bfe143", "metadata": {}, "outputs": [], "source": [ @@ -495,8 +505,8 @@ }, { "cell_type": "code", - "execution_count": 29, - "id": "8d7fdb70", + "execution_count": 30, + "id": "bfbf9bb8", "metadata": {}, "outputs": [], "source": [ @@ -505,8 +515,8 @@ }, { "cell_type": "code", - "execution_count": 30, - "id": "4d57aedb", + "execution_count": 31, + "id": "96101e9f", "metadata": {}, "outputs": [], "source": [ @@ -515,8 +525,8 @@ }, { "cell_type": "code", - "execution_count": 31, - "id": "a26db851", + "execution_count": 32, + "id": "02dd1c40", "metadata": {}, "outputs": [], "source": [ @@ -525,8 +535,8 @@ }, { "cell_type": "code", - "execution_count": 32, - "id": "ad1ec540", + "execution_count": 33, + "id": "e2e74ed9", "metadata": {}, "outputs": [], "source": [ @@ -535,8 +545,8 @@ }, { "cell_type": "code", - "execution_count": 33, - "id": "06744b93", + "execution_count": 34, + "id": "d1bfec54", "metadata": {}, "outputs": [], "source": [ @@ -546,8 +556,8 @@ }, { "cell_type": "code", - "execution_count": 34, - "id": "04c4c840", + "execution_count": 35, + "id": "b2e3e48d", "metadata": {}, "outputs": [], "source": [ @@ -557,51 +567,64 @@ }, { "cell_type": "code", - "execution_count": 35, - "id": "81b44a4c", + "execution_count": 36, + "id": "9ef88b8e", "metadata": {}, "outputs": [], "source": [ - "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e9})" + "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e8})" ] }, { "cell_type": "code", - "execution_count": 36, - "id": "433cdc54", - "metadata": { - "scrolled": true - }, + "execution_count": 37, + "id": "e3357627", + "metadata": {}, "outputs": [], "source": [ - "setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(None), update=True)" + "def plot_windows(data):\n", + " for j, w in enumerate(data.keys()):\n", + " for i, c in enumerate(data[w].keys()):\n", + " for e in data[w][c]:\n", + " plt.plot(e[\"time\"].values.T, e.values.T, color=f\"C{j}\")\n", + " plt.scatter(e[\"time\"].values.T, e.values.T, color=f\"C{j}\", marker=\"x\", alpha=.1)\n", + " plt.show()" ] }, { "cell_type": "code", - "execution_count": 37, - "id": "b5464fa3", + "execution_count": 38, + "id": "a3c56e45", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2.5111607666015624e-05" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "15e-9*1674.107177734375" + "my_lockin.register_trigger_settings(program_name=\"test\",\n", + "# trigger_input=f\"auxins/1/sample.AuxIn1\",\n", + " trigger_input=f\"demods/0/sample.TrigIn1\",\n", + " edge=\"rising\",\n", + " number_of_triggers_to_buffer=3,\n", + " level=0.5,\n", + " other_settings={\"holdoff/time\": 1e-8} #\n", + " )" ] }, { "cell_type": "code", - "execution_count": 38, - "id": "3b085324", + "execution_count": 39, + "id": "7f16ed0c", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(None), update=True)\n", + "setup.register_program('test', test_program, run_callback=lambda *a, **b: None, update=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "706745a1", "metadata": { "scrolled": false }, @@ -617,18 +640,23 @@ " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", " 'demods/0/sample.Y'}}},\n", - " 'test': {'windows': {'X': (array([1.e+10]), array([3.e+09])),\n", - " 'R': (array([6.5e+09, 1.4e+10]), array([1.4e+09, 1.0e+09])),\n", - " 'A': (array([3.0e+09, 1.2e+10]), array([1.5e+09, 3.0e+09]))},\n", - " 'windows_from_start_max': {'X': 13000000000.0,\n", - " 'R': 15000000000.0,\n", - " 'A': 15000000000.0},\n", + " 'test': {'trigger_settings': {'trigger_input': '/dev3442/demods/0/sample.TrigIn1',\n", + " 'edge': 'rising',\n", + " 'number_of_triggers_to_buffer': 3,\n", + " 'delay': 0,\n", + " 'other_settings': {'level': 0.5, 'holdoff/time': 1e-08}},\n", + " 'windows': {'X': (array([1.e+09]), array([3.e+08])),\n", + " 'R': (array([6.5e+08, 1.4e+09]), array([1.4e+08, 1.0e+08])),\n", + " 'A': (array([3.0e+08, 1.2e+09]), array([1.5e+08, 3.0e+08]))},\n", + " 'windows_from_start_max': {'X': 1300000000.0,\n", + " 'R': 1500000000.0,\n", + " 'A': 1500000000.0},\n", " 'all_channels': {'auxins/0/sample.auxin0.avg',\n", " 'demods/0/sample.r',\n", " 'demods/0/sample.x'}}}" ] }, - "execution_count": 38, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -639,24 +667,40 @@ }, { "cell_type": "code", - "execution_count": 98, - "id": "edacdee2", + "execution_count": 41, + "id": "7313120f", "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:344: UserWarning: The channel auxins/0/sample.auxin0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", - " warnings.warn(f\"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.\")\n" + "sample rates: [1674.107177734375, 1674.107177734375, None]\n", + "SETTING TRIGMODE 6\n", + "SETTING TRIGGERNODE: ('triggernode', '/dev3442/demods/0/sample.TrigIn1')\n", + "using trigger edge: 0\n" ] }, { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Will record 25112 samples in 15.000000000000002s!\n", - "MFLI returns a total record time of {'duration': array([15.00023467])}s\n" + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:376: UserWarning: The channel auxins/0/sample.auxin0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + " warnings.warn(f\"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.\")\n" + ] + }, + { + "ename": "KeyError", + "evalue": "'level'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_40988\\2579883431.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msetup\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrun_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"test\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\setup.py\u001b[0m in \u001b[0;36mrun_program\u001b[1;34m(self, name)\u001b[0m\n\u001b[0;32m 221\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mrun_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 222\u001b[0m \u001b[1;34m\"\"\"Calls arm program and starts it using the run callback\"\"\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 223\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marm_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 224\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_registered_programs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrun_callback\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 225\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\setup.py\u001b[0m in \u001b[0;36marm_program\u001b[1;34m(self, name)\u001b[0m\n\u001b[0;32m 217\u001b[0m \u001b[0mawg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marm\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 218\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mdac\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdacs_to_arm\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 219\u001b[1;33m \u001b[0mdac\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marm_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 220\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 221\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mrun_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m in \u001b[0;36marm_program\u001b[1;34m(self, program_name, force)\u001b[0m\n\u001b[0;32m 454\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"edge\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0medge_key\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 455\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 456\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"level\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mts\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"level\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 457\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 458\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mKeyError\u001b[0m: 'level'" ] } ], @@ -666,573 +710,310 @@ }, { "cell_type": "code", - "execution_count": 99, - "id": "663a88b5", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "{'buffercount': array([77], dtype=int64), 'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664529215402434], dtype=uint64), 'createdtimestamp': array([316381462056], dtype=uint64), 'changedtimestamp': array([316381462056], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '004 11:13:35.4017', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 317281356936,\n", - " 317281392776, 317281428616]], dtype=uint64), 'value': array([[ nan, nan, nan, ..., -0.00232198,\n", - " -0.00232198, -0.00232198]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664529215402983], dtype=uint64), 'createdtimestamp': array([316381462056], dtype=uint64), 'changedtimestamp': array([316381462056], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '004 11:13:35.4017', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[316381450376, 316381486216, 316381522056, ..., 317281356936,\n", - " 317281392776, 317281428616]], dtype=uint64), 'value': array([[1.59011277e-07, 4.70619023e-07, 6.68435541e-07, ...,\n", - " 5.32911742e-07, 5.30974673e-07, 4.72225932e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664529215403471], dtype=uint64), 'createdtimestamp': array([316381462056], dtype=uint64), 'changedtimestamp': array([316381462056], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '004 11:13:35.4017', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[316381450376, 316381486216, 316381522056, ..., 317281356936,\n", - " 317281392776, 317281428616]], dtype=uint64), 'value': array([[-1.00858959e-07, -6.24829378e-08, 5.21458498e-09, ...,\n", - " -9.96038947e-09, -1.75158872e-07, -3.89508749e-07]])}]}}}, 'duration': array([15.00023467]), 'forcetrigger': array([0], dtype=int64), 'triggered': array([0], dtype=int64)}\n" - ] - } - ], + "execution_count": 50, + "id": "5bc9a8a0", + "metadata": {}, + "outputs": [], + "source": [ + "for _ in range(3):\n", + " my_lockin.force_trigger(None)\n", + " time.sleep(3)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "deb54248", + "metadata": {}, + "outputs": [], "source": [ - "data = my_lockin.measure_program([\"\"])" + "for _ in range(3):\n", + " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 1)\n", + " time.sleep(1)\n", + " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 0)\n", + " time.sleep(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "a2f215d5", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.finish()" ] }, { "cell_type": "code", - "execution_count": 74, - "id": "833f68e5", + "execution_count": 53, + "id": "b9ee3d42", "metadata": { "scrolled": true }, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[-0.00211383, -0.00209682, -0.00207982, ..., -0.00121121,\n", - " -0.00121688, -0.00122255]])\n", - " Coordinates:\n", - " timestamp (row, col) float64 4.482e+12 4.482e+12 ... 4.497e+12 4.497e+12\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664528424329287]\n", - " createdtimestamp: [268898909736]\n", - " changedtimestamp: [268898909736]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 003 11:00:24.3286\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.r': [\n", - " array([[4.24502350e-08, 3.83220570e-07, 6.39577112e-07, ...,\n", - " 2.91820932e-07, 1.21077468e-07, 1.73901447e-07]])\n", - " Coordinates:\n", - " timestamp (row, col) float64 4.482e+12 4.482e+12 ... 4.497e+12 4.497e+12\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664528424329823]\n", - " createdtimestamp: [268898909736]\n", - " changedtimestamp: [268898909736]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 003 11:00:24.3286\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.x': [\n", - " array([[-4.11211373e-08, -3.45698104e-07, -5.54790943e-07, ...,\n", - " -2.84726146e-07, -1.17343409e-07, 2.52172809e-08]])\n", - " Coordinates:\n", - " timestamp (row, col) float64 4.482e+12 4.482e+12 ... 4.497e+12 4.497e+12\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664528424330307]\n", - " createdtimestamp: [268898909736]\n", - " changedtimestamp: [268898909736]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 003 11:00:24.3286\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}" + "
" ] }, - "execution_count": 74, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "data" + "data = my_lockin.measure_program()\n", + "plot_windows(data)" ] }, { "cell_type": "code", - "execution_count": 75, - "id": "c1448b03", + "execution_count": 45, + "id": "73a8a0af", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "4481648300933.333\n", - "4481648898266.667\n", - "4481649495600.0\n", - "4481650092933.333\n", - "4481650690266.667\n", - "4481651287600.0\n", - "4481651884933.333\n", - "4481652482266.667\n", - "4481653079600.0\n", - "4481653676933.333\n", - "4481654274266.667\n", - "4481654871600.0\n", - "4481655468933.333\n", - "4481656066266.667\n", - "4481656663600.0\n", - "4481657260933.333\n", - "4481657858266.667\n", - "4481658455600.0\n", - "4481659052933.333\n", - "4481659650266.667\n", - "---\n", - "4496636588933.334\n", - "4496637186266.666\n", - "4496637783600.0\n", - "4496638380933.333\n", - "4496638978266.667\n", - "4496639575600.0\n", - "4496640172933.333\n", - "4496640770266.667\n", - "4496641367600.0\n", - "4496641964933.333\n", - "4496642562266.667\n", - "4496643159600.0\n", - "4496643756933.333\n", - "4496644354266.667\n", - "4496644951600.0\n", - "4496645548933.333\n", - "4496646146266.667\n", - "4496646743600.0\n", - "4496647340933.333\n", - "4496647938266.667\n" + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(597)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 595 \u001b[1;33m \u001b[0mstart_waiting\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 596 \u001b[1;33m \u001b[1;32mwhile\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfinished\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mwait\u001b[0m \u001b[1;32mand\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mstart_waiting\u001b[0m\u001b[1;33m>\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 597 \u001b[1;33m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 598 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Waiting for device {self.serial} to finish the acquisition...\"\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# Progress: {self.daq.progress()[0]}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 599 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> r\n" ] } ], "source": [ - "for e in data['/dev3442/auxins/0/sample.auxin0.avg'][0][\"timestamp\"].values[0, :20]:\n", - " print(e)\n", - "print(\"---\")\n", - "for e in data['/dev3442/auxins/0/sample.auxin0.avg'][0][\"timestamp\"].values[0, -20:]:\n", - " print(e)" + "%debug" ] }, { "cell_type": "code", - "execution_count": 63, - "id": "bca17ff3", + "execution_count": 56, + "id": "9413b67f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.89951232" + "{'awgcontrol': array([0], dtype=int64),\n", + " 'bandwidth': array([0.]),\n", + " 'bitmask': array([1], dtype=int64),\n", + " 'bits': array([1], dtype=int64),\n", + " 'buffercount': array([10], dtype=int64),\n", + " 'buffersize': array([0.2]),\n", + " 'clearhistory': array([0], dtype=int64),\n", + " 'count': array([3], dtype=int64),\n", + " 'delay': array([-0.001]),\n", + " 'dev3442': {'demods': {'0': {'sample.x': [{'header': {'systemtime': array([1664558103553351], dtype=uint64),\n", + " 'createdtimestamp': array([2050547636776], dtype=uint64),\n", + " 'changedtimestamp': array([2050906036776], dtype=uint64),\n", + " 'flags': array([1849], dtype=uint32),\n", + " 'moduleflags': array([0], dtype=uint32),\n", + " 'chunksizebytes': array([0], dtype=uint64),\n", + " 'name': '003 19:15:03.5532',\n", + " 'status': array([0], dtype=uint32),\n", + " 'groupindex': array([0], dtype=uint32),\n", + " 'color': array([0], dtype=uint32),\n", + " 'activerow': array([2], dtype=uint32),\n", + " 'triggernumber': array([0], dtype=uint64),\n", + " 'gridrows': array([3], dtype=uint32),\n", + " 'gridcols': array([1256], dtype=uint32),\n", + " 'gridmode': array([4], dtype=uint32),\n", + " 'gridoperation': array([1], dtype=uint32),\n", + " 'griddirection': array([0], dtype=uint32),\n", + " 'gridrepetitions': array([1], dtype=uint32),\n", + " 'gridcoldelta': array([0.00119467]),\n", + " 'gridcoloffset': array([-0.001]),\n", + " 'gridrowdelta': array([1.]),\n", + " 'gridrowoffset': array([0.]),\n", + " 'bandwidth': array([nan]),\n", + " 'center': array([0.]),\n", + " 'nenbw': array([nan])},\n", + " 'timestamp': array([[2050547625096, 2050547696776, 2050547768456, ..., 2050637440136,\n", + " 2050637511816, 2050637583496],\n", + " [2050728258696, 2050728330376, 2050728402056, ..., 2050818073736,\n", + " 2050818145416, 2050818217096],\n", + " [2050906025096, 2050906096776, 2050906168456, ..., 2050995840136,\n", + " 2050995911816, 2050995983496]], dtype=uint64),\n", + " 'value': array([[-3.19561798e-07, 1.67769002e-07, 5.44787502e-07, ...,\n", + " 4.46304136e-08, -5.92941542e-08, 2.84974289e-07],\n", + " [-3.30585912e-07, 9.90783104e-08, 4.78993204e-08, ...,\n", + " -7.80902188e-10, -3.75496757e-08, -1.17205286e-07],\n", + " [-4.02696190e-07, -1.92283112e-07, -2.46849998e-07, ...,\n", + " 2.75505401e-07, -2.89131128e-08, 7.18154963e-08]])}]}}},\n", + " 'device': ['dev3442'],\n", + " 'duration': array([1.50050133]),\n", + " 'edge': array([1], dtype=int64),\n", + " 'enable': array([1], dtype=int64),\n", + " 'endless': array([0], dtype=int64),\n", + " 'eventcount': {'mode': array([1], dtype=int64)},\n", + " 'fft': {'absolute': array([0], dtype=int64),\n", + " 'window': array([1], dtype=int64)},\n", + " 'findlevel': array([0], dtype=int64),\n", + " 'flags': array([8], dtype=int64),\n", + " 'forcetrigger': array([0], dtype=int64),\n", + " 'grid': {'cols': array([1256], dtype=int64),\n", + " 'direction': array([0], dtype=int64),\n", + " 'mode': array([4], dtype=int64),\n", + " 'overwrite': array([0], dtype=int64),\n", + " 'repetitions': array([1], dtype=int64),\n", + " 'rowrepetition': array([0], dtype=int64),\n", + " 'rows': array([3], dtype=int64),\n", + " 'waterfall': array([0], dtype=int64)},\n", + " 'historylength': array([100000], dtype=int64),\n", + " 'holdoff': {'count': array([0], dtype=int64), 'time': array([0.2])},\n", + " 'hysteresis': array([0.]),\n", + " 'level': array([0.5]),\n", + " 'preview': array([0], dtype=int64),\n", + " 'pulse': {'max': array([0.001]), 'min': array([0.])},\n", + " 'refreshrate': array([5.]),\n", + " 'save': {'csvlocale': ['C'],\n", + " 'csvseparator': [';'],\n", + " 'directory': ['C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer'],\n", + " 'fileformat': array([0], dtype=int64),\n", + " 'filename': ['dataAcquisitionModule'],\n", + " 'save': array([0], dtype=int64),\n", + " 'saveonread': array([0], dtype=int64)},\n", + " 'spectrum': {'autobandwidth': array([0], dtype=int64),\n", + " 'enable': array([0], dtype=int64),\n", + " 'frequencyspan': array([13000.]),\n", + " 'overlapped': array([1], dtype=int64)},\n", + " 'triggered': array([0], dtype=int64),\n", + " 'triggernode': ['/dev3442/demods/0/sample.TrigIn1'],\n", + " 'type': array([6], dtype=int64)}" ] }, - "execution_count": 63, + "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "(130556892296-129657379976)*1e-9" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "id": "95f3cd94", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-0.0021138295076801594\n", - "-0.002096822800171233\n", - "-0.0020798160926623066\n", - "-0.00206280938515338\n", - "-0.0020458026776444538\n", - "-0.0020287959701355274\n", - "-0.002011789262626601\n", - "-0.0019947825551176745\n", - "-0.001977775847608748\n", - "-0.0019607691400998217\n", - "-0.0019437624325908953\n", - "-0.001926755725081969\n", - "-0.0019097490175730425\n", - "-0.001892742310064116\n", - "-0.0018757356025551897\n", - "-0.0018587288950462633\n", - "-0.0018417221875373369\n", - "-0.0018247154800284104\n", - "-0.001807708772519484\n", - "-0.0017907020650105576\n", - "-0.0017736953575016312\n", - "-0.0017566886499927048\n", - "-0.0017396819424837784\n", - "-0.001722675234974852\n", - "-0.0017056685274659256\n", - "-0.0016886618199569992\n", - "-0.0016716551124480727\n", - "-0.0016572554041315024\n", - "-0.001651586501628527\n", - "-0.0016459175991255515\n", - "-0.001640248696622576\n", - "-0.0016345797941196005\n", - "-0.001628910891616625\n", - "-0.0016232419891136496\n", - "-0.0016175730866106741\n", - "-0.0016119041841076986\n", - "-0.0016062352816047232\n", - "-0.0016005663791017477\n", - "-0.0015948974765987722\n", - "-0.0015892285740957968\n" - ] - } - ], - "source": [ - "for e in data['/dev3442/auxins/0/sample.auxin0.avg'][0].values[0, :40]:\n", - " print(e)" + "my_lockin.daq_read_return" ] }, { "cell_type": "code", - "execution_count": 100, - "id": "40664f2a", + "execution_count": 54, + "id": "f6e39c83", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "/dev3442/demods/0/sample.x\n", - "time_of_trigger=[5.27302317e+12]\n", - "extracted_data=[\n", - "array([[ 8.20515335e-08, -1.37302456e-07, -2.23006770e-07, ...,\n", - " -2.51220898e-07, -8.52887497e-08, -8.56558814e-08]])\n", - "Coordinates:\n", - " time (row, col) float64 5.283e+12 5.283e+12 ... 5.286e+12 5.286e+12\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664529215403471]\n", - " createdtimestamp: [316381462056]\n", - " changedtimestamp: [316381462056]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 004 11:13:35.4017\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]\n", - "/dev3442/demods/0/sample.r\n", - "time_of_trigger=[5.27302317e+12]\n", - "time_of_trigger=[5.27302317e+12]\n", - "extracted_data=[\n", - "array([[5.09070137e-07, 4.36690684e-07, 4.20131474e-07, ...,\n", - " 5.52220621e-07, 5.07130206e-07, 2.38696738e-07]])\n", - "Coordinates:\n", - " time (row, col) float64 5.28e+12 5.28e+12 ... 5.281e+12 5.281e+12\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664529215402983]\n", - " createdtimestamp: [316381462056]\n", - " changedtimestamp: [316381462056]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 004 11:13:35.4017\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan], \n", - "array([[4.39980625e-07, 5.04697280e-07, 4.95701644e-07, ...,\n", - " 2.04461446e-07, 3.65230061e-07, 5.32911742e-07]])\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(544)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 542 \u001b[1;33m \u001b[0mcn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34mf\"/{self.serial}/{_cn}\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlower\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 543 \u001b[1;33m \u001b[1;31m# print(cn)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 544 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mcn\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m<=\u001b[0m \u001b[0mshot_index\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 545 \u001b[1;33m \u001b[1;31m# then we do not have data for this shot_index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 546 \u001b[1;33m \u001b[0mwarnings\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwarn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{shot_index}]\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(640)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 636 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mrecorded_data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 637 \u001b[1;33m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 638 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 639 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 640 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcurrently_set_program\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\appdata\\local\\temp\\ipykernel_27380\\3532927405.py\u001b[0m(1)\u001b[0;36m\u001b[1;34m()\u001b[0m\n", + "\n", + "ipdb> d\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(640)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 636 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mrecorded_data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 637 \u001b[1;33m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 638 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 639 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 640 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcurrently_set_program\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> recorded_data\n", + "{'/dev3442/demods/0/sample.x': [\n", + "array([[-3.19561798e-07, 1.67769002e-07, 5.44787502e-07, ...,\n", + " 4.46304136e-08, -5.92941542e-08, 2.84974289e-07],\n", + " [-3.30585912e-07, 9.90783104e-08, 4.78993204e-08, ...,\n", + " -7.80902188e-10, -3.75496757e-08, -1.17205286e-07],\n", + " [-4.02696190e-07, -1.92283112e-07, -2.46849998e-07, ...,\n", + " 2.75505401e-07, -2.89131128e-08, 7.18154963e-08]])\n", "Coordinates:\n", - " time (row, col) float64 5.287e+12 5.287e+12 ... 5.288e+12 5.288e+12\n", + " time (row, col) float64 3.418e+13 3.418e+13 ... 3.418e+13 3.418e+13\n", "Dimensions without coordinates: row, col\n", "Attributes:\n", - " systemtime: [1664529215402983]\n", - " createdtimestamp: [316381462056]\n", - " changedtimestamp: [316381462056]\n", + " systemtime: [1664558103553351]\n", + " createdtimestamp: [2050547636776]\n", + " changedtimestamp: [2050906036776]\n", " flags: [1849]\n", " moduleflags: [0]\n", " chunksizebytes: [0]\n", - " name: 004 11:13:35.4017\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]\n", - "/dev3442/auxins/0/sample.auxin0.avg\n", - "time_of_trigger=[5.27309366e+12]\n", - "time_of_trigger=[5.27309366e+12]\n", - "extracted_data=[\n", - "array([[-0.00120247, -0.00121381, -0.00122515, ..., -0.00054094,\n", - " -0.00051259, -0.00048425]])\n", - "Coordinates:\n", - " time (row, col) float64 5.276e+12 5.276e+12 ... 5.278e+12 5.278e+12\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664529215402434]\n", - " createdtimestamp: [316381462056]\n", - " changedtimestamp: [316381462056]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 004 11:13:35.4017\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan], \n", - "array([[-0.00106838, -0.00109105, -0.00111373, ..., -0.00232198,\n", - " -0.00232198, -0.00232198]])\n", - "Coordinates:\n", - " time (row, col) float64 5.285e+12 5.285e+12 ... 5.288e+12 5.288e+12\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664529215402434]\n", - " createdtimestamp: [316381462056]\n", - " changedtimestamp: [316381462056]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 004 11:13:35.4017\n", + " name: 003 19:15:03.5532\n", " status: [0]\n", " groupindex: [0]\n", " color: [0]\n", - " activerow: [0]\n", + " activerow: [2]\n", " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", " gridmode: [4]\n", " gridoperation: [1]\n", " griddirection: [0]\n", " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", + " gridcoldelta: [0.00119467]\n", " gridcoloffset: [-0.001]\n", " gridrowdelta: [1.]\n", " gridrowoffset: [0.]\n", " bandwidth: [nan]\n", " center: [0.]\n", - " nenbw: [nan]]\n" + " nenbw: [nan]]}\n", + "ipdb> r\n" ] } ], "source": [ - "extracted_data = my_lockin._parse_data(data, program_name=\"test\")" - ] - }, - { - "cell_type": "code", - "execution_count": 103, - "id": "6de3049e", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_windows(data):\n", - " for j, w in enumerate(data.keys()):\n", - " for i, c in enumerate(data[w].keys()):\n", - " for e in data[w][c]:\n", - " print(e[\"time\"].values, e.values)\n", - " plt.plot(e[\"time\"].values.T, e.values.T, color=f\"C{j}\")\n", - " plt.show()" + "%debug" ] }, { "cell_type": "code", - "execution_count": 104, - "id": "5944b2ed", + "execution_count": 101, + "id": "a8bbb495", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[5.28302353e+12 5.28302413e+12 5.28302473e+12 ... 5.28602155e+12\n", - " 5.28602215e+12 5.28602274e+12]] [[ 8.20515335e-08 -1.37302456e-07 -2.23006770e-07 ... -2.51220898e-07\n", - " -8.52887497e-08 -8.56558814e-08]]\n" - ] - }, { "data": { - "image/png": "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\n", "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[5.27952376e+12 5.27952435e+12 5.27952495e+12 ... 5.28092152e+12\n", - " 5.28092211e+12 5.28092271e+12]] [[5.09070137e-07 4.36690684e-07 4.20131474e-07 ... 5.52220621e-07\n", - " 5.07130206e-07 2.38696738e-07]]\n", - "[[5.28702328e+12 5.28702387e+12 5.28702447e+12 ... 5.28802142e+12\n", - " 5.28802202e+12 5.28802262e+12]] [[4.39980625e-07 5.04697280e-07 4.95701644e-07 ... 2.04461446e-07\n", - " 3.65230061e-07 5.32911742e-07]]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "array([1.])" ] }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[5.27609387e+12 5.27609447e+12 5.27609506e+12 ... 5.27759198e+12\n", - " 5.27759258e+12 5.27759318e+12]] [[-0.00120247 -0.00121381 -0.00122515 ... -0.00054094 -0.00051259\n", - " -0.00048425]]\n", - "[[5.28509389e+12 5.28509449e+12 5.28509508e+12 ... 5.28802262e+12\n", - " 5.28802321e+12 5.28802381e+12]] [[-0.00106838 -0.00109105 -0.00111373 ... -0.00232198 -0.00232198\n", - " -0.00232198]]\n" - ] - }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.daq.progress()" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "id": "696bb6ec", + "metadata": { + "scrolled": false + }, + "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1244,13 +1025,23 @@ } ], "source": [ - "plot_windows(extracted_data)" + "plot_windows(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "0395da2d", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.finish()" ] }, { "cell_type": "code", "execution_count": 50, - "id": "c0ea856a", + "id": "f6ca6c0c", "metadata": {}, "outputs": [ { @@ -1356,7 +1147,7 @@ { "cell_type": "code", "execution_count": 39, - "id": "0cb4bd38", + "id": "9ba91403", "metadata": { "scrolled": true }, @@ -1380,7 +1171,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a415fdd8", + "id": "8d1d33e1", "metadata": {}, "outputs": [], "source": [ @@ -1390,7 +1181,7 @@ { "cell_type": "code", "execution_count": 43, - "id": "1d6ef3db", + "id": "e88a2b14", "metadata": {}, "outputs": [], "source": [ @@ -1400,7 +1191,7 @@ { "cell_type": "code", "execution_count": 72, - "id": "8afaaede", + "id": "7be685d9", "metadata": {}, "outputs": [ { @@ -1839,7 +1630,7 @@ { "cell_type": "code", "execution_count": 48, - "id": "b029ede6", + "id": "8dd5d9fa", "metadata": {}, "outputs": [ { @@ -1860,7 +1651,7 @@ { "cell_type": "code", "execution_count": 71, - "id": "48408b39", + "id": "6eddc918", "metadata": {}, "outputs": [ { @@ -1886,7 +1677,7 @@ { "cell_type": "code", "execution_count": 68, - "id": "e92a3415", + "id": "0c370d89", "metadata": {}, "outputs": [ { @@ -1919,7 +1710,7 @@ { "cell_type": "code", "execution_count": 55, - "id": "1fa62c49", + "id": "1bbdddd8", "metadata": { "scrolled": true }, @@ -1978,7 +1769,7 @@ { "cell_type": "code", "execution_count": 63, - "id": "d37795e8", + "id": "3020a9a9", "metadata": {}, "outputs": [ { @@ -2013,7 +1804,7 @@ { "cell_type": "code", "execution_count": 192, - "id": "1024edab", + "id": "4355046e", "metadata": {}, "outputs": [ { @@ -2082,7 +1873,7 @@ { "cell_type": "code", "execution_count": 174, - "id": "93e43a9f", + "id": "16759291", "metadata": {}, "outputs": [ { @@ -2109,7 +1900,7 @@ { "cell_type": "code", "execution_count": 123, - "id": "dda2d6d2", + "id": "488d71bb", "metadata": {}, "outputs": [], "source": [ @@ -2119,7 +1910,7 @@ { "cell_type": "code", "execution_count": 145, - "id": "5dc632e0", + "id": "4f108148", "metadata": { "scrolled": false }, @@ -2142,7 +1933,7 @@ { "cell_type": "code", "execution_count": 119, - "id": "8d06dfab", + "id": "cceaea5b", "metadata": {}, "outputs": [ { @@ -2163,7 +1954,7 @@ { "cell_type": "code", "execution_count": 110, - "id": "2fa8bad0", + "id": "c9890b61", "metadata": {}, "outputs": [], "source": [ @@ -2173,7 +1964,7 @@ { "cell_type": "code", "execution_count": 111, - "id": "7c3fb570", + "id": "f1c3a886", "metadata": {}, "outputs": [ { @@ -2236,7 +2027,7 @@ { "cell_type": "code", "execution_count": 44, - "id": "82162394", + "id": "9e290067", "metadata": {}, "outputs": [], "source": [ @@ -2246,7 +2037,7 @@ { "cell_type": "code", "execution_count": 45, - "id": "836853c2", + "id": "44a8f687", "metadata": {}, "outputs": [ { @@ -2267,7 +2058,7 @@ { "cell_type": "code", "execution_count": 202, - "id": "a9930108", + "id": "cf5ef277", "metadata": {}, "outputs": [], "source": [ @@ -2277,7 +2068,7 @@ { "cell_type": "code", "execution_count": 114, - "id": "bee6f9bb", + "id": "708ad4a2", "metadata": {}, "outputs": [ { @@ -2298,7 +2089,7 @@ { "cell_type": "code", "execution_count": 117, - "id": "1c3d0463", + "id": "c2cd629a", "metadata": {}, "outputs": [ { @@ -2319,7 +2110,7 @@ { "cell_type": "code", "execution_count": 116, - "id": "0c3fe8b6", + "id": "da47a7d4", "metadata": {}, "outputs": [], "source": [ @@ -2329,7 +2120,7 @@ { "cell_type": "code", "execution_count": 193, - "id": "9d077337", + "id": "bc1e563c", "metadata": {}, "outputs": [], "source": [ @@ -2339,7 +2130,7 @@ { "cell_type": "code", "execution_count": null, - "id": "7629f3e1", + "id": "1057c781", "metadata": {}, "outputs": [], "source": [] @@ -2347,7 +2138,7 @@ { "cell_type": "code", "execution_count": null, - "id": "15e43752", + "id": "b8cb73d1", "metadata": {}, "outputs": [], "source": [] @@ -2355,7 +2146,7 @@ { "cell_type": "code", "execution_count": null, - "id": "97ba2adc", + "id": "e0a8f4cf", "metadata": {}, "outputs": [], "source": [] @@ -2363,7 +2154,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "4fdeed1d", + "id": "48a808fa", "metadata": {}, "outputs": [], "source": [ @@ -2373,7 +2164,7 @@ { "cell_type": "code", "execution_count": 32, - "id": "70403aac", + "id": "69d10705", "metadata": {}, "outputs": [], "source": [ @@ -2384,7 +2175,7 @@ { "cell_type": "code", "execution_count": 33, - "id": "5f48c06f", + "id": "5de13d37", "metadata": {}, "outputs": [], "source": [ @@ -2394,7 +2185,7 @@ { "cell_type": "code", "execution_count": 37, - "id": "5a739e12", + "id": "bfbc73b5", "metadata": {}, "outputs": [ { @@ -3513,7 +3304,7 @@ { "cell_type": "code", "execution_count": 29, - "id": "2b4a8887", + "id": "202835f5", "metadata": {}, "outputs": [ { @@ -3539,7 +3330,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4e18fc22", + "id": "56abff6b", "metadata": {}, "outputs": [], "source": [] @@ -3547,7 +3338,7 @@ { "cell_type": "code", "execution_count": 35, - "id": "53b4a8a7", + "id": "e2e136c1", "metadata": {}, "outputs": [], "source": [ @@ -3558,7 +3349,7 @@ { "cell_type": "code", "execution_count": 31, - "id": "20fa5a67", + "id": "ccc4025d", "metadata": {}, "outputs": [], "source": [ @@ -3568,7 +3359,7 @@ { "cell_type": "code", "execution_count": 78, - "id": "b3d46f38", + "id": "ba2f2b48", "metadata": {}, "outputs": [ { @@ -3594,7 +3385,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1a0c371f", + "id": "cc11c26d", "metadata": {}, "outputs": [], "source": [] @@ -3602,7 +3393,7 @@ { "cell_type": "code", "execution_count": null, - "id": "07f26907", + "id": "9c97af1d", "metadata": {}, "outputs": [], "source": [] @@ -3610,7 +3401,7 @@ { "cell_type": "code", "execution_count": null, - "id": "07df6e4c", + "id": "9bcbcb3f", "metadata": {}, "outputs": [], "source": [] @@ -3618,7 +3409,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9fff7bd5", + "id": "e212305e", "metadata": {}, "outputs": [], "source": [] @@ -3626,7 +3417,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4b8d0834", + "id": "7bd3072a", "metadata": {}, "outputs": [], "source": [] diff --git a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb index 37e2c02c6..8d838c309 100644 --- a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb +++ b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "2f430ac2", + "id": "6b0bdb5f", "metadata": {}, "source": [ "# Zurich Instruments Lock-In MFLI Data Aquesition" @@ -11,7 +11,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "d054114e", + "id": "37894582", "metadata": {}, "outputs": [], "source": [ @@ -22,7 +22,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "30b7fbc1", + "id": "debe96ac", "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "b264f571", + "id": "c0050171", "metadata": {}, "outputs": [], "source": [ @@ -42,7 +42,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "7f78c8db", + "id": "f8975a27", "metadata": {}, "outputs": [], "source": [ @@ -52,7 +52,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "324c3b0d", + "id": "624c2d4f", "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "d531e09d", + "id": "76ba4dc7", "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "98aebcef", + "id": "65986db0", "metadata": {}, "outputs": [ { @@ -90,8 +90,8 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "9d249f5f", + "execution_count": 23, + "id": "42af2895", "metadata": {}, "outputs": [], "source": [ @@ -100,8 +100,18 @@ }, { "cell_type": "code", - "execution_count": 9, - "id": "cf10fd25", + "execution_count": 24, + "id": "a2599d33", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.api_session.setDebugLevel(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "016ae5ee", "metadata": {}, "outputs": [], "source": [ @@ -111,8 +121,8 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "89e6b5bc", + "execution_count": 26, + "id": "264cb7fa", "metadata": {}, "outputs": [], "source": [ @@ -127,8 +137,8 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "6c2de252", + "execution_count": 27, + "id": "bb0ef71a", "metadata": {}, "outputs": [], "source": [ @@ -138,8 +148,8 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "a8b630e8", + "execution_count": 28, + "id": "460a60f0", "metadata": {}, "outputs": [ { @@ -155,7 +165,7 @@ " 'demods/0/sample.Y'}}}" ] }, - "execution_count": 12, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -166,8 +176,8 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "f48d89f0", + "execution_count": 29, + "id": "bc46a01c", "metadata": {}, "outputs": [], "source": [ @@ -176,8 +186,8 @@ }, { "cell_type": "code", - "execution_count": 14, - "id": "45126b53", + "execution_count": 30, + "id": "f45534ef", "metadata": {}, "outputs": [ { @@ -200,7 +210,7 @@ " 'demods/0/sample.y'}}}" ] }, - "execution_count": 14, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -211,8 +221,8 @@ }, { "cell_type": "code", - "execution_count": 15, - "id": "def7db5f", + "execution_count": 31, + "id": "eb3c0a0e", "metadata": {}, "outputs": [], "source": [ @@ -221,8 +231,8 @@ }, { "cell_type": "code", - "execution_count": 16, - "id": "d6dbcd84", + "execution_count": 32, + "id": "60fe5854", "metadata": {}, "outputs": [ { @@ -238,7 +248,7 @@ " 'demods/0/sample.Y'}}}}" ] }, - "execution_count": 16, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -250,14 +260,14 @@ { "cell_type": "code", "execution_count": null, - "id": "b414de1c", + "id": "4955fbc2", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "043d2313", + "id": "303053e3", "metadata": {}, "source": [ "## Defining a simple qupulse pulse with a measurement window." @@ -265,8 +275,8 @@ }, { "cell_type": "code", - "execution_count": 17, - "id": "57b97220", + "execution_count": 33, + "id": "37b55006", "metadata": {}, "outputs": [], "source": [ @@ -275,8 +285,8 @@ }, { "cell_type": "code", - "execution_count": 18, - "id": "62ddbf08", + "execution_count": 34, + "id": "be93574e", "metadata": {}, "outputs": [], "source": [ @@ -292,8 +302,8 @@ }, { "cell_type": "code", - "execution_count": 19, - "id": "d34532dd", + "execution_count": 35, + "id": "1d42e3fc", "metadata": {}, "outputs": [], "source": [ @@ -310,8 +320,8 @@ }, { "cell_type": "code", - "execution_count": 20, - "id": "02693549", + "execution_count": 36, + "id": "d2632242", "metadata": {}, "outputs": [], "source": [ @@ -322,8 +332,8 @@ }, { "cell_type": "code", - "execution_count": 21, - "id": "0ac68a54", + "execution_count": 37, + "id": "ea1cdd4c", "metadata": {}, "outputs": [ { @@ -341,15 +351,15 @@ }, { "cell_type": "code", - "execution_count": 22, - "id": "418c8705", + "execution_count": 38, + "id": "eb2ea77b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'R', 'T', 'A'}\n", + "{'A', 'T', 'R'}\n", "[]\n", "set()\n" ] @@ -363,8 +373,8 @@ }, { "cell_type": "code", - "execution_count": 23, - "id": "aa339b15", + "execution_count": 39, + "id": "eeeee0ec", "metadata": {}, "outputs": [ { @@ -373,7 +383,7 @@ "" ] }, - "execution_count": 23, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -384,13 +394,13 @@ }, { "cell_type": "code", - "execution_count": 24, - "id": "71cc7cc4", + "execution_count": 40, + "id": "d325087c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -402,14 +412,14 @@ } ], "source": [ - "plot(combined_pulse, sample_rate=1e-7, plot_measurements=combined_pulse.measurement_names, parameters={\"dt\": 1e9}) # combined_pulse.measurement_names\n", + "plot(combined_pulse, sample_rate=1e-6, plot_measurements=combined_pulse.measurement_names, parameters={\"dt\": 1e8}) # combined_pulse.measurement_names\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 25, - "id": "aece2141", + "execution_count": 41, + "id": "70da8095", "metadata": {}, "outputs": [], "source": [ @@ -429,8 +439,8 @@ }, { "cell_type": "code", - "execution_count": 26, - "id": "bd7178a5", + "execution_count": 42, + "id": "20626e0f", "metadata": {}, "outputs": [], "source": [ @@ -442,13 +452,13 @@ }, { "cell_type": "code", - "execution_count": 27, - "id": "545549c5", + "execution_count": 43, + "id": "62aab374", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -460,21 +470,21 @@ } ], "source": [ - "plot(rep, sample_rate=1e-7, plot_measurements=combined_pulse.measurement_names, parameters={\"dt\": 1e9})\n", + "plot(rep, sample_rate=1e-6, plot_measurements=combined_pulse.measurement_names, parameters={\"dt\": 1e8})\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, - "id": "d03958df", + "id": "f5280e48", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "69f7b83b", + "id": "3d4b0951", "metadata": {}, "source": [ "## Execution\n", @@ -485,8 +495,8 @@ }, { "cell_type": "code", - "execution_count": 28, - "id": "89add969", + "execution_count": 44, + "id": "031fd70e", "metadata": {}, "outputs": [], "source": [ @@ -495,8 +505,8 @@ }, { "cell_type": "code", - "execution_count": 29, - "id": "085ab02a", + "execution_count": 45, + "id": "f0143c3d", "metadata": {}, "outputs": [], "source": [ @@ -505,8 +515,8 @@ }, { "cell_type": "code", - "execution_count": 30, - "id": "e3b31765", + "execution_count": 46, + "id": "843fb93c", "metadata": {}, "outputs": [], "source": [ @@ -515,8 +525,8 @@ }, { "cell_type": "code", - "execution_count": 31, - "id": "07d8259d", + "execution_count": 47, + "id": "7df89611", "metadata": {}, "outputs": [], "source": [ @@ -525,8 +535,8 @@ }, { "cell_type": "code", - "execution_count": 32, - "id": "3465b009", + "execution_count": 48, + "id": "21afd2d6", "metadata": {}, "outputs": [], "source": [ @@ -535,8 +545,8 @@ }, { "cell_type": "code", - "execution_count": 33, - "id": "7dc1a8ea", + "execution_count": 49, + "id": "2e4e2b0b", "metadata": {}, "outputs": [], "source": [ @@ -546,8 +556,8 @@ }, { "cell_type": "code", - "execution_count": 34, - "id": "65bc064c", + "execution_count": 50, + "id": "632a30f6", "metadata": {}, "outputs": [], "source": [ @@ -557,51 +567,64 @@ }, { "cell_type": "code", - "execution_count": 35, - "id": "75656d82", + "execution_count": 51, + "id": "6abf0e7f", "metadata": {}, "outputs": [], "source": [ - "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e9})" + "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e8})" ] }, { "cell_type": "code", - "execution_count": 36, - "id": "fc91e75d", - "metadata": { - "scrolled": true - }, + "execution_count": 52, + "id": "7f811d07", + "metadata": {}, "outputs": [], "source": [ - "setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(None), update=True)" + "def plot_windows(data):\n", + " for j, w in enumerate(data.keys()):\n", + " for i, c in enumerate(data[w].keys()):\n", + " for e in data[w][c]:\n", + " plt.plot(e[\"time\"].values.T, e.values.T, color=f\"C{j}\")\n", + " plt.scatter(e[\"time\"].values.T, e.values.T, color=f\"C{j}\", marker=\"x\", alpha=.1)\n", + " plt.show()" ] }, { "cell_type": "code", - "execution_count": 37, - "id": "47ad74d2", + "execution_count": 53, + "id": "d0c8669f", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2.5111607666015624e-05" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "15e-9*1674.107177734375" + "my_lockin.register_trigger_settings(program_name=\"test\",\n", + "# trigger_input=f\"demods/0/sample.AuxIn1\",\n", + " trigger_input=f\"demods/0/sample.TrigIn1\",\n", + " edge=\"rising\",\n", + " number_of_triggers_to_buffer=3,\n", + " level=.5,\n", + " other_settings={\"holdoff/time\": 1e-8} #\n", + " )" ] }, { "cell_type": "code", - "execution_count": 38, - "id": "ac914d69", + "execution_count": 58, + "id": "f069c321", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(None), update=True)\n", + "setup.register_program('test', test_program, run_callback=lambda *a, **b: None, update=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "11e558f5", "metadata": { "scrolled": false }, @@ -617,18 +640,25 @@ " 'demods/0/sample.R',\n", " 'demods/0/sample.X',\n", " 'demods/0/sample.Y'}}},\n", - " 'test': {'windows': {'X': (array([1.e+10]), array([3.e+09])),\n", - " 'R': (array([6.5e+09, 1.4e+10]), array([1.4e+09, 1.0e+09])),\n", - " 'A': (array([3.0e+09, 1.2e+10]), array([1.5e+09, 3.0e+09]))},\n", - " 'windows_from_start_max': {'X': 13000000000.0,\n", - " 'R': 15000000000.0,\n", - " 'A': 15000000000.0},\n", + " 'test': {'trigger_settings': {'trigger_input': '/dev3442/demods/0/sample.TrigIn1',\n", + " 'edge': 'rising',\n", + " 'number_of_triggers_to_buffer': 3,\n", + " 'level': 0.5,\n", + " 'delay': -0.001,\n", + " 'post_delay': 0.001,\n", + " 'other_settings': {'holdoff/time': 1e-08}},\n", + " 'windows': {'X': (array([1.e+09]), array([3.e+08])),\n", + " 'R': (array([6.5e+08, 1.4e+09]), array([1.4e+08, 1.0e+08])),\n", + " 'A': (array([3.0e+08, 1.2e+09]), array([1.5e+08, 3.0e+08]))},\n", + " 'windows_from_start_max': {'X': 1300000000.0,\n", + " 'R': 1500000000.0,\n", + " 'A': 1500000000.0},\n", " 'all_channels': {'auxins/0/sample.auxin0.avg',\n", " 'demods/0/sample.r',\n", " 'demods/0/sample.x'}}}" ] }, - "execution_count": 38, + "execution_count": 59, "metadata": {}, "output_type": "execute_result" } @@ -639,24 +669,22 @@ }, { "cell_type": "code", - "execution_count": 98, - "id": "6600a0b3", + "execution_count": 60, + "id": "cf3ce29e", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:344: UserWarning: The channel auxins/0/sample.auxin0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", - " warnings.warn(f\"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.\")\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "Will record 25112 samples in 15.000000000000002s!\n", - "MFLI returns a total record time of {'duration': array([15.00023467])}s\n" + "sample rates: [1674.107177734375, 1674.107177734375, None]\n", + "SETTING TRIGMODE 6\n", + "SETTING TRIGGERNODE: ('triggernode', '/dev3442/demods/0/sample.TrigIn1')\n", + "using trigger edge: 0\n", + "Will record 2512 per row samples for 1.500000000001s!\n", + "3 row(s) will be recorded.\n", + "the following trigger settings will be used: {'trigger_input': '/dev3442/demods/0/sample.TrigIn1', 'edge': 'rising', 'number_of_triggers_to_buffer': 3, 'level': 0.5, 'delay': -0.001, 'post_delay': 0.001, 'other_settings': {'holdoff/time': 1e-08}}\n", + "MFLI returns a total record time of 1.5005013333333335s\n" ] } ], @@ -666,537 +694,309 @@ }, { "cell_type": "code", - "execution_count": 99, - "id": "7fb8a8f3", - "metadata": { - "scrolled": true - }, + "execution_count": 57, + "id": "1505ae0a", + "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "Waiting for device dev3442 to finish the acquisition.\n", - "{'buffercount': array([77], dtype=int64), 'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664529215402434], dtype=uint64), 'createdtimestamp': array([316381462056], dtype=uint64), 'changedtimestamp': array([316381462056], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '004 11:13:35.4017', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[ 0, 0, 0, ..., 317281356936,\n", - " 317281392776, 317281428616]], dtype=uint64), 'value': array([[ nan, nan, nan, ..., -0.00232198,\n", - " -0.00232198, -0.00232198]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664529215402983], dtype=uint64), 'createdtimestamp': array([316381462056], dtype=uint64), 'changedtimestamp': array([316381462056], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '004 11:13:35.4017', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[316381450376, 316381486216, 316381522056, ..., 317281356936,\n", - " 317281392776, 317281428616]], dtype=uint64), 'value': array([[1.59011277e-07, 4.70619023e-07, 6.68435541e-07, ...,\n", - " 5.32911742e-07, 5.30974673e-07, 4.72225932e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664529215403471], dtype=uint64), 'createdtimestamp': array([316381462056], dtype=uint64), 'changedtimestamp': array([316381462056], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '004 11:13:35.4017', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([25112], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[316381450376, 316381486216, 316381522056, ..., 317281356936,\n", - " 317281392776, 317281428616]], dtype=uint64), 'value': array([[-1.00858959e-07, -6.24829378e-08, 5.21458498e-09, ...,\n", - " -9.96038947e-09, -1.75158872e-07, -3.89508749e-07]])}]}}}, 'duration': array([15.00023467]), 'forcetrigger': array([0], dtype=int64), 'triggered': array([0], dtype=int64)}\n" + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_28156\\508965523.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mmy_lockin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mforce_trigger\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " ] } ], "source": [ - "data = my_lockin.measure_program([\"\"])" + "for _ in range(3):\n", + " my_lockin.force_trigger(None)\n", + " time.sleep(3)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8504fda1", + "metadata": {}, + "outputs": [], + "source": [ + "for _ in range(3):\n", + " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 1)\n", + " time.sleep(1)\n", + " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 0)\n", + " time.sleep(3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ab20ee5", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.finish()" ] }, { "cell_type": "code", - "execution_count": 74, - "id": "a4e923e8", + "execution_count": null, + "id": "8d97dfac", "metadata": { "scrolled": true }, - "outputs": [ - { - "data": { - "text/plain": [ - "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[-0.00211383, -0.00209682, -0.00207982, ..., -0.00121121,\n", - " -0.00121688, -0.00122255]])\n", - " Coordinates:\n", - " timestamp (row, col) float64 4.482e+12 4.482e+12 ... 4.497e+12 4.497e+12\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664528424329287]\n", - " createdtimestamp: [268898909736]\n", - " changedtimestamp: [268898909736]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 003 11:00:24.3286\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.r': [\n", - " array([[4.24502350e-08, 3.83220570e-07, 6.39577112e-07, ...,\n", - " 2.91820932e-07, 1.21077468e-07, 1.73901447e-07]])\n", - " Coordinates:\n", - " timestamp (row, col) float64 4.482e+12 4.482e+12 ... 4.497e+12 4.497e+12\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664528424329823]\n", - " createdtimestamp: [268898909736]\n", - " changedtimestamp: [268898909736]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 003 11:00:24.3286\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.x': [\n", - " array([[-4.11211373e-08, -3.45698104e-07, -5.54790943e-07, ...,\n", - " -2.84726146e-07, -1.17343409e-07, 2.52172809e-08]])\n", - " Coordinates:\n", - " timestamp (row, col) float64 4.482e+12 4.482e+12 ... 4.497e+12 4.497e+12\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664528424330307]\n", - " createdtimestamp: [268898909736]\n", - " changedtimestamp: [268898909736]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 003 11:00:24.3286\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}" - ] - }, - "execution_count": 74, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "data" + "data = my_lockin.measure_program()\n", + "plot_windows(data)" ] }, { "cell_type": "code", - "execution_count": 75, - "id": "3261c214", + "execution_count": 45, + "id": "e36fb677", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "4481648300933.333\n", - "4481648898266.667\n", - "4481649495600.0\n", - "4481650092933.333\n", - "4481650690266.667\n", - "4481651287600.0\n", - "4481651884933.333\n", - "4481652482266.667\n", - "4481653079600.0\n", - "4481653676933.333\n", - "4481654274266.667\n", - "4481654871600.0\n", - "4481655468933.333\n", - "4481656066266.667\n", - "4481656663600.0\n", - "4481657260933.333\n", - "4481657858266.667\n", - "4481658455600.0\n", - "4481659052933.333\n", - "4481659650266.667\n", - "---\n", - "4496636588933.334\n", - "4496637186266.666\n", - "4496637783600.0\n", - "4496638380933.333\n", - "4496638978266.667\n", - "4496639575600.0\n", - "4496640172933.333\n", - "4496640770266.667\n", - "4496641367600.0\n", - "4496641964933.333\n", - "4496642562266.667\n", - "4496643159600.0\n", - "4496643756933.333\n", - "4496644354266.667\n", - "4496644951600.0\n", - "4496645548933.333\n", - "4496646146266.667\n", - "4496646743600.0\n", - "4496647340933.333\n", - "4496647938266.667\n" + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(597)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 595 \u001b[1;33m \u001b[0mstart_waiting\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 596 \u001b[1;33m \u001b[1;32mwhile\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfinished\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mwait\u001b[0m \u001b[1;32mand\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mstart_waiting\u001b[0m\u001b[1;33m>\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 597 \u001b[1;33m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 598 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Waiting for device {self.serial} to finish the acquisition...\"\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# Progress: {self.daq.progress()[0]}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 599 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> r\n" ] } ], "source": [ - "for e in data['/dev3442/auxins/0/sample.auxin0.avg'][0][\"timestamp\"].values[0, :20]:\n", - " print(e)\n", - "print(\"---\")\n", - "for e in data['/dev3442/auxins/0/sample.auxin0.avg'][0][\"timestamp\"].values[0, -20:]:\n", - " print(e)" + "%debug" ] }, { "cell_type": "code", - "execution_count": 63, - "id": "9b6e205d", + "execution_count": 56, + "id": "7ea34368", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.89951232" + "{'awgcontrol': array([0], dtype=int64),\n", + " 'bandwidth': array([0.]),\n", + " 'bitmask': array([1], dtype=int64),\n", + " 'bits': array([1], dtype=int64),\n", + " 'buffercount': array([10], dtype=int64),\n", + " 'buffersize': array([0.2]),\n", + " 'clearhistory': array([0], dtype=int64),\n", + " 'count': array([3], dtype=int64),\n", + " 'delay': array([-0.001]),\n", + " 'dev3442': {'demods': {'0': {'sample.x': [{'header': {'systemtime': array([1664558103553351], dtype=uint64),\n", + " 'createdtimestamp': array([2050547636776], dtype=uint64),\n", + " 'changedtimestamp': array([2050906036776], dtype=uint64),\n", + " 'flags': array([1849], dtype=uint32),\n", + " 'moduleflags': array([0], dtype=uint32),\n", + " 'chunksizebytes': array([0], dtype=uint64),\n", + " 'name': '003 19:15:03.5532',\n", + " 'status': array([0], dtype=uint32),\n", + " 'groupindex': array([0], dtype=uint32),\n", + " 'color': array([0], dtype=uint32),\n", + " 'activerow': array([2], dtype=uint32),\n", + " 'triggernumber': array([0], dtype=uint64),\n", + " 'gridrows': array([3], dtype=uint32),\n", + " 'gridcols': array([1256], dtype=uint32),\n", + " 'gridmode': array([4], dtype=uint32),\n", + " 'gridoperation': array([1], dtype=uint32),\n", + " 'griddirection': array([0], dtype=uint32),\n", + " 'gridrepetitions': array([1], dtype=uint32),\n", + " 'gridcoldelta': array([0.00119467]),\n", + " 'gridcoloffset': array([-0.001]),\n", + " 'gridrowdelta': array([1.]),\n", + " 'gridrowoffset': array([0.]),\n", + " 'bandwidth': array([nan]),\n", + " 'center': array([0.]),\n", + " 'nenbw': array([nan])},\n", + " 'timestamp': array([[2050547625096, 2050547696776, 2050547768456, ..., 2050637440136,\n", + " 2050637511816, 2050637583496],\n", + " [2050728258696, 2050728330376, 2050728402056, ..., 2050818073736,\n", + " 2050818145416, 2050818217096],\n", + " [2050906025096, 2050906096776, 2050906168456, ..., 2050995840136,\n", + " 2050995911816, 2050995983496]], dtype=uint64),\n", + " 'value': array([[-3.19561798e-07, 1.67769002e-07, 5.44787502e-07, ...,\n", + " 4.46304136e-08, -5.92941542e-08, 2.84974289e-07],\n", + " [-3.30585912e-07, 9.90783104e-08, 4.78993204e-08, ...,\n", + " -7.80902188e-10, -3.75496757e-08, -1.17205286e-07],\n", + " [-4.02696190e-07, -1.92283112e-07, -2.46849998e-07, ...,\n", + " 2.75505401e-07, -2.89131128e-08, 7.18154963e-08]])}]}}},\n", + " 'device': ['dev3442'],\n", + " 'duration': array([1.50050133]),\n", + " 'edge': array([1], dtype=int64),\n", + " 'enable': array([1], dtype=int64),\n", + " 'endless': array([0], dtype=int64),\n", + " 'eventcount': {'mode': array([1], dtype=int64)},\n", + " 'fft': {'absolute': array([0], dtype=int64),\n", + " 'window': array([1], dtype=int64)},\n", + " 'findlevel': array([0], dtype=int64),\n", + " 'flags': array([8], dtype=int64),\n", + " 'forcetrigger': array([0], dtype=int64),\n", + " 'grid': {'cols': array([1256], dtype=int64),\n", + " 'direction': array([0], dtype=int64),\n", + " 'mode': array([4], dtype=int64),\n", + " 'overwrite': array([0], dtype=int64),\n", + " 'repetitions': array([1], dtype=int64),\n", + " 'rowrepetition': array([0], dtype=int64),\n", + " 'rows': array([3], dtype=int64),\n", + " 'waterfall': array([0], dtype=int64)},\n", + " 'historylength': array([100000], dtype=int64),\n", + " 'holdoff': {'count': array([0], dtype=int64), 'time': array([0.2])},\n", + " 'hysteresis': array([0.]),\n", + " 'level': array([0.5]),\n", + " 'preview': array([0], dtype=int64),\n", + " 'pulse': {'max': array([0.001]), 'min': array([0.])},\n", + " 'refreshrate': array([5.]),\n", + " 'save': {'csvlocale': ['C'],\n", + " 'csvseparator': [';'],\n", + " 'directory': ['C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer'],\n", + " 'fileformat': array([0], dtype=int64),\n", + " 'filename': ['dataAcquisitionModule'],\n", + " 'save': array([0], dtype=int64),\n", + " 'saveonread': array([0], dtype=int64)},\n", + " 'spectrum': {'autobandwidth': array([0], dtype=int64),\n", + " 'enable': array([0], dtype=int64),\n", + " 'frequencyspan': array([13000.]),\n", + " 'overlapped': array([1], dtype=int64)},\n", + " 'triggered': array([0], dtype=int64),\n", + " 'triggernode': ['/dev3442/demods/0/sample.TrigIn1'],\n", + " 'type': array([6], dtype=int64)}" ] }, - "execution_count": 63, + "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "(130556892296-129657379976)*1e-9" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "id": "8f7b38e3", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-0.0021138295076801594\n", - "-0.002096822800171233\n", - "-0.0020798160926623066\n", - "-0.00206280938515338\n", - "-0.0020458026776444538\n", - "-0.0020287959701355274\n", - "-0.002011789262626601\n", - "-0.0019947825551176745\n", - "-0.001977775847608748\n", - "-0.0019607691400998217\n", - "-0.0019437624325908953\n", - "-0.001926755725081969\n", - "-0.0019097490175730425\n", - "-0.001892742310064116\n", - "-0.0018757356025551897\n", - "-0.0018587288950462633\n", - "-0.0018417221875373369\n", - "-0.0018247154800284104\n", - "-0.001807708772519484\n", - "-0.0017907020650105576\n", - "-0.0017736953575016312\n", - "-0.0017566886499927048\n", - "-0.0017396819424837784\n", - "-0.001722675234974852\n", - "-0.0017056685274659256\n", - "-0.0016886618199569992\n", - "-0.0016716551124480727\n", - "-0.0016572554041315024\n", - "-0.001651586501628527\n", - "-0.0016459175991255515\n", - "-0.001640248696622576\n", - "-0.0016345797941196005\n", - "-0.001628910891616625\n", - "-0.0016232419891136496\n", - "-0.0016175730866106741\n", - "-0.0016119041841076986\n", - "-0.0016062352816047232\n", - "-0.0016005663791017477\n", - "-0.0015948974765987722\n", - "-0.0015892285740957968\n" - ] - } - ], - "source": [ - "for e in data['/dev3442/auxins/0/sample.auxin0.avg'][0].values[0, :40]:\n", - " print(e)" + "my_lockin.daq_read_return" ] }, { "cell_type": "code", - "execution_count": 107, - "id": "ac968e7b", + "execution_count": 54, + "id": "8ad94d37", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "/dev3442/demods/0/sample.x\n", - "time_of_trigger=[5.27302317e+12]\n", - "extracted_data=[\n", - "array([[ 8.20515335e-08, -1.37302456e-07, -2.23006770e-07, ...,\n", - " -2.51220898e-07, -8.52887497e-08, -8.56558814e-08]])\n", - "Coordinates:\n", - " time (row, col) float64 1e+10 1e+10 1e+10 ... 1.3e+10 1.3e+10 1.3e+10\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664529215403471]\n", - " createdtimestamp: [316381462056]\n", - " changedtimestamp: [316381462056]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 004 11:13:35.4017\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]\n", - "/dev3442/demods/0/sample.r\n", - "time_of_trigger=[5.27302317e+12]\n", - "time_of_trigger=[5.27302317e+12]\n", - "extracted_data=[\n", - "array([[5.09070137e-07, 4.36690684e-07, 4.20131474e-07, ...,\n", - " 5.52220621e-07, 5.07130206e-07, 2.38696738e-07]])\n", - "Coordinates:\n", - " time (row, col) float64 6.501e+09 6.501e+09 ... 7.899e+09 7.9e+09\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664529215402983]\n", - " createdtimestamp: [316381462056]\n", - " changedtimestamp: [316381462056]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 004 11:13:35.4017\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan], \n", - "array([[4.39980625e-07, 5.04697280e-07, 4.95701644e-07, ...,\n", - " 2.04461446e-07, 3.65230061e-07, 5.32911742e-07]])\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(544)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 542 \u001b[1;33m \u001b[0mcn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34mf\"/{self.serial}/{_cn}\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlower\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 543 \u001b[1;33m \u001b[1;31m# print(cn)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 544 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mcn\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m<=\u001b[0m \u001b[0mshot_index\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 545 \u001b[1;33m \u001b[1;31m# then we do not have data for this shot_index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 546 \u001b[1;33m \u001b[0mwarnings\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwarn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{shot_index}]\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(640)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 636 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mrecorded_data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 637 \u001b[1;33m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 638 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 639 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 640 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcurrently_set_program\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\appdata\\local\\temp\\ipykernel_27380\\3532927405.py\u001b[0m(1)\u001b[0;36m\u001b[1;34m()\u001b[0m\n", + "\n", + "ipdb> d\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(640)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 636 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mrecorded_data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 637 \u001b[1;33m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 638 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 639 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 640 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcurrently_set_program\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> recorded_data\n", + "{'/dev3442/demods/0/sample.x': [\n", + "array([[-3.19561798e-07, 1.67769002e-07, 5.44787502e-07, ...,\n", + " 4.46304136e-08, -5.92941542e-08, 2.84974289e-07],\n", + " [-3.30585912e-07, 9.90783104e-08, 4.78993204e-08, ...,\n", + " -7.80902188e-10, -3.75496757e-08, -1.17205286e-07],\n", + " [-4.02696190e-07, -1.92283112e-07, -2.46849998e-07, ...,\n", + " 2.75505401e-07, -2.89131128e-08, 7.18154963e-08]])\n", "Coordinates:\n", - " time (row, col) float64 1.4e+10 1.4e+10 1.4e+10 ... 1.5e+10 1.5e+10\n", + " time (row, col) float64 3.418e+13 3.418e+13 ... 3.418e+13 3.418e+13\n", "Dimensions without coordinates: row, col\n", "Attributes:\n", - " systemtime: [1664529215402983]\n", - " createdtimestamp: [316381462056]\n", - " changedtimestamp: [316381462056]\n", + " systemtime: [1664558103553351]\n", + " createdtimestamp: [2050547636776]\n", + " changedtimestamp: [2050906036776]\n", " flags: [1849]\n", " moduleflags: [0]\n", " chunksizebytes: [0]\n", - " name: 004 11:13:35.4017\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]\n", - "/dev3442/auxins/0/sample.auxin0.avg\n", - "time_of_trigger=[5.27309366e+12]\n", - "time_of_trigger=[5.27309366e+12]\n", - "extracted_data=[\n", - "array([[-0.00120247, -0.00121381, -0.00122515, ..., -0.00054094,\n", - " -0.00051259, -0.00048425]])\n", - "Coordinates:\n", - " time (row, col) float64 3e+09 3.001e+09 3.001e+09 ... 4.499e+09 4.5e+09\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664529215402434]\n", - " createdtimestamp: [316381462056]\n", - " changedtimestamp: [316381462056]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 004 11:13:35.4017\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan], \n", - "array([[-0.00106838, -0.00109105, -0.00111373, ..., -0.00232198,\n", - " -0.00232198, -0.00232198]])\n", - "Coordinates:\n", - " time (row, col) float64 1.2e+10 1.2e+10 1.2e+10 ... 1.493e+10 1.493e+10\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664529215402434]\n", - " createdtimestamp: [316381462056]\n", - " changedtimestamp: [316381462056]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 004 11:13:35.4017\n", + " name: 003 19:15:03.5532\n", " status: [0]\n", " groupindex: [0]\n", " color: [0]\n", - " activerow: [0]\n", + " activerow: [2]\n", " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", " gridmode: [4]\n", " gridoperation: [1]\n", " griddirection: [0]\n", " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", + " gridcoldelta: [0.00119467]\n", " gridcoloffset: [-0.001]\n", " gridrowdelta: [1.]\n", " gridrowoffset: [0.]\n", " bandwidth: [nan]\n", " center: [0.]\n", - " nenbw: [nan]]\n" + " nenbw: [nan]]}\n", + "ipdb> r\n" ] } ], "source": [ - "extracted_data = my_lockin._parse_data(data, program_name=\"test\")" + "%debug" ] }, { "cell_type": "code", - "execution_count": 105, - "id": "65c30f52", + "execution_count": 101, + "id": "168c5a85", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.])" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "def plot_windows(data):\n", - " for j, w in enumerate(data.keys()):\n", - " for i, c in enumerate(data[w].keys()):\n", - " for e in data[w][c]:\n", - " print(e[\"time\"].values, e.values)\n", - " plt.plot(e[\"time\"].values.T, e.values.T, color=f\"C{j}\")\n", - " plt.show()" + "my_lockin.daq.progress()" ] }, { "cell_type": "code", - "execution_count": 108, - "id": "e06ffa46", - "metadata": {}, + "execution_count": 167, + "id": "c3a053dd", + "metadata": { + "scrolled": false + }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[1.00003600e+10 1.00009573e+10 1.00015547e+10 ... 1.29983760e+10\n", - " 1.29989733e+10 1.29995707e+10]] [[ 8.20515335e-08 -1.37302456e-07 -2.23006770e-07 ... -2.51220898e-07\n", - " -8.52887497e-08 -8.56558814e-08]]\n", - "[[6.50058400e+09 6.50118133e+09 6.50177867e+09 ... 7.89834400e+09\n", - " 7.89894133e+09 7.89953867e+09]] [[5.09070137e-07 4.36690684e-07 4.20131474e-07 ... 5.52220621e-07\n", - " 5.07130206e-07 2.38696738e-07]]\n", - "[[1.40001040e+10 1.40007013e+10 1.40012987e+10 ... 1.49982480e+10\n", - " 1.49988453e+10 1.49994427e+10]] [[4.39980625e-07 5.04697280e-07 4.95701644e-07 ... 2.04461446e-07\n", - " 3.65230061e-07 5.32911742e-07]]\n", - "[[3.00021067e+09 3.00080800e+09 3.00140533e+09 ... 4.49832267e+09\n", - " 4.49892000e+09 4.49951733e+09]] [[-0.00120247 -0.00121381 -0.00122515 ... -0.00054094 -0.00051259\n", - " -0.00048425]]\n", - "[[1.20002320e+10 1.20008293e+10 1.20014267e+10 ... 1.49289573e+10\n", - " 1.49295547e+10 1.49301520e+10]] [[-0.00106838 -0.00109105 -0.00111373 ... -0.00232198 -0.00232198\n", - " -0.00232198]]\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1208,13 +1008,23 @@ } ], "source": [ - "plot_windows(extracted_data)" + "plot_windows(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "e8877df8", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.daq.finish()" ] }, { "cell_type": "code", "execution_count": 50, - "id": "405f9760", + "id": "d3be623b", "metadata": {}, "outputs": [ { @@ -1320,7 +1130,7 @@ { "cell_type": "code", "execution_count": 39, - "id": "baed7050", + "id": "5c20f912", "metadata": { "scrolled": true }, @@ -1344,7 +1154,7 @@ { "cell_type": "code", "execution_count": null, - "id": "147a4673", + "id": "cef17340", "metadata": {}, "outputs": [], "source": [ @@ -1354,7 +1164,7 @@ { "cell_type": "code", "execution_count": 43, - "id": "8ce05631", + "id": "637ecff1", "metadata": {}, "outputs": [], "source": [ @@ -1364,7 +1174,7 @@ { "cell_type": "code", "execution_count": 72, - "id": "1b13babc", + "id": "fbdc56bb", "metadata": {}, "outputs": [ { @@ -1803,7 +1613,7 @@ { "cell_type": "code", "execution_count": 48, - "id": "1b3b9518", + "id": "a94dfaf4", "metadata": {}, "outputs": [ { @@ -1824,7 +1634,7 @@ { "cell_type": "code", "execution_count": 71, - "id": "b9a1f37a", + "id": "8805f40b", "metadata": {}, "outputs": [ { @@ -1850,7 +1660,7 @@ { "cell_type": "code", "execution_count": 68, - "id": "4bacd809", + "id": "52e6aa2b", "metadata": {}, "outputs": [ { @@ -1883,7 +1693,7 @@ { "cell_type": "code", "execution_count": 55, - "id": "2b295dca", + "id": "27dad9d5", "metadata": { "scrolled": true }, @@ -1942,7 +1752,7 @@ { "cell_type": "code", "execution_count": 63, - "id": "de5e322a", + "id": "811091f9", "metadata": {}, "outputs": [ { @@ -1977,7 +1787,7 @@ { "cell_type": "code", "execution_count": 192, - "id": "c277273e", + "id": "52865ab1", "metadata": {}, "outputs": [ { @@ -2046,7 +1856,7 @@ { "cell_type": "code", "execution_count": 174, - "id": "a71d1807", + "id": "543ff392", "metadata": {}, "outputs": [ { @@ -2073,7 +1883,7 @@ { "cell_type": "code", "execution_count": 123, - "id": "0fa92ea7", + "id": "ac680e56", "metadata": {}, "outputs": [], "source": [ @@ -2083,7 +1893,7 @@ { "cell_type": "code", "execution_count": 145, - "id": "b8101857", + "id": "dd7e1cee", "metadata": { "scrolled": false }, @@ -2106,7 +1916,7 @@ { "cell_type": "code", "execution_count": 119, - "id": "ae4e4a2e", + "id": "0d1c6fa7", "metadata": {}, "outputs": [ { @@ -2127,7 +1937,7 @@ { "cell_type": "code", "execution_count": 110, - "id": "a8954de7", + "id": "ec8c9d7a", "metadata": {}, "outputs": [], "source": [ @@ -2137,7 +1947,7 @@ { "cell_type": "code", "execution_count": 111, - "id": "24b03728", + "id": "20bace43", "metadata": {}, "outputs": [ { @@ -2200,7 +2010,7 @@ { "cell_type": "code", "execution_count": 44, - "id": "09d01f1c", + "id": "c3800665", "metadata": {}, "outputs": [], "source": [ @@ -2210,7 +2020,7 @@ { "cell_type": "code", "execution_count": 45, - "id": "38658331", + "id": "d06129a4", "metadata": {}, "outputs": [ { @@ -2231,7 +2041,7 @@ { "cell_type": "code", "execution_count": 202, - "id": "73bb08c9", + "id": "24513c96", "metadata": {}, "outputs": [], "source": [ @@ -2241,7 +2051,7 @@ { "cell_type": "code", "execution_count": 114, - "id": "0142d680", + "id": "9e35f6c6", "metadata": {}, "outputs": [ { @@ -2262,7 +2072,7 @@ { "cell_type": "code", "execution_count": 117, - "id": "b6de4fef", + "id": "1849020f", "metadata": {}, "outputs": [ { @@ -2283,7 +2093,7 @@ { "cell_type": "code", "execution_count": 116, - "id": "949a4afd", + "id": "83a442ce", "metadata": {}, "outputs": [], "source": [ @@ -2293,7 +2103,7 @@ { "cell_type": "code", "execution_count": 193, - "id": "8eb9a8a3", + "id": "88477813", "metadata": {}, "outputs": [], "source": [ @@ -2303,7 +2113,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a98682c4", + "id": "7f0085dc", "metadata": {}, "outputs": [], "source": [] @@ -2311,7 +2121,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a24964df", + "id": "19a6e2a0", "metadata": {}, "outputs": [], "source": [] @@ -2319,7 +2129,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4efc42cd", + "id": "e43a3a28", "metadata": {}, "outputs": [], "source": [] @@ -2327,7 +2137,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "20a2271a", + "id": "2a2ed4e9", "metadata": {}, "outputs": [], "source": [ @@ -2337,7 +2147,7 @@ { "cell_type": "code", "execution_count": 32, - "id": "076f88d5", + "id": "acf9f6a3", "metadata": {}, "outputs": [], "source": [ @@ -2348,7 +2158,7 @@ { "cell_type": "code", "execution_count": 33, - "id": "9f91dd46", + "id": "cf0c1df9", "metadata": {}, "outputs": [], "source": [ @@ -2358,7 +2168,7 @@ { "cell_type": "code", "execution_count": 37, - "id": "28967643", + "id": "6fd7b881", "metadata": {}, "outputs": [ { @@ -3477,7 +3287,7 @@ { "cell_type": "code", "execution_count": 29, - "id": "e15e512d", + "id": "94f249a8", "metadata": {}, "outputs": [ { @@ -3503,7 +3313,7 @@ { "cell_type": "code", "execution_count": null, - "id": "364be378", + "id": "79514940", "metadata": {}, "outputs": [], "source": [] @@ -3511,7 +3321,7 @@ { "cell_type": "code", "execution_count": 35, - "id": "3411b4bc", + "id": "4b9be78c", "metadata": {}, "outputs": [], "source": [ @@ -3522,7 +3332,7 @@ { "cell_type": "code", "execution_count": 31, - "id": "ac9dfd61", + "id": "60433d76", "metadata": {}, "outputs": [], "source": [ @@ -3532,7 +3342,7 @@ { "cell_type": "code", "execution_count": 78, - "id": "5053c5b5", + "id": "3a268246", "metadata": {}, "outputs": [ { @@ -3558,7 +3368,7 @@ { "cell_type": "code", "execution_count": null, - "id": "bd206f1b", + "id": "7a251206", "metadata": {}, "outputs": [], "source": [] @@ -3566,7 +3376,7 @@ { "cell_type": "code", "execution_count": null, - "id": "053b7e08", + "id": "aee44ece", "metadata": {}, "outputs": [], "source": [] @@ -3574,7 +3384,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b40d3759", + "id": "ab4f5c02", "metadata": {}, "outputs": [], "source": [] @@ -3582,7 +3392,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0621bc14", + "id": "c3e129c7", "metadata": {}, "outputs": [], "source": [] @@ -3590,7 +3400,7 @@ { "cell_type": "code", "execution_count": null, - "id": "14d169ab", + "id": "cc7cf2f4", "metadata": {}, "outputs": [], "source": [] diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index a5ed4a78d..d7c26a93b 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -41,12 +41,15 @@ [X] rethink handling different sample rates! [X] cut obtained data to fit into requested windows [ ] provide interface for changing trigger settings -[ ] print information about how long the measurement is expected to run +[X] print information about how long the measurement is expected to run [ ] implement multiple triggers (using rows) (and check how this actually behaves) - [ ] count + [X] count [ ] endless + [ ] check how that would behave. Does that overwrite or shift things? [ ] change in trigger input port [X] implement setting recording channel (could that be already something inside qupulse?) +[ ] see why for high sample rates (e.g. 857.1k) things crash or don't behave as expected +[ ] Implement yield for not picked up data (read() was not called) => this should be sufficient for operation [ ] implement optional operations (averaging, binning, up/down sampling, ...) [ ] implement scope interface for higher sample rates (if i understood the documentation correctly) @@ -69,6 +72,10 @@ [ ] adding multiple channels to one windows [ ] adding one channel to multiple windows [ ] measuring only one AUXIN (some channel without the rate argument) +[ ] finishing the acquisition before all rows are recorded (data processing (throwing out nans) might not work as intended) +[ ] what happens when the lock-in is not returning what it should? + [ ] missing channels + [ ] channels separated over multiple read() calls @@ -124,12 +131,12 @@ def __init__(self, device_serial: str = None, self.default_timeout = timeout self.serial = device_serial - self.daq = self.api_session.dataAcquisitionModule() - self.daq.set('device', device_serial) + self.daq = None + self._init_daq_module() - self.daq.set('type', 1) - self.daq.set('triggernode', '/dev3442/demods/0/sample.AuxIn0') - self.daq.set('endless', 0) + # self.daq.set('type', 1) + # self.daq.set('triggernode', '/dev3442/demods/0/sample.AuxIn0') + # self.daq.set('endless', 0) self.assumed_minimal_sample_rate = None @@ -142,15 +149,20 @@ def __init__(self, device_serial: str = None, self.programs = {} self.currently_set_program = None + def _init_daq_module(self): + self.daq = self.api_session.dataAcquisitionModule() + self.daq.set('device', self.serial) def reset_device(self): """ This function resets the device to a known default configuration. """ - - raise NotImplementedError() - + zhinst.utils.disable_everything(self.api_session, self.serial) self.clear() + self.daq.close() + self._init_daq_module() + + def register_measurement_channel(self, program_name:str=None, channel_path:Union[str, List[str]]=[], window_name:str=None): """ This function saves the channel one wants to record with a certain program @@ -187,6 +199,31 @@ def register_measurement_windows(self, program_name: str, windows: Dict[str, Tup # for k, v in windows.items(): # self.set_measurement_mask(program_name=program_name, mask_name=k, begins=v[0], lengths=v[1]) + def register_trigger_settings(self, program_name:str, trigger_input:Union[str, None]=None, edge:str='rising', number_of_triggers_to_buffer:int=1, level:float=0.1, delay:float=-1e-3, post_delay:float=1e-3, other_settings:Dict[str, Union[str, int, float]]={}): + """ + Parameters + ---------- + program_name + trigger_input + This needs to be the path to input to the lock-in that the lock-in is able to use as a trigger (without the device serial). (see https://docs.zhinst.com/pdf/LabOneProgrammingManual.pdf for more information) + edge + number_of_triggers_to_buffer + other_settings + """ + + if edge not in ["rising", "falling", "both"]: + raise ValueError(f"edge={edge} is not in ['rising', 'falling']") + + self.programs.setdefault(program_name, {})["trigger_settings"] = { + "trigger_input": f"/{self.serial}/{trigger_input}", + "edge": edge, + "number_of_triggers_to_buffer": number_of_triggers_to_buffer, + "level": level, + "delay": delay, + "post_delay": post_delay, + "other_settings": other_settings, + } + def _get_sample_rates(self, channel:str): try: timetype_sr = TimeType().from_float(value=self.api_session.getDouble(f"/{self.serial}/{self._get_demod(channel)}/rate"), absolute_error=0) @@ -315,7 +352,6 @@ def _get_channels_for_window(self, program_name, window_name=None): channels = set([e.lower() for e in channels]) return channels - def _get_demod(self, channel:str): """ This function gets the demodulator corresponding to a channel @@ -332,6 +368,9 @@ def arm_program(self, program_name: str, force:bool=True) -> None: # check if program_name specified program is selected and important parameter set to the lock-in if self.currently_set_program is None or self.currently_set_program != program_name or force: + self.daq.finish() + self.daq.unsubscribe('*') + for c in self.programs[program_name]["all_channels"]: # activate corresponding demodulators @@ -364,9 +403,12 @@ def arm_program(self, program_name: str, force:bool=True) -> None: for c in self.programs[program_name]["all_channels"]: raw_currently_set_sample_rates.append(self._get_sample_rates(c)) + print(f"sample rates: {[(float(e) if e is not None else None) for e in raw_currently_set_sample_rates]}") + # CAUTION # The MFLI lock-ins up-sample slower channels to fit the fastest sample rate. # This is the cased for the Lab One Data Server 21.08.20515 and the MFLi Firmware 67629. + # TODO it needs to be verified, that this code here is actually necessary. One could also query the AUXIN using one of the demods. foo = [x for x in raw_currently_set_sample_rates if x is not None] if len(foo) == 0 and self.assumed_minimal_sample_rate is None: # Ok, we activate the first demodulator @@ -384,21 +426,76 @@ def arm_program(self, program_name: str, force:bool=True) -> None: # the following two lines set the row repetitions to 1 and off self.daq.set('grid/repetitions', 1) self.daq.set('grid/rowrepetition', 0) + + # setting trigger settings + ts = {} + try: + ts.update(self.programs[None]["trigger_settings"]) + except KeyError: + pass + try: + ts.update(self.programs[program_name]["trigger_settings"]) + except KeyError: + pass + rows = 1 + if len(ts) != 0: + rows = ts["number_of_triggers_to_buffer"] + # selecting the trigger channel + if ts["trigger_input"] is not None: + + self.daq.set('endless', 1) + self.daq.set('count', rows) # defines how many triggers are to be recorded in single mode i.e. endless==0 + + if "trig" in ts["trigger_input"].lower(): + print(f"SETTING TRIGMODE 6") + self.daq.set("type", 6) + else: + print(f"SETTING TRIGMODE 1") + self.daq.set("type", 1) + + self.daq.set("triggernode", ts["trigger_input"]) + self.daq.subscribe(ts["trigger_input"]) + print(f"SETTING TRIGGERNODE: {('triggernode', ts['trigger_input'])}") + + edge_key = ["rising", "falling", "both"].index(ts["edge"]) + print(f"using trigger edge: {edge_key}") + self.daq.set("edge", edge_key) + + self.daq.set("level", ts["level"]) + + + self.daq.set("delay", ts["delay"]) + self.daq.set('bandwidth', 0) + + else: + self.daq.set("type", 0) + + self.daq.set('count', rows) + + for k, v in ts["other_settings"].items(): + self.daq.set(k, v) + # set the buffer size according to the largest measurement window # TODO one might be able to implement this a bit more cleverly measurement_duration = np.max(list(self.programs[program_name]["windows_from_start_max"].values())) + measurement_duration += ts["post_delay"] larges_number_of_samples = 1e-9*max_sample_rate*measurement_duration larges_number_of_samples = np.ceil(larges_number_of_samples) self.daq.set('grid/cols', larges_number_of_samples) self.daq.set('grid/rows', rows) # this corresponds to measuring only for one trigger + # self.daq.set("buffersize", 2*measurement_duration) # that the buffer size is set to be larger than the duration is something that the SM script did. + # # --> in the current version and/or configuration, this path is read-only. + self.currently_set_program = program_name - print(f"Will record {larges_number_of_samples} samples in {measurement_duration*1e-9}s!") # TODO this will have to change if proper multi triggers with over multiple rows is going to be used. - print(f"MFLI returns a total record time of {self.daq.get('duration')}s") + print(f"Will record {larges_number_of_samples} per row samples for {measurement_duration*1e-9}s!") # TODO this will have to change if proper multi triggers with over multiple rows is going to be used. + print(f"{rows} row(s) will be recorded.") + print(f"the following trigger settings will be used: {ts}") + print(f"MFLI returns a total record time of {self.daq.get('duration')['duration'][0]}s") # execute daq self.daq.execute() @@ -406,11 +503,6 @@ def arm_program(self, program_name: str, force:bool=True) -> None: # wait until changes have taken place self.api_session.sync() - # # TODO this should be redundant with self.currently_set_program - # if program_name != None: - # self.programs.setdefault(program_name, {}).setdefault('armed', False) - # self.programs[program_name]['armed'] = True - def unarm_program(self, program_name:str): """ unarms the lock-in. This should be program independent. """ @@ -420,11 +512,6 @@ def unarm_program(self, program_name:str): self.api_session.sync() self.currently_set_program = None - - # # TODO this should be redundant with self.currently_set_program - # if program_name != None: - # self.programs.setdefault(program_name, {}).setdefault('armed', False) - # self.programs[program_name]['armed'] = False def force_trigger(self, program_name:str): """ forces a trigger @@ -432,6 +519,9 @@ def force_trigger(self, program_name:str): self.daq.set('forcetrigger', 1) + def stop_acquisition(self): + self.daq.finish() + def delete_program(self, program_name: str) -> None: """Delete program from internal memory.""" @@ -447,7 +537,7 @@ def clear(self) -> None: self.unarm_program(program_name=None) - def _parse_data(self, recorded_data, program_name): + def _parse_data(self, recorded_data, program_name:str): """ This function parses the recorded data and extracts the measurement masks and applies optional operations """ @@ -463,55 +553,79 @@ def _parse_data(self, recorded_data, program_name): masked_data = {} - shot_index = 0 + # the MFLI returns a list of measurements. We only proceed with the last ones from this list. One might want to iterate over that and process all of them. + # This feature might be useful if after some measurements no read() operation is called. Then with the later read, the data is returned. + # TODO this might be more elegantly implemented or handled using yields! + shot_index = 0 # TODO make this more flexible to not lose things for window_name in self.programs[program_name]["windows"]: data_by_channel = {} _wind = self.programs[program_name]["windows"][window_name] for ci, _cn in enumerate(self._get_channels_for_window(program_name, window_name)): cn = f"/{self.serial}/{_cn}".lower() - print(cn) + # print(cn) if len(recorded_data[cn]) <= shot_index: # then we do not have data for this shot_index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save. warnings.warn(f"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{shot_index}]") continue applicable_data = recorded_data[cn][-1-shot_index] + applicable_data = applicable_data.where(~np.isnan(applicable_data), drop=True) extracted_data = [] for b, l in zip(*_wind): - _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)["time"][:, 0].values + # _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)["time"][:, 0].values + _time_of_first_not_nan_value = applicable_data["time"][:, 0].values time_of_trigger = applicable_data.attrs["gridcoloffset"][0]*1e9+_time_of_first_not_nan_value - print(f"time_of_trigger={time_of_trigger}") - foo = applicable_data.where((applicable_data["time"]>=time_of_trigger+b) & (applicable_data["time"]<=time_of_trigger+b+l), drop=True) - foo["time"] -= time_of_trigger - extracted_data.append(foo) + # print(f"time_of_trigger={time_of_trigger}") + foo = applicable_data.where((applicable_data["time"]>=(time_of_trigger+b)[:, None]) & (applicable_data["time"]<=(time_of_trigger+b+l)[:, None]), drop=False).copy() + foo2 = foo.where(~np.isnan(foo), drop=True) + rows_with_data = np.sum(~np.isnan(foo), axis=-1)>0 + foo2["time"] -= time_of_trigger[rows_with_data, None] + extracted_data.append(foo2) - print(f"extracted_data={extracted_data}") + # print(f"extracted_data={extracted_data}") data_by_channel.update({cn: extracted_data}) masked_data[window_name] = data_by_channel return masked_data - def measure_program(self, channels: Iterable[str], wait=True, return_raw=False) -> Dict[str, np.ndarray]: - """Get the last measurement's results of the specified operations/channels""" + def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout:float=np.inf, return_raw:bool=False, fail_if_incomplete:bool=False) -> Union[Dict[str, List[xr.DataArray]], Dict[str, Dict[str, List[xr.DataArray]]]]: + """Get the last measurement's results of the specified operations/channels + + Parameters + ---------- + channels: Iterable[str], optional + Has no function here. (default: []) + wait: bool, optional + Should the code wait until the acquisition has finished? Else incomplete data might be returned. (default: True) + timeout: float, optional + The time to wait until the measurement is stopped in units of seconds. (default: np.inf) + return_raw: bool, optional + If True, the function will return the raw data without selecting the measurement windows. This will then be in the shape of data[channel_name][shot_index]: xr.DataArray. + If False, the return value will have the structure data[window_name][channel_name][mask_index]: xr.DataArray. + Also, if False, the time axis will be shifted, such that the trigger occurred at data[window_name][channel_name][mask_index]["time"]==0 #ns. + fail_if_incomplete: bool, optional + if True and the timeout has been reached and the acquisition has not finished, an error will be raised. + + """ # wait until the data acquisition has finished # TODO implement timeout - while not self.daq.finished() and wait: + start_waiting = time.time() + while not self.daq.finished() and wait and not (time.time()-start_waiting>timeout): time.sleep(1) - print(f"Waiting for device {self.serial} to finish the acquisition.") #Progress: {self.daq.progress()[0]} + print(f"Waiting for device {self.serial} to finish the acquisition...") # Progress: {self.daq.progress()[0]} - if not self.daq.finished(): - self.daq.finish() + if fail_if_incomplete and not self.daq.finished(): raise ValueError(f"Device {self.serial} did not finish the acquisition in time.") data = self.daq.read() self.daq_read_return.update(data) - self.clock_base = self.api_session.getDouble(f'/{self.serial}/clockbase') + self.clockbase = self.api_session.getDouble(f'/{self.serial}/clockbase') # go through the returned object and extract the data of interest @@ -525,7 +639,7 @@ def measure_program(self, channels: Iterable[str], wait=True, return_raw=False) channel_name = f"/{device_name}/{input_name}/{signal_name}/{final_level_name}".lower() channel_data = [xr.DataArray( data=d["value"], - coords={'time': (['row', 'col'], d["timestamp"]/self.clock_base*1e9)}, + coords={'time': (['row', 'col'], d["timestamp"]/self.clockbase*1e9)}, dims=['row', 'col'], name=channel_name, attrs=d['header']) for i, d in enumerate(final_level_data)] @@ -538,8 +652,12 @@ def measure_program(self, channels: Iterable[str], wait=True, return_raw=False) if any([len(v)>1 for v in recorded_shapes.values()]) or len(set([e for a in recorded_shapes.values() for e in a]))>1: warnings.warn(f"For at least one received channel entries with different dimensions are present. This might lead to undesired masking! (The code will not raise an exception.) ({recorded_shapes})") + if len(recorded_data) == 0: + warnings.warn(f"No data has been recorded!") if return_raw: return recorded_data else: + if len(recorded_data) == 0: + return None return self._parse_data(recorded_data, self.currently_set_program) \ No newline at end of file From 9892900ce969e8ceaba80349b0633833c96821cf Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Tue, 4 Oct 2022 14:09:57 +0200 Subject: [PATCH 12/25] trigger working better --- ...struments_lockin_mfli_daq-checkpoint.ipynb | 719 ++++++++++++++---- .../zurich_instruments_lockin_mfli_daq.ipynb | 594 +++++++++++++-- qupulse/hardware/dacs/mfli.py | 134 +++- 3 files changed, 1202 insertions(+), 245 deletions(-) diff --git a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb index 478be723f..415c31b6b 100644 --- a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb +++ b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "43453764", + "id": "6b0bdb5f", "metadata": {}, "source": [ "# Zurich Instruments Lock-In MFLI Data Aquesition" @@ -11,7 +11,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "c69fa628", + "id": "37894582", "metadata": {}, "outputs": [], "source": [ @@ -22,7 +22,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "e855b9bf", + "id": "debe96ac", "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "9fe04cf3", + "id": "c0050171", "metadata": {}, "outputs": [], "source": [ @@ -42,7 +42,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "0b2cdab3", + "id": "f8975a27", "metadata": {}, "outputs": [], "source": [ @@ -52,7 +52,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "d6c55de0", + "id": "624c2d4f", "metadata": {}, "outputs": [], "source": [ @@ -62,7 +62,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "b32f20c2", + "id": "76ba4dc7", "metadata": {}, "outputs": [], "source": [ @@ -72,7 +72,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "f25240e4", + "id": "65986db0", "metadata": {}, "outputs": [ { @@ -91,7 +91,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "535354b6", + "id": "42af2895", "metadata": {}, "outputs": [], "source": [ @@ -101,7 +101,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "d420284a", + "id": "a2599d33", "metadata": {}, "outputs": [], "source": [ @@ -111,7 +111,7 @@ { "cell_type": "code", "execution_count": 10, - "id": "82d030c2", + "id": "016ae5ee", "metadata": {}, "outputs": [], "source": [ @@ -122,7 +122,7 @@ { "cell_type": "code", "execution_count": 11, - "id": "37577ca4", + "id": "264cb7fa", "metadata": {}, "outputs": [], "source": [ @@ -138,7 +138,7 @@ { "cell_type": "code", "execution_count": 12, - "id": "9b339ce8", + "id": "bb0ef71a", "metadata": {}, "outputs": [], "source": [ @@ -149,7 +149,7 @@ { "cell_type": "code", "execution_count": 13, - "id": "32c4d432", + "id": "460a60f0", "metadata": {}, "outputs": [ { @@ -177,7 +177,7 @@ { "cell_type": "code", "execution_count": 14, - "id": "78f39281", + "id": "bc46a01c", "metadata": {}, "outputs": [], "source": [ @@ -187,7 +187,7 @@ { "cell_type": "code", "execution_count": 15, - "id": "b8240692", + "id": "f45534ef", "metadata": {}, "outputs": [ { @@ -222,7 +222,7 @@ { "cell_type": "code", "execution_count": 16, - "id": "ba83fdae", + "id": "eb3c0a0e", "metadata": {}, "outputs": [], "source": [ @@ -232,7 +232,7 @@ { "cell_type": "code", "execution_count": 17, - "id": "2ee09290", + "id": "60fe5854", "metadata": {}, "outputs": [ { @@ -260,14 +260,14 @@ { "cell_type": "code", "execution_count": null, - "id": "55ae8542", + "id": "4955fbc2", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "1bf4a681", + "id": "303053e3", "metadata": {}, "source": [ "## Defining a simple qupulse pulse with a measurement window." @@ -276,7 +276,7 @@ { "cell_type": "code", "execution_count": 18, - "id": "5d6744c8", + "id": "37b55006", "metadata": {}, "outputs": [], "source": [ @@ -286,7 +286,7 @@ { "cell_type": "code", "execution_count": 19, - "id": "8fd2dbdd", + "id": "be93574e", "metadata": {}, "outputs": [], "source": [ @@ -303,7 +303,7 @@ { "cell_type": "code", "execution_count": 20, - "id": "d43c43a9", + "id": "1d42e3fc", "metadata": {}, "outputs": [], "source": [ @@ -321,7 +321,7 @@ { "cell_type": "code", "execution_count": 21, - "id": "bac63dff", + "id": "d2632242", "metadata": {}, "outputs": [], "source": [ @@ -333,7 +333,7 @@ { "cell_type": "code", "execution_count": 22, - "id": "db319070", + "id": "ea1cdd4c", "metadata": {}, "outputs": [ { @@ -352,14 +352,14 @@ { "cell_type": "code", "execution_count": 23, - "id": "42750aa0", + "id": "eb2ea77b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'A', 'T', 'R'}\n", + "{'A', 'R', 'T'}\n", "[]\n", "set()\n" ] @@ -374,7 +374,7 @@ { "cell_type": "code", "execution_count": 24, - "id": "e20696d6", + "id": "eeeee0ec", "metadata": {}, "outputs": [ { @@ -395,12 +395,12 @@ { "cell_type": "code", "execution_count": 25, - "id": "1a62c45a", + "id": "d325087c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -419,7 +419,7 @@ { "cell_type": "code", "execution_count": 26, - "id": "5971d8d4", + "id": "70da8095", "metadata": {}, "outputs": [], "source": [ @@ -440,7 +440,7 @@ { "cell_type": "code", "execution_count": 27, - "id": "95354416", + "id": "20626e0f", "metadata": {}, "outputs": [], "source": [ @@ -453,12 +453,12 @@ { "cell_type": "code", "execution_count": 28, - "id": "da09966f", + "id": "62aab374", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEGCAYAAACHGfl5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABzWUlEQVR4nO2dd5gcxbX2f9U9Mzub865yACGwhAQIECAJkcM1yUTjCzY4YRwxTviaaxvH68C9tnH4bGwwBgMOgDHGgEwSUSAJEAiQhARKK2m1OUwOXd8fPT07Mztx1TPdMv0+jx7t9nRPn327uk7VOafeElJKHDhw4MDBuxuK1QY4cODAgQPr4TgDBw4cOHDgOAMHDhw4cOA4AwcOHDhwgOMMHDhw4MAB4LLagFS0tbXJWbNmpR3z+wPE4xqqqlBbWwNAwB9Ai2sAKKpCTeJ4MOBPHgcIhUJoUlDl9RIOhpCaRHWrtLa1lGSXYQOQ1Y5UGzLtCIVCaJoEoYBkwjY4XDhcTMSGSnORaoPDRWW4eOmll/qklO0lGZkFtnIGs2bNYu3atWnHVjzyNB0dc+npeYszzlwOwLMrnuOQSQcDsLF7E8vOWArAmqee4Ig5M5PXrnr+FXaNCA4+YimvrVrDnLa5rN3yJNdcf3VJdhk2AFntSLUh045Vz79CS8sM1m/bSTjkmbANDhcOFxOxodJcpNrgcFEZLoQQ20syMAecMJEDBw4cOHCcgQMHDhw4cJyBAwcOHDjAZjkDBw4c6IhGo3R1dREKhfKe195Rj6L2JX/esGEDALXttXTTnfzZOO5uaOatAX/y+rrZs5kjQVH7mHf0FNxKmGNnLkqeXywMO1JtSLUj1YZMO+pmzyauqsxpmIWU7LMN/65ceL1epk2bhtvtLsmeYuE4AwcObIiuri7q6+uZNWsWQoic5w0Pj+J2eQGIxkI0NtYDMDrsw+uuAiAUDVPfWAeAf3SEmipP8nqfL0A0LvDW1BHw+/G6vPjDI3RO7ijJXsOOVBtS7Ui1IdMOny+Ay1VFMBxBk2Kfbfh35KJjUjv9/f10dXUxe/bskuwpFk6YyIEDGyIUCtHa2prXETh490AIQWtra8GZ4r7AcQYOHNgUjiNwkIpytwfHGThw4MCBA8cZOHDgoHhceeWV3HPPPZbce9u2bRx66KGW3PvdAMcZOHDg4F2BeDxutQm2huMMHDhwkBW33347Cxcu5LDDDuODH/xg8vjTTz/NkiVLOOCAA5KzBJ/Px3vPOoPly49nwYIF/P3vfwdg+/btLFi0gM9+7jPMnz+f008/nWAwCMBJp53OdV+7nhNPPZWFiw5n1QurAL3T/ta3v8XRRx/NwoUL+c1vfpPXTk3T+NSnPsWxxy7mwovex/kXnMvf/34/oEvc/OCHP+DEU0/knvvu4fEnHue4445j0aJFXP6hD+Hz+QB46eWX+Y9zzuHkU0/i3PPOonuvXop6/oXnc91117F48WLmzp3LM888Yx7BNoNTWurAgc3xrX+8wZu7R7J+Fo/HEUIf00mpoapq8riSOK6lHNficRRFMG9SPd9479yc93zjjTf43ve+x3PPPUdbWxsDAwPJz/bs2cOzzz7Lxo0bOffcc7nooovwer386e6/Ul3jIRoNc+yxx3LuuecCsGXLFm757a3c9ofbuOSSS7j33ns5/zz9s1gsxsrHHuOxJ1byox//iHvvuZ8//PE2GhrqWbNmDeFwmKVLl3L66afnTKDed999bNu2jeeff4HBwRGOPHIhl132n8nPvd4qVj62kr6+Pi669CIee+wxamtr+c63v8X//ewm/usrX+Zz136BO/9wO43N7Tz40EN8//vf5eZf/i5p4+rVq3nooYf41re+xWOPPVb4oe2HcJyBAwcOxuGJJ57goosuoq2tDYCWljHVzPe9730oisK8efPYu3cvAFJKbrjh6zzz7NO43S527dqV/Gz2rNksXLgQgCOPPJJt27Ylv+uC950HwBGHH87OnTv0ez/5GOvfeI1HVjwCwPDwMJs3b2bu3OzO69lnn+Xiiy9GURQmdU5i+fEnpH1+wfkXAvDimhfZuGkjS5fqInGhUIglxx3Lprfe4vU33uS8Cy9EStCkpKN9bG3BBRdckNX2fzeU3RkIIVRgLbBLSnl2ue/nwMG/G755zvycn+3rQqtckFLmHIlXVVWlnQfwl7/8hb6+Xp566mna2lqYNWtWsibe4xm7n6qqyTBR6nepqkosHkt+5/e++30u/cD70+6bqyM2bMgFQ0ZaSslJJ53MPff8FRjjYv3rrzN/3nv410MPpy06y2pjLJb3XvszKpEzuAYobT23AwcOLMUpp5zCX/7yF/r7+wHSwkTZMDIyTHt7B263myeffJLt2yeuqnzKyafxhz/cRjQaBeCtt97Cn9I5Z2LZsmXce++9aJrG3r17eebZp7Oed8zRx/Diiy+wZcsWAAKBAG+9tZmD586lt7ePF9esAXQpkI0b331dVlmdgRBiGnAW8LtizpdI9vj2lNOkorDbt5tIPGKpDcFYkG5/t6U2AHSNdhHVopbaEIgG6An0WGoDwM7RncQ1aytS4lqcaLz8z2P+/Plcf/31nHDCCRx22GF84QtfSPs8HA+njcgvueT9vPzKS5x44gnceeedHHLIIRO+95Uf/DBz585l0aJFHHrooXziE5/IOiKPa3GiWpQLL7yQadOmcdxxx/C5az7FUUctpqGhYdz57e3t/L9f/poPfOADLFy4kJNOOZWNmzbh8Xj465/u4pvf+hbLTzye4447ijVrVhdtbyYX+yvKHSb6KfAVoD7XCUKIq4CrABpnNnL6vafz6odeTSa/Ko2oFuWMe8/gtJmn8X8n/p8lNgB85vHPsLp7NeuvWG+ZDcPhYf7jvv/gwoMu5IYlN1hmx5WPXMmGgQ2WctHt7+a9972XK+ZdwZeO/pJldrw9/DbReJT5bblDR2bhiiuu4Iorrkg7dttttxGOhdkyuIX2mvZkNU5raytPPvFMVj2edWvXEYqGAfjSl3Tu/KMjPPnovwBdj6ettY11L72KJkFRFL72X9fzs5t+lnbvxsZGXn/99eTvm4c2E9fizG+bz4033kg8LhkZ9nPCiUuZN0/nZ9u2bYwO+5LXnHDCCaw5d03SBiNkdvhhh/HIgw+OCxP97d6/JbWJ2traxoWqAtEAW4e3Mql2Eq3VraVSbCuUrccVQpwN9EgpX8p3npTyZinlUVLKo6JCH/FYOhJNOPjHtltbMbC6Wx+ZWDniMJ7Dyp0rLbMBYMOA9VP20cgoAM/tfs5SOyoxKyiEmNRH6f5o7tBNJZA6Szv77LNZtmwpp59+Etdd9zU6OzsrYoPxjgRigYrcr5wo58xgKXCuEOK9gBdoEEL8UUp5ea4LjIRVOB6mSq3KdVp5kciZSewx7YvJGG5RHsnaQnAr+n3D8bAl97cTjPYYipVPKGx/gUi8JHYKjaxcuXJcMr0SSC3f3d9RtpmBlPK/pJTTpJSzgEuBJ/I5glQEovu/lzULVnJhOGdf1FfgzMrAylGxR9XDCV2+LstsSIWVHbHRAUY0a/NqdoDhGO0wY9tX2GoFstH5WJ28tRMcLsYQils3Kjc6wHp3zvRXRWHlzNXoAFWhWmaDXWC0C6tynGaiIn+BlHJlMWsMjMbldIDQXNUMOKOvVNihXdjleVgaokmEUu0SGrGSC2MAa5ew8r7AVu7M8K5OjBrcqhOvN2DkLqwucQX7PA87dD4xzR4LsOwwS7ILF/sCWzkDw8OPRkcttsR6GI3LF7FHvN5KGE7A4WIMdhmV2wF24MIOznlfYStn4FL04iY7VSlYhbZqXRPGDg3dahhcxKUjQZys5LGo87nyyiu57977LLl3rv0Mtm7dyl133ZXzuj179vD+y96f83MzYDwXM/CjG39s2neVAls5g2Rm3gbhAKvhUfTqFYeLMS7skDOwGskYtTNgSmLbtm05nUEsFmPy5Mn8+c4/l9WGSNS8tvnj/7vRtO8qBbZSLTUaem+g12JLrIeRM+gP9VtsifUwyjoHw4MWW2IRHv4qdOurr2fGAkgp9Xp6oVIbjyUlrD1SA1V/pavjcZTE+1QtJSQkrL3xGCgKdM6H076b97a33347N954I0IIFi5cyB133AHAs888yw9v/CH9Pf385MafcNFFF+Hz+bjssvMYHBxA0+J897vf5bzzzmP79u1cdMmFHHvMsaxZu4apU6cm9zo46bTTWXz00Tz+xJOMjIzy05/8jGOOWZLcz2DN2tWEw2E+/elP84lPfCKnndd/7Xo2bdzEsmVLufzyD9HU1MzDDz9IPB7D7/dz009/zvsvvYR1a9cRCAT46Mc/wsaNGznooDl07dzJL372U4468khu/+Mf+cnPbmLKlKnMnDmLGm813/7Ot+nt7eXqq69mxw5dVfWnP/0pS5cu5YYbbmBn1042vL2B5pZm/nnvP8fZFgqF+OQnP8natWtRhMKNP7yRY5ccx2233cbatWv5xS9+AcA577uAL177ef7x4D8JBoOccNJyDj74EG777R3FtRETYC9nkJgZGC//uxlGZZVL2OoRWYp/h/K9fUWlwkP59jPo3tPNHQ/ewdbNW/nCFV+wfD+D73zvO/z8pz/nzjvvxu3ycscfb2fNmtWsX7+elpYWXn/tjeS5v7vltzQ3N/Paa6+x+sUXWLJ0GQC7d+/mRzfeyBOPraStYxJnnHkKhx16GADXXHMN1157LcuWLWPHjh2cccYZbNigr4p/5eVX+O3ff4u32pvVtl/+8pcArF+/npfWvMT5F5zPS2tfzsn7t775TW6+5RaeevJpNGle6KkY2KqnSS5mccIB1Hl0yWGHC2io0kXH3rVc/McPkj/uHtxMJB5hZsNM6jx1+HNIWAdzSFiHipSwzrefwTnnnYOiKBx48IGW7megCAVNalkd5IknnpRms4FVq1bxxS99EYD58+axcMECAFavWcvSJUtobm7G7XZz7jnvY/vWrQA89thjvPnmm8nvGBkZYXRUL3I565yzcjoC0Pda+OxnPwvA3LkHM2PGjKRqqt1gK2eQXHRmk1puK5GMkztcOFykoFJ17fvDfgZJZ5Alf2LsYZDt78p6PA+fmqaxatUqqqurx31Wk+M+he7ncrnQtLHiEIMrK2GrebcRJto1ustiS6yHkTOwg6S31TCqzPb691psifWoVJHF/rSfQXVddXKkXgjHHXccf/nLXwDYsHEj6xMqqIuPOornnn+eoaEhYrEYD/7zgeQ1p59+ejK2D7Bu3bqi/5bly5dz5513ArB5y2Z27tzJQQcdxKxZs1i3bh2aptHV1cXqtWuT17hd7uTfXknYamZghImMEMm7GTUufcRR484/8ng3oNZdC0C1a/zI7N2GpPxBmcdxqfsZqKrKEUccwW233Zbz/EsueT8f+MClnHjiCRx55KJ93s/g7a1vsWjRIqSUtLe3c//99487z+Di0AWH4nK5WLp0CR/84BU0NTXn/O6PffTjfOZzn2bhwoUsOPRQFi5YQGNDI1OnTuWL117L6WeexpQpUzl47sE0NDQCcNNNN/HpT+vXxGIxli9fzq9//eui/pZPfepTXH311SxYsABFKPzuN7+jqqqKpUuXMnv2bBYsWMAhhxzMoiMOT17zkSs/zPEnLmPhgsOcBLJdYsP5psrlhpFEd0pLndLSVBjviEb515/k3M8gru9nAFi6n4HhDFxuF48//niaaumll16SPG/mzJmsW7sOAK/Xyx//+Ee8Xi/rX13HOeedx8yZMwC4+MILufzyK3F5vFx88fmcdvIZgL6PwZ//PL409YYbbiAUC/H20Ns5OfR6vUknamxFGoqGEUIkZwyp+yr4fAG+++3vcP31X393J5AN2KWEMKbFkuGaSsOQYBgKDVlyfzvBeAbDkWGLLbEexuDEWYyY4hi14rkIBAKcevopRKNR4vE4v7rppmRO439+9COeXPkUkUiE5ctP5JyzziUQefeoIdjSGdhFwjoQC9CoNlpyb6Oh20Y+WosmHVSlYewl4MhRjI2Grd5+0w4wHGMpK9Pr6+tZm4jP+zMqq7737W+n7XRWSlTguSee47LvX6bbE9cQQjBjxgwefPAfRX+H1bClM7BsY5sM2CFEY5c1F+FYGLfHGmdgdIBWzdIyEdNiyaR2pWEMEqwKX9oJRruwAxdLT17KVZdcBZAMV1Vqgx2zYKtqIgN2KSG0Q4zaDjaAPZ6JXTYQsfKZ2G2XMUvlo23Gxf4OWzqDHSM7rDYBsEe4aufoTqtNAPSZgdWwCxd2cNB2cM5gsXy0sy7JVNjSGTR4Gqw2AYCwZn0HaBcugvFg4ZPKjHqPPXYZC8as58Iuu4zZIZFtF5kSO3CxL7AHixmwy0YRdrDDDnkLsEeIxjZc2MAOq0IjmRLWlbQjl4T1RCcnn7j6k9xzn3ly3Pt7uMqWzsAu0z5bhANsYAPYowO0Cxd2sMMum6nYwY5UG+Jx66qs7MDFvsCWzmDr8FarTQDsIR+9bWSb1SYAMBiyfu2HXbgYiYxYbUJFtt+8/fbbWbhwIYcddhgf/OAHk8effeZZLnvvZZx51Jncc889gL747L1nncHy5cezYMGCpEz19u3bWbBoAZ/93GeYP38+p59+elKb6KTTTue6r13PiaeeysJFh7PqhVUASQnro48+moULF/Kb3/wmr51PrXyKk046iY997CMsXnwE8Xicr3/9v5PX3/r7WwF95P7FL3+RefPmcdZZZ9Hba65U/v4eJrJlaWmzN/dy8krCLawvZbQLF3aIyzZX2YOLSo8Af7j6h2wc2AjoTiCmxVAVFa/qJRaLJ5+NJjVcLj2XEI/FUZTEcU1DNY7H46iK4OCmuVx35Bdz3rNYCetrr7iW/3z/f1oqYa0KldWrV/P88y9w0JxDuPXW39HQ0JC8/rhjj+M/Tj+Tda+uY8vmzaxfv569e/cyb948PvaRK/fhyaRjfw8T2dIZ2CE+DfYIV9khJAH2sMMOoSqwBxfl9kfFSlj37O3RzbFAwtqAhsbixYuZNWsWAI8//ijrX38tueBraHCILVu28Oyzz3LRhRehqipTpkxh+fLjzaAqif09TGRLZ2CXVbeVmIoXgm24sEFl1ahNpAEq7ZSuW3xd8uddo7sYCg/hdXk5sOnAND2eVF2g0Rz7GWSuus2F/UHCOtWG2tratN9/9KMfc8EF5wNjXDyy4pGyLlDb38NE1s/9s2AoPGS1CQB0+7utNoG+YJ/VJgDQ4++x2gT6g9bncAB6AtZzUe5Kt/1JwjpTjuLUU0/nlltuSV6/ectm/H4/y5Yt45777iUej7Nnzx6eeeaZCdtYjB37G2w5M7BKAycThoz0u90GAK8r925OlYJd5LztIJdS7hzO/iBhbSBztH/llR9h67a3k9e3NLdw31/u433nvo/HnnycBQsWMHfuXJYltrx0oMOWzsAuHtYOOQM7rHUAe8Tr7WAD2CNnUIn4dDES1l39XYA1EtYGjll2DJedfRnDw3oYUVEUvvGNb/K//3tj0gYjZPa/P/7fkkNmxWJ/TyDbMkykSc0WnaAdwkSBmPWSGGCPXcYGQvlDFZVCT9D6MJFdiizs8J7awTkDxKT1XOwLbOkMwB6doF3CVXYYEVul0mlHuIT1XNhBqRPGxOKshB3Knv8dYFsW7TDysUupmB24sEulhB3ssEsY0w6wyzviYN9hX2dgg9GwXaafdrDDDvkTsAkXNrBBSmmLGLVjwxjsYsdEYVtn4I/mLiWrFLaPTLw8zkzYQSXTLrLidlj7YRcpbTuMyu0wSNCkZouO2A5c7Ats6wzsMDNorLJmy8tM2KGR2YWLkA12j7ILF3YImdlFStsOjtEuXEwU1mfCcsAOU3E7xOrB4SIVdnCMVjyPF154ieEhP33BfnwRfda8raGHUCCCK7E1aiweoa62GoCAP4jHpR+PxCLUJI6HgkGq3C4aG2s49pgjCt73b3/7GxdccAEbNmzIunbADiNysIcddnDO+wLbOgM7zAxCcetHoWCPDtAuXNjBKVnBxfCQn46OuYhAD96ELEd7wwzCgQiuxCK4WDxMXZ0uyxDwBdKdQZ2+YC8Y8OF1u+np3VLUfe+++26WLVvGn/70J2644YZxn9thRA72sMMONuwLbBsmsoMMg11iw0OhIatNsA0XdpCP3jliDy5kmUeiPp+P5557jltuuYU//elPWc+xw6wV7DEqtwsXE4VtnYEd6tqbqpqsNgGwR025Xbiww+irydtktQlA+bm4//77OfPMM5k7dy4tLS28/PLL485RFXvEye0QJtrfcwa2dQZ2CAfYITwDDhepsMPoyw7PA6Dc/d/dd9/NpZdeCsCll17K3XffncUG6zthsMcgwQ427AvKNvwWQniBp4GqxH3ukVJ+s9jr7aBcagc5CrBHaMQuXNhB0rs7YA8uyhkm6u/v54knnuD1119HCEE8HkcIwY9+9KO08+yQ2wN7hInswsVEUc6ZQRg4WUp5GHA4cKYQ4thiL7bDCNAuy9ztkLy1yxQ4ELVepsQu7UKjfB3gPffcw4c+9CG2b9/Otm3b2LlzJ7Nnz+bZZ58t2z33BXZwBnaQ5tgXlG1mIPX5ozGMcyf+FT2PskOc3C4P1y522AHv1nbR2FRLT89baaWlwu9DRkgrLQ0EcpSWBsaXlubD3XffzVe/+tW0YxdeeCF33XUXi5csNvVvc2APlDVLK4RQgZeAOcAvpZQvZjnnKuAqgNaZrTTQANhjZmCXaZ/DxRjsEK+34nkce+yRwNhOZwDT6qdBSCnLTmcrV64cd+xzn/sckL4K3C5xcn1mYO1AwS75k4mirPNdKWVcSnk4MA1YLIQ4NMs5N0spj5JSHlVbM7Z1XZevq5ymFQU7SGIA7PbtttoEW5T6Auzx77HaBFu0TbCHg7bDQAXsIR9tB6mUfUFFgp9SyiFgJXBmsdfUe+oLn1QBWKnXbkho13pqC5xZflgdJze4sMPOb7Vua5+HEaZSbFAMaJdckh1CqXYoh98XlK01CSHahRBNiZ+rgVOBjcVcW+euszwcUOfWp9VWjnxUoeISLltwYbUYmLHVpNUlrnXuOuKatRLWRt6knAnkYqAIxfIwkTFIsYMd+3uYqJyubDLwh0TeQAH+IqV8sJgLParH8umnR/VA1PqpuFt1O1wwNuqyAxdWb7wkhABpfYxaCGELG+zChdXOeV9Rzmqi14DCSlhZIBBsG9lmrkETsAHsIR9ttZS2MfqykgvjeVgtpa0IBU1qls7WDC6iWhQPXkvtiMu4pR2xgkKcOBEtggvz9jMuFQJhiy1A9wXWBx2zIBQP0extttoMwPqRaCQesVz+wKjhtpoLsF4+2njhrVz7kcwZWJzHMUIzVoZojJCZ1bkLO6xz2FfYMuMxtW6q5R1Pa3Ur/aF+y+2wAxdt1W0MhAYsj9e3V7dbHrbrqOlgKDxU8Wfy8osvExgK0h/sIxQPoUmNWnctVfHqtHUGtbUJdVJ/EI9LT7pHYlGqExLW4aCfKreLmsYajlh8eN57qqrKggULiMVizJ49mzvuuIOmpqbk5y7FRVyzdmYA9ghXuVU34VjYcjv2BbZ0Bh7FQ3+o33IbAMKateVibsVNf9AmXFhcOudW3JaXuBpcVNoZBIaCHDLpYHoCLQRjQSQa1a5qarX69P0MElLVfl+QqoQzCMei1NbpziAY8ON1u9m0t3AtR3V1NevWrQPgiiuu4Je//CXXX3998nOjmsnq5K1AWF5aahcu9gW2DBP5oj7CMWs7HqNxDYeHLbXDF/VZLkdhzAhGEzr6VsEf81vOhXF/qzWStArvgXzcccexa9euDBu0tP+tgtWVbgBxGU/asr/Cls6grbpNr2CxEK3eVsD6+uX26nbLuWivbgesr9ho87YlR+ZWobOmExh7+a2CqqgVk+aIx+M8/vjjnHvuuWnH3ao+87C6XaiKavl7aryjVnOxL7ClM6jz1FkeJzcautUxajtxYbUddZ46y/MWduFCpfx17cFgkMMPP5zW1lYGBgY47bTT0j43OmCrQyOqUC23wS5c7Ats6Qw8isfyckpjBGp5jFr1WF5OaXAxEB6w1g4bcWF1+FAgiJR5oGLkDLZv304kEuGXv/xlug2JmYnVsyQhhOX5rORCQCdMZC6GwkM0eBostcFY5GR1ydpgaJCGKmu5MDiwWv5gMDRoeWmpAatHgDHiqBUqLW1sbOSmm27ixhtvJBpNcUA2GQTHtbjl76kxS9ufnUHBaiIhxFHA8cAUIAi8DjwmpSzbMHFmw0y2DBW3YXe5YOjPWL2QZFbDLF7uGb/dYCVR59GlOaJaFJeFi5xmNcxi6/BWy+4PY+sc9PChu2L3rWmqZmP3pmRpqVtxE9fiNIim9NJSX47SUt/40tJScMQRR3DYYYfxpz/9iUv+8xJgbMtLq+PkHtVjuXPe33WJII8zEEJcCXwO2IouQ70J8ALLgOuEEK8DX5dSmj5v96gey/V4jISQ1TFq20hzoMfJrWzybtVti+cBupS2qKAzWHTMIkCXsPZH/XhdXiJahHbRWRYJawCfL71i6h//+AcwVmJshEas7ogF1ktB/DuEifK927XAUillVg0CIcThwEGA6c7ArbgZjVpbxmjEhneN7qKFqZbZ4VJc9AZ7Lbs/jHGxx7+HA2m1zA634mbn6E7L7m/YALA3sJdJzLbMDiGEPkiw0DunymKoFXSM4+wQgnA0bAsuYjKGwB5KrqUiJ31Syl/m+izx+TrTrUnA2EfASnXIapc+rTZCJFbBH/XjEtZOQQ0urJZu9kV81LutlTY3uPCq1oXLwB5xckMOw+pcUlzGLQ/TGM7A6hLXfcGEnqIQ4myzDUnFlLopgLVlnaqiogjF8hDN1LqpxGTM0rhsapjISkyvn275SlO7SGnbIU5udHxWh2iqlCrL8xZ2kdLeF0zUpR9tqhUZSC75t/iFU4VquVyx0RHbYZMdO3BhtYqs8TystkMIgaZZv58BWJ9AFkLYorwVrOdiXzAhZyCl/KbZhqTCcAKBqLWdT1zG6Qn0WGqDMRoPxi2Uj040dLtwYeWM0Rio7PXvtcwG0Dsdq0ehRruwemGmlNLyxK0RKrOai31BMaWlH8p2XEp5u/nm6GiqagKsJ9arevUdzyyUwzFKGa0O0ShCsTxnYGyFaqVulaLoL73VW5GO5Qus3UsArJfStvr+qTbYwZaJopisS2pIyAucArwMlM0ZGJ2O1eWlLd4Wy0NVdth+ExJcWGyD4Qzs8Ewq3TZfe2kNYd8ofcF+wvEQ9Z56BkOD9KhbcSfXGUSpTUhVBzLWGdQkjoeCAarcbqpq61i46Mic9+vv7+eUU04BoLu7G1VVaW/XNaqeWfVM8jyB9fLRxnoHK/HvECYq6AyklJ9N/V0I0QjcUTaLGJuK2yFG3TXaZek6bUMLx2q1TrfiZpdvV+ETywi7JLJdiosuXxeHV/CeYd8oR8yZSY+/hmAsSJO3kb5gLe2uDjyJyqZUCeuAL8MZGBLWfj9ej5tX3s5fEd7a2pqUr77hhhuoq6vjS1/6km5LPAz+xIlCn8FbWVtlB10gu+w+ty+YSDcXQF9fUDYYFSNWJ+kGQgPJUkKrYIxAg1FruRgMDVrORSimO0Sj9NgqDIWHLOfCiJFbPRKVUlZMPTUXklzYoJJnfy4tLSZn8A/GApMKMA/4SzmNavG2ANYLYM1unG15Yqqtug3A8pJKO3DRWavLR9tBIsRqLsbWnli8w5fittoEW0lp28EhTRTF5AxuTPk5BmyXUnaVyR4gfcm/lfAoHj0+baGzt0toxK26LbfBCB9aXVhgB4mQMSkIayGEsLwDtEOYKNWO/RXF5AyeqoQhqTBe+t5gL7W0Vfr2SbhVN5sGN0GTZSYknUF/qB9BaeJiptqheNg2sg0sXJBtjAAHQ4PWGUEKFxaGhu2y4MuQj663sB8cW/BlMRfoXNRi7Sr5iWKiK5BvNtuQVBiLnIz/rcJQaChZ5moVjIbuFhZzER6i2dtsqQ0GrC7fGwwP0lxlDy6sRlyzXgrCCA9ZPUuKS+slQvYFE32KvzHVigwkS0u1KFZucjircRav9LxioQXp5ZSKhWJgMxtm6hsOWfjep6+5sO6lm9Uwi5HISEVNqKqr55Ut25Olpa3eIHsDe2lQfNS4EnLrJZaWmgGP6rE8Vj/mjBwp7X3BhF5tKeVLZhuSiuSWkxbnDNyK2/IdlIzZUSQewYt1C508ikev5qmyzIQMmRLrqnncqluvdKugM1h4pL7cx5CwnlY/ja3DW2lztVPv1mcpZktYG7jhhhtyfiYQejLdwjCRbaS0hfVrLvYFBefbQoh2IcSNQoiHhBBPGP/KaZQRJ+/ylTVPXRCa1Kzf9jLRAe7277bUDg3N8udhjAC7/d2W2iGl1NefWAi7bDkJ1i8CNGA5F9L6Qo99QTHB1zuBDcBs4FvANmBNGW0ak492WysfrQjF8nhojVtPGte6rJU/ACzfitQIH1pd4y+Rlm+/aeRN7FDBYnWc3Li/LbiwwWroiaIYZ9AqpbwFiEopn5JSfgQ4tpxGuYQrseG3tV62vaaduBa3h3y0xVx01HRYXt9vl9LSzprOitiQr90ZukBWh0ZcistyG+xSWupW3WXtK8rdDxXjDIxWv0cIcZYQ4ghgWhltQgiBKlR6A9bu8OVW3EikpeV7Rs7ADuEqO8iDgA24UD0MhMq2BTgAXq+X/v7+nB1AcptFrA2NKEKxPLc3xoX1paXlGiRIKenv78frLV89czExkO8m9Ii+CPwcaACuLZtFCVi94hbGZA8i0kKVTJtoxo9G9G1IrYzLGhvLWL36dzg8XPZ7TJs2ja6uLnp70wdEQ6EhwlqYaHWUbn83w8ow/a4hAOLxKNXVemcRCoZxq/rrHY3H8Fbr3IVDITyusVBGOBwlLsHtqSISDutFE7EQA0P9OW2LaTF6Aj2EqkKE4iHCsTBhNYKqutNsSLUj1YZMO8LhKKqqEonFkZKibAB9vUlUixKuDrPXv5dhZYQ+10BFuYhqUXoDvUS8EfxRP1EtSlAJlYULr9fLtGnlG4cXs+jswcSPw8BJZbMkA23VbZZrnkyt0/c+ttox1bnrLOdiWr3eCGPS2t3nVKFaHhueUT8DKK9TcrvdzJ49fo/l/372v1ndvZqHLniIS++4lDNqz+ayA64BoLfnLc448wgAnl3xHIdMOhiAjb2bOOKMwwFY89QTHDpnZvL7Vj3/CrtGBAcfsZQ316xhTttc1m55nmuuvzqnbTtGdvCff/tPvr/s+2we2swdG+/gB+0/o6NjbpoNqXak2pBpx6rnX6GlZQZbtu0kHPIUZQPAl576Em8NvsVd772LD9z9Ac6uO59LZn+qolxsGtjE5//xeX5y4k9Y3b2aB995kG82/6DiXJiBnGEiIcR/CyFa8nx+cjm3v6xSqyzPzCd3GcP6rRYdLnRUqVWW50+M0ue4hVy4FBeKUCx/Hh7FQ0yzx7asVj4PGONif0W+mcF64B9CiBD6/gW96AvwDwIOBx4Dvl8uw9yKW1/kZGFy3ojXhy0ME4H+4u8Y2cExFtpgcBG1cGYAOhc7R3ZyWHlrGPIimci2mAtVqPTHrM2r2aEjNtpmfyx/WKnsdiTWn1gd0p0ocjoDKeXfgb8LIQ4ClgKTgRHgj8BVUsqyaioPhYeYXj8dK529kQyKWxwmGg4P66WMFm5pYCy+s7oDHImM0FDVMFbWYAEMaXWruYhqUaoV6/SqIDWvZh0XRgi1WrG25DiZV7N4hjJRFJMz2AxsroAtaZjVMMvycEBSPtrihzur0XouOmo6AOu5mNkw0/LqlUm1kwDrc0kdNR3ELQ5LTKmdAlibSwJ9DYzVz2N6/XTA+nYxUdh2w06P6rH8pU/GyS1+uB7FBlwkQiNWz5Lcittyx2iX/IlH8Vhvg124UK3nwghXWW3HRFE2ZyCEmC6EeFIIsUEI8YYQ4poSr2fr8NZymVcUjIU9Pm3UUjvswIWxstKv+ay1Q6hsG95mqQ1GuW9Qs3bdhaqo9MT2WmqDwUVYs3ZbVgWFXrtwYXGOcaIo58wgBnxRSvke9BXLnxZCzCv24lAslNzxzCoYUhCqlVlsdC6slo82RoBWl3UGY0HLuTAkSqxe8RqMBqlTrJdsAesXfAXjQWot5sJ4NyzXSJogitn2ci7w/4BOKeWhQoiFwLlSyu/mu05KuQfYk/h5VAixAZgKvFmMYVPrprK+b33y99XBVaxYeT9uxc3S+LJivmKfYWjgGNO+oegAdw3fxoqV93Ps5GOZwtSK2DG1bio7fTuTvz8feIYVK++nSq1iWfz4ithg6ERFE1z0R3q4c/j3rFh5P8dPPZ52Oipix9S6qXrSMuGfnwk8yYqV91PtquZ4bXlFbDA0mow4eU9kT5KLk2ecTBOVcVZT66cyMji2H/ST/kdZsfJ+alw1nKCdWBEbjP0+jFBqT6ybLz/1ZeIyzpmzzqSmQkq70+qmEfONhWce8z3MipX3U+eu40RZmeVRLdX64NXgYnd0F1966ktoUuPcA8/FZaEEfTEoZgXyb4Evk9jDQEr5mhDiLiCvM0iFEGIWcATwYpbPrgKuAmid2UoD+ovmUT267ECiWOLZwEp2j+hKke2NHSzhuGJvP2EYcfJQYgq8OfAGL4fWwHbYPLiZ62q+WnYbQOeiP9iPsbnDM4En6B3tAWBy02SOYXHZbUhKaWv6FHij/1VeCa2F7bBzdCfXeD5fdhtA52LH6A6MPuZJ/6OMjOorgqc3T+cojqyIDQARqecuXh9dm+SiN9DLJ9TyLxACvX36tD3J3x/3P0LIp7fVA5oP4AgOL78Nxha1ifKuDeE3eKT/EUCvrrmCK8tuA+hlnQPaUPL3Ff5/Iv36zG1uy1wWsqDsNhj9RSzBxZvh11ixbQWqUIlpMS7h/WW3YV9QTJioRkq5OuNY0RkSIUQdcC/weSnlSObnUsqbpZRHSSmPqq0ZG0X4Ir60hVYCwZymOcXe1hQYi4uCMj02XGk7RqOjGYvOLOAi4QwC0p92vNJ2+KK+tD0mrGgXhkqmHbhITVYqqBW3wUBmLqnSdvgj/jQuVFwVt8GYEfi19HYxu3H8SnI7ohhn0CeEOJDENkJCiItIhH8KQQjhRncEd0op7yvFsM7azpKkcSMxjYsfDvK7l81beGKEiUrJGXzxL69y8cPmLsHorOksSRrXF45x8cNB7n7dvL2CJ5I/+cQda7nEZC46qjtKkhXv94W5+OEgf99knp6QETJTSuDig7e8yIceNZeL9ur2kp7HrqEgFz8c5NF3zCuIMKS8lRLSj+f/6jk+8YS5XLTVtOEqYa+uLT0+Ln44yKqd/sInF4lWbysASgl5tdN/8hSff9ra5LuBYp7gp9FDRIcIIXYBnwc+Wegioa8EuQXYIKX8v1INq3HVlJSIGQ7qU7MfPGfeisyJlM3d+7L5m57UuGpKWua+a1B/0b7+pHnVFRPhYsUbe01Psda4a0oqs93UrXd83326xzQbJsLFM5v7CJpccVjrqS3JhrXbdBG3n7xgnurrWGikeDte2THEgMkFN3XuuhKfh95P/OZl89RnjUhCKaXob+31sctvjxXLxSw6ewc4VQhRCyhSymKHFUuBDwLrhRDrEse+JqV8qJiL3aqbuIwXLQamJZaAe1Tzql2Mhj4YL322EY5pVLnMKdbyqJ7kSs+izk/cd1KdeRvzjHFRXunmgnaoHvpD/VDk3jJejz5ynlxvIhcJZzAUN2/mNSE7FA8DJbTNGo/OQXuNedVxRgc4HB8y7TsnAo/ioS9WvMOvSbSLZq95XBjvyIhWflXbcqCYaqIvZPwOuoLpS1LKdbmuk1I+yz7sjOqP6J1fsTW7cU13Bib1v8BYbb1HlL7xb0wzb7vgUuWjx7gwzzF6XboU70S40KREMUl1dSQyLu2UF8Z9XSaqvnpVg4vS9hI2G8Ph4ZJsMNqDme3CkBV3CWt3BBwKD5UkR+FS9I7CxLFjMq9m9c5vE0UxXedRwNXoZaFT0St/TgR+K4T4SrkMm1KnL3MvVufD6ADNRp27bkI11JqJAZKkfHSRXGhlEMpyKS5UoU5oBbKZj8ZY8l/sjLEcomFGB2j1auwZDTNKetblWBdhDBKs3mNiRsMM4iXYUI7ewsir7a/rDIra9hJYJKX8opTyi+jOoR1YDuWrGytVCsJwBmYvivKongnprmgmvhulSkGMcWEuJrrkP25ih5zkosgdvgxHZOZ2EEYC22rZAbfiJk7p8tFmtouJ5AzKAY/qmZBAnJntwi5cTBTFOIMZQGpdYxSYmVAtLdu6a+OFKzpMVCbZWFWo9JQQizRgpj0GF0Zde8F7l2mWpAqVvglIJpvpGEuV0i7HLMnYlnUiXJg5U3Gr+rasVs5QjEFbf9z6LWrDMmyLfRVKyePYCcUE+u4CXhBC/D3x+znA3YmEclGriSeCuKaP/Iqdcmll6gBHI6NMcU0v+TozzTGktIudoZTLGfiiPmq8pa8oNdMxjklpW+sY4zJOjVI6F5o0L04diukliWEZLmp1azn6SUOOolpYK6UdiOprgeLEiyoxLYfTMEJmXmGtlPZEUUw10XeEEA+jVwcJ4Gop5drEx5eVy7BS5aOD0fLE6WY0zCAWmEBoxMROqL2mHSieC3+kPCPFGfUziEetzRl01nYCxXMxEiyP2mtHdceE1Gzj0rz9mibXTgYgpkWL+tKRkM6F2Tuo1nvqLVf2TW5Rq0VxqYWdgVGKbiYVilBwKS7Lc0kTRVElAFLKtUKIHeg7nSGEmCGl3FFOw5JbCxYdDtD/90fNTWR5FA8BrfQFMnETO8BkLLLERhaMmcyF6iEYLl2pM25h/sSVGIaHY+aOBN2qm2C0dC70sJU5XVBSCqLId8Sj6h7D5FcEt+ImVN69rgrboI6FD70UHpnXVuldn5nvKRhc2GMRWakomDMQQpwrhNgMbAWeSvz/cLkNM9L9oxbLR4e1MD6ttHJGgIiJrcyo1Mhc5l4IwyFz3/pwPDyh5xE1cWpgOMRAifLRgyFzZ46ReGRC0uYxE7kwFt+FSmwXAyavfovGo4xO4B0xM58zxkVx7cKoru0PmtsuovHofrvOoJgE8nfQJajfklLOBk4FniurVZS+zN1oWDVuc+fA1a5qqoS35OvMbOiGMmSxlVLGrTtNXHQGOhfeCXBhZgfYXFWaIqiRvO6sNZ+LibQLMydrTd4moIS8WqJhtNfYg4uoiQMmg4tiZ8/GVplt1eauCZgoF3ZAMT1tVErZDyhCCEVK+SSUXw5xbKPt4hp6uYoIWrwtEypZM9Meo6692Dh5ObmwumzOSNIVzUWZ7LBDu0hKrBcZJiobF9UT5MJEG2pcRo1/kTmicr0j1S3/1jmDoYTy6NPAnUKIHiqwTb3hDIqdfparpMyjeOifQKmYmQEagwt/kWGJcpRTGnYMxEvXtTHTHqO0tNgd18rJxY74zsInZsDMxYjJdhEvjotyviM9E2oXJtqQ4CIYLy53Ua524Vbc9E+ACyllcrZiFYqZGZwHBIBrgUeAt4Gzy2kUjI2Gi0WZKggZCg9NSHbAzLZmdIDFfqXR0M1++QdDgxOUozDPBmOpf7GracvVAQ6EBqiaABflMKfYkWi5OsCB0MCE3hEz7TFCZZEik7fl6i/s8I5MFMU4g29IKTUpZUxK+Qcp5U3AdeU2zJgCF/vSj3WA5toxq2HWhJbxm9nQjWXuslgJBtPunI5ZDbMm9HeZ2dDrPHWJ7yxWwFD/32xOZjfOnpAEg5lcNHoaE99ZJBeJ00x/RxpnTYgLM+0wtsgtVdiyHO1CTkS+Zj9xBqdlOfYfZhuSCWM0XExC6M9rdvCVe14rjx2quygbfOEY7//NquTvZj7cJBdFROf+8Pw2/vtvrwOYPu0sdsn/UCDCJb9eVfC8idoAxXFx89Nv871/biiLHW7FXZQNPaMhLv7188nfzRwklFJa+vPHN3PjvzaZdu80OxRPUbm9XUPBDC7MtQGK6y9uXLGJnz+x2bybp0CXCCnMxdY+f9o7Ymb4cKLImTMQQnwS+BRwgBAitaetpwLVREbdcDHxt+vuXV/wnInCo3iKqqFet2OIF7eOyTuXIx5azDL3bz7wRvJns0MkbsVdVNncM5v7WL0tlQvztYmKkdL+/kMbTbvvODtUT1Ftc8Xr3azZNiZ1XY4OcCBaWArifx99y7wbZ9qheuiJFd47496XusrGhdFfDEYLP5NfPLnFvBtnQOeiu+B5d6zanvaOWKiikUS+BPJd6OsJ/gdI3ex3VEpZdlF7YzRcXeLSbrNzMKNRPWlbaPoZiZdPqdColLB6mftIZKSoUt9QxmpwM196o5qo1Hi92am54fBwUc+jXCvjYWyQUKWUVspo9jsyFB6itghpjkAknQszVVSN/sKtlJa7MLtd6FzUFTzPF06fzdnBGeR7s1VgBH2ns9GUfwghWspvGtS6S9vJCcwndVpdQj66wFR8JGMhj5mjYVVR9U21LS7rnF4/HQ2t4IxjKJDOlZnOICkfXWq7MM8EICHNUUR9f78/XUPJzHZhOMZiVyAbMPsdmdkwsyguekfTRSfNtMMYMJWqMGx2u5jZMLOoUFVPBhd2yBnkmxm8xBhXmQ5UAgeUxaIUqEKdkHy0mShWJdPrTl+8YvbDtQMXybUfBRq7sdTfgKlKnSXkksoJj+ohSmGxvAZvuoBcOcKHsSJF+8oFt+IuiovG6gpwoVnfXxTjnJtr0mcwts4ZJFYbW44+i6VxjalsWMtfspa5eVQ5PL3VXBihskKy4pk7aZlJhZEUtwsXhZxSZkimHDmDnvAe8750ApDIouTVx3NhHhnGjLEnYj0Xfll43Ufm326HMFFR69KFEOeib2YDsFJK+WD5TEpHrSgcf0uF2ZwaWxwWGpWPf7jmP91aUbpksplIVq9oBV78CjjGmhK5MNsEY4+JqJbfMWZu92lmszC2Za1VrX1HjLUfhUJFmYMEMxdmGiGzGou5UIRSlGyMW02P0NshTFSMUN0PgGvQ9y54E7hGCPE/5TYMdLliq+PkhkZSoQ4wU5nT7Ic7ES7Mbl+GLlDBcFXGjc3moq26zfJ2YdS1FwoJZHb+Zi/88gpvyTkDs9Fa3QoUDleVczSsCAUFxfKQWXt1OxJZsOCk3O1iIihmZvBe4HCZWPEkhPgD8ArwX+U0DPT4WzElhKkImS1VnMwZ5G9ksYztvHwRcxVDJ8LF7lFzO8wxmeDSXvqgyZrJbsXNUHSw8Ikp2DViboc5Fq8v4AwyPGPYZM1kBbWocspU7B41mYsia/wz+zsz1WxB52IgWpp0zF6fye+IYkjvF+Aio12YKfM+URQnCQpNKT83lsGOrBgKDRWtWmqgyqxtpBJISibH88sEZ25m4zbZjqHwEEqJ26JMNlm11JAJLshFxlufmU/ZV+hclNYuptSby4Wx41ownl8yudwDvqAMlLy4cHJ94V3RSkEgpnNQSBcokwozt0MFiBEtGKDJHKiYrWbrj+rvRqhAjjGzXcT2k5nB/wCvCCGeRI8GL6cCswLQdxnb3Vd4AUc50eptTfyU/2HtHckomzPZjhn1M/ANl6bhb3Y9ubH7XKHl9t3D6S9CObigNAl/09FR0wEUjpOXm4tWtR3zq+VLg7HjWiHF0D3D6c7CzHUGAI1KU0HHWO7Y/JS6KUDhkNmuoQwurPcFeVcg/wK4S0p5txBiJXA0equ7TkpZkR7aq3ptUUIIhWPD9d50Ks2OAVa5qhiSpW0gYnYDK7Z8L7OE0Gw7qlxVhIooZSwnxkIj+blorUsvITSbC7dwl1zcYDZSdxnLh7a69IWCZnfMbuFO7heeCyZv/jcOxYYPO+rTubCDM8g3194M/K8QYhvweWCHlPLvlXIEoDey3iKWuZfVhkQMcCiaP14/7oUzu6ErbnpjPeZ+aYkwGvpIfCjveZkhM7PfP49SnPxBOWF0gKPx/PIc45qFyW+9Cxd7wvmltMs9GjYcY6BIKW0Dplc14aI70pX3nHKH5o3+olgpbQNmz5ImgpzOQEr5MynlccAJwADweyHEBiHEN4QQcyth3FB4iJoilrmXE8ll7iJ/nHVcB2jysx0ODxe15L+cUITeXArlLjJzBmaPTItd8l8JFCojzOz8zW4XPs1Hg9qU95xyOwOjcqZQhzbeMZprh1/6qFfzpzQz26LZbdOYmRRaIT8uf2K9LyichZNSbpdS/lBKeQTwn8D5QHmkIDMws2EmWpE7nZULtW69Ay40Bc50BuVY5l7srm/lsqHeXQ8UngLHMytmyiF/UICLcu1jYMAoOS7EReaWn2Zb1eHqKNg2yz0abvbqJcely2KYy0a72lG4bZa3adJe3Q4UsRK6zHZMBMWsM3ALIc4RQtyJLlz3FnBh2S1Dn36WmjMwm1QjHFCwkY2bGZhriUctnQuzUWxsePzMwFw7imkXmfc0u10UmzMoNxcu4Sqivj/9d7M74SQXBTrAcq7GBnCJwlIQmfc0vW0WmWPM5MLWOQMhxGlCiFuBLuAq4CHgQCnl+6WU91fEOKEQLEI+OhWRuOSnL/Sa1uCNh9sbyZ8qyXzp71o/xMt7Sqv+yQeBYFgbKumabl+MX6wufQu+XDBCZv2R/PF6LeMNu+3VAV7vKW4HqmKgKAp98fz5k8zR8JaBCL95qfTtS3PBWIHcH8kvi5HJxe9e7mdTn3lcCJSCOYPMd2FDX5hbXjFPeNhYCT0Yy89v5gDpV2v7eWcw/wruUqAgSs6fvLo3yO2vlrZmJR+MsOFwrDR+f/ZiHzuHrS2KyDcz+BqwCniPlPIcKeWdUsqKFvQZ8bdSd1H6xZp+dpi0yMjYca1arcl7XuZL//QOP5fcs8MUG0DnQi0Qq8/mAH/6Yh/9QXNmFMaOa1VKfunmTMf45DY/l91nHhfhWLigtHnmSx+JS378fC9+kxYDGuHDKiW/lHbmYqJ/vePjqgfzJzlLQVRGqCsYJ0//fSAY53+e7SFq0gI4gwtPwbxa+u8Pbxnlmkd2m2IDQERGCuYMMv/i3aMxvv20ecUIBheuAlxk2vGPt0a4/glry+jzJZBPklL+thJ7F+TCpNpJwMQUKvv85nSALuFCIAqWrGXK85qNSbWTCspH5/qk1yQuig2NZK65APCbuAp5ct3kgjmDXNP/AZMco8FFoXDA3pHxs4BdJq4Mb1ZbC4fMchwfiZiTjzNE4gpx0T08fpa/oc+896alCC4yByoGQibVnBYrK753eHy72Nhf3j6kEEpbxllhjMkV5yY2V+cYMWnUI4RAQWG0QDml11Pa6uBS4VE8SGTeTjBXezZLosMImRUqp6ytABeFVDIzE7cGAiY5JYMLf3w073m1VeO5MHNxugtXwbaZ610wSzLFeE/9BUpLM6XNAdpqzGsrLuEqGJ7J5f9Gwua2i2CBVfoN1eNnDm015q6GLhW2dgaBqB5zD2m58wa5ujkzNYrixIkUUKcsRqlwX2Asc89nRy7/Z9aoxygtLSTnbfbey5nwRfVOJ98oMNdfbFa7MEbDherJs7ULM+WJitmSNdftwiZxYYyGC3WA2dqFme9pUAsW1M3KBbPekWLXXGSq2QJELBYosrUzMMJE+Za55woHdPvNE+OqEbW4RH6vXe5VnpPr9CX/+dRTc9nQY1KYCMCFu2A8NLOyymwY8gf5uch+vDdgDhdG0tRIJOdCrrCEWWhSdfVULY8sRi4uzMolGY6xULvIzKuBuYKOTWpzwbxazpCZSTMDI8c4kf6i129tGb2tnUEyFpknXp+robtNVEfzKoVlgsvdARYTl83VnFWTuSi1nNJsGCPRfHbkehzZRmQTRZWoKlhOma0DNBMeUTh3kdMEk0xzKXperdTya4B6j3ldkEdUESeeN6+Wa8BkloJqsaWl2bgwM2Q2EdjaGSTjb1ruEs1cU24zpYJVXOwN5696KLczMOKy4Twhs1wmmBUOAFBR2RvelfeccYvOTIbBRf6QWXkThaCvxO6J5G8XuXIXZsGFsclOnllSjuNmhmh0LvLvMpbtmZg5cDC4yCcfnfsdMTd/UrAUPYshZX5tCqJszkAIcasQokcI8fpEvyOm6Q81V2y4Lxjh/9Znj1PuGDYvTOTXfHl3k/rnjhC3Pb/NtPtlgzE7yjXi6PaH+d/XsnOxc8S8+mW/5qdWrc/5+f3bQvx5bf5a732FIR8dybH95s7RUE4uzNTyD8pA3p21/vpOkAdeNa90MhsMDnLlcd4ZDuTkwsxQapxY3vLru7cEefTN8SWcgah5PWBY6hzkyjFuGvTzkxz9hVmhVCMv4lVyc3H7WwGe3TJ+/U+XyXtulIpyzgxuA87cly8wdlDK5envf7uXDUPZP6txmxcO6HB15nRIUkruftu8RUS5YMhH58qf3LWpm3dGs8cca9zmPeYOV+4l/3FNcs/W8nNhyEfneia3vrGbXYHsI70ql3lctKkdOW0IxzX+vr38pYKNqrH7XHY7/t9rXfSGsnNhZii1UWnKKefti8T4587yc9GcyJ/k4uInL+9gKJLd+agmhg+rRU1ObaK+YIR/7co+OGussjZQU7ZaJinl00KIWSVdFAsCDbDuLgDcfn1xTvXep3DHRiCkT8Fqhl9n40u3EdwxwIVK9ga4ey1sb4rjkpLul9+hw99Dm/sd3PkGIoPbYdvT+s97XgVNt6MmOgpakLq+F/XPQkMgNbSeFTy/5WkuVIZyfuVrb8U5sPE18PvxxhXaXG/RqeUpf9M02PQQ9LwJWizJhWd0m85F9xO44n4I6X93zeBrbOiPEH+njwuV7H/cllXQ0BRHTXAxyd9Dm3srrnxc9L8N257Sf971EkT0eGZNLADBXdTGXhrjApXY7hU889ZTXKjkLjt9fXOc2Y2vgc9PjabQ7nqLdjmUh4s4bPwn9G2GWCjJRdXwZt2W3f9C1cIQ0u9ZM/AKG3p9eLb3cmGO9+r1Z6CqKY6S4GKyv4c2z3bUfOGKvs2w9Qn9552rIaA7w+p4COHfTo2RfAwNQyRIpH8FT29cyYVKbsnxNzbHmd24Hny+JBet+STK41HY+CAMvAMRf5KLjtFNANTufhhFRpNcVA+8xJu9A7Tszs3FmidBNscR2hgXrZ7t5GhGOno2wNbH9Z93rIJRvbTWq0VRfG/TEPOOcRGLEe5ZwdNvurlQyV1d8+bmOLMSXNQluGjOt6l8LKy3i8EdEBpJctHm09tF3a4HEcSTXHj7VvNmTzcz+3qZmYOLpx+Fxc1x0CR7X36HqYEeWke6EPkWvHavH+Ni6zMwqK+Kr5Jx1JHN1Bv+IDQEmiDUvYLnAy4uVHJUXUXTuaiXOhdNJaowTBTWFrYCQoir0OUumDHNDXTC/Z8EwO3xwNRJiO1/oLqhnmgE8HiY1ruCZb77WAbgyfXNgJFq6Br7fZdyfu7zH/06vPl3mD0D3nwAVv0RgKbOdjZWeWjf/Rp0tsPIbkCwfM/PADgvnw1RIHVGuAem0Ah8L/v5e1+HP18GzU3QUJfkwuWtgsmduN/5LVXNTRCR4PEwo+dBjg/8leMLPcksXGxTL8l9/iNfhbcfhZnTYf09MPJ7ABomd9Ctumjb8wq0t+lcSDgxwcVF+biIAKnqDXugnTbgO9nP71oLf/kgtDZDbc0YF9VemNRB9du/wt3WAiPD4PEwa+/9HB8McXw+G3JwsUW9LPf5D14LO5+HGVNh3Z0wejMAdVMm0RPpp3XkJWhrgZFdoElO7l4FwAdK5KKJKcC3sp+/7Rn465X6faq9SS4OqKmGznbq3/opamc7jPjA42FO9185OhRmeSEujH4phYtN6odzn3//p6DnNZg+Bdb+Hvw6mTVTJ9MbHuAoX0B/XiO7IB7nlL2JwVWJXNSJmcA3s5+/5TG458PQ3goeT5KLWXU10N5G44YfoUzp1G3weDh4z90siERK58IPr6ufyH3+vR+HoS0wbTKs/g0E9E67avoU+oIvc1AopL/HI7shuoNTexKOo0QuqsRBwH8XMH7fYbkzkFLeDNwMMPM9U/UxyTWvAlA1sh1WfoaeeV/F1/8Pqmo9MLqDf9RfwY/653LLKfP46ONv5vzuj86IoMbhMX8TLn8vtyrXo+aTlo1FoFqfarLkMzD3/QDs+ucnqFFg54LPQs+voHUOUouz7J3rOG16C17h5x87sk+Dm10a1x3WwrPbe3mwz81tzf9kSuD53DbEE1PIA06E4deTXLgHNsKzX2b3wm8R7L2b+tpaGN3BXxs+zrcHD+D20w7lQ4/mTs9cPSuCFoWHRxpoi3Tzc24owEUY6vVdm1j+ZTjwPAC6H/wIXnctXVNOhd7fQescNKGybOtXOXt2G/HIKA/vys7F1CqNzx7awsptfTzS7+Ku5vtoCqzPw0Xie2afAKNb4JqHAFB6XoEXvsH2w39AeO/vqK9rhtHt3F73ab42NL0gF5+dHSEcgb8P1XFQrIsf8H3UfCuaYyFomgnE4ORvwCw9+tn74Ido97Sze8ox0HcHtB5ETPGybNtZXHRgB4PBIR7fnT0kcEhdnCsPbuWxrX08NuDir01/whN8J48Nie+ZdTwEuuCahwF487E/QOAe3j7qp8T2/AyaOmB0O/+v9vNcOzyZP5w2nysefSPn137xwDCjIcG9/bUsYhvflD8u3C7a5gI+OOP7MP0kAPr/8QEavLN4p3EyhB6F1oOIuBpYtv00Ljt4EjuG+nlmb/bw4pGNcS6e08rDb/fx1JCLvzXejhrOIxERS7SLmUsg3A8XPQLAhkd/C8EHeOuYX6Pt+h60zobR7fxf7ZfZ4e/k5ycdzFWP5xZc/sqcMENBwd29NZysvsWXtZsKcBGEzkOBfjjr/2DKEgCGHriQmQ0L2Bavh/BKaJ1DwN3Bsp3L+ci8KbzR28uLvdm5WNYS5+zZrTy4pY9nh1082PBb1Ih5Gmf5YLkzSINRm9s8C4Bqtx4WCnka0BQ3JKqLurV6umQHTa0H0CVzC7HNaAnS6xMMRtqLF39unAoMQ3Vz0o4W9xR2abuJefW4vW5HlC7ZgathKvHYIF0y+wM7oCFGc/NkYnugS3qIiPwaR0l4G2FYSdpQJ/S/IOhpRBOuJBe7Yw10yQ4aWmfTJXOLt01rDtI9KugPtqJFikxUNUwFuqGmJY2LYTFCvCrhNFUPElXnon46oWAfXTmmtfMTXER26VxEi+Wiqg58atKGxsTiplBVE1IokFBT3RlvoE+ZVJCLyU1Bdo8K+kabaYoVMwUXCS62Q23rGBeuSUSEJO7R4/aobqRSpXPROJOI9NIls+dQjq6L0tw8hXCXzkVMqc47YEzCUwshV9IGV9U0CECwqhnJGBfbY434PVNobD2ALplbTK+tMUhYCPaqjfQXWFmuUyGgcQpENkFtW9KOVlcnUcVFVNQnuYgrXrpkB+6GmURCnpxcnFgXobl5KmG3oEvq1xUVwXfXQGwkaYOnahoEIehtQSKSXLwTaSLmnUpr64F0ydxies0NQQIIukU9g+TmbIwLBRqmQLAf6jqSdrS5OomobmKiDsKAqj/fLtlBVeMswqMqXTmKHxrqdS6CSS6qGJvKlhf2Li1NrObLrBrxJtbz56qfn1Tn4vfnTcesEmYXrnGyA0ZYNRiL59zU4/IFTVw+3ZwKgTEtnAwuXPlfm+kNbu5433TTJBB0LtLjuUZddziu5SyP+9gRLVw81RwuxqS000fdNaoglGcV54HNHu6+YIZpe0Nn50L/PxqXOeVBPnN0K+dMMk87C8avxal1CXzR3EOgQ1qr+MtFM02xwbBjHBeJ/+NSEslR0/nlJe2c0mHOYiuDi8y1H7VuhdFoLGd/saDDy32XmM1FpkyJ/vdrUuYse//mCZ0sbbFu4Vk5S0vvRlc9PVgI0SWE+Gip32GsMxiIpo/+NQlVqm56dZZ1GvPbvRw/w7xdwWLEcjqD9moPTTm8zn8uaM5q30RgdICDWbho9OSe4B3W6eW46eZxESXKaGwo7ZjBRVu1m5aq7C/cZQuaMKtYwlj1OxhNH+VpEjprco+vF02u5uipRc5GikCM6DidJmNg0OJ10erN/gdfvrAZswq8ROIVztTkiUuYmrHncCoWT61h0eT8yq+lICqjjGS2i4RnbK5y05aDi8sWNFFgPFMyhmLpktSalEypzc3FcdNqWNhZXi4MX9jocdFRnaO/OLQJEwu8SkY5q4k+sK/fUePSX1yv4k07rkmJK8GaXhKW7mnNFAID8Arv+G0vEw3dpYicFUpmPlhDPtqTIR+tSZJcZLXB5NZVJarwZDwPYzTsEiJnuaKZq6BrXQnJ5Az56Dj5uTCzfBD0Fa9VubhQlJwdvpmPxJDyzpSC0KT+PHJBMXkYWCWq8Ga0TeO1cCl52oWJz6QmEXZURfoITJPgydcuyvCOyAyCjUFCPi6sdARg8zCRMQLMrBvWGGvoviyrKM1+uDVK7bga6tSGnuuly9cxlYoxBdf00EghZ2D2qKtWqctZT+5Scsv1memgk0v+M8IBhTpA1eTWXqfUjVsDk9oucsHMdpEMjchMLmTe9yAfTxNBbTYuEmSoQuQMpZr5rhoOMdOOuNSdcy6YPXisVerGPY+xQYLIGT4st8BjIdjaGRjy0X0ZO2uNRGTyATZ5xhNoln6/ARUXGlraJjupo+HaHAvczHy2Rs6gP5KeGB2JaMkXO1uj7g2YG4N04SKUIQ+iJWdJCg1Znof+mXlkGM5gMJqe5BuOaHnv02eSSJ0BFy6GM0IShsyASwgac4QPTXUGZA+ZDYZl3vuYJVI3Zod7nBxFTNPfF5cicoZSTVwDmORiKCNkNhDW8jq/wZD570hPhhxFND7GRavX4ilADtjaGQBoaLiV9DiwVxUMhPXGnC0vNbOpqLqMomEsc0/VBRpLIGs5wwFeE4cchkpmNi76Q8aOcOOvm9GYX0myVBjbkKbODgzHGI7nfuncJnLhVfXQjJoRGvGqgoFQ7iT19AZz20UgRwUZQFTTcs7KTJ0xJjjIDI1Uu/JzMbXe3HYRkH48IntcXpMy5+jbTOFAY5aUOT+tsYCLzB3wDIukNPdvNhO2dwYNSuO4bS+lhBn1eocwkkXbxGyuW1RdFiN16mckx9qq3dTl8AZmP3Sv8I7jQkMmucg2ETc7Dtmq6uW1aVwk/m/xuqnLMUsy0w5VUVFQkBkFw1LC9HpvjqvKwUU7oD+DMRv0n5uqcnNhZljCnVAt1cj9jmS1wWQy2tT2caEgY5DQ4HFRb6I8TC4Yzmh8fyEr2i7a1I7xzyPxf51HpcbsuJRJsL0zUFGz5gyMJMyyzvFe3WyuVUMZMosmj1tR8OaoGDI7SafiyhIbHht1L2obXw9gdtI0WcqYZofe1N2KyNMBmm9H5vPQpEy2i0OasuwwZvJbPxavH2ufxkvvVgQNOUIjZpqhoGTdllVPpuv3n1E33g6z3xGXcI17T1Pj5GZKVee2QX/mmXbE5Vh/0Z6lqsnsQZtLuMblLYxZuztPKNVq2N8ZCBfd4XQVzHhKNdFHDq7hfy5YkHFNeV76VDXE1IauCMGKzy/nsOlNZbejO5y+mXo8JWn6qXm1fOvc+Wmfmz3qMRxjqkpmKhduRfDQ545nVmt6Caf5jnG8lHY8JZn+hQV1fO29h6RfY3YHmJSPHlv7kcpFjUvw4GeX0ZixxaGZiUIhBIpQ6Ymkc6FpMtkurj+8ji+dPjftc9M7QFxItLRtWVMraFqqFB74zFJT75kJo21myoqntotvH1XH506ek36dyW1Tz6sF0+ZJybyaEEytVfnbp5aYe1MTYHtnEND81Lka046NRMacgUcVHJ7RCZsNw8unenstpbQU4OBJ9eNeerM7H38WLlKTpl5VsGBa+udmj4aNmUnqDCWWkjQFmDelgTpv+izFbMcYlEHqXA1px4YiMjkarnEJ5k9J58LsDtDYhzl1UWRqohDg0KmNZd8TOi5j42TFB8Jj7aLWrXDIpHSuzO4AQ9KQFR+rdoskymaMdrFwWhNeExV0M2Fsy5opKz6Qkkyvdysc1FmfcZ257SKUyDGmOsZwNL1dHDGj2dR7mgHbO4P2LJLJXpW0hFDmwzR7j4h6Ve9UsoWJ8m13aXYjy8ZFtUthMDTmpDLvaPbMoCELF9lukZnEM9sxtqnt40Ij1SoMprSLTPrN7gCb1CYgfcWrkqzsqlwooNnVOq5d1LgEg+EUuzL+drPbZjb5aOMebrOnhXlQk6WsU+divF0GzG6bYznGsXuqKYNXu8L2zkDFRSRj4w4tIzmW2eGZTbcrsa9q6ktvuICGlNW/mfctx/RzHBdaenJsfEM3PxwA2bmoyzMCNruGWsU1TqZEg7xcmB8aMWQxxrgwBgfVKTWT5a4fV4WbcMaub5nvSKYN5cgZAGk6/ka78KZyYfrbmQ5VuMbt+qZJyfSU1diZ/YXZ7cKo7ErjItEuPBV0jKXCvpYlINHG1S9rMn20kfkszd89Tr9B2hLzZEIod0Myu5FJ5Dgu4hk2VGpAmirDYDT0So4AJZKejK1I41oGFxnXmD1LMmLiqZo8YwnkSr5a49tFapEFVICLRBtIz6uNFRZUDpK9GTmDQv1FubhIHaykFhbYFbZ3BgB1anrsNyYzO8B0ggeC5i4iqU4ss1dSarmLeenNnhJK5HguNJnGRaYDGjJ5QY0hOSBSmo41DV1S78rfLjKlOEbDeTYqmQDGpChSS0v1/yvJhURSn5E/icQlLjH2jDLbhS9iMhdGWWdKSaVRQWPmuopiUJeRP4lo6TZk9hdm7osNYyWuqWEizcirOc5g4mhSm8dJMPiiGtGUFVaZ9E6qM1dyyVjYk5401RtQ6rMt96i8SW0ax8VolDQuMtFpMheeRF17KhfReHoCGcrPRaPaPC6HE4jJvO3CbC6MDjDVDiNpWkln0OJuG5c/iUl94ZuBzOfRUWsuF4Z+WGoHGEqoplaSi2Z3W9ZtWWN52kVrjblcGIPHVC6CCS6slpzIB9s7AxWV/gzZAY8q0jrhzK7QbLqNkrXR2FhoxBhp1brHZgtGxUC5oOIax0WVml4xlJnQNj9/onORquJqTIBS4+Tl5sKFa5w0hyrSO55YhpM0U/rAsAEgGB/bxtDIE6XGycMmjzzH2SE89EfH79/gSUlaxTJkk01fc2GUHKeERlyJhpGqCxTJIzFuih3CnYOLsb83mslFmUqOUyur3GYnEMsA21vo1/woGWZKCW3VY9IC4zY5N/nhurMIYMksU2B/xFy9l0zoXIxXZGz1jpW01pS5jNEIlaUm6VKVOg2M5ln+bwb80pdVnbI5hQuvO/1zs5OXRiljtjUXqYn7kWB5ufDFh8dxAdBcNTbizXxHylXUEpbpXFRlmBXPM4s1A774SFo410BT1Vi78GRyYbJjNEJlqVxoUtJQgVXY+wLbO4N2VweZvXs8Izac+TDNptwIjZA2GxmfNG2tNVf7JhM6F+nI5CIzNmz2tNQrEnHyLDOzVDva63Prx5uBtoQURCpkhg2Z8VmzZ+heYeRPUmZm6Eqxqbx3NJSXi07P1KyOLrVtlrsDrFHG75kh5fhqtnKvuej0TMnBxdixzLUOZlfc1Sl6ziJVnkOT5lcXmg2bm6dPueIZMcCwJlHI0wGabIOaZQclY9qdTyfdbGTjQssQvsrs/CvBhREnT+1gyjv+02dr2WLDooLtIps0RzgaL/vfngm38GRdA5P6B2e2C7MlrNUs0hzBPDutlQsepSp7u0j5c8eVX5sdPszCRSASK3NR7b7DXnsgZ4EqXMSJ0xfvZTrTAKie8ldWaRv4ytvV+MN+ap9roHr6mGztUxEXu16pYig0QkiB7noPVIf5DO0sG8q+D2s+GDHAXeEdyWM+bQ/V02/l+m334g/7+eOjd/CWGKZ6+lj45NOv1DIUGsHdW83emhDV0xW+797DYnc1n5sAFy7hIqgFiRKlEX30UT3tTp7WXmV7ggvv6nQu/ulzs/4VT5KLgUYPI3VBPivbOG7YHC5G5Xaqp9/KV94e46K7epDq6WMvQyoXe2p1Lr7l3sWxLg+fmgAXKi5GY8MIBO3o4nnV0+/g8dhLvPW2F3/Yj/vleqqnj0lM/6nfw1OvuJNcjLa42aQF+Zxs49h9aBe7U7lgC55p6Vz4m/uprhuLladysbtO5+Lr7t0cq6pcPQEuXIqbwWhvmpJs9bTbeST8Iq+9XYU/7Ed9rY7q6UPJz2/dW8UDo64kF6E2N6/i5xqtjWOGsu/PWwwXPfExuflR8SZMuYWvvH1PkgsxuZfqlLRBKhdd9SGqqxT+y93LEpfg46VTgSpc7A3vSavxr55+Gw8En+XFtz34w34I1VI9fSz/95tdXv4yoCa5iHe6eEH4uFZr48jBSLbb5LchgwspJT71VWRnMI2L6unp+b9ULnY2hKj2KnzZPcyyUY2PTICLUmF7ZzDXcwjb5DbC0QAfOOQDrNz5NCu3vIOoCeKLxwnKEDKqINSx+uaQpjIajREgRESAJuJIJcxT3mraQpl7kxaGgsLxzaezO7QDd1zh0vdcws/X/JFeNYgvrhKUIVwRF3ECCHVsVDIahQAhXFISIYJQBdvcQXY0eCfkDA6pmk8Xu4lEA1z+nst5ZOujPLd1B9SEklzEoyKNi0A8ymg0OsaFEidOgJVVNXRMgAuv8HJc48n0RHZTFXdz4SHv4xdr7mbQlc6FJgIIdaxzSuUiKnQu3naH2FPvnpAzmFd1KD2ij2g0yIfmfYi/b3mI1dt3IWuD+OIxgjKEO5bOhT8eYzTqSuEiRkT4ebKqhknB0rmoU+o5uuF4BqK91Ghezjn4vfxi9Z8ZzeBCiiBCHesBs3GxyR2mr35izmBRwxJ2h3YQi4W4Yv4V3LPpAV7e2Y3mCeKLRwnKEGqMdC5icaqiapILqcQICz9PVNcwJVA6F01qM0fUH0d/aA/zph7CgrYF/HrtvfhdoTQuUEIIMTZ3SuUiluBigzvCSN3EnMFRDcvoj+wlFgvz4UM/zF1v3sdru3qIewP44hGCMoSIy4x3JI4rjQuVoOLnseoapvhL56LN1c5h9YsZDPVw+IyFzG6cze9eeoBwBhepNuTi4g13jGCddJwBwGzPgXx92s/o6XmLMw5ezntnXcChj63gvMNncPncyWzs3sR7lh7Fkd99LHnNB45o4b8Wd7Dq+VfYNSK4c6Sd6Mg77Jr9vxOyQQjBx6d9GUC3Y+5yVr06h4e6uvjVccewsXsTy85Yyod/v5ont415+9vPOYRVz79CS8sM/vbmLn63y8OZM29kbdX4aodiMMczlyXTzk7acPzks1j85ONcfNQsLjqok43dm5i1+AiW/fDJ5DWXLGnnE0e2Jrm4dbCVutAbbJ7x6wlz8ckZ/zXGxcHLeWrtHJ7f1c2vjl2c5OK8XzzLq11jo69ULv78+i5u3+Ph1Fn/wwbXYK5b5cUhVfNZPv183YaDlnNkyxksf+pJLj/mAM4+oJ2N3ZvoPHwhp/3k6eQ1HztlEhfPa0py8f/6mpkWf4nXpt8+IRsUofDZmd8Y4+KQ5Tz6whze7O7jV8ceneRi2Q+foGtw7MVP5eKP63dxd7eHE2Z/h51K6R0PwJENSziyYYluw5zlvKfuFM545mk+snQOp85oZWP3Jhrmz+fcXzyXvObzZ03l1APqk1z8tKeRecpzrJl6z4RscAkX1876tm7DCcsBeOi5g9jdM8SvjhnjYv43HiEQGRskpHLx+1d3c0+PmyUH3MAgwRx3yo9jm07k2KYTdTsOXM509/Gc/9zzXH3CwSyb0sTG7k24DzqE99/8QvKab1w0g0WTa5Jc/HBPPYdVP85zkx6akA0e4eGLs76n27BM5+IfTx1CYMTHr445KsnFrK/+M+26VC5uXrebv/e6OfKArxOjvAUIBmzvDDIRSGiMBONjDcqKzSJGQ1HClQ+JpsGfMCAUT60nL2+cPBtGwzHCZa4SKYSRRPVSWMvNRSXgC8UIxa3lYiighzZS11xY8Y74wjFMXvNYMgYTXKSWXJu9L3gx8IVj40pa7Yb9zhkYNdvtKaWlmQ29vaa8FQsAVS61Iht25IOhkJnORfo5Tbk2WzARVS4l5wY/lYJRstjmzc1FJTT1q9yK5SWERpfTllJmm+kLaivwvKpcal4uKrEYzSgoSC2zzbytpwJlPh6XSlUezpsr8J4Wwn7rDKpdY+SlrLrn68s7uOg9TRWwIz5uIxdjJHrSVJWPHD2l/DYkFnZ5UxpzqmP8xvIOzj24Ydx1ptsR06jPscfjadNVPnz01IrYAOmLvdK56OSk2XXjrjPdjqg2rqM1zDhzpspHjp5WfhsSXHhytItvntDJ0VNrxl1nNiIxjVpX9nfkrFkqH1tcOS6qUrhInTF+68RO5rWXt/QXIBKL05rDMZ4328XHjy0/F4Vg+9LSTAwnFvCkaY2kfH7FYS3UVmAE+E6vf1x9siFQNb9V4bjp4+uuzYYxBU7XXRn7/EOHtaR1juXCO72+nOV5C1pVFleg4+n36RUwubloTusQyoV3+nzjFnQZEYpF7SqLJleX3YaeEb0yKhcXH1zYXBGNnLd7feNWfRvvyNEdKgs6y89F97Cee0gTqkv5/LIFzRUJob3T58+5Av7YSSqHtOXelrNS2O+cgREOSH3hrIiHNtd4csaGK2WNcXdXnkVnlUBzjYdQLIOLhB2VCs8ao70qJftouFJoskG7MKQPalJmz5ZwUe3OmTOoVLvwJDiocVvbLhqr3bnbhU0WIOx3ziAc01tX6vJyKx5uKBZnUnV2+ipljSEE1phnT4VK2dGZmafJs+lPOWC0i9Q9Fax4yUJR+7SL6rSQWYVunoJIXMvJRaVgtAuvaq1jjMQ0Oquz5wVs4gv2P2fQPZx/ClwpbOkZHxoxRqeVsmfPUGIKrFo7M9jSOz40YqBSnZBRuumxeGbQNRgcL48i0v8vN3YOBoCMTWUs4KLPFxnXLkSFZ4zb+3Uu0nMGlbm3ASklgUg85zvizAwmCEMJsc5tradvrHYTyZgCGyGsSpnjTrzs9e7USonKc9HgdZMpUmpUNVbKGkOILd9ua5WAR1XGqaUa1a6VejTViXej1mUdF4Z+f2b0MPmOVKhl1CaU8iqRO8uFUOLlyFV9bZdO2C52FI3uYT1RmNrQ3RbsK7pnOMSkmnT6jOR2pazZk5BQSA0HZAqSVQLDwSidGeGAoaCe3K5UB7jb4CJlBDhOzbbM0DRJJK7RkcGFkeivVLswZkmps+dKlE+mwqji6fCm33dM178yduwcCI5TTq20nHQgoWbc5s1xX2dmMDHEE8Osare1U2CAYMawp7Faz2NkzhjKBUMVMbXMttJbrBprHTKTY/VVleXCQGoHaLYyZyEYEuaZixFrqwxxv8rYMRauHPv7XRUeMBkS5pkbqhkmxSuUU1LE+OdR6cHjSEhvF5kzRgMVTq/lxH7nDAb8eiOrsXAKbKh0TslImhqNrKpCja3fF8GtZHSAFXaMgcSbNiVjlmQssDF5E6mc6PeHqXOJtA6w0itNjRXhmTNGY4+J6gpx0ecL01KVocxZ4XbhT4wCMmeMdQnH6K3QO9Lni4xrm5UeJBgzg/YcyfTMmYtV2O+cgSE7YEVs3IARDopluPSxTV4qY8doODZutFnphm6EgzJjwwYqxYUvFCOa8Twq3QEO+A3pg/Tj2Ta8KSf8WdpFpR2jse5jXLNIclEZO/yR2Lh8VqX7jt5RnYtcd7XLtsj7nTPYMxy0fLm/EQPOVSpWKeweCo6LQ1Y6ZNbnM7gYvxsdVK6h7xoK0u61dgTYl+gAM+0wUKkOMCsXFW8XOhe54uQVaxeD49+RyrcL/R1ptbhdFMJ+5wyiuYagFcRQILEKOlepWIXsiMVl2m5KVsCIDWfqzBhWVeq9i2ly3Ii80iNAX0JEMVeYsGJcxCWZ6YlKzwx8iZBZrvFSJduFzJwxVpiLYCJMVJ2zXdjDG+x3zmD3cHDcKLTS2DGg1y5njjgq3S3vGQ4yyeLZSS4uDFSqoe8ZCjLZ4tiwUdM+vl3oLaNS5ujtwloudvT7AWipyv6OVGI0LKVkwB8ZtyCy0p2v8Y40V9l7ZmArobqRUJQG4At/Xkdc6iO93buDuDe/TSgc5K9719A1GGRJp7vgd00EA/4Io0NBqIaH1u9hw4Z1xDXJrt1BPFveRpMQCgV5c+g1ADprsj/cfWlr4VicKuC1XUNEhJaTiz93r6HPF2HB5PLsuzwQiLLLF4AOuH/dLl567RU0yTguXu1/A8hTNrcPCEbjVANv7B7BRyzJRVyT7NkzxsVdu1fjj8Rp96YLjpnV/w0Fo7wzHIM2+OvanTz3ci4uNgLQ7DF/ZuCPxKgFNuwZYVBEklzs2hXEs+UdNCkJhYPc0fUimmRceatZYaKRUJS3ukehBe56cQePr0nnIhgK8te9a3lsg77LV6aYo4F94cIXjlEHbNo7Si9hrv3zOrQsXNyyTd+zIHPwaJZj9IVjbOwegUb4/fNbeXBVbi6qXIrlM8ZCsJUzMGqT12wfQBECVQgCAQ13OIQW14gMhThsehMnt8UKfNPEsGMwAIkQUNdgkIHAIIqAYEDDEw4hBGgxjbmd9cyf0kC925d2vZFA3JcSwu39AeYm7q81y6xcyLhGZDjE4dObOKG9PFzsHgoyENbjvtv7AvSGhlAVQcCfzsX8KQ0smtGMVx1Ou74vkTTblxLCd3r9zEeP+8YatNxcjIY5YkYTx3ekc2FW/qR7JERPVIE22NoboDucnYtDpzZw7OxWVCV9w56ekdK3kczElh4fh6GvpwjXaazp1rkIBeK4w0EE6Fy4Iyya0cSSzvR6SrNKS/tGw+wlBC26EN2uDC60uEZ4KMihUxs4cW4Hgr60641Q2r6Mzt/a62MR+lqfaE2ctd0DqEIQzOCiwR3jqJnNHJPRLsziYigQZU8oCI2wZa+PnZHcXJwxbxLEsm9q5TiDLGiv00d2z3zl5OSxFY88TUfHXH3XoDOPB+DZFc9lvd4MeN0qEOOq5Qdw1cKT0mwA8tphLOzJrDIqBUZ886iZzTweUC3kQlLrcQFhrjn1ID44rzQujNLS+D44RiO8cvSsFtaEenjaKi4kNCXqQr/yHwdz8dwSuXAphGPaPoURjWuPnt3Cxsgo//roySXZYOZCq9ZafTb69bPncc6B6Vyk2qDb0Zf1O/alysxoF4tntdAVj/NAiVxUu80LrXY26Mqr3zt/AafOLMRFdmdg8VYgSZTVGQghzgR+BqjA76SUPyjXva49dS7B7q3l+vqi8KOLFvKdB9/kqI4RS+341IkH4hrYUfjEMuLXlx/JjSs2Mbd5uPDJZcRHl82myb/LUhvu/Nix/L+ntjC5ZshSOy4/dgbTot2W2nDvJ4/j9lXbqXcPWGaDW1W4+MhpvEeZ2PazZuGujx3Dfa/swqP2W2qHgbI5AyGECvwSOA3oAtYIIR6QUr6Z6xptXA1E8bjm1INY89TOnJ+HEl8dUkLs3LM56zkBGSa2D156Vlstt1x5NGueeiLnORKJTxE5bRgY2c2wohCREw//fOXMQ1jz1O5cBiRlhfNyQZSgMvGx7NzOem7+0FEFuACfQk4bBke7E1xMfA/Yr589jzVPZe8AJZJw4k8MKcHcXChR/MrE81QLpjXyq8uOzM+FBH8eLob8PQwrCrF9aBfffd8C1jzVm/UzKSWRxM8hJZDTDr8Sxy8m3i6OnNnCkTNbCnAh8akypw0jwT6GFYWoNvF28eOLD8tpgyZlcm1CWPjzcKERFBNfYr9kThtL5rQV7C/8ipbTBjNRzpnBYmCLlPIdACHEn4DzgJzOoC/YR5toM90QlyLojblRgH82DfDPf12Q/cRJqdeYS42aeIH6wxrRGsF7c9kAMHMa+NZQ5zZ/Zy6XIuiO6tP8B5r38kAuO6akXmM2F/r/QxENX7VSmIuRtbRXt5tqA4BLUdid4OJvLV38LZcdU4FEV+kS5eFiNKbRVwwXQ2uZXj/dVBtA56IrrHNxT+tW7sllx3QB6Mlh9z44yGww3pFATLLbWwwXr3BQ80Gm2gC6kkBXROfiz+2b+HMuO2ZUoY9zzX9HjDxCOA5bawpwYRLK6QymAqlD9S7gmMyThBBXAVcBtM9s52cn/8x0Q65YOI0Vq4foGD6J4ejbtHfmdji1nQfQOX0uZ84601QbZngl5zVrNIuP09r3Z9o6W3OeK1QPU+cv4aC2g021AeCjR0znsTUjdIwcz3Bke14u6iYdxKRpB3HmbHO5OLBa49xmjRY+TmvfPXltEK4qph26lENa32OqDQCfWDSDJ9eO0DGyhJFIV1476qcewqQpB3LazNNMtWFujcY5zRqt2sdp77s/PxduL9MPXca8tnmm2gDw6aNn8vRLPtpHjmE0sievHY3T59E5+QCWT1tuqg3z6jTOjmi0xz5KZ98/89qgeGqYPn8JCzoWmmoDwDWLZ/P8K34Wj+xiNLI3rx1NMxfQ2TmLYycfa6oNC+viRKIqHdErmdr3r7w2/Devm3LPcjqDbDny8avTpbwZuBngqKOOkmY3MICZTdUcWw9z2j7N2i1Pcs3lV5t+j0JQBSyqgzlti1m7xW+JDQAHNNckuLjGMi5cChxZB3PalrB2S9gyLua21hJqUJjT9gXLuPAocFQdzGlbztotccu4eE9bHdEGhTltX7aMiyoFjq6DOW2nsHaLYhkXh3bUozW4mNN2nWVcVKuwuA7mtJ3J2i1VeW347w/ebso9y5nH7gJS57PTgByBbAcOHDhwYCXK6QzWAAcJIWYLITzApcADZbyfAwcOHDiYIMoWJpJSxoQQnwFWoJeW3iqlfKNc93PgwIEDBxNHWdcZSCkfAh4q5z0cOHDgwMG+wyZr3xw4cODAgZVwnIEDBw4cOHCcgQMHDhw4cJyBAwcOHDjAcQYOHDhw4ADHGThw4MCBAxxn4MCBAwcOcJyBAwcOHDjAcQYOHDhw4ADHGThw4MCBAxxn4MCBAwcOcJyBAwcOHDgAhJQT38/UbAghRoFNVttRAG1An9VGFAHHTnPh2GkuHDvNw8FSyvp9/ZKyqpZOAJuklEdZbUQ+CCHW2t1GcOw0G46d5sKx0zwIIdaa8T1OmMiBAwcOHDjOwIEDBw4c2M8Z3Gy1AUVgf7ARHDvNhmOnuXDsNA+m2GirBLIDBw4cOLAGdpsZOHDgwIEDC+A4AwcOHDhwUBlnIIQ4UwixSQixRQjx1SyfCyHETYnPXxNCLCr22grbeVnCvteEEM8LIQ5L+WybEGK9EGKdWaVe+2DniUKI4YQt64QQ3yj22grb+eUUG18XQsSFEC2JzyrCpxDiViFEjxDi9Ryf26VtFrLTLm2zkJ2Wt80ibLS8XSbuNV0I8aQQYoMQ4g0hxDVZzjGvfUopy/oPUIG3gQMAD/AqMC/jnPcCDwMCOBZ4sdhrK2znEqA58fN/GHYmft8GtNmEzxOBBydybSXtzDj/HOAJC/hcDiwCXs/xueVts0g7LW+bRdpph7aZ10Y7tMvEvSYDixI/1wNvlbPvrMTMYDGwRUr5jpQyAvwJOC/jnPOA26WOF4AmIcTkIq+tmJ1SyuellIOJX18AppXJlnzYF05sxWcGPgDcXSZbckJK+TQwkOcUO7TNgnbapG0Ww2cuVIzPEm20pF0CSCn3SClfTvw8CmwApmacZlr7rIQzmArsTPm9i/F/UK5zirnWLJR6r4+ie2QDEviXEOIlIcRVZbDPQLF2HieEeFUI8bAQYn6J15qBou8lhKgBzgTuTTlcKT4LwQ5ts1RY1TaLhdVtsyjYqV0KIWYBRwAvZnxkWvushByFyHIss5411znFXGsWir6XEOIk9BduWcrhpVLK3UKIDuBRIcTGxAjECjtfBmZKKX1CiPcC9wMHFXmtWSjlXucAz0kpU0drleKzEOzQNouGxW2zGNihbRYLW7RLIUQdukP6vJRyJPPjLJdMqH1WYmbQBUxP+X0asLvIc4q51iwUdS8hxELgd8B5Usp+47iUcnfi/x7gb+jTNEvslFKOSCl9iZ8fAtxCiLZirq2knSm4lIypeAX5LAQ7tM2iYIO2WRA2aZvFwvJ2KYRwozuCO6WU92U5xbz2WYEkiAt4B5jNWCJjfsY5Z5GeBFld7LUVtnMGsAVYknG8FqhP+fl54EwL7ZzE2ILCxcCOBLe24jNxXiN6/LbWCj4T95hF7oSn5W2zSDstb5tF2ml52yxko43apQBuB36a5xzT2mfZw0RSypgQ4jPACvQM961SyjeEEFcnPv818BB6VnwLEAA+nO9aC+38BtAK/EoIARCTuqJhJ/C3xDEXcJeU8hEL7bwI+KQQIgYEgUul3kLsxifA+cC/pJT+lMsrxqcQ4m70Cpc2IUQX8E3AnWKj5W2zSDstb5tF2ml52yzCRrC4XSawFPggsF4IsS5x7Gvojt/09unIUThw4MCBA2cFsgMHDhw4cJyBAwcOHDjAcQYOHDhw4ADHGThw4MCBAxxn4MCBAwdlRSFhvIxzlwshXhZCxIQQF2V8doUQYnPi3xVm2+k4Awf/FhBCtKYoTXYLIXYlfvYJIX5Vpnt+XgjxoQlc5xFCPC2EqIQCgAPrcRu6rEUx2AFcCdyVejChmvpN4Bj09RnfFEI0m2diZeQoHDgoO6S+4vZwACHEDYBPSnljue6X6Mg/gq5+WRKklBEhxOPA+4E7zbbNgb0gpXw6oS2UhBDiQOCXQDv6+oCPSyk3Sim3JT7XMr7mDOBRmZDGEEI8iu5gTBPRc2YGDv6tIXT9/AcTP98ghPiDEOJfQtelv0AI8SOh69M/klj6jxDiSCHEUwkxshUJFchMnAy8LKWMJa5ZKYT4oRBitRDiLSHE8Ynj8xPH1gldb/6gxPX3A5eVnQAHdsXNwGellEcCXwIKzV7LLuTnOAMH7zYciL6E/zzgj8CTUsoF6Kthz0o4hJ8DFyVe1FuB72X5nqXASxnHXFLKxcDn0af0AFcDP5NSHg4chf4SA7wOHG3S3+RgP0JCeG4J8NfEyuLfoO9dkPeyLMdMXTHshIkcvNvwsJQyKoRYj75M35ATWI+uV3MwcCi6IiWJc/Zk+Z7J6PryqTCExF5KfBfAKuB6IcQ04D4p5WYAKWVcCBERQtRLXavewbsHCjCUGCAUiy50CQ0D04CV5pnkzAwcvPsQBpBSakBUjumxaOiDIwG8IaU8PPFvgZTy9CzfEwS82b4biCe+CynlXcC5ifNXCCFOTjm/CgiZ8Dc52I8gdRnqrUKIiyG5deVhBS5bAZwuhGhOJI5PTxwzDY4zcOAgHZuAdiHEcaBLCIuxDVhSsQGYU+jLhBAHAO9IKW8CHgAWJo63Ar1SyqhpljuwJRLCeKuAg4UQXUKIj6Lniz4qhHgVeIPELmRCiKMT4nkXA78RQrwBkEgcfwdYk/j3bZm+z8I+wwkTOXCQgkSlz0XATUKIRvR35KfoL2wqHgbuKOIr3w9cLoSIAt3AtxPHT0JXnHTwbw4p5QdyfDSu3FRKuYYcW5ZKKW9Fz2GVBY5qqQMHE4QQ4m/AV4w8QInX3gf8l5Ryk/mWOXBQOpwwkQMHE8dXKVwFMg5CCA9wv+MIHNgJzszAgQMHDhw4MwMHDhw4cOA4AwcOHDhwgOMMHDhw4MABjjNw4MCBAwc4zsCBAwcOHAD/H7E3t7Z0rNIoAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -477,14 +477,14 @@ { "cell_type": "code", "execution_count": null, - "id": "67d7f4ba", + "id": "f5280e48", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", - "id": "2ed484d1", + "id": "3d4b0951", "metadata": {}, "source": [ "## Execution\n", @@ -496,7 +496,7 @@ { "cell_type": "code", "execution_count": 29, - "id": "c8bfe143", + "id": "031fd70e", "metadata": {}, "outputs": [], "source": [ @@ -506,7 +506,7 @@ { "cell_type": "code", "execution_count": 30, - "id": "bfbf9bb8", + "id": "f0143c3d", "metadata": {}, "outputs": [], "source": [ @@ -516,7 +516,7 @@ { "cell_type": "code", "execution_count": 31, - "id": "96101e9f", + "id": "843fb93c", "metadata": {}, "outputs": [], "source": [ @@ -526,7 +526,7 @@ { "cell_type": "code", "execution_count": 32, - "id": "02dd1c40", + "id": "7df89611", "metadata": {}, "outputs": [], "source": [ @@ -536,7 +536,7 @@ { "cell_type": "code", "execution_count": 33, - "id": "e2e74ed9", + "id": "21afd2d6", "metadata": {}, "outputs": [], "source": [ @@ -546,7 +546,7 @@ { "cell_type": "code", "execution_count": 34, - "id": "d1bfec54", + "id": "2e4e2b0b", "metadata": {}, "outputs": [], "source": [ @@ -557,7 +557,7 @@ { "cell_type": "code", "execution_count": 35, - "id": "b2e3e48d", + "id": "632a30f6", "metadata": {}, "outputs": [], "source": [ @@ -568,7 +568,7 @@ { "cell_type": "code", "execution_count": 36, - "id": "9ef88b8e", + "id": "6abf0e7f", "metadata": {}, "outputs": [], "source": [ @@ -578,7 +578,7 @@ { "cell_type": "code", "execution_count": 37, - "id": "e3357627", + "id": "7f811d07", "metadata": {}, "outputs": [], "source": [ @@ -593,25 +593,44 @@ }, { "cell_type": "code", - "execution_count": 38, - "id": "a3c56e45", + "execution_count": 39, + "id": "2d7cafab", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "d0c8669f", "metadata": {}, "outputs": [], "source": [ "my_lockin.register_trigger_settings(program_name=\"test\",\n", - "# trigger_input=f\"auxins/1/sample.AuxIn1\",\n", - " trigger_input=f\"demods/0/sample.TrigIn1\",\n", + " trigger_input=f\"demods/0/sample.AuxIn1\", # here AuxInN referese to the printer label N+1\n", " edge=\"rising\",\n", " number_of_triggers_to_buffer=3,\n", - " level=0.5,\n", + " level=.5,\n", + " count=np.inf,\n", " other_settings={\"holdoff/time\": 1e-8} #\n", + " )\n", + "\n", + "my_lockin.register_trigger_settings(program_name=\"test\",\n", + " trigger_input=f\"demods/0/sample.TrigIn1\", # here TrigInN referese to the printer label N\n", + " edge=\"rising\",\n", + " number_of_triggers_to_buffer=3,\n", + " level=.5,\n", + " count=3,\n", + " other_settings={\"holdoff/time\": 1e-8}\n", " )" ] }, { "cell_type": "code", - "execution_count": 39, - "id": "7f16ed0c", + "execution_count": 41, + "id": "f069c321", "metadata": { "scrolled": true }, @@ -623,8 +642,8 @@ }, { "cell_type": "code", - "execution_count": 40, - "id": "706745a1", + "execution_count": 42, + "id": "11e558f5", "metadata": { "scrolled": false }, @@ -643,8 +662,12 @@ " 'test': {'trigger_settings': {'trigger_input': '/dev3442/demods/0/sample.TrigIn1',\n", " 'edge': 'rising',\n", " 'number_of_triggers_to_buffer': 3,\n", - " 'delay': 0,\n", - " 'other_settings': {'level': 0.5, 'holdoff/time': 1e-08}},\n", + " 'level': 0.5,\n", + " 'delay': -0.001,\n", + " 'post_delay': 0.001,\n", + " 'endless': False,\n", + " 'count': 3,\n", + " 'other_settings': {'holdoff/time': 1e-08}},\n", " 'windows': {'X': (array([1.e+09]), array([3.e+08])),\n", " 'R': (array([6.5e+08, 1.4e+09]), array([1.4e+08, 1.0e+08])),\n", " 'A': (array([3.0e+08, 1.2e+09]), array([1.5e+08, 3.0e+08]))},\n", @@ -656,7 +679,7 @@ " 'demods/0/sample.x'}}}" ] }, - "execution_count": 40, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } @@ -667,40 +690,37 @@ }, { "cell_type": "code", - "execution_count": 41, - "id": "7313120f", + "execution_count": 43, + "id": "8a82b2a0", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.read_memory = {}" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "cf3ce29e", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "sample rates: [1674.107177734375, 1674.107177734375, None]\n", - "SETTING TRIGMODE 6\n", - "SETTING TRIGGERNODE: ('triggernode', '/dev3442/demods/0/sample.TrigIn1')\n", - "using trigger edge: 0\n" - ] - }, { "name": "stderr", "output_type": "stream", "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:376: UserWarning: The channel auxins/0/sample.auxin0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:399: UserWarning: The channel auxins/0/sample.auxin0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", " warnings.warn(f\"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.\")\n" ] }, { - "ename": "KeyError", - "evalue": "'level'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_40988\\2579883431.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msetup\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrun_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"test\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\setup.py\u001b[0m in \u001b[0;36mrun_program\u001b[1;34m(self, name)\u001b[0m\n\u001b[0;32m 221\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mrun_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 222\u001b[0m \u001b[1;34m\"\"\"Calls arm program and starts it using the run callback\"\"\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 223\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marm_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 224\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_registered_programs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrun_callback\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 225\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\setup.py\u001b[0m in \u001b[0;36marm_program\u001b[1;34m(self, name)\u001b[0m\n\u001b[0;32m 217\u001b[0m \u001b[0mawg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marm\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 218\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mdac\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdacs_to_arm\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 219\u001b[1;33m \u001b[0mdac\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marm_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 220\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 221\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mrun_program\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m in \u001b[0;36marm_program\u001b[1;34m(self, program_name, force)\u001b[0m\n\u001b[0;32m 454\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"edge\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0medge_key\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 455\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 456\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"level\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mts\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"level\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 457\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 458\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mKeyError\u001b[0m: 'level'" + "name": "stdout", + "output_type": "stream", + "text": [ + "sample rates: [None, 1674.107177734375, 1674.107177734375]\n", + "Will record 2512 per row samples for 1.500000000001s!\n", + "3 row(s) will be recorded.\n", + "the following trigger settings will be used: {'trigger_input': '/dev3442/demods/0/sample.TrigIn1', 'edge': 'rising', 'number_of_triggers_to_buffer': 3, 'level': 0.5, 'delay': -0.001, 'post_delay': 0.001, 'endless': False, 'count': 3, 'other_settings': {'holdoff/time': 1e-08}}\n", + "MFLI returns a total record time of 1.5005013333333335s\n" ] } ], @@ -710,20 +730,20 @@ }, { "cell_type": "code", - "execution_count": 50, - "id": "5bc9a8a0", + "execution_count": 53, + "id": "1505ae0a", "metadata": {}, "outputs": [], "source": [ - "for _ in range(3):\n", + "for _ in range(3*3):\n", " my_lockin.force_trigger(None)\n", - " time.sleep(3)\n" + " time.sleep(2)\n" ] }, { "cell_type": "code", - "execution_count": 42, - "id": "deb54248", + "execution_count": 92, + "id": "8504fda1", "metadata": {}, "outputs": [], "source": [ @@ -736,25 +756,56 @@ }, { "cell_type": "code", - "execution_count": 52, - "id": "a2f215d5", + "execution_count": 86, + "id": "8ab20ee5", "metadata": {}, "outputs": [], "source": [ - "my_lockin.daq.finish()" + "my_lockin.stop_acquisition()" ] }, { "cell_type": "code", - "execution_count": 53, - "id": "b9ee3d42", + "execution_count": 54, + "id": "8d97dfac", "metadata": { "scrolled": true }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Waiting for device dev3442 to finish the acquisition...\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -766,27 +817,397 @@ } ], "source": [ - "data = my_lockin.measure_program()\n", - "plot_windows(data)" + "data = my_lockin.measure_program()#(wait=False, fail_if_incomplete=False)\n", + "if data is not None:\n", + " for d in data:\n", + " plot_windows(d)\n", + "else:\n", + " print(\"RETURNED NONE\")" ] }, { "cell_type": "code", - "execution_count": 45, - "id": "73a8a0af", + "execution_count": null, + "id": "06e609d5", + "metadata": {}, + "outputs": [], + "source": [ + "%debug" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "81b98b2a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'auxins/0/sample.auxin0.avg', 'demods/0/sample.r', 'demods/0/sample.x'}" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin._get_channels_for_window(program_name='test', window_name=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "5b72a01b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[autoreload of qupulse.hardware.dacs.mfli failed: Traceback (most recent call last):\n", + " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\site-packages\\IPython\\extensions\\autoreload.py\", line 245, in check\n", + " superreload(m, reload, self.old_objects)\n", + " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\site-packages\\IPython\\extensions\\autoreload.py\", line 394, in superreload\n", + " module = reload(module)\n", + " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\imp.py\", line 314, in reload\n", + " return importlib.reload(module)\n", + " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\importlib\\__init__.py\", line 169, in reload\n", + " _bootstrap._exec(spec, module)\n", + " File \"\", line 630, in _exec\n", + " File \"\", line 724, in exec_module\n", + " File \"\", line 860, in get_code\n", + " File \"\", line 791, in source_to_code\n", + " File \"\", line 219, in _call_with_frames_removed\n", + " File \"z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\", line 660\n", + " for k, v in recorded_data.items()\n", + " ^\n", + "SyntaxError: invalid syntax\n", + "]\n" + ] + }, + { + "data": { + "text/plain": [ + "{'X': {'/dev3442/demods/0/sample.x': [\n", + " array([[ 2.69279111e-07, 3.76000218e-07, 4.24689409e-07, ...,\n", + " -9.44849792e-08, -5.75667221e-08, -2.49266848e-08],\n", + " [ 6.31987250e-07, 4.11887636e-07, 2.38855616e-07, ...,\n", + " 2.93972004e-07, 3.04276206e-07, 4.01271313e-07],\n", + " [ 2.96471967e-07, 2.15771765e-07, 6.63772839e-08, ...,\n", + " 4.10635562e-07, 3.79404258e-07, 2.66680489e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1e+09 1.001e+09 1.002e+09 ... 1.299e+09 1.3e+09\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664873312419283]\n", + " createdtimestamp: [308605257163]\n", + " changedtimestamp: [309086050763]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 10:48:32.4190\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [2512]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]},\n", + " 'R': {'/dev3442/demods/0/sample.r': [\n", + " array([[3.50875860e-07, 2.70602397e-07, 3.22289289e-07, 3.21639020e-07,\n", + " 3.32765766e-07, 3.65126975e-07, 3.12966538e-07, 1.64027162e-07,\n", + " 2.45165536e-07, 4.19091366e-07, 4.14326504e-07, 3.29614134e-07,\n", + " 3.98556089e-07, 6.03632644e-07, 6.03304127e-07, 5.94617891e-07,\n", + " 5.10234580e-07, 3.35210733e-07, 2.30888648e-07, 2.51064516e-07,\n", + " 2.76974768e-07, 1.91823303e-07, 1.49521913e-07, 1.75328687e-07,\n", + " 2.78571123e-07, 2.10951086e-07, 2.16255281e-07, 3.16839491e-07,\n", + " 2.76141363e-07, 2.81573604e-07, 1.37238391e-07, 2.12871898e-07,\n", + " 3.62986060e-07, 4.29124663e-07, 3.16040404e-07, 2.67266655e-07,\n", + " 3.65657304e-07, 4.48666830e-07, 5.83573620e-07, 6.42626010e-07,\n", + " 6.11464599e-07, 5.49052360e-07, 5.86160132e-07, 5.82156228e-07,\n", + " 6.03255004e-07, 7.89091970e-07, 7.84022056e-07, 6.62303305e-07,\n", + " 5.03959286e-07, 4.49465035e-07, 4.43046704e-07, 5.90456587e-07,\n", + " 6.21792060e-07, 5.72738852e-07, 5.41391892e-07, 6.26158439e-07,\n", + " 4.59861745e-07, 2.12973843e-07, 2.37172460e-07, 3.72531488e-07,\n", + " 4.36279699e-07, 4.85907475e-07, 4.92556374e-07, 4.65265233e-07,\n", + " 3.19733747e-07, 3.04607663e-07, 2.94144267e-07, 2.45885864e-07,\n", + " 3.16028078e-08, 1.85243058e-07, 2.02642415e-07, 1.80417555e-07,\n", + " 3.17077909e-07, 5.14676889e-07, 6.35520404e-07, 6.37312376e-07,\n", + " 7.26135275e-07, 7.20081269e-07, 6.00586796e-07, 4.64989563e-07,\n", + " ...\n", + " 4.50349728e-07, 4.64176142e-07, 4.07156112e-07, 3.00673748e-07,\n", + " 3.72114091e-07, 3.60206239e-07, 3.14711484e-07, 3.11498318e-07,\n", + " 3.19263711e-07, 4.13087658e-07, 5.53255690e-07, 6.62389429e-07,\n", + " 5.97159565e-07, 3.48292585e-07, 4.04279527e-07, 5.47591484e-07,\n", + " 5.15210639e-07, 3.36606101e-07, 3.26182141e-07, 3.48923075e-07,\n", + " 2.78243634e-07, 2.82163333e-07, 5.26134267e-07, 7.70090420e-07,\n", + " 7.76728207e-07, 5.89799838e-07, 3.04388253e-07, 2.47766692e-07,\n", + " 1.58789395e-07, 3.03364830e-08, 1.49812292e-07, 2.22399343e-07,\n", + " 3.88711488e-07, 3.20814441e-07, 2.11552399e-07, 4.36760799e-07,\n", + " 5.85246465e-07, 5.98170037e-07, 5.50512150e-07, 3.43713482e-07,\n", + " 1.71207817e-07, 8.49430082e-08, 3.30555288e-07, 3.34163350e-07,\n", + " 3.26281110e-07, 4.09983188e-07, 4.57014174e-07, 4.68563630e-07,\n", + " 3.69464867e-07, 5.94835249e-07, 7.14685065e-07, 6.94255244e-07,\n", + " 7.13042485e-07, 4.59999172e-07, 2.51558505e-07, 2.28146965e-07,\n", + " 3.82364839e-07, 5.39785539e-07, 5.77188043e-07, 4.28624053e-07,\n", + " 2.29961114e-07, 2.83972207e-07, 3.65491624e-07, 3.50174319e-07,\n", + " 2.72091187e-07, 3.20505843e-07, 4.70595140e-07, 5.27882868e-07,\n", + " 4.16385393e-07, 1.06342650e-07, 1.75540360e-07, 3.57477226e-07,\n", + " 5.66663118e-07, 6.23191013e-07, 4.74268790e-07, 5.57135024e-07,\n", + " 6.78589995e-07, 6.83960121e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 6.503e+08 6.509e+08 ... 7.889e+08 7.895e+08\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664873312419223]\n", + " createdtimestamp: [308605257163]\n", + " changedtimestamp: [309086050763]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 10:48:32.4190\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [2512]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[1.83064221e-07, 1.61855467e-07, 2.49241466e-07, 3.39376135e-07,\n", + " 4.36536798e-07, 5.18693392e-07, 6.30735429e-07, 5.74835074e-07,\n", + " 4.36776420e-07, 2.63859894e-07, 1.30624147e-07, 9.70415274e-08,\n", + " 1.44476414e-07, 3.81813606e-07, 6.38447230e-07, 7.45571057e-07,\n", + " 8.22906422e-07, 9.18075754e-07, 8.43259013e-07, 7.61613607e-07,\n", + " 7.57270048e-07, 6.88958757e-07, 4.83349759e-07, 3.55754578e-07,\n", + " 3.63642255e-07, 4.22655755e-07, 3.87072095e-07, 3.70289162e-07,\n", + " 3.62161548e-07, 2.70584201e-07, 2.87656239e-07, 3.19854380e-07,\n", + " 2.08389908e-07, 1.96618982e-08, 3.33132395e-07, 4.70787632e-07,\n", + " 5.12829988e-07, 6.21235123e-07, 6.78234168e-07, 8.17913035e-07,\n", + " 8.18258618e-07, 7.54368146e-07, 7.46640882e-07, 5.50770744e-07,\n", + " 5.12319511e-07, 6.08510609e-07, 6.62309838e-07, 6.44205313e-07,\n", + " 5.95868712e-07, 6.51155602e-07, 6.31010157e-07, 7.74893720e-07,\n", + " 7.73539311e-07, 7.74910192e-07, 8.02652723e-07, 8.23684689e-07,\n", + " 8.68193990e-07, 8.62732478e-07, 8.01325476e-07, 6.25764502e-07,\n", + " 5.04780975e-07, 5.93346931e-07, 6.10683738e-07, 4.86562387e-07,\n", + " 3.12983135e-07, 3.68123599e-07, 5.59757155e-07, 7.12527556e-07,\n", + " 8.47038984e-07, 9.42978974e-07, 8.63359915e-07, 6.06673635e-07,\n", + " 4.27951356e-07, 3.59254470e-07, 2.99652089e-07, 1.79138376e-07,\n", + " 2.32503549e-07, 2.27449770e-07, 2.62303298e-07, 3.27436843e-07,\n", + " ...\n", + " 1.34507520e-07, 1.02082212e-07, 1.12642947e-07, 2.57615087e-07,\n", + " 2.52001240e-07, 8.39497095e-08, 7.44285860e-08, 3.41073852e-07,\n", + " 5.83489122e-07, 6.96472052e-07, 6.53976255e-07, 5.88986968e-07,\n", + " 4.49598566e-07, 2.98920279e-07, 2.12782307e-07, 2.95983869e-07,\n", + " 4.05101586e-07, 3.98188629e-07, 4.47104691e-07, 5.23768048e-07,\n", + " 3.36085570e-07, 9.03901955e-08, 3.48991273e-07, 5.33593138e-07,\n", + " 5.62695854e-07, 4.58134554e-07, 3.08202787e-07, 2.11030979e-07,\n", + " 2.51420702e-07, 1.01853724e-07, 2.07736971e-07, 4.68642977e-07,\n", + " 7.63032151e-07, 7.22946677e-07, 4.32578803e-07, 3.27013842e-07,\n", + " 3.40702093e-07, 4.66298330e-07, 7.43736291e-07, 8.69379562e-07,\n", + " 8.87377110e-07, 7.33472718e-07, 5.23308094e-07, 4.26309170e-07,\n", + " 4.31965940e-07, 2.58649504e-07, 1.33946849e-07, 4.47104352e-07,\n", + " 6.18007476e-07, 5.56577597e-07, 5.28093625e-07, 4.13845425e-07,\n", + " 3.33008003e-07, 2.89431379e-07, 1.47540020e-07, 1.70592255e-07,\n", + " 3.10416178e-07, 5.25815591e-07, 5.15154408e-07, 2.60636244e-07,\n", + " 7.17283923e-08, 9.54203553e-08, 2.61190363e-07, 2.57871195e-07,\n", + " 7.60343295e-08, 3.05941060e-07, 4.40774851e-07, 3.01379243e-07,\n", + " 2.00560156e-07, 2.19666114e-07, 2.69370619e-07, 2.87369645e-07,\n", + " 2.86037423e-07, 3.27678416e-07, 2.66341497e-07, 1.00779122e-07,\n", + " 1.75057650e-07, 2.29900763e-07, 2.45636684e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.401e+09 1.401e+09 ... 1.499e+09 1.5e+09\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664873312419223]\n", + " createdtimestamp: [308605257163]\n", + " changedtimestamp: [309086050763]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 10:48:32.4190\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [2512]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]},\n", + " 'A': {'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[-1.60287965e-03, -1.63122416e-03, -1.65956868e-03,\n", + " -1.68791319e-03, -1.71625770e-03, -1.74460221e-03,\n", + " -1.77294673e-03, -1.80129124e-03, -1.82963575e-03,\n", + " -1.85798026e-03, -1.88632478e-03, -1.91466929e-03,\n", + " -1.94301380e-03, -1.97135831e-03, -1.99970283e-03,\n", + " -2.02804734e-03, -2.05639185e-03, -2.08473636e-03,\n", + " -2.11308088e-03, -2.14142539e-03, -2.16976990e-03,\n", + " -2.19811441e-03, -2.22645893e-03, -2.25480344e-03,\n", + " -2.28314795e-03, -2.31149246e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " ...\n", + " -1.21943914e-03, -1.20243243e-03, -1.18542572e-03,\n", + " -1.16841901e-03, -1.15141231e-03, -1.13440560e-03,\n", + " -1.11739889e-03, -1.10039218e-03, -1.08338548e-03,\n", + " -1.06637877e-03, -1.04937206e-03, -1.03236535e-03,\n", + " -1.01535865e-03, -9.98351938e-04, -9.81345231e-04,\n", + " -9.64338523e-04, -9.47331816e-04, -9.30325108e-04,\n", + " -9.13318401e-04, -8.96311693e-04, -8.79304986e-04,\n", + " -8.62298278e-04, -8.45291571e-04, -8.28284863e-04,\n", + " -8.11278156e-04, -7.94271448e-04, -7.77264741e-04,\n", + " -7.60258033e-04, -7.43251326e-04, -7.26244618e-04,\n", + " -7.09237911e-04, -6.92231203e-04, -6.75224496e-04,\n", + " -6.58217788e-04, -6.41211081e-04, -6.24204373e-04,\n", + " -6.07197666e-04, -5.90190958e-04, -5.73184251e-04,\n", + " -5.56177543e-04, -5.39170836e-04, -5.22164128e-04,\n", + " -5.05157420e-04, -4.88150713e-04, -4.71144005e-04,\n", + " -4.54137298e-04, -4.37130590e-04, -4.20123883e-04,\n", + " -4.03117175e-04, -3.86110468e-04, -3.69103760e-04,\n", + " -3.52097053e-04, -3.35090345e-04, -3.27169066e-04,\n", + " -3.21500164e-04, -3.15831261e-04, -3.10162359e-04,\n", + " -3.04493456e-04, -2.98824554e-04]])\n", + " Coordinates:\n", + " time (row, col) float64 3.003e+08 3.009e+08 ... 4.49e+08 4.496e+08\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664873312419159]\n", + " createdtimestamp: [308605257163]\n", + " changedtimestamp: [309086050763]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 10:48:32.4190\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [2512]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[-0.0018963 , -0.00187362, -0.00185095, ..., -0.0027846 ,\n", + " -0.00280727, -0.00282995],\n", + " [-0.00225985, -0.0023052 , -0.00231484, ..., nan,\n", + " nan, nan],\n", + " [-0.00135823, -0.00132989, -0.00130154, ..., -0.00036784,\n", + " -0.00037351, -0.00037918]])\n", + " Coordinates:\n", + " time (row, col) float64 1.2e+09 1.201e+09 ... 1.499e+09 1.5e+09\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664873312419159]\n", + " createdtimestamp: [308605257163]\n", + " changedtimestamp: [309086050763]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 10:48:32.4190\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [2512]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}}" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "e36fb677", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(597)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 595 \u001b[1;33m \u001b[0mstart_waiting\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 596 \u001b[1;33m \u001b[1;32mwhile\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfinished\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mwait\u001b[0m \u001b[1;32mand\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mstart_waiting\u001b[0m\u001b[1;33m>\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 597 \u001b[1;33m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 598 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Waiting for device {self.serial} to finish the acquisition...\"\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# Progress: {self.daq.progress()[0]}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 599 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "> \u001b[1;32m<__array_function__ internals>\u001b[0m(6)\u001b[0;36mconcatenate\u001b[1;34m()\u001b[0m\n", + "\n", + "ipdb> u\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(707)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 705 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 706 \u001b[1;33m \u001b[0mcreation_ts\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mattrs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"createdtimestamp\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0me\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mv\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread_memory\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 707 \u001b[1;33m \u001b[0mall_ts\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0munique\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcreation_ts\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 708 \u001b[1;33m \u001b[1;32massert\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mall_ts\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 709 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[0m\n", + "ipdb> creation_ts\n", + "{}\n", "ipdb> r\n" ] } @@ -798,7 +1219,7 @@ { "cell_type": "code", "execution_count": 56, - "id": "9413b67f", + "id": "7ea34368", "metadata": {}, "outputs": [ { @@ -904,7 +1325,7 @@ { "cell_type": "code", "execution_count": 54, - "id": "f6e39c83", + "id": "8ad94d37", "metadata": {}, "outputs": [ { @@ -985,7 +1406,7 @@ { "cell_type": "code", "execution_count": 101, - "id": "a8bbb495", + "id": "168c5a85", "metadata": {}, "outputs": [ { @@ -1006,7 +1427,7 @@ { "cell_type": "code", "execution_count": 167, - "id": "696bb6ec", + "id": "c3a053dd", "metadata": { "scrolled": false }, @@ -1031,7 +1452,7 @@ { "cell_type": "code", "execution_count": 88, - "id": "0395da2d", + "id": "e8877df8", "metadata": {}, "outputs": [], "source": [ @@ -1041,7 +1462,7 @@ { "cell_type": "code", "execution_count": 50, - "id": "f6ca6c0c", + "id": "d3be623b", "metadata": {}, "outputs": [ { @@ -1147,7 +1568,7 @@ { "cell_type": "code", "execution_count": 39, - "id": "9ba91403", + "id": "5c20f912", "metadata": { "scrolled": true }, @@ -1171,7 +1592,7 @@ { "cell_type": "code", "execution_count": null, - "id": "8d1d33e1", + "id": "cef17340", "metadata": {}, "outputs": [], "source": [ @@ -1181,7 +1602,7 @@ { "cell_type": "code", "execution_count": 43, - "id": "e88a2b14", + "id": "637ecff1", "metadata": {}, "outputs": [], "source": [ @@ -1191,7 +1612,7 @@ { "cell_type": "code", "execution_count": 72, - "id": "7be685d9", + "id": "fbdc56bb", "metadata": {}, "outputs": [ { @@ -1630,7 +2051,7 @@ { "cell_type": "code", "execution_count": 48, - "id": "8dd5d9fa", + "id": "a94dfaf4", "metadata": {}, "outputs": [ { @@ -1651,7 +2072,7 @@ { "cell_type": "code", "execution_count": 71, - "id": "6eddc918", + "id": "8805f40b", "metadata": {}, "outputs": [ { @@ -1677,7 +2098,7 @@ { "cell_type": "code", "execution_count": 68, - "id": "0c370d89", + "id": "52e6aa2b", "metadata": {}, "outputs": [ { @@ -1710,7 +2131,7 @@ { "cell_type": "code", "execution_count": 55, - "id": "1bbdddd8", + "id": "27dad9d5", "metadata": { "scrolled": true }, @@ -1769,7 +2190,7 @@ { "cell_type": "code", "execution_count": 63, - "id": "3020a9a9", + "id": "811091f9", "metadata": {}, "outputs": [ { @@ -1804,7 +2225,7 @@ { "cell_type": "code", "execution_count": 192, - "id": "4355046e", + "id": "52865ab1", "metadata": {}, "outputs": [ { @@ -1873,7 +2294,7 @@ { "cell_type": "code", "execution_count": 174, - "id": "16759291", + "id": "543ff392", "metadata": {}, "outputs": [ { @@ -1900,7 +2321,7 @@ { "cell_type": "code", "execution_count": 123, - "id": "488d71bb", + "id": "ac680e56", "metadata": {}, "outputs": [], "source": [ @@ -1910,7 +2331,7 @@ { "cell_type": "code", "execution_count": 145, - "id": "4f108148", + "id": "dd7e1cee", "metadata": { "scrolled": false }, @@ -1933,7 +2354,7 @@ { "cell_type": "code", "execution_count": 119, - "id": "cceaea5b", + "id": "0d1c6fa7", "metadata": {}, "outputs": [ { @@ -1954,7 +2375,7 @@ { "cell_type": "code", "execution_count": 110, - "id": "c9890b61", + "id": "ec8c9d7a", "metadata": {}, "outputs": [], "source": [ @@ -1964,7 +2385,7 @@ { "cell_type": "code", "execution_count": 111, - "id": "f1c3a886", + "id": "20bace43", "metadata": {}, "outputs": [ { @@ -2027,7 +2448,7 @@ { "cell_type": "code", "execution_count": 44, - "id": "9e290067", + "id": "c3800665", "metadata": {}, "outputs": [], "source": [ @@ -2037,7 +2458,7 @@ { "cell_type": "code", "execution_count": 45, - "id": "44a8f687", + "id": "d06129a4", "metadata": {}, "outputs": [ { @@ -2058,7 +2479,7 @@ { "cell_type": "code", "execution_count": 202, - "id": "cf5ef277", + "id": "24513c96", "metadata": {}, "outputs": [], "source": [ @@ -2068,7 +2489,7 @@ { "cell_type": "code", "execution_count": 114, - "id": "708ad4a2", + "id": "9e35f6c6", "metadata": {}, "outputs": [ { @@ -2089,7 +2510,7 @@ { "cell_type": "code", "execution_count": 117, - "id": "c2cd629a", + "id": "1849020f", "metadata": {}, "outputs": [ { @@ -2110,7 +2531,7 @@ { "cell_type": "code", "execution_count": 116, - "id": "da47a7d4", + "id": "83a442ce", "metadata": {}, "outputs": [], "source": [ @@ -2120,7 +2541,7 @@ { "cell_type": "code", "execution_count": 193, - "id": "bc1e563c", + "id": "88477813", "metadata": {}, "outputs": [], "source": [ @@ -2130,7 +2551,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1057c781", + "id": "7f0085dc", "metadata": {}, "outputs": [], "source": [] @@ -2138,7 +2559,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b8cb73d1", + "id": "19a6e2a0", "metadata": {}, "outputs": [], "source": [] @@ -2146,7 +2567,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e0a8f4cf", + "id": "e43a3a28", "metadata": {}, "outputs": [], "source": [] @@ -2154,7 +2575,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "48a808fa", + "id": "2a2ed4e9", "metadata": {}, "outputs": [], "source": [ @@ -2164,7 +2585,7 @@ { "cell_type": "code", "execution_count": 32, - "id": "69d10705", + "id": "acf9f6a3", "metadata": {}, "outputs": [], "source": [ @@ -2175,7 +2596,7 @@ { "cell_type": "code", "execution_count": 33, - "id": "5de13d37", + "id": "cf0c1df9", "metadata": {}, "outputs": [], "source": [ @@ -2185,7 +2606,7 @@ { "cell_type": "code", "execution_count": 37, - "id": "bfbc73b5", + "id": "6fd7b881", "metadata": {}, "outputs": [ { @@ -3304,7 +3725,7 @@ { "cell_type": "code", "execution_count": 29, - "id": "202835f5", + "id": "94f249a8", "metadata": {}, "outputs": [ { @@ -3330,7 +3751,7 @@ { "cell_type": "code", "execution_count": null, - "id": "56abff6b", + "id": "79514940", "metadata": {}, "outputs": [], "source": [] @@ -3338,7 +3759,7 @@ { "cell_type": "code", "execution_count": 35, - "id": "e2e136c1", + "id": "4b9be78c", "metadata": {}, "outputs": [], "source": [ @@ -3349,7 +3770,7 @@ { "cell_type": "code", "execution_count": 31, - "id": "ccc4025d", + "id": "60433d76", "metadata": {}, "outputs": [], "source": [ @@ -3359,7 +3780,7 @@ { "cell_type": "code", "execution_count": 78, - "id": "ba2f2b48", + "id": "3a268246", "metadata": {}, "outputs": [ { @@ -3385,7 +3806,7 @@ { "cell_type": "code", "execution_count": null, - "id": "cc11c26d", + "id": "7a251206", "metadata": {}, "outputs": [], "source": [] @@ -3393,7 +3814,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9c97af1d", + "id": "aee44ece", "metadata": {}, "outputs": [], "source": [] @@ -3401,7 +3822,7 @@ { "cell_type": "code", "execution_count": null, - "id": "9bcbcb3f", + "id": "ab4f5c02", "metadata": {}, "outputs": [], "source": [] @@ -3409,7 +3830,7 @@ { "cell_type": "code", "execution_count": null, - "id": "e212305e", + "id": "c3e129c7", "metadata": {}, "outputs": [], "source": [] @@ -3417,7 +3838,7 @@ { "cell_type": "code", "execution_count": null, - "id": "7bd3072a", + "id": "cc7cf2f4", "metadata": {}, "outputs": [], "source": [] diff --git a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb index 8d838c309..415c31b6b 100644 --- a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb +++ b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 8, "id": "42af2895", "metadata": {}, "outputs": [], @@ -100,7 +100,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 9, "id": "a2599d33", "metadata": {}, "outputs": [], @@ -110,7 +110,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 10, "id": "016ae5ee", "metadata": {}, "outputs": [], @@ -121,7 +121,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 11, "id": "264cb7fa", "metadata": {}, "outputs": [], @@ -137,7 +137,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 12, "id": "bb0ef71a", "metadata": {}, "outputs": [], @@ -148,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 13, "id": "460a60f0", "metadata": {}, "outputs": [ @@ -165,7 +165,7 @@ " 'demods/0/sample.Y'}}}" ] }, - "execution_count": 28, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -176,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 14, "id": "bc46a01c", "metadata": {}, "outputs": [], @@ -186,7 +186,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 15, "id": "f45534ef", "metadata": {}, "outputs": [ @@ -210,7 +210,7 @@ " 'demods/0/sample.y'}}}" ] }, - "execution_count": 30, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -221,7 +221,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 16, "id": "eb3c0a0e", "metadata": {}, "outputs": [], @@ -231,7 +231,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 17, "id": "60fe5854", "metadata": {}, "outputs": [ @@ -248,7 +248,7 @@ " 'demods/0/sample.Y'}}}}" ] }, - "execution_count": 32, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -275,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 18, "id": "37b55006", "metadata": {}, "outputs": [], @@ -285,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 19, "id": "be93574e", "metadata": {}, "outputs": [], @@ -302,7 +302,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 20, "id": "1d42e3fc", "metadata": {}, "outputs": [], @@ -320,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 21, "id": "d2632242", "metadata": {}, "outputs": [], @@ -332,7 +332,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 22, "id": "ea1cdd4c", "metadata": {}, "outputs": [ @@ -351,7 +351,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 23, "id": "eb2ea77b", "metadata": {}, "outputs": [ @@ -359,7 +359,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'A', 'T', 'R'}\n", + "{'A', 'R', 'T'}\n", "[]\n", "set()\n" ] @@ -373,7 +373,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 24, "id": "eeeee0ec", "metadata": {}, "outputs": [ @@ -383,7 +383,7 @@ "" ] }, - "execution_count": 39, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -394,13 +394,13 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 25, "id": "d325087c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -418,7 +418,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 26, "id": "70da8095", "metadata": {}, "outputs": [], @@ -439,7 +439,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 27, "id": "20626e0f", "metadata": {}, "outputs": [], @@ -452,13 +452,13 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 28, "id": "62aab374", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -495,7 +495,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 29, "id": "031fd70e", "metadata": {}, "outputs": [], @@ -505,7 +505,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 30, "id": "f0143c3d", "metadata": {}, "outputs": [], @@ -515,7 +515,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 31, "id": "843fb93c", "metadata": {}, "outputs": [], @@ -525,7 +525,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 32, "id": "7df89611", "metadata": {}, "outputs": [], @@ -535,7 +535,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 33, "id": "21afd2d6", "metadata": {}, "outputs": [], @@ -545,7 +545,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 34, "id": "2e4e2b0b", "metadata": {}, "outputs": [], @@ -556,7 +556,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 35, "id": "632a30f6", "metadata": {}, "outputs": [], @@ -567,7 +567,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 36, "id": "6abf0e7f", "metadata": {}, "outputs": [], @@ -577,7 +577,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 37, "id": "7f811d07", "metadata": {}, "outputs": [], @@ -593,24 +593,43 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 39, + "id": "2d7cafab", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 40, "id": "d0c8669f", "metadata": {}, "outputs": [], "source": [ "my_lockin.register_trigger_settings(program_name=\"test\",\n", - "# trigger_input=f\"demods/0/sample.AuxIn1\",\n", - " trigger_input=f\"demods/0/sample.TrigIn1\",\n", + " trigger_input=f\"demods/0/sample.AuxIn1\", # here AuxInN referese to the printer label N+1\n", " edge=\"rising\",\n", " number_of_triggers_to_buffer=3,\n", " level=.5,\n", + " count=np.inf,\n", " other_settings={\"holdoff/time\": 1e-8} #\n", + " )\n", + "\n", + "my_lockin.register_trigger_settings(program_name=\"test\",\n", + " trigger_input=f\"demods/0/sample.TrigIn1\", # here TrigInN referese to the printer label N\n", + " edge=\"rising\",\n", + " number_of_triggers_to_buffer=3,\n", + " level=.5,\n", + " count=3,\n", + " other_settings={\"holdoff/time\": 1e-8}\n", " )" ] }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 41, "id": "f069c321", "metadata": { "scrolled": true @@ -623,7 +642,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 42, "id": "11e558f5", "metadata": { "scrolled": false @@ -646,6 +665,8 @@ " 'level': 0.5,\n", " 'delay': -0.001,\n", " 'post_delay': 0.001,\n", + " 'endless': False,\n", + " 'count': 3,\n", " 'other_settings': {'holdoff/time': 1e-08}},\n", " 'windows': {'X': (array([1.e+09]), array([3.e+08])),\n", " 'R': (array([6.5e+08, 1.4e+09]), array([1.4e+08, 1.0e+08])),\n", @@ -658,7 +679,7 @@ " 'demods/0/sample.x'}}}" ] }, - "execution_count": 59, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } @@ -669,21 +690,36 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 43, + "id": "8a82b2a0", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.read_memory = {}" + ] + }, + { + "cell_type": "code", + "execution_count": 52, "id": "cf3ce29e", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:399: UserWarning: The channel auxins/0/sample.auxin0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + " warnings.warn(f\"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.\")\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "sample rates: [1674.107177734375, 1674.107177734375, None]\n", - "SETTING TRIGMODE 6\n", - "SETTING TRIGGERNODE: ('triggernode', '/dev3442/demods/0/sample.TrigIn1')\n", - "using trigger edge: 0\n", + "sample rates: [None, 1674.107177734375, 1674.107177734375]\n", "Will record 2512 per row samples for 1.500000000001s!\n", "3 row(s) will be recorded.\n", - "the following trigger settings will be used: {'trigger_input': '/dev3442/demods/0/sample.TrigIn1', 'edge': 'rising', 'number_of_triggers_to_buffer': 3, 'level': 0.5, 'delay': -0.001, 'post_delay': 0.001, 'other_settings': {'holdoff/time': 1e-08}}\n", + "the following trigger settings will be used: {'trigger_input': '/dev3442/demods/0/sample.TrigIn1', 'edge': 'rising', 'number_of_triggers_to_buffer': 3, 'level': 0.5, 'delay': -0.001, 'post_delay': 0.001, 'endless': False, 'count': 3, 'other_settings': {'holdoff/time': 1e-08}}\n", "MFLI returns a total record time of 1.5005013333333335s\n" ] } @@ -694,31 +730,19 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 53, "id": "1505ae0a", "metadata": {}, - "outputs": [ - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_28156\\508965523.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mmy_lockin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mforce_trigger\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ - "for _ in range(3):\n", + "for _ in range(3*3):\n", " my_lockin.force_trigger(None)\n", - " time.sleep(3)\n" + " time.sleep(2)\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 92, "id": "8504fda1", "metadata": {}, "outputs": [], @@ -732,30 +756,439 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 86, "id": "8ab20ee5", "metadata": {}, "outputs": [], "source": [ - "my_lockin.daq.finish()" + "my_lockin.stop_acquisition()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 54, "id": "8d97dfac", "metadata": { "scrolled": true }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Waiting for device dev3442 to finish the acquisition...\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEFCAYAAAAbsWtZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAB7KElEQVR4nO39eZBl2X3fB37O3e99a+6ZtXRV9YZGgwQgsgGRNKkNhATQCyjJUpDiiJCCHpq06JmwQ7ShUdCO8YhhKDzh8MiiKUMcyaBtGcbYsgiLoGASBiUTBCk0DBDsDd3V1VXVteT+8i13X878cd69lVmVWZVVmbV01/lUZGS+l+/ed2/le+93z2/5foWUEo1Go9Fo7gbjYR+ARqPRaN556OCh0Wg0mrtGBw+NRqPR3DU6eGg0Go3mrtHBQ6PRaDR3jfWwD+BBMT8/L8+ePfuwD0Oj0WjeUXzjG9/YlFIu3Hz/YxM8zp49y4svvviwD0Oj0WjeUQghLu13v05baTQajeau0cFDo9FoNHeNDh4ajUajuWt08NBoNBrNXaODh0aj0WjuGh08NBrNO44wDxln4z33jbMxYR7e1XZhHnJ9cn3PdofZj0YHj2NhPVrn+uT6nvuuT66zHq0/pCPSaN7dVLLi7dHbnB+cB9QHflzEd3zfrYfrXBxebALIi6sv8qULX+Ktnbea/Xzj+jd4ZeuV+38S73AemzmP+8k4HTNIBwySAe+dey+r4SpXJ1eZcWdYDBYf9uFpNO86Ok6HUpa8Pnid/+3S/8afe+bPMckm7KQ7CMS+77v1aJ1RNiKrMr569as8N/scr26+ylujt5gUEy6MLtC1urw9eZuTnCTMQ1p26yGc3TsDHTyOAUMYbEab/Pz/8fN8/OzH+Yvv+YtMsglz3tzDPjSN5l1JmIcIBN/c+Cafe+1z2IbNs/1niYuYWW92323G2ZhhOqSSFT//L36eZ/rP8P3L348lLP7phX/KarTKT73vp5j35zGFyVq4xpP9Jx/wmb1z0GmrY6CSFVERAfAbF3+Dq+OrCCGoZPWQj0yjeXdSyYqtZItxqtJP31z7Jm8M3kAIwUEGd0IItqItvnbtawC8OXyTQTLAMR3W43VKWfKHm39IVmYkZXLgfjQKvfI4BlpOi510p7m9lWzhmA4tRy95NZr7QZRHIGEn2QHg9Z3XOdU+pdJMM+ybcgrzkLRK+dbGtwAIrIBBMmAz3iSvcgAujy4z782z2FpECPEgT+kdh155HJEwD1kL1xgkgxv3ZSGTbMJauKa7NjSa+4BEUlExTIcAbMQbCCGY5BNe336dtXBtz+PDPMQ3fTbjTa6F1wDIyozNeJNBqt67tmEzLsZcn1zn7dHbjLOxbnq5DTp4HJFKVuRlvmflkVUZeaXuu7mdUKPRHJ3l1jItq0VWZYB6H+6kO1RVxTgf35JyWovWuDK6giUsRukIUO/TQhYkZYJt2LStNpNsgmu7jLMxO8lOkxbT3IoOHkek43RwTIekTJr7JvkE0zDZTrbV8lqj0Rwra+EaUR4hkbimi0BweXSZzWSTsixvSTmFecjlyWWuTa5RUTHrqqK6a7qERUjX7uKaLhUVBgaGYXBtck2nrm7DsQQPIcTHhBDfEUKcF0J8ap/fCyHE35n+/ttCiO+507ZCiFkhxG8KId6Yfp+Z3n9WCBELIb41/fp7x3EO90qYhwghKGXZ3DdIB2xGKo+qi24azfEjkSQyoaxK2nabrtNlPV4nzENMw7wl5RRYAVVV8cq2mt+oOyHDPKSQBY7h4Jquuq8ICbOQXOb64u82HDl4CCFM4JeAjwPPAz8uhHj+pod9HHhm+vXTwC8fYttPAV+WUj4DfHl6u+ZNKeUHp18/c9RzOAqVrIiLGBMTAM/0uDS6RF7l2MLWRXON5j4gEPiGT0WFa7r03T6bySaWYRFm4Z6UU113lEg2401m3JmmnXecq8cst5YJrADP9LgeXScpEpI8wbM8Xbc8gONYeXwYOC+lvCClzIDPAZ+46TGfAH5VKn4P6AshVu6w7SeAz05//izwo8dwrPeFwAqabo15f56dZAfHdDCEQZjpF55Gc9xIJHPBHHER41s+i/4ilVQF9KRK9qScJtmEzWgTKSU72Q6L/iJZoWolURFhGzYdu8OMN0PLarEZb9JxO3i2x5XRlVuK7xrFcQSPk8Dbu25fmd53mMfcbtslKeV1gOn33SOj54QQ3xRC/HMhxA8ddGBCiJ8WQrwohHhxY2Pjbs7p0MRFzJw/hxACx3CY8WYYpAMkEimlWgLrKxeN5ljpOB080yMtUwxhcLpzGlApp1EywjTNJmUcFiHXxte4PL5MKUu6TrfZT1ZlLHgLpEWKiclSsERe5VSyQpaS9WRdp54P4DiCx34VpZv/tw96zGG2vZnrwBNSyj8C/PvAPxJCdPd7oJTyM1LKF6SULyws3GLBeyz4lk9cxoyzMY7p0LGUbIKBgUQyiAe640qjOWZGqZIZiYqIWW8W13DpOT0ujy+TlAlhGoJQKaswD9lMNnlrpPSrTrZPUlQFpjApZclya5mSkkxmnO2dBeDS6BJr8dq+xXeN4jiCxxXg9K7bp4Brh3zM7bZdm6a2mH5fB5BSplLKrenP3wDeBJ49hvO4J6I8IsoiklLlR5c7ywBsxpsIBEmV3GEPGo3mbum6XUxMsjLDNV2kkPSdPhvxBi27RUXF69uv89bOW/imj2u5XB1fZd6fJ8xD1VUl1MffcmsZz/Swhc2sM0vX6bIRbxDlEbnM9bzHARxH8Pg68IwQ4pwQwgF+DPjCTY/5AvCT066r7wOG01TU7bb9AvDJ6c+fBH4NQAixMC20I4R4ElWEv3AM53FPSCSBE5CXOb7pc7qlYuFGvEFWZXiG97AOTaN51zLJJsRlDMCp9ilc02XOn6OoCpIioSgLxvmYrXiL7XibwAzYSrZYCVaIixgxTXoIBJawaDktnug+gW/7zLgzXB5fpu/1qapKz3scwJGDh5SyAH4O+BLwKvB5KeXLQoifEULUnVBfRH3Anwf+PvDv3G7b6TafBj4qhHgD+Oj0NsAfA74thPgD4H8CfkZKuX3U87hXllvL+KZPVEQ4poNjOvScHjvpDmmRNi9wjUZzfNSdUwC+7RNYAUvBEgAXxxeJyoiyLImLmLdGb/HG4A0KWTDrzlJUBZZhUVYqJTXOx7Tsluq4sgNOtE6o1FceUlSFnvc4gGPRtpJSfhEVIHbf9/d2/SyBv3bYbaf3bwEf2ef+/xn4n494yMfGWrhGXMRkZcZSawmJpO/2WY1WcS2XtEhVx5Xu2NVojoUwD5FSNoXswAqQlaTn9Og6XVbDVc51zmG2VU1jI9rgpa2XAGjbbcbJmLRMqahAQlIkGK5BYAUMsyHneuf42urXWI/WsYSFYzl63mMf9IT5EZGojqqkTGjbbfIqp+N02Ig3sA0bz/R0x5VGc4xUsiIt06Y93jd9VjortJ02c94c18Jr2KatmlXSMUmesBqtMuvNqi4t22OUj5r9CQSu7VLJiqX2ErPeLIEVcHl8mXE21vMeB6CDxxFp2S1aVouoiOg4HWzTZsadoagK4iLGMR3SItUdVxrNMdFxOsz5c42gYdttYxs2M/4Mp1qnyKucYTZkM9nkO9vfQQjBdrrNidYJtuItbNMmKiKM6cdfy26BBNMwWfQX8W2fOW+O69F1um5Xz3scgA4eR6QOEEmR4Fs+nukx5yvpg9VolazK2Iq39LJXozkmwlypVtdy7E/3n2bOm2OUjBrzpkEyYJJNCPOQt8dvU1Sq3pFXOXERE5URfbcPqOzBifYJOk6HrtvFFjZLwRJhHmIZlp73OAAdPI6Ib/nNFVBgBSRFwqyvpA/WwjXWwjXSMtUvPI3mmGiMoHat5qMiYqG1QMfu0Hf7XB5fJq3Uir+WYF8OljEMg6zMSMu0KbBP8gltp81Ca4FJNiGrMp7sqSD01ugtPe9xADp4HAP1qsK3fPpenxl7ho7d4crkiuopl5XWuNJojonaCKqQhdK4sn0MYdC225imyZw7x2q0SmAG2KbN9fA6XadLUiRkRUZYqtrFqdYpAIbpkEE8aJw/Pcvjic4T+Jby/4jyiEk+aVYyGoUOHkegnl71LDXL0ff6OMJRveLejHIUNLTGlUZznNSzVWEeEtgBBganuqdY8BcwMVkMFknLlFE+Ii9yxvmYBX+BQhaUlEyyidKzcjo4hoMQgo7TQSBo2S2em30OBMx781weX24u/JIi0bXLXejgcQQqqaZUN6Npv7npY5omw2zIrDfLerSObdha40qjOUbq2apRNlKp4jLBN33mgjkCO+Cp/lMAXNi5wGa6SSlLFj0VUFpWi2E2ZMFfYJSPGlHTnt9DSknLbtF22gDqMdkIKSWO4XA1vKprl7vQweMIGMJglI5Yi1QXxpw/hy1sirKg5/SUwJqotMaVRnOM1LNVSZHQdbp4lkdcxGxH2ziGw5w7R8tuMcknzSAhgqa9NyoiloNlxum4aXappYQ8y0MIgZSSldYKoNQiJvmEcTbWwWMXOngcgUpWyj9g14qi43RUy2BH5VN3kh2tcaXRHCP1bFWYh2qVIJVyrmd7nOicICkSZtwZhtmQsAhxTRfXdNXAYKLUtee9eTzLo2WrlciMO4NruCRFgpSSntvjZOskjuFweXyZ9Uh1W+l5jxvo4HEEOk4H13RJyxRQfeKO6XCidYL3zLwHuNGuqzWuNJrjQSAQUhDmoZrRECCkoG238W2fTGYEZkAhC9Iypef0WAvXyIucnXQH27A51TnFUrCEYzhMsgkS2QgqJkXCyfZJFoIF5v15rk2u4ZoujumwFW/peY8pOngcgXr5XE+69t2+ciArEma8GbpOl7VoTWtcaTTHSF0wj/KoGfALnADf9mk7bSwsdT9QUeGZHpWsKGTBMB0qSXZZYJs2s94sFRWjdERYhAgEc/4cc8Ecrumy6C+yk+3gmi5ZkbEaruq2+yk6eByBevkc5yow+JYPBkrTqkpZ8BfYiDf2alxpNJojURfMJ/kES1hNwXy5tYyUEt/ycU23kVw3DPW9oiIsQk61T7ERbVBUBWe6ZwDYSXcwMJjkEzpOB4BRPuJc7xwA18JrrEVrRHmk5z2m6OBxBHZLk3imh2mYzHvzzPqzJFnCrDfLariKYzha40qjOSbWwjXCPCQuYuaD+aZgXmcCWo56X9byI7KSJGXCMB0CcLZ7lsAOqKgI7ACApFS1DlOYqjBeRHiWx5O9J7ENW8977IMOHkeg9k/Oq1y1+NltfMvHFCaVrOjYHdIyJSkTHNNhEA90vlSjOSISyWayiUTStm8UzCVSDQ06PkIISlkCqrFFIhlnY0xh0rJbdJ0uM+4Ms65Sg1gNVxnmw6aOshQs8dzscwghmPPm9LzHPujgcQRqC9phOiSwg8agxrM8PMtj1pvKlERrDLMhO+mOzpdqNEfgZjn2tt0mzEMMjKbgfWFwgWE6RE4draMyQiCYFBPmvDlKWTLnz7EQLDQ6dFER4RouAlWIXwwW98x7bCabSp5dz3s06OBxVKRagQRWoBzZp7EhsAOe6T8DKD/krWgL13K1TIlGcwRqOfayUqsKU5iYhsmsN4shlCeHQDQtuSZm08SSVRkL/gLXJ9dxTZdzvXN0vS4dp8MgGRDYAb7l33AZvGneYzPe1PMeu9DB4wjUaau0TPekrZIiwbd9TnRO0LJbjSWtRqM5GrUc+3aqzENtU3nm1KsEUJ1Xk3yCYzi4pktcxk07/Yw7g4FBWqjbruk2zp+1EkS9YqnnPc60z2AKk0vjS3reYxc6eByBOm01ySZ70lZz/hy+5bOT7jDnzTUaV8NkqDuuNJojUMuxDxKlZH2ifQLf8tmKt7iwc4G3h29jYjLKRvTdPrZhU8mKpFRT5J6lLBOEIbg+uU6SJ8z5c4yzMZ7lkeRJIzckhOBk+ySLrcXGZErPe9zgWGxohRAfA/4/gAn8ipTy0zf9Xkx//yNABPwVKeX/ebtthRCzwP8InAUuAn9RSjmY/u5vAD8FlMD/TUr5peM4j3tCqnzp7rRVy26xzjqjdMScN8er2682V0Yb8QbL7eWmD/2x5n/6t+HCV6DMVbpPAOlDs6MHHLB9MC11PG4bvucvw5/4+Yd4TEfj//oPv8aLF7dvpFQFDN7JYgdGgrA3sdqv4i3CT/7K15HlG8jKAXOMYV/BcK/jL2Zc2ZRUUuK1IakSytzjf/3Di1RxiUwrZLWDMC7hzsWY/lU+8Uu/jTQSgmoOR1xCipTK2OHUyeu0ezO8NX6dlt1q5j3m/fl7O4cXfxW++nch3Ljxd8ki4D78Yby5G+8tw4En/zj8m//1sez6yMFDCGECvwR8FLgCfF0I8QUp5Su7HvZx4Jnp1x8Ffhn4o3fY9lPAl6WUnxZCfGp6+z8UQjwP/BjwPuAE8FtCiGelnLZWPEDqtFVcxE3aqqxK4iKm7bTp2B3m/Xl11SNE0301zsY6eACkY4gGwKOS0ssgzyCf3qwySCcP9YiOyiQtGaQP+yiOESMFJMJQb3cpXRAp4ELlIkWG6W0BUBU9pEyQcoQQUJUOSAnSQ5azIA0QKbJsIcwIqMCIiMwdwlRCtoxwU3bi65ydayORrEarpGVK1+3ee/0yCyHehOwBXCglWzd+Fq56zx0Tx5G2+jBwXkp5QUqZAZ8DPnHTYz4B/KpU/B7QF0Ks3GHbTwCfnf78WeBHd93/OSllKqV8Czg/3c8Dx7d8oiIiyqM9aSvf8mlZLWb9WZaDZUD1phuG0RTUNcBP/CN48k897KPYH7sDL/wU/Jn/58M+kiPxP/zMD/Lcov+wD+P4KDrI9ARIEwCZrKjbRQfyOeT4+xDSp8rb5Nd/nGL1r1IlJwDI13+UYu3/QjX8fsjmIZ9HJstUyUmEkMh8Hjn5buTkg5B3Mdvf4vTCBu85XbDY6mNgsBlvUlRFU0O5J37gZ+GP/TyIY0n8HBILnv5h9Z47Jo4jeJwE3t51+8r0vsM85nbbLkkprwNMvy/exfMBIIT4aSHEi0KIFzc2Ng59QoclyiNlIkPVpK2iLNrTiVHLQ69Gq82QkmYXP/6rD/sI9ufEH3nHB46aP/e9Zx72IRwjBmAijBRZOoCDyngb0+8OZnCZMnoKZAtki2T1z5Jt/yuU4XtA+tNtrOk2NrLoAyCsUP1O+jhzv0tw+nO0Fv8AyymZ9WdZCBa4Hl2n7/UxhHG0tvsf+Fl4kJPqraVjDRxwPDWP/f4Hbv5fPegxh9n2Xp5P3SnlZ4DPALzwwgvHfs0vkU343a2x0wwr2T5zzNG221rj6iA+/1dRb+ZHJXU15do34Uv/8bsigHzl1esP+xCOD2uIECnCHiArF+GsgwRpbWFYOwhnB8MeUcgKa/m/A1LIZ8nHT2EEb4AxAGFTJadBeghjjDRGAJi938YoWxSywJn/BgBXR9eYdWeYnZ9lpbXC+Z3znOqcoqxKtuItVtor93Yev/vL4HT3ppXuJ9Em/Pd/6ZFbeVwBTu+6fQq4dsjH3G7btWlqi+n39bt4vgfCcmuZqlLWlaUs92jstB3VtptWKfP+vNa42o///i/BG7/JIxc4APIxvPj/VQHkHcyP/73f4WsX30UrXgmYqVp5VF5zG2kDOaazCkCVt6ESyCqgiM9RRe+nypahmqEqAqh8qDykqKBQzSzCLJGUeJ2LCKGuNXNSXr8ecXlni1lvlkk+oWW1CKwAKe7xevR3fxn+xX/24AIHgEzh/G+p99wxcRzB4+vAM0KIc0IIB1XM/sJNj/kC8JNC8X3AcJqKut22XwA+Of35k8Cv7br/x4QQrhDiHKoI/y+P4TzuijAPVatfqTokloIlyqrcUxAP7IAkS5jz5rgeXtcaVzfjdiCYAXcWnFn1/aHigN1THSruHPizquPqHUzbNZlxYcaj+f6Opu5OMlOo3GkeQl18yMrH9LaQpYMsW1TZIjI9Cfl0dVD0VQDJTkHZBSRCelSVC4BhjRBmhOVtQWlCaWIZAset2E42sKY1irzK6Xt9Aiu4t/ex0wJ//sZr3pkF7tMfpn4te/XruXNsuz5y2kpKWQghfg74Eirp+A+klC8LIX5m+vu/B3wR1aZ7HtWq+1dvt+10158GPi+E+CngMvAXptu8LIT4PPAKUAB/7WF0WtWTrnVPuIGBaZgUVdGoebbtdqNxVUu398ye0riy13iy/+SDPuxHi2NqGdQczN//q9//sA/hWFkNV4mKiH//K/+MhWCBv/Fjf5y3x28TFzGDaMB/8a3fYKV1mg+/d4Fz/XM82XuShWBh3/damIesTlZ5aesl/tbveTz3RJvteIP1WNI2fVXDLCI+dGoZhBoohKkkvB2wHW8rcdS77Zx84SfV1zucYyn3Sym/iAoQu+/7e7t+lsBfO+y20/u3gI8csM0vAr94hEM+Mh2nwySbMMpUvnQumGPGncE0lChizc0aV7ZpIxCckqfu6XnDPFQByblxBTHOxhjC0O2/mnc99ftukk84YZwgKROqqmKYDrk4ukhURJxonSAtU7IyY86fY6m1tO++WnaLpEi4NLiEZ3kM4gFbyRaWsHANF8uymBQTbNPmie4TJIXKMqzH68x5c0q99zF+z+kJ83skzEOEEBSyACCwAtpOGylls/KAvRpXF0cXj6RxFeYhF3YucGl4qVH1vD65zmtbrzU+6hrNu5lROiKrMsI8ZNabpaxKCgrWJmu8NXoLUJLri8EiQgiSIrntB/xGvEFOjmM4bCfblLKkbSlHwrPds4Ca5+q7ffpOH4DVySqZzPZ4hjyOPMhG43cVlayaGQ8ApHohLvgLe16svu1zsnMS3/LZiDd4qvfUPT/nxeFFroyvEFgBX3n7K3xg4QNcm1zDNMzGM12jeTfTdbuNn4YhVKrYwiJwAlbDVaVzZbdp2S06Tqfx6ziItXCNOI9xTZdc5riGS2AG9NxeI9deOw3WootRGVGWJYNkQNtpP7arDx08jsJUmgRUkLi5YbjuuLo2ucacN8d2sr1X4+ouXnPr0TqXh5cZ52MGyYBfeelXeM/Me3h25ll+4MQP3HvLoEbzDmKSTUjLFIlkMVhsTKGSImE9WedU+xRhEWKbNidbJ28bPF7ZfIUwV4/dTtS0d2AGOJbDyfZJOm6Htt1uVvmDbEDLbjW6WnEZP9YWC4/vmuuI1NIkRVVgGzYz3kwjVVLTsltIZKNxtR6t79G4uptOjUvDSwyzIZWs+KcX/ilIcA2XvMh5dubZYz8/jeZRpDaCAvX+2oq2eG37NcbZmDAPOdM907TCe5a3pzZ4M5dHlxlmQ66OrzYXgbZpE5gBLadFJStmvVk24g0l0y5VE8xWvEVgB7iG29RBHkd08LhHdhtBtezWHmmS3ezWuIqKCMuw6DrdpqX3MNRKolmZcWV8hZe2XmLWm6UoCxZbi9rZTPNYcIsRlKP0poqy4O2xEp2Y8+YI7IC23b5tSuni8CK2aSORvLr9aiPDbhkWH1j6ACaq8WXBX2A1XMUyrEaKfTvZRgjR+H48rujgcY9EeaSkSIpIvUD3kSYBGo2rpUB1fKyGq3etcfXq5qsM0gG2YfObl38TmBbo7TYrrRW24i3Ww/U77EWjeWdTt8cXlWpSyYsc0zBZaC3w9uRtXNNl1lPvtcAObptSujS8xFasrBI2k01MlFZWx+ngWmo/p1qnmHVnKWXJMB1SyALP9BhmKu2cVAme9U4fnLl3dPC4RySSwAmI86mL4C5pkv14uv80MLWkvQuNq/VonbVojTALeWnzJa6H12lZLTzTYylYwjIs1bp7jMM/Gs2jyM1GUHEZE2XKYnYz3mSltcIwHeJYDsutZcQB2lGvbL7COB+DgK9c/gqFLGhZaoXStttKBdsUnO6e5nRHiVmsR0oGpeuogr1rujpt9bAP4J3KcmsZ3/QZ52Ns094jTXIzvu0z78/jW/5da1xdGl4ir3LyMuf3V38fiWTOn6Pv9nlm9hkqWdF22iwGi3femUbzDqZO3+4kOwAs+UvspDucH5xXcx+HnO+4PLrMWrjG+mSdt8ZvYQubntsDVEAyMVlwFxBCcKKtFHlH2Yi4iDENE4lknI8bz/THVS1CB497ZC1cIy5i0iKl7/bxLI+4iG9xF6s7rjKp/JPvRuOqfrOM0hEXRxdZj9fp2l06VoenZ55GCKFsMnvvJtVUjWZ/KlmxlWztqe9txVtcC5W03WHmO+pah23a/O9v/+/kVc6MO0PbbuOaLkVV4FouK50VpJS4pkvf7TMpJioNNk0sDJIBYREiEHuGgh8ndPC4RyTK77hxEZTs8T+uadktBIKdeIdZb5br4XVc00VKyVa8ddurlt21jt+99rtIJH23T9tusxQs0XFUIV6vOjSPA1EegaQZzPUsj6IsWI/WcQyHrtOlbbdvO99R1zqQcGl8CcdwlA6dFeBbPqUseXrm6T3v40V/kY14gxlvhq7dBWCYDjEwmOSTfQcFwzy8pYml7gh7t6CDxz3Sslu0rJYKHrby8mhZ+8sV+LbPOBvjGA6TfNK8gK5OrvLWzlv77j/MQ9ajdQbxgG+tf4v1ZJ2O3aFjd1gIFrANG8d09KpD89hQ1xnDPMQ1XbIyw7IsttItTrZPEhURWZXddr7jZOckCPj1C79OVmUsB8v4ls+p9iklV1ImarJ8ahghEKpdN9rAEEZzoTbKRkgpMYW5b6fjJJtwaXiJ6xMlhz/OxmxEG6yGq++aAKKDxz0SFzGe6RHnNyxob57zqGnb7T2aV1cnV9lJdtiKt3h7/LYqxt3ExeFFhBDkVc431r6BRLLgLeCZHs/OPkvLbrEYLOpVh+axoa4zjtIRjunw+vbrFFXBJJ9wpnPn+Y4wD1lqLRFYAW+O3sQzPZ6bfY5nZ57FNE1aVoswD0nLFN/2OdU5hWM6zLgzFLJAIhtZoWvhNYb5kDAPD2wH3oq3eHXzVT732udYD9fZiDbYjrffNW31OnjcI77lM8pHFLIgsIID5zxqznbPMuPNAPD713+f9XidSipBt0vDS3seG+Yh6+F6c7Wynqhah2d6nOufwxAGs/4sz88/f9/PU6N5VKjrjEmZ0LbVjMebgzcBmPPvPN8xySZsRBu8tfMWaZnydO9p5v15zvXOqW2dNqNsRFmV+LbfqOfWTTCbySaO6eBbvlr9GC4Cse9KIrADfMfnd679Dr/4+7/Ib136LZIyeWAT6Q8ibaaDxxGoZzrqtNXtZjfmg3me7T/LjDvDGztvcGl4qekMCfO9/h51raOsSn73uqp19JwerulyunOajtO5NylojeYdTF1nDPOQwAqwhMWV8AqWsDjZPsmSv4Rpmrf9gH5t6zUujy4D8J7Z96i5jXRI3+2z6C9SyYpJPkFIQZwr2ZPaSnor3mI72aZltRhlo2aWJM5vzTYYwqCqKjZiZX/9xvANBsngwPbh46YOlHUAqS9EJ9nk2J5DB497oP6wr1cZtQVty27dVmVzIVjgTPsMFRXf2fkOb43ewjVd4jxuah+7ax2vbr3KtfAabatN1+my0lYdILrWoXkcEQiEFIzSUSNkuJ1ss9xaZifdQZiCRW/xth/QG9FGY+D23rn38p7Z9+CYDkKIprV3J9khLG6kwHpujxl3hkE6IMojXMtlmN5+UHA1XGUtXGs0s66NrzXCpg+KMA/5yuWv8J/+/n/K5dHlY6+16OBxD1SywhAGG5G6qjAwlK+ArPZdDbSdNmEeUlQFZ3pn6Ngd1uN1ro2vcXl8mVE2amofda3DEAa/t/p7VFTMecoH/QOLHyCwAzpOR9c6NI8ddcF8kk8QQgWRsAhZ8BcYJkOSPOFU99SB8x2BHbDcWW4u8Cxhcbp3mvfOvZdzvXOcaKmZjp10BwMDKSSerSbKZ71ZNuNNAisgsAL1GMM4cFAwzmPWJmuNiOJ2us0gHrAZbz5QG+qvXvsq/+N3/kdG6ejY962Dxz1gCINROmo8NGb9WRzDOVCvqmW3MIUaLjrdOc3p4DQSyfXoOue3z7OT7jBMh7y29dqNWke8wVq0Rttq07JanO6exjIsllvLPDf33IM+ZY3moVMXzOMiJisyrk6uAvBs/1k6TgfP9m7r3xHlETPuDCUltmHTcTvEecy53jmWW8vM+kqCvVbLbdttkJDkCV2n2wQP31Ldk5N80thN74druTcUeZMBjuU0Lf0PouMqyiMujS6xGCwyzsa3SCcdFR087oFKVliG1bwABIKu272tOcyZ3hl6Tg/f8nnfwvvo2l0GqXIuWw1XycqM72x/h9VwlbIq+edX/jkVFX2339Q6bMPW0+Sax5a1cI0oj4iLmJ7XYy1awxQmlmkx589hC/u2Euwb0QaDZMBOusNisIhruAySARvRBi2n1XRorYVrTSfVfDBP1+ky581RyIK1eA3XcJFIoixCCkklb50ynw/mWWwtNoOEURHhWz7zwTxpcXhR1HtlkqtJ/NVwlZXWCnERs5PsMMkfkZqHEGJWCPGbQog3pt9nDnjcx4QQ3xFCnBdCfOow2wsh/sb08d8RQvyZXff/9vS+b02/Hvgnacfp4JouaZkCYAqTsipZaa8ceNWzGCyqF6Lb5en+05zrnmvkpa+N1YTsRrTBhZ0LvLb1GlfCK7SsFj2np2sdGg0qbXVhdIFSlo2gYe0maBkWJ9on7tjNFOcx2/E2C/5Cc1sIgawkXVcNGYbFjU6qKFdzXLXZ2jAd4hjO7oPiyvjKnmCwW/03r/JGFHWQDpp93k/CPCTKo6YmtNJaIS1TVes5xmavo648PgV8WUr5DPDl6e09CCFM4JeAjwPPAz8uhHj+dttPf/9jwPuAjwH/1XQ/NT8hpfzg9OuBy8nWLYN5lQMw483sK01yM2d6Z+g6XUzD5GTnJG2rzSAdMEgGvLz1MqN0xDgf87XrX6OSutah0dTUH8jbkSpA1/pSJ1snifIIwzDoe/0DBULDXKk/zPgzbCVbLAQLJGVC4ATMerMYwiDOlN3sIBk0nVRJruoZJ1snAWX+Zps2oLzM4zwmsIM9F42TbMLb47cb2ZQnOk8A6uJwM94kLuL7GkAm2UStNNIdJJJZb5a0SO/Z/vogjho8PgF8dvrzZ4Ef3ecxHwbOSykvSCkz4HPT7W63/SeAz0kpUynlW8D56X4eCRppkukLwLf8faVJbmYxWKTjdJBITrZPcjI4SUXFRrrB69uvs5VssRVtsRav0bJatC0lua5rHZrHnVqO3THVVf9WtAWghv7sAFvYt724mmQTBALHcIiKCMdwGKUjuk6X5fYynuWRVGp+ZCfdaTqpXMsFbgwehnlI3+0DcG1y7UAv8ziPuTpWNZmlYAlTmOykKm00zIb3fd4jzuOms2spWMK1XHxz/xm0e+WowWNJSnkdYPp9v7/cSeDtXbevTO+73fa32wbgH05TVr8gbtOXJ4T4aSHEi0KIFzc2Nu7mvG5LLU0SlzGmMHFM50Bpkpupax99t89z88/RsTtK7C0fE+cxr+28RkVFz+2ppXjnhK51aB57ajn2nWwHgJ1sB0MYnOmc4VTr1B3nOwI7QArJxdFFAGbcGRzLoW23qWRFUiS4hsucP9esPFzDxRQmnq1acRf9RbaSLbqO0rea5JPGy3y/GsYwU9YLHbtDz+k1K4HjTB3tR1iExHnMxdFFDAwW/AUcwyGpjlc+/o7BQwjxW0KIl/b5+sSdtq13sc99d/rvu902PyGl/G7gh6Zff/mgnUgpPyOlfEFK+cLCwsKhDvYw1Ba0eZk36aSDpEluZnft4/nZ5znhn1BL8GzMarTKMFM5VRubxdYijuHoWofmsSfMQy4NLzXt8WEesugvKouDKr3jfIchlAFb7Th4onOClUAVknc3vvTdfvMhLxAEdsC8P49AMO/Ns5lsNjWXcTYmrdJbvMzr6fJJPsExHcqqpOt2GWZDuk6Xvtu/rx1XUkp2MlUsn/fnG2kVzzhe4yrrEAfywwf9TgixJoRYkVJeF0KsAPvVH64Ap3fdPgVcm/580PYHbiOlvDr9PhZC/CNUOutX73Qex4lv+WzEG8qC1lIWtAhYcA4XoM70zjDOxgyTIT2vhzNxiMuYrMzUH1l4IOD98+9vlst61aF5nKlkxZXJlcYxMyxCzvXOERURaZXedr4DVNpqO95u5i5WgpUmQABN2iqwAkpZsh6u0/W6eJaHIQylceXNUFSF8tCx28rUTXLLrEet/jvKRsy4MyAgMNV8imM4lLJsOq6OWyWirg35ls92ss2J9gk2wg3mg3lOdk7e1tP9bjlq2uoLwCenP38S+LV9HvN14BkhxDkhhIMqhH/hDtt/AfgxIYQrhDgHPAP8SyGEJYSYBxBC2MC/Brx0xHO4N6RagRxGmuRmFoNFTGEihGDen6drd5UXMwUGBo7l0LW6rEfrutah0UzxTb9JBQGcaJ1gxp2h5/ZuO98BN1pXR9kI27CxhMVOsoNruXScDoYw8EyvSUmlZcqMO0NURIRFqAYMA6VxNUhVWmuYDZHiRgCq2d0SPOfNqbSz3QZUum2cjdlKto77v0edZzZhO9kmsNUg46w7S1ZluJZ7W0/3e+GowePTwEeFEG8AH53eRghxQgjxRQApZQH8HPAl4FXg81LKl2+3/fT3nwdeAf4Z8NeklCXgAl8SQnwb+BZwFfj7RzyHu6ZOW6Vl2oixHTZtVXOmd4akSLCFzUqw0rwA65zofGuerMrIqkyvOjSPPYYwmPFneO/se1kJVjCEwYn2CeaD+TvOd4AqIHu2xygbsRAol0CEUodo2a3GtK3uRkqqBN/ySYqkmQh/akZpXG3Gm1hCzXklebJHoqTu6kLAdrLNrD+rFLEDlZUYJAPSIr2vGldxHnNh54J63mm9435wx7TV7ZBSbgEf2ef+a8CP7Lr9ReCLh91++rtfBH7xpvtC4HuPcszHQZ22Gmdj5v35u05bgdK5SoqEnBzXcptOrdqZzDRMpeWzb/lHo3m8qNMxbbtNXMTMe/NUssI3/UPNd8wH84RFyGa8Sd/tk5Ypfa/PfDAPqLQYAuY9dXt1ssrVyVXmPKXWGxcxEvX8o2yEZ3mEkxDP9Pakreo2WVe4xEXcDPmeaJ3AMizWojU143Ufu62iPOLNHaU2fK53jr7Xv+FceoxZMj1hfpfUwoVRFjVpqzAP2Yq27qp3ey1a44nOE1hYvDl8s7m/osIxHMIsJK/yplVQo3mcGaUjLo0vkVc5w2zI2e5ZoiLCs7zbznfU1Bdig2TAnDeHMMSei7MojxBS8NysShEPsyFpkVJRNXWCnWyHeX+enWyncR28Hl7f18t8M9kEoGN1cEwHz/ZusaHejDbvi2x6UiRsJ9sIBAv+QtPdedyrHR087pL/c+3/5F9e/5dKnmDaL/6NtW9wcXTxjnMeu5FSDSxVVcUwG2IJC1+oPuxxMWYz3mQpWFKdGe8S5zGN5l5Zaa/QtZW+lETyZP9JznXP0Xf7d2woaZSqp77jpzunqapKzV1MJcrbTps5f07VBuw2k3yCa6pWXd/y8SyPcTKm7/TZTraxhRoU3Ew22Yq3moxBYAf4ts/5nfOAmkNpO22yImPem2c1XG1sqK+Or3JxeHGPbPrF4cWmKeBeqG1xR/mo6bTKyowZf+a2DQX3wpHSVo8jm9EmL2+8zNujtxvN/Nc2X2POn+NDyx869H6EEEgp+c7wO1RUjUvgWrxGXMakRUrP7dFxO/elK0OjeSfRsluc7pwmLpRz5/ed+D4Wg0W2o+07poDqVNJWrIrUXaer5jp2TVy37FYjSNpze+wkOwR20NhGLwVLTW2zqIpmWDHKI9IyZZJPWBLqwznMwmblcbJzkrIqCbOQjtNhkA5IioS+2ycqIy7sXGAtWlPS706Pa+NrnOieuOf/pzhX6bWteIuV1oq6r4ib2s5xolced8lTM08xiAd8/vXPU8iCQTIgr3LG+ZhvrX/r0PuRUvLa9mtsxps4hsOTnSeZd+eZcWaoqPBsTwnBZZEOHBoNsJVs8QOnfoD/8k/+l6y0VvBNn9lg9lDpmDiPG2+NOW8Oz/KY8+b2PGYz2iTJE2a9Wcb5WLXv5gmbkQoEs/5s03FVyAJQq5qKqvEyXw1XGaUjoizCNV08w6OoCkxhMuer5xtlI6I8YpgMicuYf++3/z1+9rd+lm+tf4thPiQwb1/8P4i6WO9YDlvJFittpWklhDjQ4fQo6OBxF4R5iIFB3++TVkoUcT1eJyxCRukIIQ+XU6yLf8NkSFqlLAVLBE6AZVnNi3M+mGeUjViP1m9rMKXRPA5cn1zHNEyen32eD618iBl3hqzK8E3/jumYwA6YC+YaCwXbsJn1Z5nxZvbMPSwEC/i2T9fpshFtNF7mdadUlEecbCuhi7qzcidV7b+1l3mcK92qUTZiwVddXTuJmoZf8tVxrkarjLIR28k22/F28/xvDt5sOsfuJVVdr7BG6YhSlsy690fTqkZ/Kt0Fa9EabwzeaHR1QBWnLu5cxDIsel7vUPuZZBOujq+y2F4kLmLOdM8gEHiWx3cvfDcAfa9Py2nx9ujt+y7frNE86piGyYnWCZ6eeRpQNZAZd4au273jytwQBmVVspVsYRlWo9xgGZbqspoikfi230yZ7/Yyr2sJi63FpuPLEhajTLka7vYy922/EV8ENYAopWSptaQ6rqYOg5N00nRFATcm1ot4z3EdlrAI2Y62uTK5oWklpbxvbcG65nEXSCl5dfNVLo0vNfeVlIyzMTvJTvMCOkyaKSkSJtmk6cXuWB1ymbMYLNKyW+RVzhOdJ5TH+TG32Gk07zT2K4ivtFcOtW1tCTtMh8qnvKoYpkOEEM0HPKiOrCS/MWVev5fDPMQUpro4zGDWm2WYDZUgah6CpPEyr1uCt5Itnuw/SVqm9DzV7VRRMe/Nc2VyhTl3jkk+2fNZkpQJ1yfXWY/W76m4LaUkKZMmIPXcHmVV3re2YL3yuAuEEMR53Pgb72aQDnhr5607yrLXVLJqdHbO9c7xzNwz9Fy1cpn1ZtmINlhuLbPYWryr4UONRrOXOpW0k+40wWI73r6liBzYARUVgaVqDoN00Jg5zflzajYrS5hxlax7YAWkZcpOssNOukMlK3WlLwVxETPnzal2fitgub2MaZj03B4b8YZ6LlmxGq02z1/JCtuwycrsnlYebbuNlJLVcJW+20dKqQQlb6rtHBc6eByS9Wid9XCd5c7yLR/mlrAwMbk8unzoWY/dvdiL/iI9p8fJ9kl6bo8Zd0a5C8qMGW9mz9WRRqM5PLt9PLYTZQJV+3jcXESO8oiW1WpWNDuJ8jKvU1Ztu41jKiXeoirwbE/VQQ2DSlZsx9u8PX57jxQ6qBWBIQzCVMm51wXz2pNk2Vd1zqRM1GpBlndd5wzzUHVlui120h2WgiVG6QjLsG6p7RwXOngckjo1tZPuNMXymlIolc28yg+1SjioF7vv9ZnxZpjx1JVNVVbI6T+NRnP31D4enuk1woS7fTx203baSGTTFZWUCVLKppMK1OqkboE1MBqJEt/28W1fSaGPLwIw7883siVRHiGEaLbdSDbYTrapZNVcHAoh6NgdLGGxOlnlbqg1rbIyY5AOmPWUplWYh8euaVWjg8chEUKwOlnl8ujyLR/mcakKXLXh/Xp0+yGfg3qxkyJpBNnyKierMtIiZT1a14OCGs09UPt4vDV8C1Ap4d0+HrupZKW8zO2pl3l0w8t894fvs7PPAlBURXPhJ6VsfEFq2fg5b46+2yewgyaAvWf2PYC6gFyP1efEon/DT10I0YgY3i1b0RZvj9+mlCVPdJ6gZbfUiie7P58dOngcktqPuG73201WZQhTkJQJ42zMOD24O2p3L/ZmsrmnF7v2Y64VOMM8pKxuyDdrNJq7o/bxuDy+DMBKZ+UWH4/dj5WVpOt1m0J57WW+u5PKMz0CKyCrMgBSmTbSJxLJIB1gGzZlVRI4yv98vjXPbDDLrDuLKUwGyYBRNiKwAgJLTaWnZUpapE2H172c67WxcrtYDpZZai2pTrD71G2lg8chqF84hSzYiDewxI0mtVobZ5KqSdTVcPW2f6zdvdiVrJhz55pebN/2mQvmmk6LrWQLQxj31e9Yo3k3c7OPx4ngxIEfzPWV+n5e5nEeN6uBrMpUWqhUwWN1ssrqRL3vPctjnI2Z8+YwTIM4j9WMR7CEb/mM8zE9p0dURERFRMfusBqv4ps+hSyYCWaIs5g4v/smmUpWzSDkYqDakef8uTsqDt8rOngcgrVojde3XifKlba/a7mNqJprKOHCnJxJOqGoiju2xsV53FwJ7fYXbtktZr1Znuw/CahhoqRMmA/m9ZS5RnMP1D4e42y8r4/HzdSmUB1bSYnUXuae5dGyWyo4pGO6dnePJtU4H7MVbzFMhwzSAUutJRzhMEgGbEQbtOwWAsEoVauNUaYG+fpun6zIcExH1WSEs0fi/W7OMyszttNtZtwZJJKszA48z+NAB49DIKVklI24Pr5OKUuEVIHDEEajlb+T7AAoyYF9lsQ1tb/wpdEl1Wk1vUJIqgSJVMOGTo+W3WI9XCeXOUVV6ClzjeYe2OPj4d/q43EzB3mZ15LrtcZVYAeNREm9ktmMNtlJdhgkAxb8heb5a3zbJytVoEhKtb+2pTq4PMtjkikxxpudCQ97nhLJdrLddIvdL02rGv2JdAiEUIqZ12KVT5So1rv6C2BSTHBsdfXwjdVvHDjvsdtfeNabpaJq/IUFQnV1TR3AoiLCFjZr0dpdd19oNBol89P3+srHw7vVx2M/BEKJI+7yMt/NSnulGVo0hEFURGo6vExVEMgnaibkppZgAwPf8vFNdds1XQIrUMq9ht+07u4n8X476jqqa7tsxBustO6vplWNDh53YD1aZ5yOMQ2T1XCVjt0hr3IMYWAJC9tQ0swS2aS1JsVk39TVbn/hWr5gI9zAEAYnOydZai2pwls8YNafZSPewDO9xjtEo9HcHXV6eTvdZtabvcXH42b28zK/OY0U5RGLvgoetrCbeopruU190sS8pSV4I95QtZNpQ4xv+qRVqmZI3KlNbbrTDCYedlCwrqPWHkD3W9OqRgePO1DPd4yzMYN0QNfpNl0WNytzXg+vI6XEEta+RfO6F7ttt1Uv9j7+wr7tE9hBI84mpWTWn72rKxGNRnPDx2Mn3SHMQ051Tt3i43EztZd5z1FqD2m1y8s8D5sZrTl/jsAKEEJ1YqVlikRyLVLZiRlv5taWYAnb6Q0JecuwmGQTZUXd2n8w8VDnOdW0qhUr7remVc2RgocQYlYI8ZtCiDem32cOeNzHhBDfEUKcF0J86k7bCyHmhBBfEUJMhBB/96Z9fa8Q4g+n+/o74j7/DwkhuDa5xoWdCxSyYNabbX5nCYuu18U27GaQKC5iDMM4cN4jzmMuDC9QyYq+29/jLzzOxnScTiP2llUZcRXTc3t7BpU0Gs2ducXHw1Y+HvU8x37UXuaBozqU0jJtvMzr92fP6yGEUHIgKD2ppEjYjrdZDVV6+WTn5K0twQJsbDYSNQdSSjVcHFcxc+5Urj0fEWbhnvf7ndwFb9a08i2fCzsX+Pb6t5vHjLMxv/7mr/M7V37nXv87b+GoK49PAV+WUj4DfHl6ew9CCBP4JeDjwPPAjwshnr/D9gnwC8Bf3+c5fxn4aeCZ6dfHjngOt6WWFrgwvADQaO1LJJ7l4Vt+0ws+zseUsmSYDNVqZZ95jyiPeHnzZQA806PltEiLlFc2X+F3r/0uF4cXaTmtZkVzdXxV5V6l1B1XGs1dEudxk1aqJ75vp/VUyYq4jGlbKo20Giov83rQbjFYZCFYYG2yhmd65GVOUiZYwuJ6eJ3VcBXLsJj35ve0BNd1iYqKnUxJtCdlgmd7dJ0uucwRCC4NL3ElvNJ0aF2fXOfy6PJtLxwXg0Vcy2Uz2cS3fPIyBwHDdMhXr3yVcTbmC298gde2XyMt0wP3c7ccNXh8Avjs9OfPAj+6z2M+DJyXUl6QUmbA56bbHbi9lDKUUv4OKog0CCFWgK6U8mtSrf1+9YDnPBbqaB/myhmsbbeb//xKVviWj2VYtJ02pSwba9rteJu3hm/tu2xMioRrE7W0LauSb29+mwvDC3z16ld5c/vNpqf86b6Snh4kA4bpkIpKd1xpNHdB7eNRrwZssb+Px26iPCLOYxY81S21k+6wk+ywnWw39Yy23cY0TExhUlGRVzmbySY78U4z45EUyZ6W4Ek2AamK5ONsjGd6xEWMa7rMe/Oqg8sKGGZDoiziy5e/zDdWv8Hr2683ZlQHEeURgR0QFzEz3gwY8N6599JxOnz+9c/zyd/4JG8M3uBs9ywfOfORY/v/Peqn0ZKU8jrA9Pt+RsIngbd33b4yve+w29+8rysH7OsWhBA/LYR4UQjx4sbGxh12fSv1fEdRFWwn25xqn2KcqyuAUpbM+/MEZoBneM1VRlZmjPLRvvMek3xCXuVMigmBFbARb/BPL/xTfv3Cr7MVb9Hzeiy01It23lPdIHERI6VkEA902kqjuQsaH490C0tYLLb39/HYTZ22CssQ3/LZjDdJioRhOtwzrHu2dxbPvFFEr82qokKJKwJ7WoLDIuTa+Bo72Q6FLJqaSl7lSKRa7ThthumQ9Xidf/LmP+Efv/GP91W0uJmNaINBPGCSTVj0F7GFzUa0wUa0wSvbr3BheAEpJT946geP8L95K3cMHkKI3xJCvLTP1yfutG29i33uu1elv7val5TyM1LKF6SULyws3L0ybT3fsR6tK9cyy2+mSkHp5Xump6I9qntiK9kiL3O1ahHsyVXGecxGvMEoG9Fze5wfnkeinqOi4pmZZ5RUgeWTSpVrHWZDPMtTRb/7pFGj0bwbqX08dhIlxS4ryTAdMspGB67i60HdcTam7/S5MLzAOBsjhGg8PgDm/DlOtU41ahNZmTVtuqYwb2kJDvOQcTHeMxwMEBURUkqKqiCwlGf6hR2VIr86uco4HROXB3da1kX8tEoZpANOtk8ikeykO7y6/Sq2YfOR0x+hpDzWegccInhIKX9YSvld+3z9GrA2TSXVKaX9FAGvAKd33T4FXJv+fJjtb97XqQP2dezU8x21SuaCv0BJiS1Ue24lK+b8OZ7sqYlwy7DYydRStZIVr2+/3sx7hLkyiNnJbky71sJoWaUGh2qHQoEAqYTVNuNNPNPDszzdrqvR3AW1j8cwHd7Wx+NmOk5Hpbi8Wa5NrpFXOW27zU6y07yfAztgubNMz1YriI1kg7XJGnmVE9gBb4/fvrHqyEN800dKybXwmrrgdGcQCNIypZBFMxw8zsZsJipNtRlvMspGDJPhgReOk2xCWqYEZkBe5aobtMy4Fl5jkA6Y8+b4Y6f+GH2nz+uD1/nypS8f2//vUdNWXwA+Of35k8Cv7fOYrwPPCCHOCSEc4Mem2x12+4ZpamsshPi+aZfVT95pm3slzEMm2YSsyrgyvkLbbjfLXddUkiQtq4VrucwH8ziG0wSbuIipqBjn4yZ1NckmXBxcZBAPqKga5U1LWMq0xe5wLbzGxZ2LLAQLzHgz9L0+18Pr2tdDo7lLdvt4bCVbt/XxOIha5uPa5BqjdMRquEqUR7SdNpNsgiUsTrZU1nyUj5ouKs/02Eq21NxXHrIWrbEdb+MYDoN00BxLXUNtWS2KQqlIxEXcNNqMshGDZEBSJYRFuG/HVWAHzPlzjUGdKUwA5t15kjLh6ZmnScuUZ2af4YnOE81n13Fw1ODxaeCjQog3gI9ObyOEOCGE+CKAlLIAfg74EvAq8Hkp5cu32366j4vAfw78FSHElV0dWj8L/ApwHngT+I0jnsO+TLIJcR6TZAkb8QYL3gKjdERcxM2Lr+7hDrNQyThPE2jr0boyoS/Lpmi+EW+wGW02bYNxGWNj4xgOFRWu4ZKVGV2323h4zLqzSvNf+3poNHfFzT4eruEe6ONxy7b5hKRMeLL/JIYwuDS+xPmd8yRFgm8pDbq8zHEtl+fmngNommVABY+yKrk8UikqKVUAWgvXSMuUBX+BoiroOl0G6YCVzgqVqBAIJLIJBIUsSIoEWaqa536qFfVcytsTVVae8WdwDZfl9jJ5lTPn3RBe/cjZjxxr3eNIHuZSyi3glvK9lPIa8CO7bn8R+OJht5/+7uwB978IfNe9HfHhqQtcg3RAVmWc6pyiqArlSTwtdhmmQc/tMckntOwWV8Or+KbPKBsxykbN6iXMQ66MrxCWIYN00DyHa7pYhkVURiBUK+GMN0OYhwyTIX1XySkUVdH4enScjm7Z1WjuQO3jcXF0EThgaO8AoiJipb2CZ3nM+/NcC69xpn0G13KRSNajdd4z9x6uTq6SVRm2sJWvh5xKtJcpcREzzIbA1L66iHlp6yUAnug80XRiXQ2vkpUZvuk3HWBJqYQZx/mYUTYiqzJ20h1OyVO3HOskm3B1fLUJLIv+IuuTda5MbrgZ1sKrx43u/TwA3/QxDbOpd/SdPgveQiNsBuAKF8/yaNtt5cUhy2Z6PMmVKUxSJLy18xaDeEBURGzEamnrCAdb2M0LxjRMnug9gSEMVZzb5esRlZH29dBo7oLGx2N69b/SPtjH42aWgiWe6j8FQM/usRFt0PPVBeP5wXnWw3XO9s7i276SFnHamMJsMgOr4Sptu81ya5mr46tMsgnjbMy18FpTkG85rWaWJC/zPZ1cEtnIn6zH642S936DjbVq8Cgb0bJbpHnKdrLdpMWXg+VGePW40cHjAFbaK3ScDlcmqt6x2Fqk7/WpqJq84kKwQNftYhhG4z7mmi6lLJkUSl7ganiVl7deZiPeoKgKJrmSRXANF9/xG/VNIQQLwUKjf7Xb12Mz3tS+HhrNXXCzj8dKsHLotO9isIgQgqRIONE6QYXyJ69TT3Xa+lT7lPLpMP093VtJnpCVGTvJDm+P31bKuhI2k01Otk6q1LWA023VR7QWr2EYxh4F3o6j7GjTMqWsygOPtVENTpVqsEQSlRGbiWq0cUynEV49bnTwOIBxNsYwDEbZiKf7T++rwlkrbs55c40HRy24FhcxUsgbVwbpiLXJmgo+mNimTc/uNXInhjCIsgiJpON0mPVmm6uftWhN+3poNHdB4+ORj7EMJWB6Ox+Pm4mKCMMw+MD8BxAIroXXGGUj9Z6f1jGfnX2Wlt1SroGyxJh+nMZVzEsbLzHOxmzH27x4/UXiIiYuYk61T6kmGgkn2icwhMFGtEGYhXtMmwxDKfBO8gmmYR7YcdWoBiebyhukzAisgDAPWQwWGaUjBIIZ/+DByHvlSDWPdzNhHoKE/+QH/hNMw+Ta5BrDVOUwa0exWuJ51pslaSc4hkMuc3zTZzPZZJJOWBfr2IbNJJ9wfnQeUCmxOtVVv2BquYL66sgyLPpuH9/yWQ1Xta+HRnMX3OzjYQjjtj4eN9OyWzzRfoL1eJ15f57r4XXOds5iGIZqkpl2c/W9Pr7tN8FDIJgUEwbJQKWq84hxPm4yDovBoiq2Gy5dp8usN8v18Dpz7lyj9msIAyEFbafNZrzZpLc24g2W28vN8ddZisAMGCQDnpt9jlE2ouN0GGZDnp97nqzMEELQslrHfuGpg8cBhFlIy2lxsn0SQ6gXzFfzrwKqHc4xHHzLZ86bYyvZYpJP6DpdkjKhZbUYpAPSImUj2iCvclbHq0yKacrKdOk5PdpOm77Tx8BgO9kmzEKkLZVUe7TR+HrERdz4erTtNk/NPPUw/2s0mkee+WCesAiVj4d7OB+P3SwFS1RVxRs7bzDjznB+eJ6O20FWkiujK8rvHGWv4BsqjVVR4Zs+cRkzKSZcHF7kgysfZJSOeGPwBr7lM+PONEN/Qgjm3LlmrqOWYrcMC1Oa2MImr3J8x6frdElLVfOsg8Akm/D2+G3G6Zisyui7ffJK1U+iImLGnSGrstsKQR4FfRl7AB23w8n2SVbaKwR2gGd5FJVyDsurHM/ymtY611TCiPP+PGEe0nE6lLJkNVpllI8YpSPemrzV7DuwApbby/i2T9/v03bajLKReh5b5SZ3+3rUg4La10OjORyNj0eyzZw/d0cfj5tp2a3mQ345WKaSFUmRkFUZb+y8QZRHLLeWsQyLpc5Ss13bamNgEJURk2JCXuRkVcZmssmp9inCImTBX+BEcIJJPqHn9thOttlKtiirsqmp+o7fDCMPkgGGYeyrpRHnMRdGaiJ91pslLdNGzfts92zjy34/1Cl08DiAxWCxsXOM8ggDdaXhmSqI+JbfKO62bKWCW0f+ephvPV4nzJSo4qSYYGBgCpM5f67xDDjTPUPH6ajcpBCNxW3t69FzemzE2tdDozkstY/HMB0yySecat/Zx2M/WnaLtt3m6f7TCARvjd5iO97GNV18y6eSFUutJU61brTQzvvz+KZPIQsG2YBvrn+TsAjJqoyu0yXKI2zDVg05boc5bw6JxDRMhFSBLa9ySlk2boVr0VqTMt+P9VAFixl3hrbVblqEl4IlllpL6uL2PjhX6OBxCKI8opJVo0mVVzmO4TRtd4YwmPVnm84ppBoUmhQT0iJlNVxtiuuO4XCycxLTMOl5PXpej47dUcU4qQaEJJLl1jJdt9uoZaYy1b4eGs0huMXHw7mzj8d+SCk50T7BSnuFOW+Ot8dvqxkMp4NEshVvqUyDe6MQbZs2i94ipjAZZkM2o02ujK80x+GZHnmVI4Rg0VvkdEd1XEV5RCqVYndeqbrpor+IZ3pquLBID9S4qmfHTMxGZNExnMYvaM6f21OMPy508DgEnuWRVinDbKjklfMJjqkmw+Mybiwq6+6onXQHSyiXsHE+ZlJOsLAoKenYHSVJYLdYCBYwMOh7fSb5BM/yMDAI87B5oTe+HiPt66HRHJY4j9lOtoHD+XjsR8fpcLKj5Ed6Tk/VHB0lKVLPewAURdFsE1gBJzsn6dsqCxEWKvNgGzaBGTSpbgDf9nmy/yQCwTAbNscLYJnq86Lnqud1LZe0SPeknypZIQzBTrqjxFQrFWDG2ZiV9gpJqVqGD9thdrfo4HEIkiLBM7ymWJVXuXIXyxNVh8hjfNvnROtEs+LwTI+KqrGlrB0D54N5yqrENmye7j+NYzr0nB476Q6mYeKYDh2n0/gKNL4eqfb10GgOw80+Hpaw7ujjsR83z3uUsmQn2WnmPQI7UL7h5JjCxDZsum4XhBI1NYVJXMakZUrH7jDMh5SUPDf7nJoVEarLcs6baxQpapVeJI2EyWq0imM4eKa3R+MqKRKqqmKcjZU/uxBYwmI72WaltUJapk0Dz/244NSfQofAt/2m7W/GmyEpElrO1G/cCQhsJbZmmAaz3ixZmXGidQJQ+jQmJo6lgseiv4hv+ywGi1RU2KZN22krH+QixTbtPUNB877qDknKRPt6aDSHYLePhylMltpLd/TxOIjd8x7AnnmPwA5IqxSkek7LsHCEQ1mVnOmeYdlfpkQVwS1hYQubc71zzPlznO2fpe/2uRZewzVdhtmQtEoJLJVe2k63VeHc9ImLWFnWms4ejavaO32QDpj355GVsqMNi3CPptX96LQCHTzuSN1LHeURRVUw686qD/JquvQ0byw94yxWXgD5eI/Wf8tsNQNEdXF9obVA225TVmXzgomKCMdwGokS3/LJqgzP9Bim2tdDozkMtY/HMBmqqetD+HgcRD3vMRPMNDMZSJp5jxlvRqWwZUUlVVbAsz2WWkt834nva/ZjYnKmd4blYBlDGCwGiyy3llkfr1PJikmu6jRN8Ei2CeygGSJei9YYZsMmdV3PmUgkW8kWc94c43zcdFotB8v3TdOqRgePO1D3UtcyB11b6eV3HaV+GxexkiywlVFUy2qRlimZVH3XPbvHTDBDIQscw6FjdzjdPd10WbScVqNhlRYphqFqHr7lN62Fs94sG/GG9vXQaA5B7eOxk+7clY/HfiwFS5zqnmKYDpl1VfDoul1kJTm/fZ5r42sEZkApS0pZ0vN6BEaAYzqc7pzmAwsfYDlYZiFYICvUwN5uh9FZfxYTJXdUN9UAjZz7kq/agC8OL7IVbTUribopwBa2MqIyPcIs3NNpdb80rWp08LgDga3SUvVSsZ4C73v9xl5SImnbbWzDbq4UrofXOd06zYeWP8S5zjkKWdCyW2QyY9adbYpYspLN4NJGstFIlBjC2OPrsRqual8PjeYO7Pbx2E6378nHYzc3z3sUsiArM7Iq45XtV9iMNtlM1ZBfrQCx1FlCIFidrPLds9/Nf/Dh/4DvWf4eKlmxlWztaZtdbC2y6C42mQmJxBQmuczJyoyF1gKO6bARb5BVN1xM68+lzVg9d61uMckn2IaNb/v3TdOqRgePO1Dr5W+lqu2vrkEEdqA6onYVo2b9Wc50zgCq3e6J3hM8N/scZ7pnGhmTjt1hJ92hZbXU6sIQjYJmnMckZYJAmUrVy9IZVxnayEo292k0mlupfTwCK2CcjXHNw/t4HEQ971F3U14cXWzmPWzTVqmsKaUsaVlK72rGm+FjT36Mj575KJ94+hOc7p7GwGgETyf5hMAOODtztklxh3mIKUwqWeEYDlfHV+k7fbbSLRzDaTSubvbxWGwt0jJb7KQ7zHvzjNPxfdO0qtHyJHdgkk2UxHGoJI7rnKRnes2A4O486lMzT6ninGkx782TlzmO6VDKkmf6z9B3+40TuyEMAito/rhbyRZSKjHFJbHU+HrMuDOqaDaVZde+HhrN/tQ+Hm8NlaLDjHt4H4+DkFKqjIJQU9yXx5dZaa3QN/pkVbZngE9KiW8rOZHnF57n/QvvB+DpGdU1aRlW877tOB31ni5TpdQtlUSJiUlWZWyn21RJxaw3y5XJFSWPIiUb8QbCEHt8PDp2ByEFo2zEud65+6ppVaNXHnegkhVJmTDKRk1XBKjZj9p2tv7j1EvFxWCRMA/Jq5xBMmArUauWp/pP0XW79Jye+sPaLcIspJQlAkFRFXiWR1ZmrE5Wm4J6HVyiQvt6aDS3o/HxGCsfjxOdE4f28TiIjtNpnPn6Tp/VaLWRKxonY7aT7aZWkZWZmkqffbqZEK95euZpzvbONrcXg0XWojWlYGEo9Ylq+i/KI3zbxzEdHMNhkivb21rjaiPcaHw8fMsnL3O2422iImLem7+vmlY1OnjcgXrGI62Ug2BtNdmyWsy4M5iGmvhuO21c02WSTZj1ZtlKtgjsACFE80JeDpbpuT18y28mPmuF3pbdYjVcJS1TKlk1988Fc82LcDPRvh4aze04io/HQSwGi7SdNnEWs+AvkFc5cREzykYM86Fq3Z9eQG6mm+RVvuei8iDCPGwcBOt5DIGgoqKQBa7hNiKsoDquao2rpEjwbI9hNmzmRGoP9Sd7T95XTauaIwUPIcSsEOI3hRBvTL/PHPC4jwkhviOEOC+E+NSdthdCzAkhviKEmAgh/u5N+/rt6b6+Nf1avPn5jhuJZDvZput2mxkMz/JoO+09+lYdVxm4zHlzKp9pBZjCZCPeoG23CewAx3D2SAVI1DK349yQKKlXMG2njW/5rLSUxlbt63E/pAY0mncDjY9HNm4G9+7Gx+MgoiLCd3yenXkWgGuTa0yyCVmRERYhfbePQA0UIpUw451WOpNswkpnBcdWae3lYBlPeE2we2vnLdIibWSPdmtczflz9L0+W/EWXUd9LtXPt9S6v5pWNUddeXwK+LKU8hngy9PbexBCmMAvAR8Hngd+XAjx/B22T4BfAP76Ac/7E1LKD06/1o94DrellibZSXZo2+0mXeSaLhvxBoEdNFcYLavFrD/LcqAKc9cm1yhlyTgbsxgsEhfxLXIBAiWG2HW6jLK94oj1snPen8cxHNbCNcb5WLX46nqHRnMLtY/HMBvek4/HQbTsFgvegqp1uCp1FecxrukS5iE9p0dgBYzSEQhV+9jtDHgguxZFgRXQttpNCmyQDvBtJbJoGRZrkdK4GqQDKioCM2A72WbGmyGtUmV8JSxmvdn7qmlVc9Tg8Qngs9OfPwv86D6P+TBwXkp5QUqZAZ+bbnfg9lLKUEr5O6gg8lCp01ajfNTMdsDUMfCA1XDdlbEarZKVGaN8xFKwtK9cgESJIe5eedTtv4Yw1DDitFA3zIY4hkOc33v+VqN5N9M468WbjVnb3fh4HETLanGqe4pCFsx781yZXMEUJkVVEOYhjungWZ66uJOSpEoazbs7sZPsANB3+5zsnMQRKk2VVAnXJ9dJi5SW1eLq5CqupbrHLgwusB6tk1UZPadHURUM0yHz/rxqJb6PmlY1Rw0eS1LK6wDT7/ulkE4Cb++6fWV632G3349/OE1Z/YK4j+uyWqAQQxXCZj01XQ6qEOdb/i0De7X0iGM6bCabRIWaTJ9xZ/aVCwjzUIkjun0m2V5xxJbdIi5idpId5vw5humQntMjKRM2o837ddoazTuWerB2kAyU3tNd+ngcRNtp35i/mtY9Mpk1c1+u4RJYAUmRMOPN4BquSmHdgSiPWIvWCKyAeX+euWCOGUdl/8MiZJyNiYqItt1WAommi5RqYv7i6CKgVkWWYTHKR019NC7iI6+27sQdg4cQ4reEEC/t8/WJO21b72Kf+45SwfoJKeV3Az80/frLBz6xED8thHhRCPHixsbGXT9RrVq5OpkKrBkW40x5IlvCIi7jPYNHdY2iHgTcSraaNFfP7SGlvCUH2XE6ShzR7THKRgCNOGJNnMfNlHl9W6PR7GW3j8c4H3Oqc28+HvvRslu0nTaO4dwQK00GzXvSszw6Toe4iBt1iDsxySdkZcYgHXCqo1Y1aZHy3vn3AmpmZJJP2Iq3sA2bqIhYj9bxTI+kSHhrpNqRu06Xtt1ufMvTMm3kje4ndwweUsofllJ+1z5fvwasCSFWAKbf96s/XAFO77p9Crg2/fkw2998PFen38fAP0KlxQ567GeklC9IKV9YWLj7qey6W6H+UO86XSqprCajIiLKoj2dTy27tUfjaifdaWSWPcPDtdw90gSAUtg17UaiZJgO94gj1qZQXadLmIfERaxNoTSafbjZx6Nn9+7Jx+Mg6nmP093TdJ0ua/Fa07rfttWF4yRXNgx3SlutR+tsRBu4tstmvMlya1mtXhxlAFf7odcS656p9vXW6C0qWREVEdvxdnNc41xdpC4Gi/ddELHmqGmrLwCfnP78SeDX9nnM14FnhBDnhBAO8GPT7Q67fYMQwhJCzE9/toF/DXjpSGdwG+pp1fqP1LaVlr9nebTsFoET3NIGWGtcdZ0ucRGzmWzimi6FLKiobvEUqDu46quEST5pxBHDPGS5tcxSa4me2wNgJ9uh5/aaQKbRaG4Q53HTpjvnz92Tj8dB7J736DpdJRlSKskQU5iYQpkxhVnIjDtDVEQHXuCNszHDZMhOskNSJvScHh23g41NKUoCO8A2bDKZNd7lAFfGV3g7fBsplDhiPR6wFqlhwVPtU/tmOO4HRw0enwY+KoR4A/jo9DZCiBNCiC8CSCkL4OeALwGvAp+XUr58u+2n+7gI/OfAXxFCXJl2aLnAl4QQ3wa+BVwF/v4Rz+FAAjsgLMLmDzPvzxMXqsMiyiN802e5tVfyoNa4qnuzt9Ntek6PUTrat4hVXxV1bHVfUiSNOGKt1GkaJvOeKvhdm1wjq7JGR0ej0dzAt31WI5Vmtg0b3/KPrXC8e96j5yhH0WE2VGmkMlFT4tCkjGqZkf2oJ97rSfi+02fGVcq9rnDpOl0sYWFgEJcxRane7zvpDleGV7CFzTgf03f7GIbB9fA6hjBo2+19Mxz3gyPJk0gpt4CP7HP/NeBHdt3+IvDFw24//d3ZA572e+/lWO+F2rs8LEJsw1Y+AbJsZjZqRd1aq6YmsANmXFX0qoeF6iuIm+UC6o6quUBdHW0lW0SZmi41hMEkm7AVbTWzHkmRqJWQVDUW3bKr0SgCW2UC1sI1TGHSdbq4lnskaZKbqec9TrZP8vL2y80HeFzEzXtxkAwYpANm3JnbXuAFdsDVyVUAFoIFltpLdN0ubw7fxDEdECpVvpPtkFUZjuEwykYkZcK1ifIVWQqWMDHZSXfoOl2KqqDjdI5ttXU79KXrbai9y8MsbHyQozzCszx8y29aam+m9iCvr0QCK8A3fVzDveWxlVRWtj2n1zxnUqrnqZeqvu3Tsls4hsNWskVSJI3kiUajUWzEG8osLVfOeqZpqrb2Ijy2VXo97/FU76km1Wxikhe50q0DcpkTZdEe7an92I632Yg38C2fltVq0tfz3jw9V9VrTvonEQgmxQQhBVERIYRgnCpZlJbdwjAMJvmEBX+BUTrCMqy7dk28F3TwuA31gGA9iAOQlqkqbgsOFB072TlJ223TdbqAEi3ruT3OdM/ckousbSjrtNV2sk2YhY3kQd3BZRhGU4T3LO++Sw9oNO8k1qN1Xtt8jWE6ZJgOWWotsR1tc35wniiPjm2FXs979Nxec3XfslsIQ5CXOQAb0QZxEbMarrIZbe5b91iL1pjkE4bpkBPtE0gkk2xCRcVKewXXcKmoODdzjgVvgVzmjX9Qy24xF8yRV7maZM9UI82cN0dWZYR5+ECyEjp43IbGuzwf03W69L0+WZnhmE7TXXHznEf9YT/jzjSpq6dmnlISA4JbJj5bdgshBIaperKH2ZDADvBsr5n1WAwW8S2fvtdXuU1DzYXU+lcazePOa5uvcXV8lSiL2Iw3cQ2XV7ZeYSveauqFx0E979GyW42SRN/rM+/NM0zVEO+VyRWG6RBhCK5MrvDWzlt79hHm6uKw7bbZTpXfuBACiWTOm6Pn9RrrB4Bn+s80oomA8vWYXoOWVclOtgPA2d7ZB6JpVaODxx2QSHbSHTUgWCQkpWrBm2STW+Y8gGYZWVUV37P4PXxo+UN8z+L3MO/PH9gBUUuU1FPmuyVK6mOofT22k23t66HR7OLi8CKjfEQhC86PzhMWU0XrbMAzs88ca8tqnQ2QUvInT/9JPrz8YT525mOc7JwkcJVB07fWv8VmsklRFmzH27ekmOuZE1OYxEXMvDdPWqT0vJ5KUVstvnvhuwEYZSPO9M5wrnuu8f3Zire4NlHTDn2334wLLPqLD0TTqkYHj9tQyw3ERUzP7THJJpSyVCkmwYGjjlIqe9mPnfsYn/6hT7PSXqHltA7MQzYSJXaHcTreI1EC7PH1qD3Va18PPeuhedy5NLxElEcsBov8/urvYxs2RVnQd/q8f+H9x577l1IS2AFPdJ/gb37f3+SPLP0RJVTo9Flyl0jKhN+99rtcGF7AtVzG2ZhXNl/Zs484j3l7rIQ3loKlxm+8ZbeQyMaR1DEdDAxeWHyBj5z+CAYGW8lWM5zYc9RwsUDQttsPRNOqRptBHUCYhyqiTwNE/UcFlXqqvTbiIr7lxWlgsNJe4WzvLB2n06xO2vb+ecjdEiXr8TqepSZI68Cwn6+HYzqNr4fuuNI8rqxH65SyJM5jXt5+mbVojSVvCUtYnOueY5AMaNnHa4jUcTqc6Jyg5bRY8Bfo9DpsRBtsxVucaJ/gcniZV7dfpWt3mXVnycoMS1g8P//8nv1cHF4EVPDouqo+KlEXnnW9tG7dn3PnWG4t03WVn4chjGbqfCfdYcabwTKtB6JpVaNXHgdQz1fU/h0du0NUqp9rHar90lagLCHrwAHqxXa2d5bF1v7SXbVESdftMkgGmIZ5i0SJ9vXQaG7ltc3X2Ig2sA2br179KqYwadkteq4yXKuLycfJYrDIk/0nVeCYvkfnW/Oc6Jzg+fnnWfbVIOGF4QVeHbxKJSts026CBdzQtPJMj67TbawaBAJZSXqeUum1TItnZp5hxp9RwofePGmZUsqSwAqUIVU+Zt5TytsPQtOqRgePAzCEQVEVXJlcAZQ2VVlMJUMsX0mFHKAx1bJbt0T+29nG1hIlHafDJJuQl/keiZLG16OtfT00mpq61pHLnC9f+rJSvra7BHbAMzPPYJlKf+7mOazj4Ob3+FKwRNfp4ls+T888jWd6rMfrbIabTarp0ugScEPTajvZ5kT7BEmZNCuGpdYShjCIs1jVM4qIU51TOIbT+IaERUiYh3imR1qmTPIJJzonHpimVY0OHgdQe5evh0puq+f0MA01t5FXOaZhMuvNHkv/eC1RElgBFWruY7dEST2FvugvYhkWq+Gq9vXQPPbUtY40T3lt5zUMYTDvqxmJk52T9N0+Z7pnHsh7ZDFYxBQmvu3zvrn3segvUsiCjWSDb29+G6SSJPnG6jfYjDeRSDYTpWmVlik76U6zYvAsj6RK6DgddtIdwizEMIxmHgTUysUzVeOORDLrzD4wTasaHTwOILADEKrbwRQmgRUwKVSXRMtq4ZnesfVS18GhFkdMi3SPRMluX48Zd4ZxNta+HprHmt21jq+vf51RPmLOmcM3fT648EHiXNUib64z3E/O9M40nxtn22fxTI+tZIvNaJPNaJO1cI03tt8gyVU9M8xD5r15xul0GHi6YkiKBNdwmfVmGSQDAjtQlrSG2ax2SlS2YpRPRVvd7gPTtKrRweMAojwiMINmqZhWadNid65/Dt/y2YpvSK4fhZslSjbiDaIsavwDdvt6zPvz7KQ72tdD81izu9bx0sZLGBh0HDWM61kei8HiA5Ho2M3Z3llsYeOYDt9/6vs5EZygkAVr8Rp/uPmHOKaDbdqsRWtNt1R9wdjzentWDAJB3+0zSAfNfWmRstJeaVr4q7JqbGlnvJkHpmlVo4PHAUgkUijTlZ7bY5gObxTeJMSlEkg8jrRV7Ruy5KvcbFzEJGXSWNHWaF8PjUatOsb5mHE25iuXv8IwH9J3+wR2wJnuGSzTAqEu8h4075l7DyfaJ3Ash6f6T+EaLtvpNqNEtdMO0gHr0TrXQjWnseAv0HE7+OaNOkWdtqoL4uvROmmV0nE7ZGV2QxbFMAkLNUiM5IFpWtXo4HEALbuFkIKddIe+28ezvOaD3Hf8YxUmNIRBYAXNknQr3kJKySSfNMFpt6/HOBuTlqn29dA8llwaXiKvcvIy55XBKxgYLHgLdGzVQvsgax03c7Z3FktYIGlqH3mVs56u8/XVr4OEUTrizZ03cQyn6bTajSEMPNNrbBiyMmOltUJZlqRFekMzzw7IyoyO3WGUPzhNq+Y4H8izvAMJ85DACfjk+z7Jv3ruX2WptYQQAlOYzLqz+0qT3Cstu0WYhU1wKmSBZ3lkZda4GNa+HnU/+DAbal8PzWPHerSuLp6KlFe3X2WUj5hxZ7ANm/fNv4+qqh54reNmdtc+znXO4RpuU/tYnaxyPbzOVrKlpsGtW8VS6+7KupsyqRJmvVnabpuSsnmcb/hkVdZ8fjwoTasaHTwOoOOopeRHnvgIL6y80EgJBFag2nQPmPG4V9pOu1mBrIarpGVKJatGv0r7emg0N2odZVXyB5t/gIFB11HtuT2391BqHTezX+0jr3JW41Ve2X4F31St/rPubNNeu3vFUMkKBM17fW2yxtXJVaVcsSswbGabjWxRYAcPXCxVf+ocQP1h7Vs+C/5CY/ji2/5tpUnuFYnEt/1G30pKdbueao/yiK1oixOtE8ANX49BMjiWor1G86izu9bxO1d/pzFaa9ktnuw/SVEVD63WcTO7ax9ne2dxDIdBMmCSTjCFqcyjDLNpr11sLTaBIcojhBQ8N/scoNxD0yJlkAwoyqIpiteaWYEVcKJ14oFpWtXo4HEAhlB91bWp/Zw/18xiHKSoexR2iyOO0/Et4oig6h5tp41lWGwmm9rXQ/NYUdc6DAxe2noJgWDOm2PGneHp/tPMerPM+/OPxOzT7trHc7PPMe/Nk8ucnXyHb299G4Cu3WVSTPYUy0FlIeb8OXzbbwaSpZQYGFhCDT4CTSdWy2rhmA9O06pGB48D2D1B6ls+cRkTFRFtp31baZJ7Zbc44jAb3iKOWOdBTcNkxp3Rvh6ax4rdtY5Xtl9hkA3oO3080+M9s+8BYNaffai1jpupax+u5fJ092lsQ81l7CQ7wPRzZZ+OydqmYSPeuNGuK5QUu2ValLLENmwAPNNr5tEelKZVzZGChxBiVgjxm0KIN6bfZw543MeEEN8RQpwXQnzqTtsLIT4qhPiGEOIPp9//1K5tvnd6/3khxN8RD2CdFuURURYRFZGa8BSo28eoLdWII3pKN8uzPGWBO+2katlqiHB1skpgq7qIYRg4hsPbo7f36OZoNO82yqpslBheXHsRgeBk6yQr7ZWmceRRWXXU3Fz7WPQWKWWpXAERBGaAb/mkVXrLtpvRJkmuCuWTbELf7eOabuNMWHdo9dye8jNPxw9M06rmqCuPTwFfllI+A3x5ensPQggT+CXg48DzwI8LIZ6/w/abwL8upfxu4JPAf7trl78M/DTwzPTrY0c8hzsikQROQJzHalkoIXCCY/XTqMURe26PYTZECHGLOKJneUghcQynGSRcjVaVl0FVHNuxaDSPGivtFU62T/KdwXfYSrdYDpZ579x7eWH5hUeq1nEzde2jouL5ueexhU1FhW3Yyt7B7dCxO7esGBaChaYGuhFvkFUZbadNJjPgxnChb/pYhrVHvftBcdTg8Qngs9OfPwv86D6P+TBwXkp5QUqZAZ+bbnfg9lLKb0opr03vfxnwhBCuEGIF6EopvyZV1ehXD3jOY2W5taw6JKZeyEmZ4Js+y63lY3uOWhyxbbepZMU4He8RRwRVhznXPcdSsESYh3zp4pcI05DFYJGnZ54+tmPRaB5VLgwvYAqTP/XEn+LJmScJ7OCRqnXczNneWfJSzaR87/L38uzMs4CqcW4mm8x5c5zrn7vl2OsGmr7bZ5AMCLOQcTZmlCo5krqjrG23aTktltpLD0zTquaofh5LUsrrAFLK60KI/TTHTwJv77p9Bfijd7H9nwe+KaVMhRAnp9vv3tfJI57DHVkL14iLuPEJ9iyPuIhZC9eOTbGz63bZjDcJLFXwCouQBWOhEUesX1yBHfDHT/1xXtl+haIqcC2Xc71H74pLozluvrX2Ld6/8H7+lZP/Ct+18F2MkzGjbMRSa+mRqnXczBPdJyhkwWq4yoeWPoRE4pnebeezBIIkT2hZLfIqZyfbYZJOGOdK1+752edp2S01iBgs3lJ0fxDcMXgIIX4L2O8S+28e8jn2q0kcKt8jhHgf8LeBP30v+xJC/DQqxcUTTzxxmKfcF4lkmA3JyqyRAgiL8Fg7G24WR6xNYML81udZCpb4+Q/9PHEWk5Ypbw3fui+y0xrNo8L1yXUKWfBdc9/FD57+QSbZhKvmVYBHdtVR8/z882xEG6zKVVbaK/xbS/8Wg3jAK1uvcH5wnj+y9Edu2SawlcJ2nYrajDZVrTWP6DgqzfXC8gvMe/P0vN6DPiXgEMFDSvnDB/1OCLEmhFiZrhpWgPV9HnYFOL3r9imgTkkduL0Q4hTwvwA/KaV8c9e+Th2wr/2O/TPAZwBeeOGFey5QtOwWxjTDV0+OtqzjdSerxRHnAzUYtBlvEmURvu3vGQLcjDbJq5znZp5jqbXEi9dfZCPe4PzgvE5dad61mIbJ83PPs9habD48QXVYLQWP/oXTmd4ZJvkEx3I41z3HR898lC9f+jKrk1U2oo1bUuBRrppzTrTVXFdapnTsDoN0QM/p0XW7nGif4InuE0gkSZE88HM6atrqC6iC9qen339tn8d8HXhGCHEOuAr8GPCXbre9EKIP/DrwN6SUX613NA0yYyHE9wG/D/wk8F8e8Rz2ZbccepiHzRVA3bvdslvHOtldSeXj0bFvWM0mZYJENlazbafNQrCAZ3lNoHhh5QXeGr6FZWhHYc27l8VgsXHSrKnN0d4JnO2dBaCoiua9+5EzH+H84Py+792202Y9Wm+8zCtZgVRGUud65+g4HdqumgdpO22iPGrUKB4UR/3E+TTweSHETwGXgb8AIIQ4AfyKlPJHpJSFEOLngC8BJvAPpJQv32574OeAp4FfEEL8wvS+Py2lXAd+FvhvAB/4jenXsTPOxkRFhG+q2YrLo8uA+uMnZaKMWY555THnzZEXOaCmR8MsRNo3JAladovvWviuPdt1nA7vX3j/sR2HRqO5P9QBZDcHZQvqNHbtZX49vI7VscirnFPtU6rzslL+HbtXYg+SIwUPKeUW8JF97r8G/Miu218EvngX2/8t4G8d8JwvAt+13++OmzALeTN6k6RIuDpR+dWe12PGncE0TMbZ+Nj+aC27xTgbY1kWnukxTscEdoBne4R5+FBeHBqN5uFQp7H7vprvGGWjZq5sxtt3nO6Bo3Mdd+Bv/8u/zUprhffPq6t73/KbZeJxCxLuligZZaN9JUo0Gs27nzotHmcxXafLTrpzQ45kalX7sNHyJAfQslskRULf7XNlcqX5wwkEl0eXCezg2Ds8GomSXeKIuyVKNBrN40NtCtW224R5yGasXEOXg+XG/OphooPHbajlSLbirUaDJi1S1Ql1jNIkNY1EidtXBvc3SZRoNJrHh9rLfM6fUzYQRYxjOEyyCYETcKpz6qGms3XwOIAoj0Aqm0iJZDVSpkxpkeJb/n1ZDeyWKNlOtjEN8xaJEo1G8/ggEKoemqsGnq7TRSCI8xhDPFgtq5vRweMO1JOrdcFcIvEs71ilSWp2S5SMszFFWdwiUaLRaB4P6rSVkIKiKtiMN+l7fdpum0EyYCPaeKjHp4PHbfBtn7bVbozrHcNBIkmLtFG3PE5MwyQvc3puj0IWpFVKXuaYhnnsz6XRaB5tDGEgpWxqG5N8woK/wDAZMkyHD1wI8Zbje6jP/ghT+2dIIZu0kWu65GXOVrx1X9JWu1ceAINkoFceGs1jSttpI6VsvDsAVQ8tIhzDeeBCiDejg8cBtOwWAqEkQ6Zewq7pIpFNHvK4qf0K6iuKMA9xDKeZctdoNI8PlazwbZ+FYKG5LyszHNPhXP/cQ6+F6uBxG3zbJ6/yZijHMix6Tg/btNmKj9/+9XbiiLdT4NRoNO8+ojzCwODp/o0p9I7TIbACsip76J8JOnjchrbdpmW3lHsgEBex8trIxpTy+FNJ9VTpQktdaWwmShxRIo99IFGj0TzatJ02rukyySdN6mrRX8QQBlEWPfRshP5EugMz3kyjbDnKRmSVcvKqfTeOk1ocsWsrPZs4j0nKhCiPGGfjY38+jUbz6NKyWwR2wDgbE1gBjungmR5pldL3+jpt9ajTclr80KkfAuCZ/jPKza9/jq7bPfbnqsURXdPFNd1GHDEpkkfar0Cj0dwfkiLhdOe0ckv05llsLbIULGEK86F/Jmhtqzsw789TyYr/6Pv/IwIjICrUZPn9+MPV4ohSSDq2kijR4ogazePLYmuRUpb8hff8BfIqZy6Yo2N3WGztZ7r6YNHB4za0HTWsN0gHjfnSxZ2LDNMh1yfX74ufgBZH1Gg0NWVVklUZH1z4IEutJdbCNZIyeSTa93XwuA0tu4UpTDzT42zvLB2ng2/5XBxevG/OXXvEEdMb4ojzqHbhuvNq9ypknI0fulSBRqM5fpIieaCfP3eDDh53YLG1yLycbz6sO06Hs72z9637abc44vXwupIoKJKms2KSTZqfO06HcTZmI9pQXWE6eGg07yoe9OfP3aCDxx3Y7wP5ftYeOk6HSTah5/bYSXcwhHGLOGKYh/zBpT/gqf5TjVyzDhwazbuPB/35czc8/PCl2UMjUeK0yaucMA8biZI6ZRXYAb/4+7/If/fKf8eV8RUMYTx0bX+NRvN4oYPHI0YtUVLPkUzySSNRshatERcxG9EGaZnSslqshWuUsnxkrkY0Gs3jwZGChxBiVgjxm0KIN6bf9zXXFUJ8TAjxHSHEeSHEp+60vRDio0KIbwgh/nD6/U/t2ua3p/v61vTr4fesHSM3S5SkRdpIlEgp2Yg2+Ob6NwFYai01Kr96iFCj0TxIjrry+BTwZSnlM8CXp7f3IIQwgV8CPg48D/y4EOL5O2y/CfzrUsrvBj4J/Lc37fYnpJQfnH6tH/EcHilqiZK5YA7YK1EihCApEl7ffh2ApWCJntsjyh++VIFGo3m8OGrw+ATw2enPnwV+dJ/HfBg4L6W8IKXMgM9NtztweynlN6WU16b3vwx4Qgj3iMf6juB2EiVhFhLlEWvRWqO75RiOrndoNJoHzlGDx5KU8jrA9Pt+KaSTwNu7bl+Z3nfY7f888E0pZbrrvn84TVn9ghDiwOk5IcRPCyFeFEK8uLHxcF23DkstUdJzegB7JEokkqzMGKQDTrRPEBcxWZnhWq6ueWg0mgfKHYOHEOK3hBAv7fP1iTttW+9in/sO5aQkhHgf8LeBf3vX3T8xTWf90PTrLx+0vZTyM1LKF6SULywsLBz0sEeKlt1CCIFjOTiG00iUSCHZjrdxbZfNeJPl1jJpmZKUCS1Lz3hoNJoHyx3nPKSUP3zQ74QQa0KIFSnldSHECrBf/eEKcHrX7VNAnZI6cHshxCngfwF+Ukr55q7juTr9PhZC/CNUWuxX73Qe7yQEAgNjj0RJlEWkRdoEjDlvjrRI6brdh+4optFoHj+Omrb6AqqgzfT7r+3zmK8DzwghzgkhHODHptsduL0Qog/8OvA3pJRfrXckhLCEEPPTn23gXwNeOuI5PHLUEiVtp91IlMRlTFzEXB5fBmA5WMa1XHzz4foYazSax5OjBo9PAx8VQrwBfHR6GyHECSHEFwGklAXwc8CXgFeBz0spX77d9tPHPw38wk0tuS7wJSHEt4FvAVeBv3/Ec3jk2C1REhURnuWRFik76Q4XhxcB1WnlGA5J9fA1bjQazePHkeRJpJRbwEf2uf8a8CO7bn8R+OJdbP+3gL91wNN+770e7zuFWqKk63S5OrmKaZhYhkVe5VwPr9OyWliGRSUrPMN72Ier0WgeQ/SE+SNILVFSCx/WtyWSrWSLhWCBUTpCIJjxZ3SnlUajeeDo4PEIYhomeZnTc3ukpZoeH6djek6P7WSbxWCRrMwQQuhOK41G81DQweMRpFl52GpFcX1ynUpWjLIRSZkw486QVVkjZaLRaDQPGh08HkFqcUTfUp1UURkxySdcHV8F4Gz3LC27hSEMwkzLkmg0mgeP9vN4BKlkhRACS6g/T5qnOJbTtOkuBUt03S5SKr0rjUajedDo4PEIYggDz/RYaKmp+O10myAPGOUjPNOj63RxDIe209a6VhqN5qGg01aPIJWssAyL0201mL8erRNXMeNszHJrmaRMtKaVRqN5qOjg8QhiCAPXdGnZLSxhEeYhJiaDdMBisKg1rTQazUNHB49HkFoccTPZpGW3GGdjTNMkLmJ6To+0SHEtV3daaTSah4YOHo8otURJx+kQlzGDZABAz+1pTSuNRvPQ0cHjEaXjdHBMh5bdYpgOWQ1XATjZPqk1rTQazUNHB49HlHpQMLAC4iJmI97ANmwcw0EitaaVRqN5qOjg8YhSS5R0nA5RHjHKRsy4M4RFqDWtNBrNQ0cHj0eUsiopZIFt2BSyYDvZZtabJSkSrWml0WgeOjp4PKJ03S7jdIxlqDnOrMrou33KqiQuYt1ppdFoHio6eDyiVLJS3uXyht37qc4pTMNECKE1rTQazUNFB49HFEMYIFVrbk3H6jDrzeJarta00mg0DxUdPB5RKlmBgK7TBcASFp7l4ZouM86M1rTSaDQPlSMFDyHErBDiN4UQb0y/zxzwuI8JIb4jhDgvhPjUnbYXQnx4l3f5Hwgh/uyubb5XCPGH0339HfEuvQQ3hMGsN8usOwvAvD9PWqUIBCc7J3WnlUajeagcdeXxKeDLUspngC9Pb+9BCGECvwR8HHge+HEhxPN32P4l4AUp5QeBjwH/tRCiVgD+ZeCngWemXx874jk8krTsFgLBYnsRQxgst5eZ9+bp+30EQndaaTSah8pRg8cngM9Of/4s8KP7PObDwHkp5QUpZQZ8brrdgdtLKSMpZTG93wMkgBBiBehKKb8mVSX5Vw94zncFtTT7v/HUv8GfOfNnWO4s4xquqodoNBrNQ+Son0JLUsrrANPvi/s85iTw9q7bV6b33XZ7IcQfFUK8DPwh8DPTYHJyuv1++7oFIcRPCyFeFEK8uLGxcdcn97CpTaH+4rN/kT999k+zHCwjhFD1EI1Go3mI3NEMSgjxW8DyPr/6m4d8jv1qEnKf+/Y+QMrfB94nhHgv8FkhxG/c7b6klJ8BPgPwwgsv3PE5HzXqusfZ3lk6TqexpdUrD41G87C5Y/CQUv7wQb8TQqwJIVaklNenKaX1fR52BTi96/Yp4Nr05ztuL6V8VQgRAt813depA/b1rmOxtci8nG+K4x2nw9neWR08NBrNQ+eon0JfAD45/fmTwK/t85ivA88IIc4JIRzgx6bbHbj99LHW9OczwHuAi9PU1lgI8X3TLqufPOA53xW07NYtXVUdp6OL5RqN5qFz1ODxaeCjQog3gI9ObyOEOCGE+CLAtFbxc8CXgFeBz0spX77d9sAPAn8ghPgW8L8A/46UcnP6u58FfgU4D7wJ/MYRz0Gj0Wg0d4nYLX/xbuaFF16QL7744sM+DI1Go3lHIYT4hpTyhZvv18lzjUaj0dw1OnhoNBqN5q7RwUOj0Wg0d81jU/MQQmwAlx72cdyGeWDzjo96Z6DP5dHj3XIeoM/lQXNGSrlw852PTfB41BFCvLhfUeqdiD6XR493y3mAPpdHBZ220mg0Gs1do4OHRqPRaO4aHTweHT7zsA/gGNHn8ujxbjkP0OfySKBrHhqNRqO5a/TKQ6PRaDR3jQ4eGo1Go7lrdPB4wBzk577P4z4khCiFEP/mgzy+u+Ew5yKE+BNTL/qXhRD//EEf42G403kIIXpCiP9VCPEH0/P4qw/jOA+DEOIfCCHWhRAvHfB7IYT4O9Nz/bYQ4nse9DEehkOcx09Mj//bQojfFUJ84EEf42G507nsetwj/57fg5RSfz2gL8BEKQE/CTjAHwDPH/C4/x34IvBvPuzjvtdzAfrAK8AT09uLD/u47/E8/h/A357+vABsA87DPvYDzuePAd8DvHTA738EpUQtgO8Dfv9hH/M9nscPADPTnz/+qJ7HYc5l+phH/j1/85deeTxYbufnvpt/F/if2d9c61HhMOfyl4B/LKW8DCClfBTP5zDnIYHO1EOmjQoexYM9zMMhpfwXqOM7iE8AvyoVvwf0p0ZsjxR3Og8p5e9KKQfTm7/HXpO4R4pD/E3gnfGe34MOHg+W2/m5AyCEOAn8WeDvPcDjuhfueC7As8CMEOK3hRDfEEL85AM7usNzmPP4u8B7Ua6Vfwj836V8xxrJH+Z832n8FO9gX5930Ht+D3e0odUcK4fxYP8vgP9QSlmqC91HlsOciwV8L/ARwAe+JoT4PSnl6/f74O6Cw5zHnwG+Bfwp4CngN4UQ/4eUcnSfj+1+cJjzfccghPiTqODxgw/7WI7Af8E74z2/Bx08Hiy383OveQH43PRFNA/8iBCikFL+kwdyhIfnMOdyBdiUUoZAKIT4F8AHgEcpeBzmPP4q8GmpktPnhRBvAc8B//LBHOKxcpjzfUcghHg/ylX041LKrYd9PEfgnfKe34NOWz1YbufnDoCU8pyU8qyU8izwP6EseP/JAz/SO3PHc0H5y/+QEMISQgTAH0VZET9KHOY8LqNWTwghloD3ABce6FEeH18AfnLadfV9wFBKef1hH9TdIoR4AvjHwF9+xFayd8076D2/B73yeIBIKQshRO3nbgL/QEr5shDiZ6a/f8fkPA9zLlLKV4UQ/wz4NlABvyKlvG274oPmkH+T/xfw3wgh/hCV9vkPpZSPpIy2EOJ/AP4EMC+EuAL8x4ANzbl8EdVxdR6IUKuqR45DnMd/BMwB/9X0ir2Qj6g67SHO5R2JlifRaDQazV2j01YajUajuWt08NBoNBrNXaODh0aj0WjuGh08NBqNRnPX6OCh0Wg070IOK8g4fewZIcSXp0KTvy2EuKPciw4eGo1G8+7kvwE+dsjH/r9RmmfvB/4T4D+90wY6eGg0Gs27kP0EGYUQTwkh/tlUa+7/EEI8N/3V88CXpz9/hf0FW/egg4dGo9E8PnwG+HellN8L/HXgv5re/wfAn5/+/GdRKtJzt9uRnjDXaDSaxwAhRBvlg/L/2yXA6E6//3Xg7woh/grwL4Cr3MF2QAcPjUajeTwwgB0p5Qdv/oWU8hrw56AJMn9eSjm80840Go1G8y5naiHwlhDiL0BjSfyB6c/zQog6HvwN4B/caX86eGg0Gs27kKkg49eA9wghrgghfgr4CeCnhBB/ALzMjcL4nwC+I4R4HVgCfvGO+9fCiBqNRqO5W/TKQ6PRaDR3jQ4eGo1Go7lrdPDQaDQazV2jg4dGo9Fo7hodPDQajUZz1+jgodFoNJq7RgcPjUaj0dw1/39CJHYJTz1MhAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data = my_lockin.measure_program()#(wait=False, fail_if_incomplete=False)\n", + "if data is not None:\n", + " for d in data:\n", + " plot_windows(d)\n", + "else:\n", + " print(\"RETURNED NONE\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06e609d5", + "metadata": {}, "outputs": [], "source": [ - "data = my_lockin.measure_program()\n", - "plot_windows(data)" + "%debug" ] }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 84, + "id": "81b98b2a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'auxins/0/sample.auxin0.avg', 'demods/0/sample.r', 'demods/0/sample.x'}" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin._get_channels_for_window(program_name='test', window_name=None)" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "5b72a01b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[autoreload of qupulse.hardware.dacs.mfli failed: Traceback (most recent call last):\n", + " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\site-packages\\IPython\\extensions\\autoreload.py\", line 245, in check\n", + " superreload(m, reload, self.old_objects)\n", + " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\site-packages\\IPython\\extensions\\autoreload.py\", line 394, in superreload\n", + " module = reload(module)\n", + " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\imp.py\", line 314, in reload\n", + " return importlib.reload(module)\n", + " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\importlib\\__init__.py\", line 169, in reload\n", + " _bootstrap._exec(spec, module)\n", + " File \"\", line 630, in _exec\n", + " File \"\", line 724, in exec_module\n", + " File \"\", line 860, in get_code\n", + " File \"\", line 791, in source_to_code\n", + " File \"\", line 219, in _call_with_frames_removed\n", + " File \"z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\", line 660\n", + " for k, v in recorded_data.items()\n", + " ^\n", + "SyntaxError: invalid syntax\n", + "]\n" + ] + }, + { + "data": { + "text/plain": [ + "{'X': {'/dev3442/demods/0/sample.x': [\n", + " array([[ 2.69279111e-07, 3.76000218e-07, 4.24689409e-07, ...,\n", + " -9.44849792e-08, -5.75667221e-08, -2.49266848e-08],\n", + " [ 6.31987250e-07, 4.11887636e-07, 2.38855616e-07, ...,\n", + " 2.93972004e-07, 3.04276206e-07, 4.01271313e-07],\n", + " [ 2.96471967e-07, 2.15771765e-07, 6.63772839e-08, ...,\n", + " 4.10635562e-07, 3.79404258e-07, 2.66680489e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1e+09 1.001e+09 1.002e+09 ... 1.299e+09 1.3e+09\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664873312419283]\n", + " createdtimestamp: [308605257163]\n", + " changedtimestamp: [309086050763]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 10:48:32.4190\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [2512]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]},\n", + " 'R': {'/dev3442/demods/0/sample.r': [\n", + " array([[3.50875860e-07, 2.70602397e-07, 3.22289289e-07, 3.21639020e-07,\n", + " 3.32765766e-07, 3.65126975e-07, 3.12966538e-07, 1.64027162e-07,\n", + " 2.45165536e-07, 4.19091366e-07, 4.14326504e-07, 3.29614134e-07,\n", + " 3.98556089e-07, 6.03632644e-07, 6.03304127e-07, 5.94617891e-07,\n", + " 5.10234580e-07, 3.35210733e-07, 2.30888648e-07, 2.51064516e-07,\n", + " 2.76974768e-07, 1.91823303e-07, 1.49521913e-07, 1.75328687e-07,\n", + " 2.78571123e-07, 2.10951086e-07, 2.16255281e-07, 3.16839491e-07,\n", + " 2.76141363e-07, 2.81573604e-07, 1.37238391e-07, 2.12871898e-07,\n", + " 3.62986060e-07, 4.29124663e-07, 3.16040404e-07, 2.67266655e-07,\n", + " 3.65657304e-07, 4.48666830e-07, 5.83573620e-07, 6.42626010e-07,\n", + " 6.11464599e-07, 5.49052360e-07, 5.86160132e-07, 5.82156228e-07,\n", + " 6.03255004e-07, 7.89091970e-07, 7.84022056e-07, 6.62303305e-07,\n", + " 5.03959286e-07, 4.49465035e-07, 4.43046704e-07, 5.90456587e-07,\n", + " 6.21792060e-07, 5.72738852e-07, 5.41391892e-07, 6.26158439e-07,\n", + " 4.59861745e-07, 2.12973843e-07, 2.37172460e-07, 3.72531488e-07,\n", + " 4.36279699e-07, 4.85907475e-07, 4.92556374e-07, 4.65265233e-07,\n", + " 3.19733747e-07, 3.04607663e-07, 2.94144267e-07, 2.45885864e-07,\n", + " 3.16028078e-08, 1.85243058e-07, 2.02642415e-07, 1.80417555e-07,\n", + " 3.17077909e-07, 5.14676889e-07, 6.35520404e-07, 6.37312376e-07,\n", + " 7.26135275e-07, 7.20081269e-07, 6.00586796e-07, 4.64989563e-07,\n", + " ...\n", + " 4.50349728e-07, 4.64176142e-07, 4.07156112e-07, 3.00673748e-07,\n", + " 3.72114091e-07, 3.60206239e-07, 3.14711484e-07, 3.11498318e-07,\n", + " 3.19263711e-07, 4.13087658e-07, 5.53255690e-07, 6.62389429e-07,\n", + " 5.97159565e-07, 3.48292585e-07, 4.04279527e-07, 5.47591484e-07,\n", + " 5.15210639e-07, 3.36606101e-07, 3.26182141e-07, 3.48923075e-07,\n", + " 2.78243634e-07, 2.82163333e-07, 5.26134267e-07, 7.70090420e-07,\n", + " 7.76728207e-07, 5.89799838e-07, 3.04388253e-07, 2.47766692e-07,\n", + " 1.58789395e-07, 3.03364830e-08, 1.49812292e-07, 2.22399343e-07,\n", + " 3.88711488e-07, 3.20814441e-07, 2.11552399e-07, 4.36760799e-07,\n", + " 5.85246465e-07, 5.98170037e-07, 5.50512150e-07, 3.43713482e-07,\n", + " 1.71207817e-07, 8.49430082e-08, 3.30555288e-07, 3.34163350e-07,\n", + " 3.26281110e-07, 4.09983188e-07, 4.57014174e-07, 4.68563630e-07,\n", + " 3.69464867e-07, 5.94835249e-07, 7.14685065e-07, 6.94255244e-07,\n", + " 7.13042485e-07, 4.59999172e-07, 2.51558505e-07, 2.28146965e-07,\n", + " 3.82364839e-07, 5.39785539e-07, 5.77188043e-07, 4.28624053e-07,\n", + " 2.29961114e-07, 2.83972207e-07, 3.65491624e-07, 3.50174319e-07,\n", + " 2.72091187e-07, 3.20505843e-07, 4.70595140e-07, 5.27882868e-07,\n", + " 4.16385393e-07, 1.06342650e-07, 1.75540360e-07, 3.57477226e-07,\n", + " 5.66663118e-07, 6.23191013e-07, 4.74268790e-07, 5.57135024e-07,\n", + " 6.78589995e-07, 6.83960121e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 6.503e+08 6.509e+08 ... 7.889e+08 7.895e+08\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664873312419223]\n", + " createdtimestamp: [308605257163]\n", + " changedtimestamp: [309086050763]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 10:48:32.4190\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [2512]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[1.83064221e-07, 1.61855467e-07, 2.49241466e-07, 3.39376135e-07,\n", + " 4.36536798e-07, 5.18693392e-07, 6.30735429e-07, 5.74835074e-07,\n", + " 4.36776420e-07, 2.63859894e-07, 1.30624147e-07, 9.70415274e-08,\n", + " 1.44476414e-07, 3.81813606e-07, 6.38447230e-07, 7.45571057e-07,\n", + " 8.22906422e-07, 9.18075754e-07, 8.43259013e-07, 7.61613607e-07,\n", + " 7.57270048e-07, 6.88958757e-07, 4.83349759e-07, 3.55754578e-07,\n", + " 3.63642255e-07, 4.22655755e-07, 3.87072095e-07, 3.70289162e-07,\n", + " 3.62161548e-07, 2.70584201e-07, 2.87656239e-07, 3.19854380e-07,\n", + " 2.08389908e-07, 1.96618982e-08, 3.33132395e-07, 4.70787632e-07,\n", + " 5.12829988e-07, 6.21235123e-07, 6.78234168e-07, 8.17913035e-07,\n", + " 8.18258618e-07, 7.54368146e-07, 7.46640882e-07, 5.50770744e-07,\n", + " 5.12319511e-07, 6.08510609e-07, 6.62309838e-07, 6.44205313e-07,\n", + " 5.95868712e-07, 6.51155602e-07, 6.31010157e-07, 7.74893720e-07,\n", + " 7.73539311e-07, 7.74910192e-07, 8.02652723e-07, 8.23684689e-07,\n", + " 8.68193990e-07, 8.62732478e-07, 8.01325476e-07, 6.25764502e-07,\n", + " 5.04780975e-07, 5.93346931e-07, 6.10683738e-07, 4.86562387e-07,\n", + " 3.12983135e-07, 3.68123599e-07, 5.59757155e-07, 7.12527556e-07,\n", + " 8.47038984e-07, 9.42978974e-07, 8.63359915e-07, 6.06673635e-07,\n", + " 4.27951356e-07, 3.59254470e-07, 2.99652089e-07, 1.79138376e-07,\n", + " 2.32503549e-07, 2.27449770e-07, 2.62303298e-07, 3.27436843e-07,\n", + " ...\n", + " 1.34507520e-07, 1.02082212e-07, 1.12642947e-07, 2.57615087e-07,\n", + " 2.52001240e-07, 8.39497095e-08, 7.44285860e-08, 3.41073852e-07,\n", + " 5.83489122e-07, 6.96472052e-07, 6.53976255e-07, 5.88986968e-07,\n", + " 4.49598566e-07, 2.98920279e-07, 2.12782307e-07, 2.95983869e-07,\n", + " 4.05101586e-07, 3.98188629e-07, 4.47104691e-07, 5.23768048e-07,\n", + " 3.36085570e-07, 9.03901955e-08, 3.48991273e-07, 5.33593138e-07,\n", + " 5.62695854e-07, 4.58134554e-07, 3.08202787e-07, 2.11030979e-07,\n", + " 2.51420702e-07, 1.01853724e-07, 2.07736971e-07, 4.68642977e-07,\n", + " 7.63032151e-07, 7.22946677e-07, 4.32578803e-07, 3.27013842e-07,\n", + " 3.40702093e-07, 4.66298330e-07, 7.43736291e-07, 8.69379562e-07,\n", + " 8.87377110e-07, 7.33472718e-07, 5.23308094e-07, 4.26309170e-07,\n", + " 4.31965940e-07, 2.58649504e-07, 1.33946849e-07, 4.47104352e-07,\n", + " 6.18007476e-07, 5.56577597e-07, 5.28093625e-07, 4.13845425e-07,\n", + " 3.33008003e-07, 2.89431379e-07, 1.47540020e-07, 1.70592255e-07,\n", + " 3.10416178e-07, 5.25815591e-07, 5.15154408e-07, 2.60636244e-07,\n", + " 7.17283923e-08, 9.54203553e-08, 2.61190363e-07, 2.57871195e-07,\n", + " 7.60343295e-08, 3.05941060e-07, 4.40774851e-07, 3.01379243e-07,\n", + " 2.00560156e-07, 2.19666114e-07, 2.69370619e-07, 2.87369645e-07,\n", + " 2.86037423e-07, 3.27678416e-07, 2.66341497e-07, 1.00779122e-07,\n", + " 1.75057650e-07, 2.29900763e-07, 2.45636684e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.401e+09 1.401e+09 ... 1.499e+09 1.5e+09\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664873312419223]\n", + " createdtimestamp: [308605257163]\n", + " changedtimestamp: [309086050763]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 10:48:32.4190\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [2512]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]},\n", + " 'A': {'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[-1.60287965e-03, -1.63122416e-03, -1.65956868e-03,\n", + " -1.68791319e-03, -1.71625770e-03, -1.74460221e-03,\n", + " -1.77294673e-03, -1.80129124e-03, -1.82963575e-03,\n", + " -1.85798026e-03, -1.88632478e-03, -1.91466929e-03,\n", + " -1.94301380e-03, -1.97135831e-03, -1.99970283e-03,\n", + " -2.02804734e-03, -2.05639185e-03, -2.08473636e-03,\n", + " -2.11308088e-03, -2.14142539e-03, -2.16976990e-03,\n", + " -2.19811441e-03, -2.22645893e-03, -2.25480344e-03,\n", + " -2.28314795e-03, -2.31149246e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", + " ...\n", + " -1.21943914e-03, -1.20243243e-03, -1.18542572e-03,\n", + " -1.16841901e-03, -1.15141231e-03, -1.13440560e-03,\n", + " -1.11739889e-03, -1.10039218e-03, -1.08338548e-03,\n", + " -1.06637877e-03, -1.04937206e-03, -1.03236535e-03,\n", + " -1.01535865e-03, -9.98351938e-04, -9.81345231e-04,\n", + " -9.64338523e-04, -9.47331816e-04, -9.30325108e-04,\n", + " -9.13318401e-04, -8.96311693e-04, -8.79304986e-04,\n", + " -8.62298278e-04, -8.45291571e-04, -8.28284863e-04,\n", + " -8.11278156e-04, -7.94271448e-04, -7.77264741e-04,\n", + " -7.60258033e-04, -7.43251326e-04, -7.26244618e-04,\n", + " -7.09237911e-04, -6.92231203e-04, -6.75224496e-04,\n", + " -6.58217788e-04, -6.41211081e-04, -6.24204373e-04,\n", + " -6.07197666e-04, -5.90190958e-04, -5.73184251e-04,\n", + " -5.56177543e-04, -5.39170836e-04, -5.22164128e-04,\n", + " -5.05157420e-04, -4.88150713e-04, -4.71144005e-04,\n", + " -4.54137298e-04, -4.37130590e-04, -4.20123883e-04,\n", + " -4.03117175e-04, -3.86110468e-04, -3.69103760e-04,\n", + " -3.52097053e-04, -3.35090345e-04, -3.27169066e-04,\n", + " -3.21500164e-04, -3.15831261e-04, -3.10162359e-04,\n", + " -3.04493456e-04, -2.98824554e-04]])\n", + " Coordinates:\n", + " time (row, col) float64 3.003e+08 3.009e+08 ... 4.49e+08 4.496e+08\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664873312419159]\n", + " createdtimestamp: [308605257163]\n", + " changedtimestamp: [309086050763]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 10:48:32.4190\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [2512]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[-0.0018963 , -0.00187362, -0.00185095, ..., -0.0027846 ,\n", + " -0.00280727, -0.00282995],\n", + " [-0.00225985, -0.0023052 , -0.00231484, ..., nan,\n", + " nan, nan],\n", + " [-0.00135823, -0.00132989, -0.00130154, ..., -0.00036784,\n", + " -0.00037351, -0.00037918]])\n", + " Coordinates:\n", + " time (row, col) float64 1.2e+09 1.201e+09 ... 1.499e+09 1.5e+09\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664873312419159]\n", + " createdtimestamp: [308605257163]\n", + " changedtimestamp: [309086050763]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 10:48:32.4190\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [2512]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00059733]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}}" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 47, "id": "e36fb677", "metadata": {}, "outputs": [ @@ -763,13 +1196,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(597)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 595 \u001b[1;33m \u001b[0mstart_waiting\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 596 \u001b[1;33m \u001b[1;32mwhile\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfinished\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mwait\u001b[0m \u001b[1;32mand\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtime\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mstart_waiting\u001b[0m\u001b[1;33m>\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 597 \u001b[1;33m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 598 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Waiting for device {self.serial} to finish the acquisition...\"\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# Progress: {self.daq.progress()[0]}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 599 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "> \u001b[1;32m<__array_function__ internals>\u001b[0m(6)\u001b[0;36mconcatenate\u001b[1;34m()\u001b[0m\n", + "\n", + "ipdb> u\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(707)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 705 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 706 \u001b[1;33m \u001b[0mcreation_ts\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mattrs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"createdtimestamp\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0me\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mv\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread_memory\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 707 \u001b[1;33m \u001b[0mall_ts\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0munique\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcreation_ts\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 708 \u001b[1;33m \u001b[1;32massert\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mall_ts\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 709 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[0m\n", + "ipdb> creation_ts\n", + "{}\n", "ipdb> r\n" ] } diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index d7c26a93b..f82910c64 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -40,13 +40,13 @@ [X] extract window things [X] rethink handling different sample rates! [X] cut obtained data to fit into requested windows -[ ] provide interface for changing trigger settings +[X] provide interface for changing trigger settings [X] print information about how long the measurement is expected to run -[ ] implement multiple triggers (using rows) (and check how this actually behaves) +[X] implement multiple triggers (using rows) (and check how this actually behaves) [X] count - [ ] endless - [ ] check how that would behave. Does that overwrite or shift things? - [ ] change in trigger input port + [X] endless + [X] check how that would behave. Does that overwrite or shift things? + [X] change in trigger input port [X] implement setting recording channel (could that be already something inside qupulse?) [ ] see why for high sample rates (e.g. 857.1k) things crash or don't behave as expected [ ] Implement yield for not picked up data (read() was not called) @@ -141,6 +141,7 @@ def __init__(self, device_serial: str = None, self.assumed_minimal_sample_rate = None self.daq_read_return = {} + self.read_memory={} # self.read_memory[]:List[xr.DataArray] if reset: # Create a base configuration: Disable all available outputs, awgs, demods, scopes,... @@ -153,15 +154,20 @@ def _init_daq_module(self): self.daq = self.api_session.dataAcquisitionModule() self.daq.set('device', self.serial) - def reset_device(self): + def reset(self): """ This function resets the device to a known default configuration. """ + self.read_memory = {} + zhinst.utils.disable_everything(self.api_session, self.serial) self.clear() + self.reset_daq_module() + + def reset_daq_module(): + self.daq.finish() self.daq.close() self._init_daq_module() - def register_measurement_channel(self, program_name:str=None, channel_path:Union[str, List[str]]=[], window_name:str=None): """ This function saves the channel one wants to record with a certain program @@ -199,7 +205,7 @@ def register_measurement_windows(self, program_name: str, windows: Dict[str, Tup # for k, v in windows.items(): # self.set_measurement_mask(program_name=program_name, mask_name=k, begins=v[0], lengths=v[1]) - def register_trigger_settings(self, program_name:str, trigger_input:Union[str, None]=None, edge:str='rising', number_of_triggers_to_buffer:int=1, level:float=0.1, delay:float=-1e-3, post_delay:float=1e-3, other_settings:Dict[str, Union[str, int, float]]={}): + def register_trigger_settings(self, program_name:str, trigger_input:Union[str, None]=None, edge:str='rising', number_of_triggers_to_buffer:int=1, level:float=0.1, delay:float=-1e-3, post_delay:float=1e-3, count:bool=np.inf, other_settings:Dict[str, Union[str, int, float]]={}): """ Parameters ---------- @@ -221,6 +227,8 @@ def register_trigger_settings(self, program_name:str, trigger_input:Union[str, N "level": level, "delay": delay, "post_delay": post_delay, + "endless": count==np.inf, + "count": 0 if count==np.inf else count, "other_settings": other_settings, } @@ -335,7 +343,7 @@ def _get_channels_for_window(self, program_name, window_name=None): """ Returns the channels to be measured for a given window """ if window_name is None: - window_name = list(self.programs[program_name].keys()) + window_name = list(self.programs[program_name]["windows"].keys()) if not isinstance(window_name, list): window_name = [window_name] @@ -371,6 +379,14 @@ def arm_program(self, program_name: str, force:bool=True) -> None: self.daq.finish() self.daq.unsubscribe('*') + # TODO TODO TODO TODO TODO TODO TODO TODO + # # if the program is changed, the not returned data is removed to not have conflicts with the data parsing operations. The cleaner way would be to keep track of the time the program is changed. + # if self.currently_set_program != program_name: + # self.read() + # self.daq.close() + # self._init_daq_module() + # TODO TODO TODO TODO TODO TODO TODO TODO + for c in self.programs[program_name]["all_channels"]: # activate corresponding demodulators @@ -444,22 +460,21 @@ def arm_program(self, program_name: str, force:bool=True) -> None: # selecting the trigger channel if ts["trigger_input"] is not None: - self.daq.set('endless', 1) - self.daq.set('count', rows) # defines how many triggers are to be recorded in single mode i.e. endless==0 + if ts["endless"]: + self.daq.set('endless', 1) + else: + self.daq.set('endless', 0) + self.daq.set('count', ts["count"]) # defines how many triggers are to be recorded in single mode i.e. endless==0 if "trig" in ts["trigger_input"].lower(): - print(f"SETTING TRIGMODE 6") self.daq.set("type", 6) else: - print(f"SETTING TRIGMODE 1") self.daq.set("type", 1) self.daq.set("triggernode", ts["trigger_input"]) self.daq.subscribe(ts["trigger_input"]) - print(f"SETTING TRIGGERNODE: {('triggernode', ts['trigger_input'])}") edge_key = ["rising", "falling", "both"].index(ts["edge"]) - print(f"using trigger edge: {edge_key}") self.daq.set("edge", edge_key) self.daq.set("level", ts["level"]) @@ -536,6 +551,7 @@ def clear(self) -> None: """Clears all registered programs.""" self.unarm_program(program_name=None) + self.read_memory = {} def _parse_data(self, recorded_data, program_name:str): """ This function parses the recorded data and extracts the measurement masks and applies optional operations @@ -655,9 +671,91 @@ def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout: if len(recorded_data) == 0: warnings.warn(f"No data has been recorded!") + # update measurements in local memory + for k, v in recorded_data.items(): + self.read_memory.setdefault(k, []) + # for all the measurement that we just read of the device: + for m in v: + # get the time stamp of when the measurement was created + crts = m.attrs["createdtimestamp"][0] + + # now look, if that measurement is measurement is already in the memory + for i, e in enumerate(self.read_memory[k]): + if e.attrs["createdtimestamp"][0] == crts: + # then we can overwrite that. + # TODO don't overwrite that. Only replace nan values + self.read_memory[k][i] = m + break + else: + # if we did not find that element in the list, we append it. + self.read_memory[k].append(m) + + # sort the element by their createdtimestamp + order = np.argsort([e.attrs["createdtimestamp"][0] for e in self.read_memory[k]]) + self.read_memory[k] = [self.read_memory[k][o] for o in order] + # CAUTION this only sorts the ones that have been updated. This might not be intended!!! + + if return_raw: return recorded_data - else: - if len(recorded_data) == 0: + + # now we package everything in self.read_memory, such that the elements with one creation time stamp are processed at once. + # If for every self._get_channels_for_window(self.currently_set_program, None) some measurement is present: try parsing the data. If that was successful: remove these elements from the read_memeory and return (or yield) the results. + + # TODO this might lead to leaving some measurements in the memory that will never be used, if they don't get related with measurements from the other channels of the program. + + creation_ts = {k:[e.attrs["createdtimestamp"][0] for e in v] for k, v in self.read_memory.items()} + if len(creation_ts)==0: + # Then we have nothing to process + return None + all_ts = np.unique(np.concatenate(list(creation_ts.values()))) + assert len(all_ts.shape) == 1 + if len(all_ts)==0: + # Then we have nothing to process + return None + + channels_to_measure = self._get_channels_for_window(self.currently_set_program, None) + channels_to_measure = [f"/{self.serial}/{c}" for c in channels_to_measure] + + things_to_remove = {} + + results = [] + + for ts in all_ts: + contained = [k for k, v in creation_ts.items() if ts in v] + if all([(c in contained) for c in channels_to_measure]): + # then we have all measurement for that shot + that_shot = {} + _indexs = [creation_ts[c].index(ts) for c in channels_to_measure] + + for c, i in zip(channels_to_measure, _indexs): + that_shot[c] = [self.read_memory[c][i]] # Here the inner list could be removed if one would remove the old functionality from the _parse_data function. + + try: + that_shot_parsed = self._parse_data(that_shot, self.currently_set_program) + # except KeyError: + # print(f"Error") + # warnings.warn(f"Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory, resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter.") + except: + raise + else: + # the parsing worked, we can now remove the data from the memory + results.append(that_shot_parsed) + for c, i in zip(channels_to_measure, _indexs): + things_to_remove.setdefault(c, []).append(i) + + else: + pass + # TODO do something here. Maybe raise a warning. + + # then we can remove the element that worked: + for k, v in things_to_remove.items(): + v.sort() + assert (len(v)==0) or (v[0] <= v[-1]) + for i in reversed(v): + self.read_memory[k].pop(i) + + if not return_raw: + if len(results) == 0: return None - return self._parse_data(recorded_data, self.currently_set_program) \ No newline at end of file + return results \ No newline at end of file From 4a8fff37e23812f37db50015d2543d8d4c80f6bf Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Tue, 4 Oct 2022 15:10:44 +0200 Subject: [PATCH 13/25] small improvements --- ...struments_lockin_mfli_daq-checkpoint.ipynb | 2427 ++++++++++++++++- .../zurich_instruments_lockin_mfli_daq.ipynb | 2427 ++++++++++++++++- qupulse/hardware/dacs/mfli.py | 55 +- 3 files changed, 4721 insertions(+), 188 deletions(-) diff --git a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb index 415c31b6b..20760fd2c 100644 --- a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb +++ b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb @@ -359,7 +359,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'A', 'R', 'T'}\n", + "{'T', 'R', 'A'}\n", "[]\n", "set()\n" ] @@ -400,7 +400,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -458,7 +458,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -567,12 +567,12 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 67, "id": "6abf0e7f", "metadata": {}, "outputs": [], "source": [ - "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e8})" + "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e6})" ] }, { @@ -593,8 +593,8 @@ }, { "cell_type": "code", - "execution_count": 39, - "id": "2d7cafab", + "execution_count": 38, + "id": "024f4c66", "metadata": {}, "outputs": [], "source": [ @@ -603,7 +603,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 68, "id": "d0c8669f", "metadata": {}, "outputs": [], @@ -611,25 +611,25 @@ "my_lockin.register_trigger_settings(program_name=\"test\",\n", " trigger_input=f\"demods/0/sample.AuxIn1\", # here AuxInN referese to the printer label N+1\n", " edge=\"rising\",\n", - " number_of_triggers_to_buffer=3,\n", - " level=.5,\n", - " count=np.inf,\n", - " other_settings={\"holdoff/time\": 1e-8} #\n", + " trigger_count=3, # this defines the number of triggers to capture in one element (i.e. rows)\n", + " level=.5, # this sets the trigger level\n", + " count=np.inf, # this defined the number of rounds that are to be measured (e.g. how often the \"single\" button should be pressed)\n", + " other_settings={\"holdoff/time\": 1e-3} # this sets the duration for which new triggers are ignored\n", " )\n", "\n", "my_lockin.register_trigger_settings(program_name=\"test\",\n", " trigger_input=f\"demods/0/sample.TrigIn1\", # here TrigInN referese to the printer label N\n", " edge=\"rising\",\n", - " number_of_triggers_to_buffer=3,\n", + " trigger_count=3,\n", " level=.5,\n", " count=3,\n", - " other_settings={\"holdoff/time\": 1e-8}\n", + " other_settings={\"holdoff/time\": 1e-3}\n", " )" ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 69, "id": "f069c321", "metadata": { "scrolled": true @@ -642,56 +642,8 @@ }, { "cell_type": "code", - "execution_count": 42, - "id": "11e558f5", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{None: {'channel_mapping': {'R': {'demods/0/sample.R'},\n", - " 'X': {'demods/0/sample.X'},\n", - " 'Y': {'demods/0/sample.Y'},\n", - " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", - " 'many': {'auxins/0/sample.AuxIn0.avg',\n", - " 'demods/0/sample.R',\n", - " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y'}}},\n", - " 'test': {'trigger_settings': {'trigger_input': '/dev3442/demods/0/sample.TrigIn1',\n", - " 'edge': 'rising',\n", - " 'number_of_triggers_to_buffer': 3,\n", - " 'level': 0.5,\n", - " 'delay': -0.001,\n", - " 'post_delay': 0.001,\n", - " 'endless': False,\n", - " 'count': 3,\n", - " 'other_settings': {'holdoff/time': 1e-08}},\n", - " 'windows': {'X': (array([1.e+09]), array([3.e+08])),\n", - " 'R': (array([6.5e+08, 1.4e+09]), array([1.4e+08, 1.0e+08])),\n", - " 'A': (array([3.0e+08, 1.2e+09]), array([1.5e+08, 3.0e+08]))},\n", - " 'windows_from_start_max': {'X': 1300000000.0,\n", - " 'R': 1500000000.0,\n", - " 'A': 1500000000.0},\n", - " 'all_channels': {'auxins/0/sample.auxin0.avg',\n", - " 'demods/0/sample.r',\n", - " 'demods/0/sample.x'}}}" - ] - }, - "execution_count": 42, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.programs" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "8a82b2a0", + "execution_count": 89, + "id": "2258a41c", "metadata": {}, "outputs": [], "source": [ @@ -700,7 +652,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 88, "id": "cf3ce29e", "metadata": {}, "outputs": [ @@ -716,11 +668,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "sample rates: [None, 1674.107177734375, 1674.107177734375]\n", - "Will record 2512 per row samples for 1.500000000001s!\n", + "sample rates: [107142.859375, 107142.859375, None]\n", + "Will record 1608 per row samples for 0.015000000001000002s!\n", "3 row(s) will be recorded.\n", - "the following trigger settings will be used: {'trigger_input': '/dev3442/demods/0/sample.TrigIn1', 'edge': 'rising', 'number_of_triggers_to_buffer': 3, 'level': 0.5, 'delay': -0.001, 'post_delay': 0.001, 'endless': False, 'count': 3, 'other_settings': {'holdoff/time': 1e-08}}\n", - "MFLI returns a total record time of 1.5005013333333335s\n" + "the following trigger settings will be used: {'trigger_input': '/dev3442/demods/0/sample.TrigIn1', 'edge': 'rising', 'trigger_count': 3, 'level': 0.5, 'delay': -0.001, 'post_delay': 0.001, 'endless': False, 'count': 3, 'other_settings': {'holdoff/time': 1e-08}}\n", + "MFLI returns a total record time of 0.003752s\n" ] } ], @@ -730,7 +682,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 79, "id": "1505ae0a", "metadata": {}, "outputs": [], @@ -742,12 +694,12 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 98, "id": "8504fda1", "metadata": {}, "outputs": [], "source": [ - "for _ in range(3):\n", + "for _ in range(3*3):\n", " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 1)\n", " time.sleep(1)\n", " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 0)\n", @@ -756,7 +708,7 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 85, "id": "8ab20ee5", "metadata": {}, "outputs": [], @@ -766,22 +718,25 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 99, "id": "8d97dfac", "metadata": { "scrolled": true }, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Waiting for device dev3442 to finish the acquisition...\n" + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:740: UserWarning: Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter.\n", + " pass\n", + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:740: UserWarning: Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter.\n", + " pass\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -790,10 +745,38 @@ "needs_background": "light" }, "output_type": "display_data" + } + ], + "source": [ + "data = my_lockin.measure_program(return_raw=False)#(wait=False, fail_if_incomplete=False)\n", + "if data is not None:\n", + " for d in data:\n", + " plot_windows(d)\n", + "else:\n", + " print(\"RETURNED NONE\")" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "69277b3e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:684: UserWarning: No data has been recorded!\n", + " warnings.warn(f\"No data has been recorded!\")\n", + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:596: UserWarning: The received data for channel auxins/0/sample.auxin0.avg is empty.\n", + " warnings.warn(f\"The received data for channel {_cn} is empty.\")\n", + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:596: UserWarning: The received data for channel auxins/0/sample.auxin0.avg is empty.\n", + " warnings.warn(f\"The received data for channel {_cn} is empty.\")\n" + ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -805,7 +788,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -817,7 +800,7 @@ } ], "source": [ - "data = my_lockin.measure_program()#(wait=False, fail_if_incomplete=False)\n", + "data = my_lockin.measure_program(return_raw=False)#(wait=False, fail_if_incomplete=False)\n", "if data is not None:\n", " for d in data:\n", " plot_windows(d)\n", @@ -827,10 +810,2284 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "06e609d5", + "execution_count": 108, + "id": "3efa4e68", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664887609699785]\n", + " createdtimestamp: [1166080844523]\n", + " changedtimestamp: [1167529609323]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 14:46:49.6996\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1608]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664887657586630]\n", + " createdtimestamp: [1168331979003]\n", + " changedtimestamp: [1180144016443]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 005 14:47:37.5862\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1608]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.r': [\n", + " array([[1.38888485e-07, 1.43719805e-07, 1.48582047e-07, ...,\n", + " 4.34784579e-07, 4.33234794e-07, 4.31670555e-07],\n", + " [4.04857345e-07, 4.03119455e-07, 4.01376717e-07, ...,\n", + " 4.97918708e-07, 5.00165983e-07, 5.02359520e-07],\n", + " [4.41924624e-07, 4.39022641e-07, 4.36096277e-07, ...,\n", + " 7.97933342e-07, 7.96385363e-07, 7.94804775e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.943e+13 1.943e+13 ... 1.946e+13 1.946e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664887609699917]\n", + " createdtimestamp: [1166080844523]\n", + " changedtimestamp: [1167529609323]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 14:46:49.6996\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1608]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[3.63043354e-07, 3.63724650e-07, 3.64442278e-07, ...,\n", + " 1.84079775e-07, 1.83911762e-07, 1.83743967e-07],\n", + " [3.83388020e-07, 3.82172869e-07, 3.80939033e-07, ...,\n", + " 4.64023112e-07, 4.63896600e-07, 4.63726540e-07],\n", + " [6.12628005e-07, 6.12437061e-07, 6.12181524e-07, ...,\n", + " 5.86469886e-07, 5.87969943e-07, 5.89465841e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.947e+13 1.947e+13 ... 1.967e+13 1.967e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664887657586707]\n", + " createdtimestamp: [1168331979003]\n", + " changedtimestamp: [1180144016443]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 005 14:47:37.5862\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1608]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.x': [\n", + " array([[-1.32408364e-07, -1.37151777e-07, -1.41934653e-07, ...,\n", + " -3.26519959e-08, -3.30352718e-08, -3.34245270e-08],\n", + " [ 4.01130200e-07, 3.99142667e-07, 3.97138989e-07, ...,\n", + " -4.93793274e-07, -4.95846580e-07, -4.97835310e-07],\n", + " [ 2.59233217e-07, 2.56886923e-07, 2.54549598e-07, ...,\n", + " -7.81379937e-07, -7.80011266e-07, -7.78618677e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.943e+13 1.943e+13 ... 1.946e+13 1.946e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664887609699837]\n", + " createdtimestamp: [1166080844523]\n", + " changedtimestamp: [1167529609323]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 14:46:49.6996\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1608]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[ 1.51871723e-07, 1.49524831e-07, 1.47228763e-07, ...,\n", + " 9.08997651e-08, 9.05643240e-08, 9.01774605e-08],\n", + " [-2.19322299e-07, -2.20265839e-07, -2.21161545e-07, ...,\n", + " -3.30884282e-07, -3.29631609e-07, -3.28349638e-07],\n", + " [-5.72672766e-07, -5.73008805e-07, -5.73258741e-07, ...,\n", + " 5.86422265e-07, 5.87938626e-07, 5.89447214e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.947e+13 1.947e+13 ... 1.967e+13 1.967e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664887657586670]\n", + " createdtimestamp: [1168331979003]\n", + " changedtimestamp: [1180144016443]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 005 14:47:37.5862\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1608]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.read_memory" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "2519f212", "metadata": {}, "outputs": [], + "source": [ + "data_r1 = my_lockin.measure_program(return_raw=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "119c96e7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_r1" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "id": "0d7e0eb6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:674: UserWarning: No data has been recorded!\n", + " warnings.warn(f\"No data has been recorded!\")\n" + ] + } + ], + "source": [ + "data_r2 = my_lockin.measure_program(return_raw=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "id": "d93364e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_r2" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "75068d8d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[-0.0005597 , -0.000469 , -0.0003783 , ..., -0.00186879,\n", + " -0.00185745, -0.00184611],\n", + " [-0.00098405, -0.00088201, -0.00077997, ..., -0.0012212 ,\n", + " -0.00115317, -0.00108514],\n", + " [-0.00097637, -0.00101038, -0.0010444 , ..., -0.00090118,\n", + " -0.0008785 , -0.00085583]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886364795117]\n", + " createdtimestamp: [1091745849803]\n", + " changedtimestamp: [1091986551243]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 024 14:26:04.7949\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[-8.42900002e-04, -8.65575612e-04, -8.88251222e-04, ...,\n", + " -2.31813318e-03, -2.37482220e-03, -2.43151123e-03],\n", + " [-7.22152379e-05, -3.82018229e-05, -4.18840788e-06, ...,\n", + " -1.90278484e-03, -1.86877143e-03, -1.83475801e-03],\n", + " [-8.78525512e-04, -8.89863317e-04, -9.01201122e-04, ...,\n", + " -9.62771983e-04, -1.00812320e-03, -1.05347442e-03]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886370722229]\n", + " createdtimestamp: [1092107045323]\n", + " changedtimestamp: [1092347961803]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 025 14:26:10.7220\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[-1.87361530e-03, -1.81692628e-03, -1.76023725e-03, ...,\n", + " -2.81537691e-03, -2.87206594e-03, -2.92875496e-03],\n", + " [-1.33956419e-03, -1.46428005e-03, -1.58899590e-03, ...,\n", + " -2.70161419e-03, -2.66760077e-03, -2.63358736e-03],\n", + " [-1.73439819e-03, -1.79108722e-03, -1.84777624e-03, ...,\n", + " 1.23551705e-05, 8.03820006e-05, 1.48408831e-04]])\n", + " Coordinates:\n", + " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886376646618]\n", + " createdtimestamp: [1092468384203]\n", + " changedtimestamp: [1092709085643]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 026 14:26:16.6464\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.r': [\n", + " array([[3.67919224e-07, 2.83155155e-07, 1.98424922e-07, ...,\n", + " 3.46452632e-07, 8.21098062e-07, 9.25034948e-07],\n", + " [1.96074040e-07, 2.21383078e-07, 4.68834272e-07, ...,\n", + " 9.52262078e-07, 4.83415782e-07, 5.52015728e-07],\n", + " [3.55882336e-07, 3.27200774e-07, 4.19314029e-07, ...,\n", + " 2.92538330e-07, 5.21568235e-07, 5.05150107e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886364795192]\n", + " createdtimestamp: [1091745849803]\n", + " changedtimestamp: [1091986551243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 024 14:26:04.7949\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[2.92395192e-07, 2.25222683e-07, 1.21325519e-07, ...,\n", + " 5.39336686e-07, 3.84301196e-07, 3.74622534e-07],\n", + " [3.05529466e-07, 9.36520953e-08, 3.03995805e-07, ...,\n", + " 1.02236696e-06, 9.93392222e-07, 5.19542514e-07],\n", + " [3.01692648e-07, 3.83754234e-07, 2.70232334e-07, ...,\n", + " 5.81183641e-07, 6.24799778e-07, 4.31362127e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886370722270]\n", + " createdtimestamp: [1092107045323]\n", + " changedtimestamp: [1092347961803]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 025 14:26:10.7220\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[7.93975965e-07, 8.93030872e-07, 1.23001589e-06, ...,\n", + " 3.67492049e-07, 2.34827369e-07, 2.35706276e-07],\n", + " [3.61742908e-07, 4.48546210e-07, 2.31477247e-07, ...,\n", + " 5.86607223e-07, 5.45344640e-07, 3.19530491e-07],\n", + " [1.80878244e-07, 1.47223775e-07, 1.42378570e-07, ...,\n", + " 1.75339378e-07, 3.28294689e-07, 8.26655524e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886376646657]\n", + " createdtimestamp: [1092468384203]\n", + " changedtimestamp: [1092709085643]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 026 14:26:16.6464\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.trigin1': [\n", + " array([[0., 1., 1., ..., 0., 0., 0.],\n", + " [0., 1., 1., ..., 0., 0., 0.],\n", + " [0., 1., 1., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886364795316]\n", + " createdtimestamp: [1091745849803]\n", + " changedtimestamp: [1091986551243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 024 14:26:04.7949\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 1., 1., ..., 0., 0., 0.],\n", + " [0., 1., 1., ..., 0., 0., 0.],\n", + " [0., 1., 1., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886370722345]\n", + " createdtimestamp: [1092107045323]\n", + " changedtimestamp: [1092347961803]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 025 14:26:10.7220\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 1., 1., ..., 0., 0., 0.],\n", + " [0., 1., 1., ..., 0., 0., 0.],\n", + " [0., 1., 1., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886376646733]\n", + " createdtimestamp: [1092468384203]\n", + " changedtimestamp: [1092709085643]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 026 14:26:16.6464\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.x': [\n", + " array([[ 6.65674270e-08, -1.10711122e-07, -1.75238995e-07, ...,\n", + " 3.00088872e-07, 5.42731804e-07, 6.73676425e-07],\n", + " [ 1.76368493e-07, 2.20327427e-07, -3.09841778e-07, ...,\n", + " 2.28058119e-07, 2.14299053e-07, 3.54935591e-07],\n", + " [-3.51589550e-07, -3.15060548e-07, -3.47898502e-07, ...,\n", + " 1.59659817e-07, 1.15966965e-07, -5.18576454e-08]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886364795245]\n", + " createdtimestamp: [1091745849803]\n", + " changedtimestamp: [1091986551243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 024 14:26:04.7949\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[-4.09052830e-08, 2.13295121e-08, 5.33865634e-08, ...,\n", + " -4.00140619e-07, -3.50272899e-07, -3.20757666e-07],\n", + " [-1.21754969e-07, -7.33503936e-08, 2.64174546e-07, ...,\n", + " -1.00753722e-06, -7.90096025e-07, -2.52642785e-07],\n", + " [-2.68055140e-07, -2.78390434e-07, -9.46063598e-08, ...,\n", + " -5.33591780e-07, -5.72202191e-07, -4.30658588e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886370722308]\n", + " createdtimestamp: [1092107045323]\n", + " changedtimestamp: [1092347961803]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 025 14:26:10.7220\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[ 1.55824069e-07, 4.11162940e-07, 4.66974725e-07, ...,\n", + " 2.71678622e-07, 2.18573685e-07, -1.56646826e-07],\n", + " [ 3.33768717e-07, 4.47974167e-07, 2.30547319e-07, ...,\n", + " -2.92901103e-07, -1.49833963e-07, 1.35891929e-07],\n", + " [ 1.80673620e-07, 1.28038062e-07, 4.32264639e-08, ...,\n", + " 1.68609698e-07, -3.28192979e-07, -8.26423523e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886376646697]\n", + " createdtimestamp: [1092468384203]\n", + " changedtimestamp: [1092709085643]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 026 14:26:16.6464\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "69e61de7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885494031060]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885499560433]\n", + " createdtimestamp: [1039013445533]\n", + " changedtimestamp: [1039023023213]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 002 14:11:39.5600\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886126694424]\n", + " createdtimestamp: [1076950339563]\n", + " changedtimestamp: [1077288735243]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 019 14:22:06.6936\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.r': [\n", + " array([[ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [3.83335709e-07, 3.83594719e-07, 3.83857600e-07, ...,\n", + " nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885494088087]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885499593310]\n", + " createdtimestamp: [1039013445533]\n", + " changedtimestamp: [1039023023213]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 002 14:11:39.5600\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[8.60182422e-08, 8.74794163e-08, 8.90240508e-08, ...,\n", + " nan, nan, nan],\n", + " [6.62406884e-08, 6.46201620e-08, 6.30831144e-08, ...,\n", + " nan, nan, nan],\n", + " [5.27267604e-07, 5.28614361e-07, 5.30040283e-07, ...,\n", + " nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886126698076]\n", + " createdtimestamp: [1076950339563]\n", + " changedtimestamp: [1077288735243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 019 14:22:06.6936\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.trigin1': [\n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885489547296]\n", + " createdtimestamp: [1038982525553]\n", + " changedtimestamp: [1038993876613]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 000 14:11:29.2195\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [ 0., 0., 0., ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885494168868]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885499657769]\n", + " createdtimestamp: [1039013445533]\n", + " changedtimestamp: [1039023023213]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 002 14:11:39.5600\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.747e+13 1.747e+13 ... 1.748e+13 1.748e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885639072999]\n", + " createdtimestamp: [1048217067723]\n", + " changedtimestamp: [1048455009483]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 003 14:13:59.0712\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.748e+13 1.748e+13 ... 1.748e+13 1.748e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885644955400]\n", + " createdtimestamp: [1048575557323]\n", + " changedtimestamp: [1048816518603]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 14:14:04.9542\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.748e+13 1.748e+13 ... 1.749e+13 1.749e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885651071285]\n", + " createdtimestamp: [1048934683083]\n", + " changedtimestamp: [1049175017163]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 005 14:14:11.0700\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.762e+13 1.762e+13 ... 1.763e+13 1.763e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885791762410]\n", + " createdtimestamp: [1057372530123]\n", + " changedtimestamp: [1057611081163]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 006 14:16:31.7604\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.763e+13 1.763e+13 ... 1.763e+13 1.763e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885797604338]\n", + " createdtimestamp: [1057731646923]\n", + " changedtimestamp: [1057971963083]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 007 14:16:37.5946\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.763e+13 1.763e+13 ... 1.764e+13 1.764e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885803622668]\n", + " createdtimestamp: [1058092555723]\n", + " changedtimestamp: [1058331088843]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 008 14:16:43.6214\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.77e+13 1.77e+13 ... 1.771e+13 1.771e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885871598865]\n", + " createdtimestamp: [1062162716363]\n", + " changedtimestamp: [1062400613323]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 009 14:17:51.5969\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.771e+13 1.771e+13 ... 1.771e+13 1.771e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885877429641]\n", + " createdtimestamp: [1062521824203]\n", + " changedtimestamp: [1062762167243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 010 14:17:57.4282\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.771e+13 1.771e+13 ... 1.772e+13 1.772e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885883413040]\n", + " createdtimestamp: [1062882741963]\n", + " changedtimestamp: [1063120674763]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 011 14:18:03.4118\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.782e+13 1.782e+13 ... 1.782e+13 1.782e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885985636933]\n", + " createdtimestamp: [1069007968203]\n", + " changedtimestamp: [1069245453003]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 012 14:19:45.6351\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.782e+13 1.782e+13 ... 1.783e+13 1.783e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885991611307]\n", + " createdtimestamp: [1069365866443]\n", + " changedtimestamp: [1069607607243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 013 14:19:51.6101\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.783e+13 1.783e+13 ... 1.783e+13 1.783e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885997735588]\n", + " createdtimestamp: [1069727993803]\n", + " changedtimestamp: [1069966114763]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 014 14:19:57.7343\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.789e+13 1.789e+13 ... 1.79e+13 1.79e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886060607309]\n", + " createdtimestamp: [1073499831243]\n", + " changedtimestamp: [1073737351883]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 015 14:21:00.6054\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.79e+13 1.79e+13 1.79e+13 ... 1.79e+13 1.79e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886066623023]\n", + " createdtimestamp: [1073858338763]\n", + " changedtimestamp: [1074098852043]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 016 14:21:06.6218\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.79e+13 1.79e+13 ... 1.791e+13 1.791e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886072592296]\n", + " createdtimestamp: [1074219838923]\n", + " changedtimestamp: [1074457977803]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 017 14:21:12.5911\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[ 0., 0., 0., ..., nan, nan, nan],\n", + " [ 0., 0., 0., ..., nan, nan, nan],\n", + " [ 0., 0., 0., ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886120155827]\n", + " createdtimestamp: [1076891918123]\n", + " changedtimestamp: [1076929715883]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 018 14:22:00.1345\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[ 0., 0., 0., ..., nan, nan, nan],\n", + " [ 0., 0., 0., ..., nan, nan, nan],\n", + " [ 0., 0., 0., ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886126705825]\n", + " createdtimestamp: [1076950339563]\n", + " changedtimestamp: [1077288735243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 019 14:22:06.6936\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[ 0., 0., 0., ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 1.796e+13 1.796e+13 1.796e+13 ... 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886132860354]\n", + " createdtimestamp: [1077609510523]\n", + " changedtimestamp: [1077652213403]\n", + " flags: [1848]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 020 14:22:12.8482\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.x': [\n", + " array([[ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [-3.79128012e-07, -3.79368980e-07, -3.79612937e-07, ...,\n", + " nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885494133030]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885499625269]\n", + " createdtimestamp: [1039013445533]\n", + " changedtimestamp: [1039023023213]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 002 14:11:39.5600\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[ 5.15736266e-08, 5.26349600e-08, 5.37237984e-08, ...,\n", + " nan, nan, nan],\n", + " [-6.12978321e-08, -5.92433298e-08, -5.72438376e-08, ...,\n", + " nan, nan, nan],\n", + " [-4.08640255e-08, -3.73170793e-08, -3.38018236e-08, ...,\n", + " nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886126701691]\n", + " createdtimestamp: [1076950339563]\n", + " changedtimestamp: [1077288735243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 019 14:22:06.6936\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.read_memory" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "3717ff32", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'X': {'/dev3442/demods/0/sample.x': [\n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886120147957]\n", + " createdtimestamp: [1076891918123]\n", + " changedtimestamp: [1076929715883]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 018 14:22:00.1345\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]},\n", + " 'R': {'/dev3442/demods/0/sample.r': [\n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886120141796]\n", + " createdtimestamp: [1076891918123]\n", + " changedtimestamp: [1076929715883]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 018 14:22:00.1345\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886120141796]\n", + " createdtimestamp: [1076891918123]\n", + " changedtimestamp: [1076929715883]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 018 14:22:00.1345\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]},\n", + " 'A': {'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[-0.00221065, -0.00221092, -0.00221119, ..., -0.00150499,\n", + " -0.00150526, -0.00150552]])\n", + " Coordinates:\n", + " time (row, col) float64 3e+08 3e+08 3e+08 ... 4.5e+08 4.5e+08 4.5e+08\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886120135151]\n", + " createdtimestamp: [1076891918123]\n", + " changedtimestamp: [1076929715883]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 018 14:22:00.1345\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886120135151]\n", + " createdtimestamp: [1076891918123]\n", + " changedtimestamp: [1076929715883]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 018 14:22:00.1345\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}},\n", + " {'X': {'/dev3442/demods/0/sample.x': [\n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886132856158]\n", + " createdtimestamp: [1077609510523]\n", + " changedtimestamp: [1077652213403]\n", + " flags: [1848]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 020 14:22:12.8482\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]},\n", + " 'R': {'/dev3442/demods/0/sample.r': [\n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886132852379]\n", + " createdtimestamp: [1077609510523]\n", + " changedtimestamp: [1077652213403]\n", + " flags: [1848]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 020 14:22:12.8482\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886132852379]\n", + " createdtimestamp: [1077609510523]\n", + " changedtimestamp: [1077652213403]\n", + " flags: [1848]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 020 14:22:12.8482\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]},\n", + " 'A': {'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[-0.00127274, -0.00127318, -0.00127363, ..., -0.00089014,\n", + " -0.00088996, -0.00088978]])\n", + " Coordinates:\n", + " time (row, col) float64 3e+08 3e+08 3e+08 ... 4.5e+08 4.5e+08 4.5e+08\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886132848581]\n", + " createdtimestamp: [1077609510523]\n", + " changedtimestamp: [1077652213403]\n", + " flags: [824]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 020 14:22:12.8482\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[-0.00359344, -0.00359255, -0.00359166, ..., -0.00202245,\n", + " -0.00202272, -0.00202298]])\n", + " Coordinates:\n", + " time (row, col) float64 1.2e+09 1.2e+09 1.2e+09 ... 1.5e+09 1.5e+09\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886132848581]\n", + " createdtimestamp: [1077609510523]\n", + " changedtimestamp: [1077652213403]\n", + " flags: [824]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 020 14:22:12.8482\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}}]" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "90131f4e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m(1160)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 1158 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1159 \u001b[1;33m \u001b[0marray\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_indexing_array_and_key\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m-> 1160 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0marray\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1161 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1162 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\variable.py\u001b[0m(786)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 784 \u001b[1;33m \"\"\"\n", + "\u001b[0m\u001b[1;32m 785 \u001b[1;33m \u001b[0mdims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnew_order\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_broadcast_indexes\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 786 \u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mas_indexable\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_data\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 787 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mnew_order\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 788 \u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmoveaxis\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnew_order\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnew_order\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\variable.py\u001b[0m(1193)\u001b[0;36misel\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 1191 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1192 \u001b[1;33m \u001b[0mkey\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtuple\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdim\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mslice\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mdim\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdims\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m-> 1193 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1194 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1195 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0msqueeze\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> uu\n", + "*** NameError: name 'uu' is not defined\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(1208)\u001b[0;36misel\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 1206 \u001b[1;33m \u001b[1;31m# lists, or zero or one-dimensional np.ndarray's\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1207 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m-> 1208 \u001b[1;33m \u001b[0mvariable\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_variable\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmissing_dims\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmissing_dims\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1209 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1210 \u001b[1;33m \u001b[0mcoords\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(745)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 743 \u001b[1;33m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 744 \u001b[1;33m \u001b[1;31m# xarray-style array indexing\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 745 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_item_key_to_dict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 746 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 747 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mAny\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mAny\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(593)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 591 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ml\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0m_wind\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 592 \u001b[1;33m \u001b[1;31m# _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)[\"time\"][:, 0].values\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 593 \u001b[1;33m \u001b[0m_time_of_first_not_nan_value\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mapplicable_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"time\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 594 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 595 \u001b[1;33m \u001b[0mtime_of_trigger\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mapplicable_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mattrs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"gridcoloffset\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m1e9\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0m_time_of_first_not_nan_value\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(735)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 733 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 734 \u001b[1;33m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 735 \u001b[1;33m \u001b[0mthat_shot_parsed\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mthat_shot\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcurrently_set_program\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 736 \u001b[1;33m \u001b[1;31m# except KeyError:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 737 \u001b[1;33m \u001b[1;31m# print(f\"Error\")\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> that_shot\n", + "{'/dev3442/demods/0/sample.r': [\n", + "array([[ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [3.83335709e-07, 3.83594719e-07, 3.83857600e-07, ...,\n", + " nan, nan, nan]])\n", + "Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664885494088087]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]], '/dev3442/demods/0/sample.x': [\n", + "array([[ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [-3.79128012e-07, -3.79368980e-07, -3.79612937e-07, ...,\n", + " nan, nan, nan]])\n", + "Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664885494133030]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]], '/dev3442/auxins/0/sample.auxin0.avg': [\n", + "array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + "Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664885494031060]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ipdb> r\n" + ] + } + ], "source": [ "%debug" ] @@ -838,7 +3095,7 @@ { "cell_type": "code", "execution_count": 84, - "id": "81b98b2a", + "id": "0eb17aad", "metadata": {}, "outputs": [ { @@ -859,7 +3116,7 @@ { "cell_type": "code", "execution_count": 71, - "id": "5b72a01b", + "id": "2453eef6", "metadata": {}, "outputs": [ { diff --git a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb index 415c31b6b..20760fd2c 100644 --- a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb +++ b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb @@ -359,7 +359,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'A', 'R', 'T'}\n", + "{'T', 'R', 'A'}\n", "[]\n", "set()\n" ] @@ -400,7 +400,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEGCAYAAABvtY4XAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA82UlEQVR4nO3dd3hUVfrA8e/JpBNCSKGX0HsPHRsCshZQwIq6ll3U1f3pqmt3de26ttV1VcTesGFdO1V67zWUQIQASQjpbXJ+f9xJSMjMZCbMzJ3yfp4nz53M3Dn3zSTz5s6557xHaa0RQggRfMLMDkAIIYR3SIIXQoggJQleCCGClCR4IYQIUpLghRAiSIWbHUBtycnJOjU11eww/EJRUTFWa5WpMVgsYTRpEmtqDO4qLiqmyqTXLcwSRmyAvV7VSoqLTHvdGqO0tJSqKi+NAFRhREVHe7zZspJStBdiPnBwf7bWOsXeY36V4FNTU1m9erXZYfiFn35cRIsW3U2N4ciRnZwz8XRTY3DX4p+W0LNVD1OOvT1rB2POGW3KsU/VqoXzGNS1o9lhuGzZ0nUkJnbwStub9h2gxyDP/x43LltF12TPv6fHXNYzw9Fj0kUjhBBBShK8EEIEKUnwQggRpPyqD14IYaioqCAzM5PS0lKfHC8ivjk7c4t8cixPiOvUCavF4pW2u8anEmbJ9ni7vYe2ISKsrFHP1UBVmaL0UDhYXT8vlwQvhB/KzMykadOmpKamopTy+vGKCvKJjYr0+nE8pbCwmPDwKK+0XVJWTnRsnMfbLS4qIjq8caNztNbkFRzjCDmUZrr+e5IuGiH8UGlpKUlJST5J7sL/KaVIaNqcsCj3hllKghfCT0lyF7UppXD3L0ISvBBCBClJ8EIIl137pz/z+Zw5phx7374M+g0aYsqxA5UkeCFESLBarWaH4HOS4IUQdr33wYcMGDKUgWnDuPra62ruX/TbYkafcSZdevSqOZsvLCxk3Dl/YMjwkfQfnMbX33wLGGfdvfsP5M83/YW+AwdzzrnnU1JSAsBZ4ydw9333M3z0GHr06cdvixcDRiL++z33MmzUaAYMGcrrb8xyGmdVVRW33n4bQ4anMeWSaVw4bQpffvUlAD379eaJp5/k7HPGM+fLOfw6dy5njhvLyNNGM/3qKyksLARg7bp1TDj3HEadPoZpl0zlUNYhACZOHMcDD97L6WeMYsDA3ixZstiDr7D3yTBJIfzcP7/dwtaD+R5ts3ebeB66oI/Dx7ds3coTTz3N4gXzSE5OJjc3t+axrKwsfps/j+07djB5yjSmTZlCdHQ0cz77hPj4eLKzsxl52hlMuuB8AHalp/PR++/yxqv/5dIrpvPFl19x5RWXA1BZWcmKJYv5/ocfeeSxJ/jlx+958+13aNasGSuXLqGsrIwxZ45lwrhxDi86f/3N12Ts38+qZSs5cvQog4cO4Y9XXlXzeHRUNHN/+oXsnGwuv/IK/vf1tzRp0oTnXniel155mb/ffid33HUnn348m5TkFD76ZDb//Oc/eO3VN2wxWlm0cCk//vQDTzz5GP/77sdTfv19RRK8EKKeefMXMHXKRSQnJwOQmJhY89jkSRcQFhZG7169OHzkCGCM077vwX/w2+IlhIWF8fvBgxw+fBiATqmpDBwwAIDBgwexL+NEbawpF04GYEit+3/59Vc2btrMF3OMs/Djx4+zKz2d7t262Y116fJlTLnwIsLCwmjVsiWnn3ZancenTZkKwMpVq9i+fTtjzxkHQEV5OcOGDmfnrp1s3baV8y+cBBj/dFq3blvr570QgEEDB7N/v8O6Xn7J6wleKWUBVgO/a63P9/bxhAg2zs60vUVr7fCMOSoqqs5+AB9+PJvs7GxWL19KREQEnbr3oLS0rN7+ljALJZWl9dqyWCxUWitr2nzphec5Z8L4Osfdt89+cq2OwZHqEs5aa8aeNZZ333qnzuObt2ymV89eLPh1HlB/olOdGCsrnR7L3/iiD/5WYJsPjiOE8JCzx57FZ59/QU5ODkCdLhp7jh8/TkpKChEREcxfsJCMjP2NPvaE8eN5beZMKioqANi5cxdFRY7LKIwaMZKvvvmaqqoqDh85XNOXf7JhQ4eybMVydu/eDUBxcTG70nfRvVt3srOzWbFyBWCUidi6dUuj4/cnXj2DV0q1A84DHgdu9+axHMo7YGwT2ptyeCECUZ/evbnvnrs5c9wELBYLgwYO4O1Zbzjcf/rllzFpylSGjhzNgAH96dmj8TX5/3TdtezLyGDI8JForUlJSebLzz51uP+Fky9k/sIFpI0YSteu3UhLSyM+vlm9/VKSU5j539f44/XXUl5ufLr4xwP/oFvXbnz43gfcefed5OfnU15RwV9vuY3evX3/ycnTVEMfb06pcaU+B54EmgJ32uuiUUrNAGYAdOjQYUhGhof7uJ5oB+UF8I9cCPNOcSJvkAU/GidYFvzYtm0bvXr18khbrgj0WjSFhYXExcWRk5vD6Wedydyff6VVy5aNatsfa9FUS9+zk6LddWvwjLms5xqtdZq9/b3WRaOUOh84orVe42w/rfVMrXWa1jotJcXuqlOnprzA2M5/wvNtCyH8wtRLpzF8zEjGT5zAPXfd3ejkHmy82UUzGpiklDoXiAbilVIfaK2v9OIx64tOgNI8+O1ZOPtBnx5aCOEbP/0vcIYu+pLXzuC11vdqrdtprVOBy4B5Pk/uALEnhneRscznhxdCCLOExkzW2CRj++E0c+MQQggf8kmC11ovMHUMfJexxra8EIpyTAtDCCF8KTTO4AFG/Z+xnfMnc+MQQggfCZ0Ef/ZDxnb3PPDi0FAhglkwlQuecdMNNUXJglXoJHhLOLTsa9xe8bq5sQghvCIUSwI7EzoJHuDy2cb2x7vNjUOIABAo5YIX/baIief/gWuuv5ahI4dhtVq574H7GXPm6QwbNZxZb70JGLVo/nbn7QweNoSLLp7KkaNHPf6a+ZvQqiZZu1xB1mZo1de8WIRw1Q/3QNYmz7bZqh/84SmHDwdSuWCA1WvWsHrZSlJTU3nz7beIbxbP4gWLKCsrY+yEcYwbezbrN25g165drFq2ksNHjjBkeFqdssLBKLQSPMC0t+Dz64whk3dsNzsaIfxSIJULBkgbMoTU1FQA5s6by+YtW/jy668AyD+eT/ru3SxZuoSLp12MxWKhTevWnHFaYJXhaIzQS/B9pxoJvuAQVJRCxKnVhhDC65ycaXtLIJULBoiNbVInpueeeZbx48bV2eenX35y+ikgGIVWH3y1AVcY229vNTcOIfxUIJULPtm4s8fxxluzap6/K914/uhRo/n8i8+xWq0cyspi0W+/NTrGQBF6Z/AA5z0HGz6CjbNhioyoEeJkgVQu+GTX/vEaMvbvZ9Tpo9Fak5yczCcfzmbyBZNYuGghQ0cOo2vXbowZM6bRMQYKr5YLdldaWppevXq1Zxt9aRC0HQJTT7oS/0JfOH4ALnodBlzm2WN6gJQLbhwpF9w4gV4u2JOkXHAwuMJ2RvDlDebGIYQQXhK6Cb5l7xO3jwXWQrpCCOGK0E3wAOc9b2w/vNjcOIQQwgtCO8Gn2WbnZe8Aa2Ctli6EEA0J7QSvFHSbYNz+RVZ7EkIEl9BO8ABTbEO/lv/X3DiEEMLDJMHHJECkbUhU+lxTQxFCCE+SBA9w5RfGVpb0E8Ipf6wHn5GRwSdOJkIdPHSIK66a7s3QPOpfzz/jsbYkwQN0GGFsdRUUZJkbixDCLRn7HSf4yspK2rRuzUfvf+jVGCorPTdI47kXPZfgQ7NUgT1n3gcLnoBP/wjX/2R2NELUeHrl02zP9Wzl056JPbl7mPN1Ed774EOee+FFlFL079eX995+CzDqwb/w75fIyjrM008+zrQpUygsLOTCqRdzLC+PiooKHn34ISZPuoB9+zI4d9JkRo8exbJly2nbpg1fffEZMTExnDV+AsOGDmXBwoXk5R1n1uuvctqYMVitVu65/wEWLlpEWVk5f7nxBm74s+OlNh98+CF27NzB8DEjufLy6SQkJPDjTz9SWlZGcVERr73yKlMvncbq5asoLi5mxk03sHPXTnp070HG/v288OzzDBk8mHfee5fnX3yBli1b0q17D6Iio3j++X9z9OhRbr31Zg5kHgDgmaefY+TIUTz++CMcOnSIjP0ZJCUl8c7b79eLrbS0lFtvu4W1a9cQFhbG04/9i9NPO4MPPnqfdevX8NwzLwIw7fIp3Hrzbfwy92dKSkoYdcZwevXsxZuvv9O4X7CNJPhqp//dSPAHlkOVFcIsZkckhGkCqR78ow//kxdffok5n34OwPsffsCKVStZuWQ5iYmJZNQqTzxz1hskJCSwcukKtmzdwogxowCjG+epfz3N0oWLCY+MYsq0KfTr1x+Av991O7fcciujRo3mwIH9TJ58HmvXGvX5161fy6+/LCAmJsZubK/PfBWAVSvXsWH9Oi65dCrrVjqu7f/IQ48x883XWLpwRcO/JBdIgq8WFgbthkLmKljyIpx2h9kRCQHQ4Jm2NwRaPfiTjT1rbJ2Yqy1dvoybb7wJgD69+9C3j7Hoz+o1qzlt9BgSExMpKSvnooumkp6+C4D58+exffu2mjbyCwooKCgA4Lxzz3eY3AGWLV3CjTfeDEC3bt1p374D6bt3ufxznCpJ8LVd9jE82xXmPiIJXoS0QKsHf7ImsbEOfy537gfQVVXMn/eb3UQe26SJnWfUei722w0PD6eq6sRjZaWldvc7VXKRtba4lBO3M9eYF4cQJgukevBxcU0pLCxwqe1RI0byxZfGKKBt27exZesWANKGpPHbksUcO3aMyspKvv76y5rnjD17HK+9fmKezIaN613+WUaPPo1PPv0YgN2708nMPEC3rt3p0KEDGzdvoKqqiszfD7Bm7YkquhHhETU/+6mSBH+y6oW5P5hibhxCmKh2PfiBacO44y7n3UTTL7+MNWvXMnTkaD6cPfuU68H36tWLIcNH0m/QEG685Rano1T69e1LuCWc4aNH8PIr/3Ha9ow//Zns7GyGjRrO8y++QN8+fWnWLJ62bdrw99vv5Iyzz2LKtIvo2bMX8fHxADz7rxdYt3YNw4YPZsiQ/rzppC5+veP9+UasVitDhw3iTzOu47X/vEFUVBQjh48itWMqw8ekcf8/7mXAgIE1z7nm6usYcdpQrr/hGpeP40jo1oN35uFmxvaeAxAd79l4XCT14BtH6sE3TqjUg7darVRUVBAdHc2ePXs4d/L5bFyznsjISAoLC4mLi6OgqJhrrr+Gq6+6hkmTLvRYzGbUg5c+eHuGzYCVM+Grm+Ay746fFUL4TnFxMRPPP5fKygq01vz7+ReJjDT+sT3+5BPMWzifkpJSxo+bwAUXTDY52lMnCd6eCY8bCX77d6C1UZRMCBHwmjZtypKF9tdiffLxJ4DGrej0y68/8+CD99W5L7VjKrNnf964QD1EErw94ZGQ3MMoI7z6LRh6vdkRCSH82PhxExg/boLZYdQjF1kdudy48s3/bjc3DiGEaCRJ8I4kdTlx++gO8+IQQohGkgTvzEUzja1UmRRCBCDpg3em/yXw5QzI2w+V5UbfvBAmWL58DcfzHE/2cVezhCaMGFG/9O7Jvvz6a6ZechlbN6ynZ09zhp+KxpME74xS0PtC2PoVfH8HTHrZ7IhEiDqeV+TReRFHjux0ab/Zn3zKmNGjmP3ZZzz84AMeO77wDemiachk28y4te+ZG4cQPlZYWMiSZcuY9dprfPLpZ2aHIxpBEnxDoppCE1uNmq1fmxuLED701Tffcs6ECXTv3o3ExOasXbfO7JCEmyTBu+JK2xJln15tbhxC+NDsTz7lsosvBuDSiy/m408cL4sn/JPX+uCVUtHAIiDKdpzPtdYPeet4XtW6/4nbxzOhWTvzYhHCB3Jycpi3YAGbt25BKYXVakUpxTNPPuGwjLDwP948gy8DxmqtBwADgYlKqRFePJ53TXjM2H58ublxCOEDn8/5kqumT2ffrp3s3bmD/bvT6ZSayuIlS8wOTbjBa2fw2ihTWWj7NsL25T+lK9018hb4+QHI2gjWCrBEmB2RCCHNEpq4PPLF1facmf3pp9x955117pty4YV8NPtTThszxmNxCO/y6jBJpZQFWAN0BV7RWtdbaFApNQOYAdChQwdvhnNqlIJOp8PeRTD/CRgXmL1NIjC5Mmbdk+b/8nO9+/7vlpt9GoM4dV69yKq1tmqtBwLtgGFKqb529pmptU7TWqelpKTUa8OvXGJbNX3x8+bGIYQQLvDJKBqtdR6wAJjoi+N5TUwCWGyzWfctNjUUIYRoiNcSvFIqRSmVYLsdA4wDtnvreD5zhW2o2AdSn0YI4d+82QffGnjX1g8fBnyqtf7Oi8fzjS5nGdvKEijOhdhEc+MRQggHvHYGr7XeqLUepLXur7Xuq7V+xFvH8rnRtxnbz68zNQwhhHBGZrI2xtgHje2e+caSfkII4YekmmRjWMKh9QA4tAGW/QdG/dXsiESQW7tiLcV5JR5rLzYhhsHDBzvdJzymCf369qWyspJOqam89/abJCQkeCwG4X2S4Bvr0g/hxb7G5CdJ8MLLivNK6NnKc/XYt2c1vEpZTEwM61YZU1euuf5PvPLa69x/z90ei0F4n3TRNFZC+xO3D643LQwhfGHE8OH8/vtBs8MQbpIEfyqqJz59dIm5cQjhRVarlXnz5zPp/PPMDkW4SRL8qeg9ydgWHoaKUnNjEcLDSkpKGDR0OMmt25Kbe4zx4842OyThJknwp2rgdGP7zS3mxiGEh1X3we/btYPyinJeefU1s0MSbpIEf6rOfdbYbvpMhkyKoNSsWTP+/fxzPPfii1RUVJgdjnBDg6NolFJpwGlAG6AE2Az8qrXO9XJsgSEyFpp1gOP7YcPHMPAKsyMSQSg2IcalkS/utOeOQQMHMqBff2Z/+hlXTZe/8UDhMMErpa4B/g/Yi1HydwcQDYwB7lZKbQYe1Frv90Gc/m36Z/Df4fDVTZLghVc0NGbdGwpys+t8/82XX/g8BnFqnJ3BNwFGa63tzq5QSg0EugGS4Fv0PHE7dy8kdjIvFiGEsHHYB6+1fsVRcrc9vl5rPdc7YQWg818wth9ebG4cQghh06iLrEqp8z0dSMAbcq2xzdkFleXmxiKEEDR+FM1Qj0YRDJSC7rb1TH5+wNxYhBCCRiZ4rbUsSGrP1FnGduXr5sYhhBC4Nkzyanv3a63f83w4AS6qKUTFQ1k+pP8KXceZHZEQIoS5Uk2ydndMNHA2sBaQBG/P9M/hrQnGxdaHjpkdjQgSG9esoqywwGPtRcU1pf8Qxz2tOTk5jJt4LgBZhw9jsYSRkpwCwIolvxEZGemxWIT3NJjgtdZ1auEqpZoB73stokDXYbix1VVQkAVNW5kbjwgKZYUFDOra0WPtrUvPcPp4UlJSTanghx99jLgmTbjz9r957PjCNxrTB1+MMf5dOHLmfcb2U7u9W0II4ROu9MF/C1QXWQkDegOfejOogHf632HBE3BgBVRVQZiU/BFC+J4rffDP1rpdCWRorTO9FE9wCAuD9iPgwHL47Tk44+9mRySECEENnlpqrRfW+loiyd1Fl9ouU8x/zNw4hBAhq7EzWWd6OpCgE9fixO39K8yLQwgRshq76LbM5HHF9M/hw2nGkMl7pSabaLyouKYNjnxxtz0R/BqV4LXWazwdSFDqNt7Ylh2HskKIijM3HhGwnI1Z97aHH5TSG4GqwS4apVSKUupZpdT3Sql51V++CC4oDJthbL+8wdw4hBAhx5U++A+BbUAn4J/APmCVF2MKLhNsF1m3fydL+gkhfMqVBJ+ktX4TqLCNpLkOGOHluIJHeBQk9zBur5plbiwioGg5IRC1aK1x9y/ClQRfvcruIaXUeUqpQUA7N48T2i7/2Nh+f6e5cYiAER0dTU5OjiR5ARjJPa/gGFVlyq3nuXKR9TFb/Zk7gJeBeECKUrgjqcuJ20e2113iTwg72rVrR2ZmJkePHvXJ8cpKS4kMt/jkWJ5QVlaBxeKdeMsrrURERnm+3bIyIsIiGvVcDVSVKUoPuTcuxpViY9/Zbh4HznI/NAHAlFkw50/wwVS4fYvZ0Qg/FxERQadOvlvbd9XCefT1YDEzb1u2dB2JiR280nb6vgP0GDTa4+1uXbWKrsndPd6uMw67aJRSDyilEp08PlaW7nNDv2nGNj8TKkrNjUUIERKcncFvAr5VSpVi1H8/ilEPvhswEPgVeMLbAQYNpaDvVNj8BXx/B0x+xeyIhBBBzuEZvNb6a631aOBGYAtgAfKBD4BhWuu/aa1900EYLCa9bGzXfWBuHEKIkOBKH/wuYJcPYgl+kU2gSQsoOgJbv4Hek8yOSAgRxKRQua9d+YWx/fQqc+MQQgQ9ryV4pVR7pdR8pdQ2pdQWpdSt3jpWQGnd/8TtPClAJoTwHm+ewVcCd2ite2HMfL1ZKdXbi8cLHBMeN7YfX2FuHEKIoObKkn3dgVeBllrrvkqp/sAkrbXTlSy01oeAQ7bbBUqpbUBbYOuphx3gRt4MP98PhzeBtQIsjZv84Df2L4fl//VOrZ2opjDxKYiO93zbQgQ5V6ZFvQH8HVsNeK31RqXUR4DLSxUppVKBQUC9lS+UUjOAGQAdOnhn4oLfUQo6nwV75sO8R2H8I2ZHdGo2fwHbvj1Rc8dTyovg+H4YeAWkjvFs20KEAFcSfKzWeqVSdWogVLp6AKVUHPAFcJvWOv/kx7XWM4GZAGlpaaFTeOPid+DpjrDk34Gf4AGim8HNyz3b5t5F8O4Fnm1TiBDiSh98tlKqC0Y5BJRS07B1vTREKRWBkdw/1FrPaXSUwSgmAcJjjNt7F5kaihC1lVs1XV/eTteXt/PZ1jyzwxGnwJUEfzNG90xPpdTvwG3ATQ09SRmn/G8C27TWz59KkEFr+qfG9oOp5sYhRC2z1ubU3L53bpaJkYhT5cpEpz3AOKVUEyBMa13gYtujgauATUqp9bb77tNaf9+oSINRp9ONrbUcinMh1mHpHyF85usddXtSC8utxEUGTqVJcYIro2huP+l7MCpLrtFar3f0PK31YsC94sWhaMztsPh5+Pw6uPors6MRgt3HygG4fUQyzy/P5vtdBVzSJ8HcoESjuNJFk4ZRj6at7WsGcCbwhlLqLu+FFiLOut/Y7pkvS/oJ0x0rsQIwpkMTzu1mDE1dcqDIzJDEKXBpyT5gsNb6Dq31HRgJPwU4HbjGi7GFBks4tB5o3F7yb1NDEWLNoWIARrSNpX28MT9jZ06ZmSGJU+BKgu8AlNf6vgLoqLUuAeQ37wmX2qpL/vqQuXGIkHcg31ihc2ibGCxhiqaRYRwucnlUtPAzriT4j4DlSqmHlFIPAUuAj20XXWVWqicktD9x++A68+IQIW/JfqM7pmuisWTd6R2bkF9WRXFFlZlhiUZqMMFrrR/F6HfPw7i4eqPW+hGtdZHWerqX4wsdl882tjJkUpio+gJrs2hj1EyrOKOb5lBBhWkxicZzaQVXrfVqpdR+jBWdUEp10FpLKURP6vEHY1ucA+XF5sYiQlqU5cTgt+5JkQBszS6jS6LnF6IW3tXgGbxSapJSahewF1ho2/7g7cBC0qArje3XfzE3DhGSKqs0B/IrGN85rua+/i2N2dYbD5eYFZY4Ba70wT+KUe53p9a6EzAOox9eeNq5zxrbLV/KkEnhcwVlRj+7JezEGXyHZkYXjfw5BiZXEnyF1joHCFNKhWmt52Msui08LSIGEoyKmm2y55kcjAg1GceN/ve+LaJr7ouyhBEeBj+kuzqBXfgTVxJ8nq0i5CLgQ6XUv3GjmqRw05VGTbZ+u180Nw4RcnJtk5zaxdddnyA+ykKTCFndMxC58lubDBQDfwN+BHYD53szqJCW3K3mZlThPvPiECFn7SGjn711XN0En5oQyZ68crT00wQcVxL8P7TWVVrrSq31u1rrl4C7vR1YSDv/BQA6r7jB5EBEKKle8qGbbeRMtW6JxveS3gOPKwl+vJ37/uDpQEQtQ64FILpoH8oqk4WFYyv25JB6z/8Y/OgvZB0vPaW2lmUak5yiLHXTQnyUMSZ+l5QsCDgOE7xS6ial1Cagh1JqY62vvcBG34UYgpTicPMRALTd8pTJwQh/dulMYxWt3KJyxj+/8JTaOjmxVxvc2hgqWVAus1kDjbMz+I+AC4BvbNvqryFa6yt9EFtI29T1DgBS9n1kciTCX23KPF7n+4KySiqtjU/C27JLSbMl89riIo00sSxTJuAFGmcJ3gLkY6zoVFDrC6WUrEzhZVZLNJURRrnW+MOndmYmgtNri3Yb2ysHc8GANgD8tOVwo9vLL6viSHH9AXJ9U4xhk9HhsrxDoHGW4NcAq21fa076Wu390MTu4W8A0GXFDJMjEf7ofxuNpZEn9G7F/43tCsC3Gw42uj0FTOjctN79EbbSBb/uKWx028IcDmvR2GatChMVJw6suR1eeoTK6BbmBSP8Skm5MWY9OS6KsDBFlxSjvMCa/cca1V5uqUZjlCs4WXS4cR6YHCvL9gUal2Yv2OrRPGv7kjHwPnSw560AdFp9q8mRCH+yJD0bgAsHGl0zYWGK5rERHC1o3EiX4+VGYk9NiLT7eJfmkfwiZ/ABx5ViY08Bt2LUft8K3KqUetLbgQnD4W43AhCXuxa0jGIQhh+3ZAFwydATawmM6poMwJEC94dLHis1EnzLJo4LzDaPljP4QOPKGfy5wHit9Vta67eAicB53g1L1FBhFCQNBaDVjldMDkb4izUZRldM95Yn+sxHdE4CYMOB43af48zhYiPBN4+xn8TT2sSQU2LFaqcLR/gvVwtMJNS63cwLcQgn9g15EYDWO/9jbiDCb+zNLiIhtm5Jgd6tjVFXm393P8FXF5Ds5KCLptL24TGrUMpQBRJXEvyTwDql1DtKqXcxRtE84d2wRG2V0clo26+qSY4MYAp12YVGP/uQDs3r3N+1hXGh9Ugj+uHXHTUu2ioHIyGHtjHGx5dWSjdhIHE2k/U/SqlRWuuPMerBz7F9jdRaz/ZVgMKwe8QsQIZMCli2Owc40SVTrVlMBLGRFuZtd38sfGyEkdkTY+z3wVtsmX/TkVMrhyB8y9mSfbuA55RSrYFPgI+11ut9EpWop6DFaAAslUWEVRZRFd7E5IiEWZbuNkbQjOySVO+xqPCwmiGU7jhcrOuVCa5tQCtjslOYzHUKKA7P4LXW/9ZajwTOAHKBt5VS25RS/1BKdfdZhKLGkU5XAZC65naTIxFm2mTrY699gbVah8RY8ksrqXCzZEFWcRXZdmaxVouwZfaFGUVutSvM1WAfvNY6Q2v9tNZ6EHAFcBGwzeuRiXoO9r4LgGaHF8gaaiFs71EjyUaG13/7ntE9BYBiN8/ioy2K0e0dfyqsPrtvFiVDJQOJK+PgI5RSFyilPsRYbHsnMNXrkYl6tCWSkrguACRLEbKQVFphpajcyuiu9btnAKIjjQS89WC+y21qrTlSomkS6TgdKKVoEhHGov0y2SmQOLvIOl4p9RaQCcwAvge6aK0v1Vp/5aP4xEn2DH8dgPabHjE5EmGGHVnG2qgD2iXYfXxQe2Nkza4jrq+hmltkrMVaWuG8W6fMWkVcZOPP4J9bdpTHFh3msd8aXxBNuMfZRdb7MEoG36m1zvVRPKIB5U1OzFyMLkintGlXE6MRvrbYVqJgQPsEu493TIoFoKDU/fHqI5100QCMad+EBY3sg7/k84yaJQEB3ll/jPS/9mxUW8J1zi6ynqW1fkOSu//ZN/hZALosu97kSISvrdufB9QfIlktKc6YqFQ9lNIVmceMxNvQZZ0c26Lc9gqSOX1ecWVNcp97deea+/+19Ihb7Qj3yVLpAehYuwsAiCzNQlWWNLC3CCbVXS/NYuwPaYy0rcoUHeH6W7t6YlSLJs67X8Z1jnO5zdpu/ckoYXzdwOZ0bBbJr1cZSf71NbmUW2WwgDdJgg9QuW2Nop7tN/3T5EiEL2XkFNM52XFXilKK3q3jmb/jqNttt4u3X6agWrGtjz49172ZssttK0HdM8Yod52aEMmAlsa4+ks/z3A3TOEGSfABav9Ao1pE0oEvTY5E+Ep1lcj+7ZyXgyqtsNLEjYuh1aWH7Yy6rGNgK9varGWuj7HfbJv52j0pirBadRA+ntoRMGbGFpS5PzFLuEYSfIDSligqoowxz80O/mxyNMIXqvvV+zsYQVNtdNdktyY7xdj+GXRPinK6X6ztP4A75Qre32hUvfzbiOQ690daFJO6G8XRpn0mZ/HeIgk+gFXXp+m8+q8mRyJ8YfEu40zb0QXWasbaTPD7MdeuzxSUVgDUOcO2p/ofgDsXWb/absy6PbtT/f77Zye0BmD3sXLySuUs3hu8luCVUm8ppY4opTZ76xihrqTZiWFmEcW/mxiJcCbzWDG3fLSWiS8uYtqrS7n27ZVMn7Xc7drq1TXgu7V0frFzSEdjLHyObXx7Q5bvcW2gXJxtItRGF8/gtdZYNcSEK7v/PMKUYnq/BABOfyfdpTaFe7x5Bv8OxuIgwosy+9wLQOeVN5sciTjZ/B1HGPXkXMY8PZ/vNh5ie1YBWw7mM3/HUZak59Dlvu9rJhm5Yk92EeFhigiL87dtXJQxwmbPUddmnSY1iaRFTMNVxKLCjX0qXBz5ssY2NPJ8W1eMPQ+f0RKA4grNmoPFLrUrXOdsotMp0VovUkqluvOcvLI8vk7/2rOBRFRBxVHwdLtetqlkB/HH9jW8Y/PWdIxrAlX7ycj9AZTnaoXkl2RRmu7CIs6lv0N0uOdf46M7IK4JZC2DStfGde8s2cW+3L0N7vd7QRlHS8qpnarqpC1d9z6NPmkH41td687jJQV8+f021h3IY3/uiWSV0iqCSQPb0K9dMxSVWKs0d32xEYBhL63hman9sTRQprGorJLwZlvo1iKOr9MrnO6bU15GeLPtLD18kMj0hhdq31m0hfjmVr452PCnwPZtj7KtFL45mNLgvl/vyCe8WREtWyXxzUHH5aumjyzhk615TP91DU+Pa4XC+Wvxe34Fi48epvjoTvIrqogJD8MCWJTxqaCsSpMYGUalhvgIhSXMKHdcUaWJbuB11kBuaSG/7Tpc831DXP0cptVRjloPuri3ZyjtxaJVtgT/nda6r5N9ZmCUQiA6NXpI14dlZqYQQrhq8zWb12it0+w95rUzeFdprWcCMwH6D+6vv5/yvWcP8M750KovTHzKs+162aJFK0lO6uTSvmHlBfRcdCEAW8fN9VgM2Tl7Of30YQ3vuOBJ2PE93PCbx44NwIGVMOdPMPUtaGf377ee1YvW0CWls/N9juTzyIo9DE5pyk3929esYlT73E4pas4k7Z3zqTr7GTJyMhg4aiARljBiXRimaK2q4sxnFwLw0uWDGOSg/ADAPXM2sSQ9m09mjKRNQnSDbZ/93ELO7tWC+87t1eC+pz0zn7PbW3hwbGqD+z61+DC/7i3k16u6NLjvme/uJiJM8ctVzn8fYHT7jP9gT833n0/rQNMoCxuPlDJrbS47ck6MvU9rHcPQqOMMadvS4YVhrTVlVqjQmooqY8nBiipdr569vWfvPXyU9l37ON3n5KWvTt7n5O/f2/Q7x44Xcl/3VLvxnooLOcPhY6Yn+NoiwyJp17SdZxvVCsKiwdPtelmSZQ8pka1d2zmyNa11JBZrCaV5uyloMcYjMWhLgWu/D0ssWLXnX+OYPVBphZhkl9veF55B6yjnr9vcPfnoikT+0rs3A5rXr6neaMUl9Gnh2j/lai9OHcuts9fz1/cy2PeUww+6rNy5CW1NZFh71z7hhlmTWL4T2l3q/HWrtFahKxJpSjhtY1o22G5ElZWKskhiSHK4+hNAQZkVXXGMwe1iXWoXYNU1KaS9sQuAqR/Xvn7QhIiwOO4ancIfBzQnTCmWLV1HYkQD3U+O1y9xSuVW0CMxtXFPdqBpWAXHKyNJDnPttfAUv0rwovF2j5hF9yXT6bziRjZcIAOXnFl8MA+A/smNm3rvSZMHtuXW2esB+GTVfi4d2qHePpXWKsqtVSTHOR+nXlvrhOiasgXObLdVp6x0sae2X8tovtmZT2F5FYkxjvdbm2VcYB3RNta1hoGEaAvpf+3Jtzvz2XOsjOjwMLSGsZ3iGhyjL+zz5jDJj4FlQA+lVKZSSipjeVFRktGFEaYrsJQfNzka/5VdYoxaSY6JQDUw7ttXfvnb6QDc/cUm+49vNS74XTDAxU90QOfkOLZnFVDVwFDM6ktwvZu7lgqqh0puPep8qORv+42qkyPbuZ7gq13QPZ5bh6dww5AkbkxLkuR+CryW4LXWl2utW2utI7TW7bTWb3rrWMKQ1e1GADrJxCeH5qQbFQyv6d3G5EhO6FZr6b23FtcfATTLdt/Uwa53gVX3NZc3MJt1b4575X97JRv9/2UNDJVcfdA4g+/f0slpvvA6mckaRA71MBJ70+wVoN1bkzNUvL3VGKY2uXPDw/x8acGdZwLwyHdb69yvta6Z4NSnjePx5Ccb1MGY7NTQAty5hcbFy6Ro1z7NNI0yUsayA87HrO/INs7wIyz+8SkpVEmCDyZh4RQlGBfqWqTPMjkY/1NZVUWFrcsiJty/1hZNTW5SM/Lmrs831Nz/4+YsAHq3jnerS6n6DH7bIedL91W3meTCRCeA9ra1WaPDHe+vbSNXekjXiukkwQeZvUNfAaDttudMjsT//LLfmJJ/UZeGJ/+YYfHdYwH4dHVmTeXImz5cC8DTU/u71dZA25DLhrpoqleIcvVfR5htbdZf9jieJbsr17jOMaq9+/3vwrMkwQeZiphWNbdj8mQ0TW2vbDgAwPSerRrY0xyJTSK5YIBxbWDY43NJe+zXmsf6NVAi+GTVFSJX7HVeZ6b6U0OcG0MKIyyQGOP4E9Bi2wXWYW6MoBHeIQk+CO0e9l8AusqSfjWqtCar2DizTI333wt/L18+qOZ2tq1//NfbHU9kcaRnK6O/vqG68KUVVjokxrrV/dO3RQzbssuocjALfpWtpsxAucBqOhkHH4TyW50NQHhFHmGVhVSFmz/e22zLDxlDR0e1du9M2Az7njqPdfuPkVdcweCOzR0uz+dMdb6et/0It4zt5nC/eduP0Dw2EnfO9arP3iurwN7/j+pFPpJj/es6RyiSM/ggld3xUgA6rLvP5Ej8w2ubMgGY0S8wZjQP6tCcs3q2aFRyB2oqTibEOl+Gr0XTaFo3a7j0QW1tmxox7cyxv3TfocJKmkaG+c08g1AmCT5IZfZ9AIDmh346MZslRGmt2Zpr9Av3TQqdTzN928bXrALlyO95JXRJce81GWRbui8zv36p42MlxrBM6X/3D5Lgg5S2RFIW2x6AxBBft3V5ltE90zvR8WLVwSivuKJeca26jxsJ2tWFQaq1aWr07O7Mqf+8ddUlChoxg1V4niT4ILZ7xBsAdFx/r8mRmOuZ1fsAuGtIqqlx+NrZPVtQ5GSiU/XCHeN6uTdstFOC0e2z5lD9yU5LDhiflKrP8oW5JMEHsbK4E5UNowobXgQjGFVpzQHbaJS+flBczJfySoyFQX7Ps782a9ZxWz0ZN/vKI22zUwvL64+xX/m7kfT7tnCvX194hyT4ILe//z8B6LziRpMjMcc3e44CgTF6xtPO7GGUYyitsH8Wf/C4kfibx7p3IVcpRdum4Ww4XL/g2LZs459peAMrJwnfkAQf5HJso2mii/ahrPZHPQSzf63ZB8DfQ6x7praNmXl276+uNNkp2f1rE31SbEXHKk+cxZfbunz6y9m735AEH+yU4lgbY+3ztpufMDkY3yqptNZUPWzfNPSSTt82xqeWSgeVHxftMj7dREe4P169tW2oZHVZAoBltv730R1C62K2P5MEHwL2D3wSgJSM2SZH4lvPrc0A4PIe/lmawNuqE/dKB+UK4qONJN25EWfwaW2Mi6hrD53o3/8+3Vg8ZHzn0LrW4c8kwYeAqvBYKiMTAGh26FfnOweRr3YbZ6g3BcjkJk9rk2Ak4XAHKzst35uLJUw1akJSWmtjGGT1qBmA+fuMAmTVNeOF+aRUQYjYPfwNevx2MZ1X3Ux+imtrtrYvL4ajzRve8eiOU4yuAT8/CDEuxAH0yc6jye5Y8soqeTeiiPAwRauVrtdRPxV9yorhSIJPjuUKC/BRdA7hWxQUJdZ7/OHjeeRbKuD9WXQ/lkvYLtcTc0vg3Ygi1O8Q9oPxCeCFyiIsUYqon70/Br5PXgERB73zjySxpJQmy97yaJv3FxRTGlZJj/2+nR8gCT5EFDfvT267yUQV7sVSWeDSc8KtpVDqwoe8pq2g/bBTjNCOlF7Q+UwoK4RS15YhtFgLURVWDh4rJF5Bp6YxqArXft5TZbGWQKl/jR6JrSokymKB0vr97BEV+bSJtkDpcSyVRajyCrfaTrKUUVGl0WVVFJVXEa/KaR5lQTWwyIgnhFuLsahKr7QdUVWOpdKzdXRiq0oJp5LwBso3e5ok+BCSMfgZt/Y/cmQn50w83UvRuCAuBa7+2q2nbPxpCa2ad+bCOUYd9dXjh+OrFWq3Z+1gzDmjfXQ017z6/mp+2nKYfX8+r95j59/zP7q3jOPnP5/BtoXzGNS1o1ttfzQ/i4825/Fk91bMWpvL7vJyPrmgA+3aeP8sdcPSdSQm1l+g3BM27TtAj0Ge/T0+sTidzKN5PNvJceG3xuvp8BHpgxdB5/8WGF1G1/RyfZHqYJVfYpzlOlq6b1SX5Ea3fWNaEgD3zs1i9zFjNM0QHyR34TpJ8CKoVFSdKCx2U//2JkdjvurJTiUnTXY6ZJvkFBXR+BTQpmndCVIX9vDNtQ7hOumiEUHltW3GVPlhLeOxyGzKmioEWw/mM6bbibP1I/nGpLd2zU/tjHvRNV14e30uzaIs3Dw06ZTaEp4nCV4EDWuVZsUR40LhC2f0MDka/zCogzH6aH9u3cJg27OMxbjbuFkL/mRtmkZw/2ktT6kN4T3SRSOCxo0frAGMssBRDsZ+h5rqxTwO59etG1Ns65Pv7GYteBFY5F0ggkJxeSW/bD0MwGtje5kcjf9o3cyY7LQm41id+1fsMWa3ultoTAQWSfAiKJz93EIA+jYPJ7YRtVWCVfVliLCTrkdEhBtv/cYuCSgCgyR4EfC2Z+VzyFbb/K4BUuiqNqUUfdvGs2jn0Tr3/7wli45JsbJuapCTBC8C3sQXfwPggfN6ESYJq54IO9cjosLlrR8K5LcsAtplM5fV3P7TaZ1NjMR/Vdd7zzxmjKQpKK0gv7SS3q1l3HqwkwQvAtYvWw+z3HaxcMM/Jpgcjf86zTb+fdshoyZP9Yianq0kwQc7SfAiIGUeK+bP760G4NHJfWgmo0Ecqp7MtMM29n1HllHWt21zWRg72EmCFwHnSEEpY56eD8CQjs25amSquQH5ue4tmwKw5aCR4BenGxdcB3VIMCsk4SOS4EVAWbDjCMMenwtAbKSFL24aZXJE/q9ZTAQRFsXi9GwA1mbkAY1byUkEFilVIAJCSbmVQY/+TGmFUU+7VXw0y+872+SoAkfbhBj25RRTYa1ix2GjL16GSAY/v0rwvx8r4Z4vNta5T9tZL1hT/077+8HdhWUc2H+Mjz7b4HA/R226eBfaTqMODuMwzpMdOlhC9O49LhzbXnuOju5ePGVlJcw5urrB/Vxp097erra5cOdRrFUnHrltXDduG9fdwdGFPQPbJ7Avp5ilu3MA6Z4JFX6V4PNLK5i/40i9+xX1zzTsnXzYOx8pragiu7KcZbY/bGfstmn3OI2Px9jXzvNP+r6oyEp4aXG9/ey16s6x7cdj7/mKysoqSnPsxVD7ufaPZO/exr6+vVvHk1tUzhXDO3DTGV3qzcoUDbskrT1frT/IH99aCcC4XlIgLBT4VYLv1TqeFfeN82yjL8XQvm1LJkwd69l2veynHxfRooW5Z6mmr+gkPGZkl7qlfKcP985qSMK/ePUiq1JqolJqh1IqXSl1jzePJYRwTCnFXRN70DEplutGdyIhNtLskIQPeO0MXillAV4BxgOZwCql1Dda660On1RVCcW5ng2kyvsLAAsRCP5yZlf+cmZXs8MIWVVAYaVv85E3u2iGAela6z0ASqnZwGTAcYLP2gTPdPJ8JB39ayFkIURosSjF4QrFDZv2+vS43kzwbYEDtb7PBIafvJNSagYwA6BHu0SY+LjnI+ku09iFEOa5ol8bmhflktykhcfbfszJY95M8PaGOtQbBae1ngnMBEhLS9OMuNGLIQkhhO+1j49hRFPompzg8badJXhvXmTNBGova98OOOjF4wkhhKjFmwl+FdBNKdVJKRUJXAZ848XjCSGEqMVrXTRa60ql1C3AT4AFeEtrvcVbxxNCCFGXVyc6aa2/B7735jGEEELYJ9UkhRAiSEmCF0KIICUJXgghgpQkeCGECFKS4IUQIkhJghdCiCAlCV4IIYKUJHghhAhSkuCFECJISYIXQoggJQleCCGClCR4IYQIUkrremtwmEYpVQDsMDsONyQD2WYH4aZAiznQ4gWJ2RcCLV7wXswdtdYp9h7wajXJRtihtU4zOwhXKaVWB1K8EHgxB1q8IDH7QqDFC+bELF00QggRpCTBCyFEkPK3BD/T7ADcFGjxQuDFHGjxgsTsC4EWL5gQs19dZBVCCOE5/nYGL4QQwkMkwQshRJDyeYJXSk1USu1QSqUrpe6x87hSSr1ke3yjUmqwr2O0E1NDMU+3xbpRKbVUKTXAjDhrxeM03lr7DVVKWZVS03wZn4NYGoxZKXWmUmq9UmqLUmqhr2O0E09DfxfNlFLfKqU22GK+1ow4a8XzllLqiFJqs4PH/fG911DM/vbecxpvrf18897TWvvsC7AAu4HOQCSwAeh90j7nAj8AChgBrPBljI2MeRTQ3Hb7D2bG7Eq8tfabB3wPTAuA1zgB2Ap0sH3fIgBivg942nY7BcgFIk2M+XRgMLDZweN+9d5zMWa/ee+5Em+tvx2fvPd8fQY/DEjXWu/RWpcDs4HJJ+0zGXhPG5YDCUqp1j6Os7YGY9ZaL9VaH7N9uxxo5+MYa3PlNQb4K/AFcMSXwTngSsxXAHO01vsBtNZmx+1KzBpoqpRSQBxGgq/0bZi1gtF6kS0GR/ztvddgzH723nPlNQYfvvd8neDbAgdqfZ9pu8/dfXzJ3XiuxzgLMkuD8Sql2gIXAa/5MC5nXHmNuwPNlVILlFJrlFJX+yw6+1yJ+T9AL+AgsAm4VWtd5ZvwGsXf3nvuMvu91yBfv/d8XapA2bnv5HGaruzjSy7Ho5Q6C+OPbIxXI3LOlXhfBO7WWluNk0vTuRJzODAEOBuIAZYppZZrrXd6OzgHXIn5HGA9MBboAvyilPpNa53v5dgay9/eey7zk/eeK17Eh+89Xyf4TKB9re/bYZzduLuPL7kUj1KqPzAL+IPWOsdHsdnjSrxpwGzbH1gycK5SqlJr/ZVPIqzP1b+LbK11EVCklFoEDADMSvCuxHwt8JQ2Ol7TlVJ7gZ7ASt+E6DZ/e++5xI/ee67w7XvPxxcgwoE9QCdOXJjqc9I+51H3Qs9KX8bYyJg7AOnAKDNjdTXek/Z/B/MvsrryGvcC5tr2jQU2A339POZXgYdtt1sCvwPJJr/WqTi+YOlX7z0XY/ab954r8Z60n9ffez49g9daVyqlbgF+wriS/JbWeotS6kbb469hXFk+1/ZLK8Y4CzKNizH/A0gC/mv7z1ypTap052K8fsWVmLXW25RSPwIbgSpgltba6VA0s2MGHgXeUUptwkiad2utTStxq5T6GDgTSFZKZQIPARHgn+89cClmv3nvgUvx+jYe238SIYQQQUZmsgohRJCSBC+EEEFKErwQQgQpSfBCCBGkJMELIYRJXC1OZtu3o1Jqrq2w2gKlVINlGSTBi6CglEqyVZpcr5TKUkr9brtdqJT6r5eOeVtjSiYopSKVUouUUv626L3wvXeAiS7u+yxGraD+wCPAkw09QYZJiqCjlHoYKNRaP+vFY4QDa4HBWmu3C4gppR7CKFb2oceDEwFFKZUKfKe17mv7vgvwCkYF0mLgz1rr7UqpLcA5WutMWwG741rreGdtyxm8CGq2GvLf2W4/rJR6Vyn1s1Jqn1JqilLqGaXUJqXUj0qpCNt+Q5RSC21FzX5yUFFxLLC2OrnbPjI/rZRaqZTaqZQ6zXZ/H9t9620frbvZnv8VMN3rL4AIRDOBv2qthwB3AtWfQDcAU223L8KoVJrkrCFJ8CLUdMGYkj8Z+ACYr7XuB5QA59mS/MsYU8iHAG8Bj9tpZzSw5qT7wrXWw4DbMGYwAtwI/FtrPRCjDkmm7f7NwFAP/UwiSCil4jBq3H+mlFoPvA5Un2DcCZyhlFoHnIFR+sLpp0fpAxSh5getdYWtfIAF+NF2/yaMGiI9gL4YlR+x7XPITjutgW0n3TfHtl1jawtgGXC/7YLYHK31LgBtVBMsV0o11VoXeOIHE0EhDMiznRDUobU+CEyBmn8EU7XWxxtqTIhQUgagjbrsFfrERagqjBMeBWzRWg+0ffXTWk+w004JEG2vbcBqawut9UfAJNv+PymlxtbaPwoo9cDPJIKENkpJ71VKXQw1yygOsN1OVkpV5+x7MT5dOiUJXoi6dgApSqmRAEqpCKVUHzv7bQO6NtSYUqozsEdr/RLwDdDfdn8ScFRrXeGxyEXAsRUnWwb0UEplKqWux7g2c71SagOwhRMrhZ0J7FBK7cSoTmqv67AO6aIRohatdbkyFkJ+SSnVDOM98iLGG622H4D3XWjyUuBKpVQFkIUxvA3gLIzqjSKEaa0vd/BQvaGTWuvPgc/daV+GSQrRSEqpL4G7qvvV3XzuHOBerfUOz0cmhEG6aIRovHs4McLBZUqpSOArSe7C2+QMXgghgpScwQshRJCSBC+EEEFKErwQQgQpSfBCCBGkJMELIUSQ+n+WloB05EHbUwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -458,7 +458,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -567,12 +567,12 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 67, "id": "6abf0e7f", "metadata": {}, "outputs": [], "source": [ - "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e8})" + "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e6})" ] }, { @@ -593,8 +593,8 @@ }, { "cell_type": "code", - "execution_count": 39, - "id": "2d7cafab", + "execution_count": 38, + "id": "024f4c66", "metadata": {}, "outputs": [], "source": [ @@ -603,7 +603,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 68, "id": "d0c8669f", "metadata": {}, "outputs": [], @@ -611,25 +611,25 @@ "my_lockin.register_trigger_settings(program_name=\"test\",\n", " trigger_input=f\"demods/0/sample.AuxIn1\", # here AuxInN referese to the printer label N+1\n", " edge=\"rising\",\n", - " number_of_triggers_to_buffer=3,\n", - " level=.5,\n", - " count=np.inf,\n", - " other_settings={\"holdoff/time\": 1e-8} #\n", + " trigger_count=3, # this defines the number of triggers to capture in one element (i.e. rows)\n", + " level=.5, # this sets the trigger level\n", + " count=np.inf, # this defined the number of rounds that are to be measured (e.g. how often the \"single\" button should be pressed)\n", + " other_settings={\"holdoff/time\": 1e-3} # this sets the duration for which new triggers are ignored\n", " )\n", "\n", "my_lockin.register_trigger_settings(program_name=\"test\",\n", " trigger_input=f\"demods/0/sample.TrigIn1\", # here TrigInN referese to the printer label N\n", " edge=\"rising\",\n", - " number_of_triggers_to_buffer=3,\n", + " trigger_count=3,\n", " level=.5,\n", " count=3,\n", - " other_settings={\"holdoff/time\": 1e-8}\n", + " other_settings={\"holdoff/time\": 1e-3}\n", " )" ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 69, "id": "f069c321", "metadata": { "scrolled": true @@ -642,56 +642,8 @@ }, { "cell_type": "code", - "execution_count": 42, - "id": "11e558f5", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{None: {'channel_mapping': {'R': {'demods/0/sample.R'},\n", - " 'X': {'demods/0/sample.X'},\n", - " 'Y': {'demods/0/sample.Y'},\n", - " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", - " 'many': {'auxins/0/sample.AuxIn0.avg',\n", - " 'demods/0/sample.R',\n", - " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y'}}},\n", - " 'test': {'trigger_settings': {'trigger_input': '/dev3442/demods/0/sample.TrigIn1',\n", - " 'edge': 'rising',\n", - " 'number_of_triggers_to_buffer': 3,\n", - " 'level': 0.5,\n", - " 'delay': -0.001,\n", - " 'post_delay': 0.001,\n", - " 'endless': False,\n", - " 'count': 3,\n", - " 'other_settings': {'holdoff/time': 1e-08}},\n", - " 'windows': {'X': (array([1.e+09]), array([3.e+08])),\n", - " 'R': (array([6.5e+08, 1.4e+09]), array([1.4e+08, 1.0e+08])),\n", - " 'A': (array([3.0e+08, 1.2e+09]), array([1.5e+08, 3.0e+08]))},\n", - " 'windows_from_start_max': {'X': 1300000000.0,\n", - " 'R': 1500000000.0,\n", - " 'A': 1500000000.0},\n", - " 'all_channels': {'auxins/0/sample.auxin0.avg',\n", - " 'demods/0/sample.r',\n", - " 'demods/0/sample.x'}}}" - ] - }, - "execution_count": 42, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.programs" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "8a82b2a0", + "execution_count": 89, + "id": "2258a41c", "metadata": {}, "outputs": [], "source": [ @@ -700,7 +652,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 88, "id": "cf3ce29e", "metadata": {}, "outputs": [ @@ -716,11 +668,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "sample rates: [None, 1674.107177734375, 1674.107177734375]\n", - "Will record 2512 per row samples for 1.500000000001s!\n", + "sample rates: [107142.859375, 107142.859375, None]\n", + "Will record 1608 per row samples for 0.015000000001000002s!\n", "3 row(s) will be recorded.\n", - "the following trigger settings will be used: {'trigger_input': '/dev3442/demods/0/sample.TrigIn1', 'edge': 'rising', 'number_of_triggers_to_buffer': 3, 'level': 0.5, 'delay': -0.001, 'post_delay': 0.001, 'endless': False, 'count': 3, 'other_settings': {'holdoff/time': 1e-08}}\n", - "MFLI returns a total record time of 1.5005013333333335s\n" + "the following trigger settings will be used: {'trigger_input': '/dev3442/demods/0/sample.TrigIn1', 'edge': 'rising', 'trigger_count': 3, 'level': 0.5, 'delay': -0.001, 'post_delay': 0.001, 'endless': False, 'count': 3, 'other_settings': {'holdoff/time': 1e-08}}\n", + "MFLI returns a total record time of 0.003752s\n" ] } ], @@ -730,7 +682,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 79, "id": "1505ae0a", "metadata": {}, "outputs": [], @@ -742,12 +694,12 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 98, "id": "8504fda1", "metadata": {}, "outputs": [], "source": [ - "for _ in range(3):\n", + "for _ in range(3*3):\n", " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 1)\n", " time.sleep(1)\n", " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 0)\n", @@ -756,7 +708,7 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 85, "id": "8ab20ee5", "metadata": {}, "outputs": [], @@ -766,22 +718,25 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 99, "id": "8d97dfac", "metadata": { "scrolled": true }, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Waiting for device dev3442 to finish the acquisition...\n" + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:740: UserWarning: Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter.\n", + " pass\n", + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:740: UserWarning: Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter.\n", + " pass\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -790,10 +745,38 @@ "needs_background": "light" }, "output_type": "display_data" + } + ], + "source": [ + "data = my_lockin.measure_program(return_raw=False)#(wait=False, fail_if_incomplete=False)\n", + "if data is not None:\n", + " for d in data:\n", + " plot_windows(d)\n", + "else:\n", + " print(\"RETURNED NONE\")" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "69277b3e", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:684: UserWarning: No data has been recorded!\n", + " warnings.warn(f\"No data has been recorded!\")\n", + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:596: UserWarning: The received data for channel auxins/0/sample.auxin0.avg is empty.\n", + " warnings.warn(f\"The received data for channel {_cn} is empty.\")\n", + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:596: UserWarning: The received data for channel auxins/0/sample.auxin0.avg is empty.\n", + " warnings.warn(f\"The received data for channel {_cn} is empty.\")\n" + ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -805,7 +788,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -817,7 +800,7 @@ } ], "source": [ - "data = my_lockin.measure_program()#(wait=False, fail_if_incomplete=False)\n", + "data = my_lockin.measure_program(return_raw=False)#(wait=False, fail_if_incomplete=False)\n", "if data is not None:\n", " for d in data:\n", " plot_windows(d)\n", @@ -827,10 +810,2284 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "06e609d5", + "execution_count": 108, + "id": "3efa4e68", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664887609699785]\n", + " createdtimestamp: [1166080844523]\n", + " changedtimestamp: [1167529609323]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 14:46:49.6996\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1608]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664887657586630]\n", + " createdtimestamp: [1168331979003]\n", + " changedtimestamp: [1180144016443]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 005 14:47:37.5862\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1608]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.r': [\n", + " array([[1.38888485e-07, 1.43719805e-07, 1.48582047e-07, ...,\n", + " 4.34784579e-07, 4.33234794e-07, 4.31670555e-07],\n", + " [4.04857345e-07, 4.03119455e-07, 4.01376717e-07, ...,\n", + " 4.97918708e-07, 5.00165983e-07, 5.02359520e-07],\n", + " [4.41924624e-07, 4.39022641e-07, 4.36096277e-07, ...,\n", + " 7.97933342e-07, 7.96385363e-07, 7.94804775e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.943e+13 1.943e+13 ... 1.946e+13 1.946e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664887609699917]\n", + " createdtimestamp: [1166080844523]\n", + " changedtimestamp: [1167529609323]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 14:46:49.6996\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1608]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[3.63043354e-07, 3.63724650e-07, 3.64442278e-07, ...,\n", + " 1.84079775e-07, 1.83911762e-07, 1.83743967e-07],\n", + " [3.83388020e-07, 3.82172869e-07, 3.80939033e-07, ...,\n", + " 4.64023112e-07, 4.63896600e-07, 4.63726540e-07],\n", + " [6.12628005e-07, 6.12437061e-07, 6.12181524e-07, ...,\n", + " 5.86469886e-07, 5.87969943e-07, 5.89465841e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.947e+13 1.947e+13 ... 1.967e+13 1.967e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664887657586707]\n", + " createdtimestamp: [1168331979003]\n", + " changedtimestamp: [1180144016443]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 005 14:47:37.5862\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1608]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.x': [\n", + " array([[-1.32408364e-07, -1.37151777e-07, -1.41934653e-07, ...,\n", + " -3.26519959e-08, -3.30352718e-08, -3.34245270e-08],\n", + " [ 4.01130200e-07, 3.99142667e-07, 3.97138989e-07, ...,\n", + " -4.93793274e-07, -4.95846580e-07, -4.97835310e-07],\n", + " [ 2.59233217e-07, 2.56886923e-07, 2.54549598e-07, ...,\n", + " -7.81379937e-07, -7.80011266e-07, -7.78618677e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.943e+13 1.943e+13 ... 1.946e+13 1.946e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664887609699837]\n", + " createdtimestamp: [1166080844523]\n", + " changedtimestamp: [1167529609323]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 14:46:49.6996\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1608]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[ 1.51871723e-07, 1.49524831e-07, 1.47228763e-07, ...,\n", + " 9.08997651e-08, 9.05643240e-08, 9.01774605e-08],\n", + " [-2.19322299e-07, -2.20265839e-07, -2.21161545e-07, ...,\n", + " -3.30884282e-07, -3.29631609e-07, -3.28349638e-07],\n", + " [-5.72672766e-07, -5.73008805e-07, -5.73258741e-07, ...,\n", + " 5.86422265e-07, 5.87938626e-07, 5.89447214e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.947e+13 1.947e+13 ... 1.967e+13 1.967e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664887657586670]\n", + " createdtimestamp: [1168331979003]\n", + " changedtimestamp: [1180144016443]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 005 14:47:37.5862\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1608]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.read_memory" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "2519f212", "metadata": {}, "outputs": [], + "source": [ + "data_r1 = my_lockin.measure_program(return_raw=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "119c96e7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_r1" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "id": "0d7e0eb6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:674: UserWarning: No data has been recorded!\n", + " warnings.warn(f\"No data has been recorded!\")\n" + ] + } + ], + "source": [ + "data_r2 = my_lockin.measure_program(return_raw=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "id": "d93364e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{}" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_r2" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "75068d8d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[-0.0005597 , -0.000469 , -0.0003783 , ..., -0.00186879,\n", + " -0.00185745, -0.00184611],\n", + " [-0.00098405, -0.00088201, -0.00077997, ..., -0.0012212 ,\n", + " -0.00115317, -0.00108514],\n", + " [-0.00097637, -0.00101038, -0.0010444 , ..., -0.00090118,\n", + " -0.0008785 , -0.00085583]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886364795117]\n", + " createdtimestamp: [1091745849803]\n", + " changedtimestamp: [1091986551243]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 024 14:26:04.7949\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[-8.42900002e-04, -8.65575612e-04, -8.88251222e-04, ...,\n", + " -2.31813318e-03, -2.37482220e-03, -2.43151123e-03],\n", + " [-7.22152379e-05, -3.82018229e-05, -4.18840788e-06, ...,\n", + " -1.90278484e-03, -1.86877143e-03, -1.83475801e-03],\n", + " [-8.78525512e-04, -8.89863317e-04, -9.01201122e-04, ...,\n", + " -9.62771983e-04, -1.00812320e-03, -1.05347442e-03]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886370722229]\n", + " createdtimestamp: [1092107045323]\n", + " changedtimestamp: [1092347961803]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 025 14:26:10.7220\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[-1.87361530e-03, -1.81692628e-03, -1.76023725e-03, ...,\n", + " -2.81537691e-03, -2.87206594e-03, -2.92875496e-03],\n", + " [-1.33956419e-03, -1.46428005e-03, -1.58899590e-03, ...,\n", + " -2.70161419e-03, -2.66760077e-03, -2.63358736e-03],\n", + " [-1.73439819e-03, -1.79108722e-03, -1.84777624e-03, ...,\n", + " 1.23551705e-05, 8.03820006e-05, 1.48408831e-04]])\n", + " Coordinates:\n", + " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886376646618]\n", + " createdtimestamp: [1092468384203]\n", + " changedtimestamp: [1092709085643]\n", + " flags: [825]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 026 14:26:16.6464\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.r': [\n", + " array([[3.67919224e-07, 2.83155155e-07, 1.98424922e-07, ...,\n", + " 3.46452632e-07, 8.21098062e-07, 9.25034948e-07],\n", + " [1.96074040e-07, 2.21383078e-07, 4.68834272e-07, ...,\n", + " 9.52262078e-07, 4.83415782e-07, 5.52015728e-07],\n", + " [3.55882336e-07, 3.27200774e-07, 4.19314029e-07, ...,\n", + " 2.92538330e-07, 5.21568235e-07, 5.05150107e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886364795192]\n", + " createdtimestamp: [1091745849803]\n", + " changedtimestamp: [1091986551243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 024 14:26:04.7949\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[2.92395192e-07, 2.25222683e-07, 1.21325519e-07, ...,\n", + " 5.39336686e-07, 3.84301196e-07, 3.74622534e-07],\n", + " [3.05529466e-07, 9.36520953e-08, 3.03995805e-07, ...,\n", + " 1.02236696e-06, 9.93392222e-07, 5.19542514e-07],\n", + " [3.01692648e-07, 3.83754234e-07, 2.70232334e-07, ...,\n", + " 5.81183641e-07, 6.24799778e-07, 4.31362127e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886370722270]\n", + " createdtimestamp: [1092107045323]\n", + " changedtimestamp: [1092347961803]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 025 14:26:10.7220\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[7.93975965e-07, 8.93030872e-07, 1.23001589e-06, ...,\n", + " 3.67492049e-07, 2.34827369e-07, 2.35706276e-07],\n", + " [3.61742908e-07, 4.48546210e-07, 2.31477247e-07, ...,\n", + " 5.86607223e-07, 5.45344640e-07, 3.19530491e-07],\n", + " [1.80878244e-07, 1.47223775e-07, 1.42378570e-07, ...,\n", + " 1.75339378e-07, 3.28294689e-07, 8.26655524e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886376646657]\n", + " createdtimestamp: [1092468384203]\n", + " changedtimestamp: [1092709085643]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 026 14:26:16.6464\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.trigin1': [\n", + " array([[0., 1., 1., ..., 0., 0., 0.],\n", + " [0., 1., 1., ..., 0., 0., 0.],\n", + " [0., 1., 1., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886364795316]\n", + " createdtimestamp: [1091745849803]\n", + " changedtimestamp: [1091986551243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 024 14:26:04.7949\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 1., 1., ..., 0., 0., 0.],\n", + " [0., 1., 1., ..., 0., 0., 0.],\n", + " [0., 1., 1., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886370722345]\n", + " createdtimestamp: [1092107045323]\n", + " changedtimestamp: [1092347961803]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 025 14:26:10.7220\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 1., 1., ..., 0., 0., 0.],\n", + " [0., 1., 1., ..., 0., 0., 0.],\n", + " [0., 1., 1., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886376646733]\n", + " createdtimestamp: [1092468384203]\n", + " changedtimestamp: [1092709085643]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 026 14:26:16.6464\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.x': [\n", + " array([[ 6.65674270e-08, -1.10711122e-07, -1.75238995e-07, ...,\n", + " 3.00088872e-07, 5.42731804e-07, 6.73676425e-07],\n", + " [ 1.76368493e-07, 2.20327427e-07, -3.09841778e-07, ...,\n", + " 2.28058119e-07, 2.14299053e-07, 3.54935591e-07],\n", + " [-3.51589550e-07, -3.15060548e-07, -3.47898502e-07, ...,\n", + " 1.59659817e-07, 1.15966965e-07, -5.18576454e-08]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886364795245]\n", + " createdtimestamp: [1091745849803]\n", + " changedtimestamp: [1091986551243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 024 14:26:04.7949\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[-4.09052830e-08, 2.13295121e-08, 5.33865634e-08, ...,\n", + " -4.00140619e-07, -3.50272899e-07, -3.20757666e-07],\n", + " [-1.21754969e-07, -7.33503936e-08, 2.64174546e-07, ...,\n", + " -1.00753722e-06, -7.90096025e-07, -2.52642785e-07],\n", + " [-2.68055140e-07, -2.78390434e-07, -9.46063598e-08, ...,\n", + " -5.33591780e-07, -5.72202191e-07, -4.30658588e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886370722308]\n", + " createdtimestamp: [1092107045323]\n", + " changedtimestamp: [1092347961803]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 025 14:26:10.7220\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[ 1.55824069e-07, 4.11162940e-07, 4.66974725e-07, ...,\n", + " 2.71678622e-07, 2.18573685e-07, -1.56646826e-07],\n", + " [ 3.33768717e-07, 4.47974167e-07, 2.30547319e-07, ...,\n", + " -2.92901103e-07, -1.49833963e-07, 1.35891929e-07],\n", + " [ 1.80673620e-07, 1.28038062e-07, 4.32264639e-08, ...,\n", + " 1.68609698e-07, -3.28192979e-07, -8.26423523e-07]])\n", + " Coordinates:\n", + " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886376646697]\n", + " createdtimestamp: [1092468384203]\n", + " changedtimestamp: [1092709085643]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 026 14:26:16.6464\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1256]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00119467]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "69e61de7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885494031060]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885499560433]\n", + " createdtimestamp: [1039013445533]\n", + " changedtimestamp: [1039023023213]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 002 14:11:39.5600\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886126694424]\n", + " createdtimestamp: [1076950339563]\n", + " changedtimestamp: [1077288735243]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 019 14:22:06.6936\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.r': [\n", + " array([[ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [3.83335709e-07, 3.83594719e-07, 3.83857600e-07, ...,\n", + " nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885494088087]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885499593310]\n", + " createdtimestamp: [1039013445533]\n", + " changedtimestamp: [1039023023213]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 002 14:11:39.5600\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[8.60182422e-08, 8.74794163e-08, 8.90240508e-08, ...,\n", + " nan, nan, nan],\n", + " [6.62406884e-08, 6.46201620e-08, 6.30831144e-08, ...,\n", + " nan, nan, nan],\n", + " [5.27267604e-07, 5.28614361e-07, 5.30040283e-07, ...,\n", + " nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886126698076]\n", + " createdtimestamp: [1076950339563]\n", + " changedtimestamp: [1077288735243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 019 14:22:06.6936\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.trigin1': [\n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885489547296]\n", + " createdtimestamp: [1038982525553]\n", + " changedtimestamp: [1038993876613]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 000 14:11:29.2195\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [ 0., 0., 0., ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885494168868]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885499657769]\n", + " createdtimestamp: [1039013445533]\n", + " changedtimestamp: [1039023023213]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 002 14:11:39.5600\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.747e+13 1.747e+13 ... 1.748e+13 1.748e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885639072999]\n", + " createdtimestamp: [1048217067723]\n", + " changedtimestamp: [1048455009483]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 003 14:13:59.0712\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.748e+13 1.748e+13 ... 1.748e+13 1.748e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885644955400]\n", + " createdtimestamp: [1048575557323]\n", + " changedtimestamp: [1048816518603]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 004 14:14:04.9542\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.748e+13 1.748e+13 ... 1.749e+13 1.749e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885651071285]\n", + " createdtimestamp: [1048934683083]\n", + " changedtimestamp: [1049175017163]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 005 14:14:11.0700\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.762e+13 1.762e+13 ... 1.763e+13 1.763e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885791762410]\n", + " createdtimestamp: [1057372530123]\n", + " changedtimestamp: [1057611081163]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 006 14:16:31.7604\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.763e+13 1.763e+13 ... 1.763e+13 1.763e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885797604338]\n", + " createdtimestamp: [1057731646923]\n", + " changedtimestamp: [1057971963083]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 007 14:16:37.5946\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.763e+13 1.763e+13 ... 1.764e+13 1.764e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885803622668]\n", + " createdtimestamp: [1058092555723]\n", + " changedtimestamp: [1058331088843]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 008 14:16:43.6214\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.77e+13 1.77e+13 ... 1.771e+13 1.771e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885871598865]\n", + " createdtimestamp: [1062162716363]\n", + " changedtimestamp: [1062400613323]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 009 14:17:51.5969\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.771e+13 1.771e+13 ... 1.771e+13 1.771e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885877429641]\n", + " createdtimestamp: [1062521824203]\n", + " changedtimestamp: [1062762167243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 010 14:17:57.4282\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.771e+13 1.771e+13 ... 1.772e+13 1.772e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885883413040]\n", + " createdtimestamp: [1062882741963]\n", + " changedtimestamp: [1063120674763]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 011 14:18:03.4118\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.782e+13 1.782e+13 ... 1.782e+13 1.782e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885985636933]\n", + " createdtimestamp: [1069007968203]\n", + " changedtimestamp: [1069245453003]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 012 14:19:45.6351\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.782e+13 1.782e+13 ... 1.783e+13 1.783e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885991611307]\n", + " createdtimestamp: [1069365866443]\n", + " changedtimestamp: [1069607607243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 013 14:19:51.6101\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.783e+13 1.783e+13 ... 1.783e+13 1.783e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885997735588]\n", + " createdtimestamp: [1069727993803]\n", + " changedtimestamp: [1069966114763]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 014 14:19:57.7343\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.789e+13 1.789e+13 ... 1.79e+13 1.79e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886060607309]\n", + " createdtimestamp: [1073499831243]\n", + " changedtimestamp: [1073737351883]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 015 14:21:00.6054\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.79e+13 1.79e+13 1.79e+13 ... 1.79e+13 1.79e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886066623023]\n", + " createdtimestamp: [1073858338763]\n", + " changedtimestamp: [1074098852043]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 016 14:21:06.6218\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]])\n", + " Coordinates:\n", + " time (row, col) float64 1.79e+13 1.79e+13 ... 1.791e+13 1.791e+13\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886072592296]\n", + " createdtimestamp: [1074219838923]\n", + " changedtimestamp: [1074457977803]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 017 14:21:12.5911\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [10045]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [0.00014933]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[ 0., 0., 0., ..., nan, nan, nan],\n", + " [ 0., 0., 0., ..., nan, nan, nan],\n", + " [ 0., 0., 0., ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886120155827]\n", + " createdtimestamp: [1076891918123]\n", + " changedtimestamp: [1076929715883]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 018 14:22:00.1345\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[ 0., 0., 0., ..., nan, nan, nan],\n", + " [ 0., 0., 0., ..., nan, nan, nan],\n", + " [ 0., 0., 0., ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886126705825]\n", + " createdtimestamp: [1076950339563]\n", + " changedtimestamp: [1077288735243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 019 14:22:06.6936\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[ 0., 0., 0., ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 1.796e+13 1.796e+13 1.796e+13 ... 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886132860354]\n", + " createdtimestamp: [1077609510523]\n", + " changedtimestamp: [1077652213403]\n", + " flags: [1848]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 020 14:22:12.8482\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]],\n", + " '/dev3442/demods/0/sample.x': [\n", + " array([[ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [-3.79128012e-07, -3.79368980e-07, -3.79612937e-07, ...,\n", + " nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885494133030]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664885499625269]\n", + " createdtimestamp: [1039013445533]\n", + " changedtimestamp: [1039023023213]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 002 14:11:39.5600\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[ 5.15736266e-08, 5.26349600e-08, 5.37237984e-08, ...,\n", + " nan, nan, nan],\n", + " [-6.12978321e-08, -5.92433298e-08, -5.72438376e-08, ...,\n", + " nan, nan, nan],\n", + " [-4.08640255e-08, -3.73170793e-08, -3.38018236e-08, ...,\n", + " nan, nan, nan]])\n", + " Coordinates:\n", + " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886126701691]\n", + " createdtimestamp: [1076950339563]\n", + " changedtimestamp: [1077288735243]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 019 14:22:06.6936\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.read_memory" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "3717ff32", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'X': {'/dev3442/demods/0/sample.x': [\n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886120147957]\n", + " createdtimestamp: [1076891918123]\n", + " changedtimestamp: [1076929715883]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 018 14:22:00.1345\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]},\n", + " 'R': {'/dev3442/demods/0/sample.r': [\n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886120141796]\n", + " createdtimestamp: [1076891918123]\n", + " changedtimestamp: [1076929715883]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 018 14:22:00.1345\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886120141796]\n", + " createdtimestamp: [1076891918123]\n", + " changedtimestamp: [1076929715883]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 018 14:22:00.1345\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]},\n", + " 'A': {'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[-0.00221065, -0.00221092, -0.00221119, ..., -0.00150499,\n", + " -0.00150526, -0.00150552]])\n", + " Coordinates:\n", + " time (row, col) float64 3e+08 3e+08 3e+08 ... 4.5e+08 4.5e+08 4.5e+08\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886120135151]\n", + " createdtimestamp: [1076891918123]\n", + " changedtimestamp: [1076929715883]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 018 14:22:00.1345\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886120135151]\n", + " createdtimestamp: [1076891918123]\n", + " changedtimestamp: [1076929715883]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 018 14:22:00.1345\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}},\n", + " {'X': {'/dev3442/demods/0/sample.x': [\n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886132856158]\n", + " createdtimestamp: [1077609510523]\n", + " changedtimestamp: [1077652213403]\n", + " flags: [1848]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 020 14:22:12.8482\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]},\n", + " 'R': {'/dev3442/demods/0/sample.r': [\n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886132852379]\n", + " createdtimestamp: [1077609510523]\n", + " changedtimestamp: [1077652213403]\n", + " flags: [1848]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 020 14:22:12.8482\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([], shape=(0, 0), dtype=float64)\n", + " Coordinates:\n", + " time (row, col) float64 \n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886132852379]\n", + " createdtimestamp: [1077609510523]\n", + " changedtimestamp: [1077652213403]\n", + " flags: [1848]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 020 14:22:12.8482\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]},\n", + " 'A': {'/dev3442/auxins/0/sample.auxin0.avg': [\n", + " array([[-0.00127274, -0.00127318, -0.00127363, ..., -0.00089014,\n", + " -0.00088996, -0.00088978]])\n", + " Coordinates:\n", + " time (row, col) float64 3e+08 3e+08 3e+08 ... 4.5e+08 4.5e+08 4.5e+08\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886132848581]\n", + " createdtimestamp: [1077609510523]\n", + " changedtimestamp: [1077652213403]\n", + " flags: [824]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 020 14:22:12.8482\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan],\n", + " \n", + " array([[-0.00359344, -0.00359255, -0.00359166, ..., -0.00202245,\n", + " -0.00202272, -0.00202298]])\n", + " Coordinates:\n", + " time (row, col) float64 1.2e+09 1.2e+09 1.2e+09 ... 1.5e+09 1.5e+09\n", + " Dimensions without coordinates: row, col\n", + " Attributes:\n", + " systemtime: [1664886132848581]\n", + " createdtimestamp: [1077609510523]\n", + " changedtimestamp: [1077652213403]\n", + " flags: [824]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 020 14:22:12.8482\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [0]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [160715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [9.33333333e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}}]" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "90131f4e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m(1160)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 1158 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1159 \u001b[1;33m \u001b[0marray\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_indexing_array_and_key\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m-> 1160 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0marray\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1161 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1162 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\variable.py\u001b[0m(786)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 784 \u001b[1;33m \"\"\"\n", + "\u001b[0m\u001b[1;32m 785 \u001b[1;33m \u001b[0mdims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnew_order\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_broadcast_indexes\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 786 \u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mas_indexable\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_data\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 787 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mnew_order\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 788 \u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmoveaxis\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnew_order\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnew_order\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\variable.py\u001b[0m(1193)\u001b[0;36misel\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 1191 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1192 \u001b[1;33m \u001b[0mkey\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtuple\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdim\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mslice\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mdim\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdims\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m-> 1193 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1194 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1195 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0msqueeze\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> uu\n", + "*** NameError: name 'uu' is not defined\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(1208)\u001b[0;36misel\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 1206 \u001b[1;33m \u001b[1;31m# lists, or zero or one-dimensional np.ndarray's\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1207 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m-> 1208 \u001b[1;33m \u001b[0mvariable\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_variable\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmissing_dims\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmissing_dims\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1209 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 1210 \u001b[1;33m \u001b[0mcoords\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(745)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 743 \u001b[1;33m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 744 \u001b[1;33m \u001b[1;31m# xarray-style array indexing\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 745 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_item_key_to_dict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 746 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 747 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mAny\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mAny\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(593)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 591 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ml\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0m_wind\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 592 \u001b[1;33m \u001b[1;31m# _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)[\"time\"][:, 0].values\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 593 \u001b[1;33m \u001b[0m_time_of_first_not_nan_value\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mapplicable_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"time\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 594 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 595 \u001b[1;33m \u001b[0mtime_of_trigger\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mapplicable_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mattrs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"gridcoloffset\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m1e9\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0m_time_of_first_not_nan_value\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> u\n", + "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(735)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", + "\u001b[1;32m 733 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 734 \u001b[1;33m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m--> 735 \u001b[1;33m \u001b[0mthat_shot_parsed\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mthat_shot\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcurrently_set_program\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 736 \u001b[1;33m \u001b[1;31m# except KeyError:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[1;32m 737 \u001b[1;33m \u001b[1;31m# print(f\"Error\")\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + "ipdb> that_shot\n", + "{'/dev3442/demods/0/sample.r': [\n", + "array([[ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [3.83335709e-07, 3.83594719e-07, 3.83857600e-07, ...,\n", + " nan, nan, nan]])\n", + "Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664885494088087]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]], '/dev3442/demods/0/sample.x': [\n", + "array([[ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [ nan, nan, nan, ...,\n", + " nan, nan, nan],\n", + " [-3.79128012e-07, -3.79368980e-07, -3.79612937e-07, ...,\n", + " nan, nan, nan]])\n", + "Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664885494133030]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]], '/dev3442/auxins/0/sample.auxin0.avg': [\n", + "array([[nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan],\n", + " [nan, nan, nan, ..., nan, nan, nan]])\n", + "Coordinates:\n", + " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1664885494031060]\n", + " createdtimestamp: [1038999074673]\n", + " changedtimestamp: [1039009255333]\n", + " flags: [313]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 14:11:34.0307\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [1285715]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [1.16666667e-06]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]]}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ipdb> r\n" + ] + } + ], "source": [ "%debug" ] @@ -838,7 +3095,7 @@ { "cell_type": "code", "execution_count": 84, - "id": "81b98b2a", + "id": "0eb17aad", "metadata": {}, "outputs": [ { @@ -859,7 +3116,7 @@ { "cell_type": "code", "execution_count": 71, - "id": "5b72a01b", + "id": "2453eef6", "metadata": {}, "outputs": [ { diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index f82910c64..9408d82b4 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -7,7 +7,9 @@ from enum import Enum import warnings import time +import traceback import xarray as xr +import numpy as np from qupulse.utils.types import TimeType from qupulse.hardware.dacs.dac_base import DAC @@ -27,8 +29,6 @@ # backward compability from zhinst import ziPython as zhinst_core -# from zhinst.toolkit import Session -import numpy as np """ @@ -205,7 +205,7 @@ def register_measurement_windows(self, program_name: str, windows: Dict[str, Tup # for k, v in windows.items(): # self.set_measurement_mask(program_name=program_name, mask_name=k, begins=v[0], lengths=v[1]) - def register_trigger_settings(self, program_name:str, trigger_input:Union[str, None]=None, edge:str='rising', number_of_triggers_to_buffer:int=1, level:float=0.1, delay:float=-1e-3, post_delay:float=1e-3, count:bool=np.inf, other_settings:Dict[str, Union[str, int, float]]={}): + def register_trigger_settings(self, program_name:str, trigger_input:Union[str, None]=None, edge:str='rising', trigger_count:int=1, level:float=0.1, delay:float=-1e-3, post_delay:float=1e-3, count:bool=np.inf, other_settings:Dict[str, Union[str, int, float]]={}): """ Parameters ---------- @@ -213,7 +213,7 @@ def register_trigger_settings(self, program_name:str, trigger_input:Union[str, N trigger_input This needs to be the path to input to the lock-in that the lock-in is able to use as a trigger (without the device serial). (see https://docs.zhinst.com/pdf/LabOneProgrammingManual.pdf for more information) edge - number_of_triggers_to_buffer + trigger_count other_settings """ @@ -223,7 +223,7 @@ def register_trigger_settings(self, program_name:str, trigger_input:Union[str, N self.programs.setdefault(program_name, {})["trigger_settings"] = { "trigger_input": f"/{self.serial}/{trigger_input}", "edge": edge, - "number_of_triggers_to_buffer": number_of_triggers_to_buffer, + "trigger_count": trigger_count, "level": level, "delay": delay, "post_delay": post_delay, @@ -456,7 +456,7 @@ def arm_program(self, program_name: str, force:bool=True) -> None: rows = 1 if len(ts) != 0: - rows = ts["number_of_triggers_to_buffer"] + rows = ts["trigger_count"] # selecting the trigger channel if ts["trigger_input"] is not None: @@ -472,7 +472,6 @@ def arm_program(self, program_name: str, force:bool=True) -> None: self.daq.set("type", 1) self.daq.set("triggernode", ts["trigger_input"]) - self.daq.subscribe(ts["trigger_input"]) edge_key = ["rising", "falling", "both"].index(ts["edge"]) self.daq.set("edge", edge_key) @@ -510,7 +509,7 @@ def arm_program(self, program_name: str, force:bool=True) -> None: print(f"Will record {larges_number_of_samples} per row samples for {measurement_duration*1e-9}s!") # TODO this will have to change if proper multi triggers with over multiple rows is going to be used. print(f"{rows} row(s) will be recorded.") print(f"the following trigger settings will be used: {ts}") - print(f"MFLI returns a total record time of {self.daq.get('duration')['duration'][0]}s") + print(f"MFLI returns a duration of {self.daq.get('duration')['duration'][0]}s") # execute daq self.daq.execute() @@ -537,6 +536,9 @@ def force_trigger(self, program_name:str): def stop_acquisition(self): self.daq.finish() + def clear_memory(self): + self.read_memory = {} + def delete_program(self, program_name: str) -> None: """Delete program from internal memory.""" @@ -553,7 +555,7 @@ def clear(self) -> None: self.unarm_program(program_name=None) self.read_memory = {} - def _parse_data(self, recorded_data, program_name:str): + def _parse_data(self, recorded_data, program_name:str, fail_on_empty:bool=True): """ This function parses the recorded data and extracts the measurement masks and applies optional operations """ @@ -587,9 +589,17 @@ def _parse_data(self, recorded_data, program_name:str): applicable_data = recorded_data[cn][-1-shot_index] applicable_data = applicable_data.where(~np.isnan(applicable_data), drop=True) + if len(applicable_data)==0 or np.product([*applicable_data.shape])==0: + if fail_on_empty: + raise ValueError(f"The received data for channel {_cn} is empty.") + else: + warnings.warn(f"The received data for channel {_cn} is empty.") + continue + extracted_data = [] for b, l in zip(*_wind): # _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)["time"][:, 0].values + _time_of_first_not_nan_value = applicable_data["time"][:, 0].values time_of_trigger = applicable_data.attrs["gridcoloffset"][0]*1e9+_time_of_first_not_nan_value @@ -608,7 +618,7 @@ def _parse_data(self, recorded_data, program_name:str): return masked_data - def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout:float=np.inf, return_raw:bool=False, fail_if_incomplete:bool=False) -> Union[Dict[str, List[xr.DataArray]], Dict[str, Dict[str, List[xr.DataArray]]]]: + def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout:float=np.inf, return_raw:bool=False, fail_if_incomplete:bool=False, fail_on_empty:bool=False) -> Union[Dict[str, List[xr.DataArray]], Dict[str, Dict[str, List[xr.DataArray]]]]: """Get the last measurement's results of the specified operations/channels Parameters @@ -625,15 +635,18 @@ def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout: Also, if False, the time axis will be shifted, such that the trigger occurred at data[window_name][channel_name][mask_index]["time"]==0 #ns. fail_if_incomplete: bool, optional if True and the timeout has been reached and the acquisition has not finished, an error will be raised. + fail_on_empty:bool, optional + if one of the channels is empty, which occurred in the development process for large sample rates, an error is raised in the parsing function and this these incomplete measurements will sit in this classes memory, never to be returned. If False, the empty channels are ignored and it will be returned, what every is there. """ # wait until the data acquisition has finished # TODO implement timeout start_waiting = time.time() - while not self.daq.finished() and wait and not (time.time()-start_waiting>timeout): + while not self.daq.finished() and wait and not (time.time()-start_waiting>timeout) and not self.programs[self.currently_set_program]["trigger_settings"]["count"]==np.inf: time.sleep(1) - print(f"Waiting for device {self.serial} to finish the acquisition...") # Progress: {self.daq.progress()[0]} + print(f"Waiting for device {self.serial} to finish the acquisition...") + print(f"Progress: {self.daq.progress()[0]}") if fail_if_incomplete and not self.daq.finished(): raise ValueError(f"Device {self.serial} did not finish the acquisition in time.") @@ -732,12 +745,18 @@ def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout: that_shot[c] = [self.read_memory[c][i]] # Here the inner list could be removed if one would remove the old functionality from the _parse_data function. try: - that_shot_parsed = self._parse_data(that_shot, self.currently_set_program) - # except KeyError: - # print(f"Error") - # warnings.warn(f"Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory, resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter.") - except: - raise + that_shot_parsed = self._parse_data(that_shot, self.currently_set_program, fail_on_empty=fail_on_empty) + except IndexError as e: + traceback.print_exc() + warnings.warn(f"Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter.") + except KeyError as e: + traceback.print_exc() + warnings.warn(f"Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter.") + except ValueError as e: + if "The received data for channel" in str(e): + pass + else: + raise else: # the parsing worked, we can now remove the data from the memory results.append(that_shot_parsed) From efa69a1e44a5ba927540f2e3f7eed9e6f2461cc3 Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Tue, 4 Oct 2022 15:29:07 +0200 Subject: [PATCH 14/25] small changes --- ...struments_lockin_mfli_daq-checkpoint.ipynb | 222 ++++++++++++++---- .../zurich_instruments_lockin_mfli_daq.ipynb | 222 ++++++++++++++---- qupulse/hardware/dacs/mfli.py | 6 +- 3 files changed, 365 insertions(+), 85 deletions(-) diff --git a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb index 20760fd2c..611b9079d 100644 --- a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb +++ b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb @@ -575,6 +575,16 @@ "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e6})" ] }, + { + "cell_type": "code", + "execution_count": 112, + "id": "d02ed4aa", + "metadata": {}, + "outputs": [], + "source": [ + "test_program_single = combined_pulse.create_program(measurement_mapping={\"A\":None, \"R\":\"R\", \"T\":None},parameters={\"dt\": 1e6})" + ] + }, { "cell_type": "code", "execution_count": 37, @@ -594,7 +604,7 @@ { "cell_type": "code", "execution_count": 38, - "id": "024f4c66", + "id": "cd8f83e8", "metadata": {}, "outputs": [], "source": [ @@ -643,7 +653,7 @@ { "cell_type": "code", "execution_count": 89, - "id": "2258a41c", + "id": "0e0ddc37", "metadata": {}, "outputs": [], "source": [ @@ -759,7 +769,7 @@ { "cell_type": "code", "execution_count": 111, - "id": "69277b3e", + "id": "dfc88289", "metadata": {}, "outputs": [ { @@ -811,7 +821,7 @@ { "cell_type": "code", "execution_count": 108, - "id": "3efa4e68", + "id": "d34c362a", "metadata": {}, "outputs": [ { @@ -1040,79 +1050,209 @@ }, { "cell_type": "code", - "execution_count": 60, - "id": "2519f212", + "execution_count": null, + "id": "e0279a45", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d96d4b0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "00f4e282", "metadata": {}, "outputs": [], "source": [ - "data_r1 = my_lockin.measure_program(return_raw=True)" + "my_lockin.clear_memory()\n", + "my_lockin.reset_daq_module()" ] }, { "cell_type": "code", - "execution_count": 61, - "id": "119c96e7", + "execution_count": 117, + "id": "28689c4e", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(None), update=True)\n", + "setup.register_program('test2', test_program_single, run_callback=lambda *a, **b: None, update=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "id": "d5934ebe", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{}" - ] - }, - "execution_count": 61, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "data_r1" + "my_lockin.register_trigger_settings(program_name=\"test2\",\n", + " trigger_input=f\"demods/0/sample.TrigIn1\", # here TrigInN referese to the printer label N\n", + " edge=\"rising\",\n", + " trigger_count=3,\n", + " level=.5,\n", + " count=3,\n", + " other_settings={\"holdoff/time\": 1e-3}\n", + " )" ] }, { "cell_type": "code", - "execution_count": 107, - "id": "0d7e0eb6", + "execution_count": 119, + "id": "ad0ed003", "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:674: UserWarning: No data has been recorded!\n", - " warnings.warn(f\"No data has been recorded!\")\n" + "sample rates: [107142.859375]\n", + "Will record 1608 per row samples for 0.015000000001000002s!\n", + "3 row(s) will be recorded.\n", + "the following trigger settings will be used: {'trigger_input': '/dev3442/demods/0/sample.TrigIn1', 'edge': 'rising', 'trigger_count': 3, 'level': 0.5, 'delay': -0.001, 'post_delay': 0.001, 'endless': False, 'count': 3, 'other_settings': {'holdoff/time': 0.001}}\n", + "MFLI returns a duration of 0.01s\n" ] } ], "source": [ - "data_r2 = my_lockin.measure_program(return_raw=True)" + "setup.run_program(\"test2\")" ] }, { "cell_type": "code", - "execution_count": 108, - "id": "d93364e5", + "execution_count": 129, + "id": "46a571d7", + "metadata": {}, + "outputs": [], + "source": [ + "for _ in range(3*3):\n", + " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 1)\n", + " time.sleep(1)\n", + " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 0)\n", + " time.sleep(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "id": "57df3ce1", "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "{}" + "
" ] }, - "execution_count": 108, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "data_r2" + "data = my_lockin.measure_program(return_raw=False)#(wait=False, fail_if_incomplete=False)\n", + "if data is not None:\n", + " for d in data:\n", + " plot_windows(d)\n", + "else:\n", + " print(\"RETURNED NONE\")" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "c894793c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23d79a08", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e61a3cf1", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "453ec743", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1eae59e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d8716e9b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15826bae", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": 88, - "id": "75068d8d", + "id": "cc324843", "metadata": {}, "outputs": [ { @@ -1555,7 +1695,7 @@ { "cell_type": "code", "execution_count": 77, - "id": "69e61de7", + "id": "20bb0981", "metadata": {}, "outputs": [ { @@ -2577,7 +2717,7 @@ { "cell_type": "code", "execution_count": 75, - "id": "3717ff32", + "id": "974e560e", "metadata": {}, "outputs": [ { @@ -2910,7 +3050,7 @@ { "cell_type": "code", "execution_count": 48, - "id": "90131f4e", + "id": "c29511b9", "metadata": {}, "outputs": [ { @@ -3095,7 +3235,7 @@ { "cell_type": "code", "execution_count": 84, - "id": "0eb17aad", + "id": "76dd008a", "metadata": {}, "outputs": [ { @@ -3116,7 +3256,7 @@ { "cell_type": "code", "execution_count": 71, - "id": "2453eef6", + "id": "8816fccf", "metadata": {}, "outputs": [ { diff --git a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb index 20760fd2c..611b9079d 100644 --- a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb +++ b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb @@ -575,6 +575,16 @@ "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e6})" ] }, + { + "cell_type": "code", + "execution_count": 112, + "id": "d02ed4aa", + "metadata": {}, + "outputs": [], + "source": [ + "test_program_single = combined_pulse.create_program(measurement_mapping={\"A\":None, \"R\":\"R\", \"T\":None},parameters={\"dt\": 1e6})" + ] + }, { "cell_type": "code", "execution_count": 37, @@ -594,7 +604,7 @@ { "cell_type": "code", "execution_count": 38, - "id": "024f4c66", + "id": "cd8f83e8", "metadata": {}, "outputs": [], "source": [ @@ -643,7 +653,7 @@ { "cell_type": "code", "execution_count": 89, - "id": "2258a41c", + "id": "0e0ddc37", "metadata": {}, "outputs": [], "source": [ @@ -759,7 +769,7 @@ { "cell_type": "code", "execution_count": 111, - "id": "69277b3e", + "id": "dfc88289", "metadata": {}, "outputs": [ { @@ -811,7 +821,7 @@ { "cell_type": "code", "execution_count": 108, - "id": "3efa4e68", + "id": "d34c362a", "metadata": {}, "outputs": [ { @@ -1040,79 +1050,209 @@ }, { "cell_type": "code", - "execution_count": 60, - "id": "2519f212", + "execution_count": null, + "id": "e0279a45", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d96d4b0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "00f4e282", "metadata": {}, "outputs": [], "source": [ - "data_r1 = my_lockin.measure_program(return_raw=True)" + "my_lockin.clear_memory()\n", + "my_lockin.reset_daq_module()" ] }, { "cell_type": "code", - "execution_count": 61, - "id": "119c96e7", + "execution_count": 117, + "id": "28689c4e", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(None), update=True)\n", + "setup.register_program('test2', test_program_single, run_callback=lambda *a, **b: None, update=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "id": "d5934ebe", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{}" - ] - }, - "execution_count": 61, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "data_r1" + "my_lockin.register_trigger_settings(program_name=\"test2\",\n", + " trigger_input=f\"demods/0/sample.TrigIn1\", # here TrigInN referese to the printer label N\n", + " edge=\"rising\",\n", + " trigger_count=3,\n", + " level=.5,\n", + " count=3,\n", + " other_settings={\"holdoff/time\": 1e-3}\n", + " )" ] }, { "cell_type": "code", - "execution_count": 107, - "id": "0d7e0eb6", + "execution_count": 119, + "id": "ad0ed003", "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:674: UserWarning: No data has been recorded!\n", - " warnings.warn(f\"No data has been recorded!\")\n" + "sample rates: [107142.859375]\n", + "Will record 1608 per row samples for 0.015000000001000002s!\n", + "3 row(s) will be recorded.\n", + "the following trigger settings will be used: {'trigger_input': '/dev3442/demods/0/sample.TrigIn1', 'edge': 'rising', 'trigger_count': 3, 'level': 0.5, 'delay': -0.001, 'post_delay': 0.001, 'endless': False, 'count': 3, 'other_settings': {'holdoff/time': 0.001}}\n", + "MFLI returns a duration of 0.01s\n" ] } ], "source": [ - "data_r2 = my_lockin.measure_program(return_raw=True)" + "setup.run_program(\"test2\")" ] }, { "cell_type": "code", - "execution_count": 108, - "id": "d93364e5", + "execution_count": 129, + "id": "46a571d7", + "metadata": {}, + "outputs": [], + "source": [ + "for _ in range(3*3):\n", + " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 1)\n", + " time.sleep(1)\n", + " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 0)\n", + " time.sleep(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "id": "57df3ce1", "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "{}" + "
" ] }, - "execution_count": 108, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEQCAYAAACgBo8fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA2IElEQVR4nO3deXCc933n+ff3eZ6+TxyNgwDBQ6QoiTpp6vAZX5tYjjfeyXhmlM0kVd5UqZz1prJVu5WZ2drK1szu1O5szWQyjhOrlEw2ySaxN/HEjuPYTpw4tuWDkimZuiWSAu8DaBBA308fz/PbP7qbakKgCEqNbnTj+6pCsdH98MGPLeGDH77P9/d7xBiDUkqpwWf1ewBKKaW6QwNdKaWGhAa6UkoNCQ10pZQaEhroSik1JDTQlVJqSPQ10EXk90VkUURe6MK5PiAixzo+XBH5b7owTKWUGgjSzz50EXkfUAT+yBhzZxfPOwqcBGaNMeVunVcppbayvs7QjTHfBZY7nxORW0TkGyLytIg8ISK3vYVTfwL4uoa5Umo72Yo19MeBXzHGvAP4n4HfeQvneAT4fFdHpZRSW5zT7wF0EpE48C7gz0Wk/XSo9drPAv9mnb92wRjzUx3nmAbuAv5mc0erlFJby5YKdJq/MawaY+5d+4Ix5i+Av9jAOf4p8CVjTL3LY1NKqS1tS5VcjDF54JSI/BMAabrnJk/zc2i5RSm1DfW7bfHzwA+BAyJyXkR+Cfh54JdE5FngReDjN3G+3cBO4DubMFyllNrS+tq2qJRSqnu2VMlFKaXUW9e3i6Lj4+Nm9+7d/frySik1kJ5++uklY0xmvdf6Fui7d+/m6NGj/frySik1kETkzPVe21DJRUTSIvJFEXlFRF4WkXeueV1E5DMiclJEnhORQ2930EoppW7ORmfo/wn4hjHmEyISBKJrXn8Y2N/6eBD4XOtPpZRSPXLDGbqIJIH3Af8ZwBhTM8asrjns4zQ32DLGmCNAurViUymlVI9spOSyF8gC/4+I/FhEfk9EYmuOmQHOdXx+vvXcNUTkURE5KiJHs9nsWx60UkqpN9pIoDvAIeBzxpj7gBLwL9ccI2/4W/CGBndjzOPGmMPGmMOZzLoXaZVSSr1FGwn088B5Y8yTrc+/SDPg1x6zs+PzWeDi2x/e8ClWG+Tda7eZybt1itVGn0aklBoWNwx0Y8xl4JyIHGg99SHgpTWHfQX4xVa3y0NAzhhzqbtDHXwLeZdnzy0zny1eDfVXL+c5enqZhZzb59EppQbdRrtcfgX4k1aHyzzwSRH5FIAx5jHga8BHad4lqAx8chPGOtAW8i4nFvKsVuqslOucWy7zNy9c5o7pJBPJMAemEv0eolJqwG0o0I0xx4DDa55+rON1A3y6e8MaLu0wr3k+Icfi1csFfutbrwEwGg3yoTsmmUmv7QRVSqmbs9X2Q98S5rNFTmWLVz+fHW2G7fmV1+9ot2c8zt5MfEPnOrmYx7EtPN/w/IUcv/2teRxbeOeeEe7ZlWY6Hen+P0Ipte1ooHdYyLvMZwvkK3WWijUWVivkqw3OXikhYtg5EicZdphMRWh4Pgt5l72ZOJPJ8BvOVaw2mM8WuLRawTfg1hscObXM5588R8ixuGM6zn27Rwg5FvPZInszcZLhQB/+1UqpXihWG/jGXPN9nnfrWCLEQ92JYg10Xg/fXLlO3q3jNnwcgafOrHBysUil7uNYcP6Ky0O3jHFwNkWp6lGolCm4NfZNJK+Zrc9ni8xnC5RqHgHbAmP44yNneer0CiFH2DsW4cN3TLF/Mk614XN+pUw0aGugKzXEfGOo1DwAkuEAebdOpeYRCdpd+xrbPtCL1QYnFwucuVIiYFskwwG+89xFvvzji9Q8g2MJAVvIuT45t8yFQpXTK2Xec8s4E6kwDR9OLORZyLskwg4Ft06+UqdU9fB9w2uLJf70ybMslWrEgha7x6J87O4d7JuMY1tCyLGIBh1SkWC/3wql1CZptyVHgjb/7e8e4SfvmOKjd00RCzldncht60Bvh3m20AzjfKXOb//wDEfml4kGbfaNh5lKhxERGg2fC6sup66U+c7xK5xeKvHuW8YYiQZx6z6+bwiHLNyaj1hCyBGOzK/w7PkcxkAmFmDfZIyfvGOasXgQ2xI835BJhNk3kejar1xKqa2n4NYptUL9hQt53rc/w1KxSqzL3/fbNkU6w9y2hLrn8/8eOcvTZ1ZJRRymEkHGE0EsESYTIQxC0BaSYZtXF0ucWXZZLFzi4HScVCSAbQueD5aBpVKNE9kSxapHJGAxGQ9yYDrOe2+dJBMP4hsoug3mxmIa5kptA7GQQ7nq8XcvLwAwmQwhCH6X7xi3bZNkIee+HuYNn899Z55j53KkwjZz6RC370gxm45Qrvu49Wbda2Yszu6MsGs8zo/PrXJ2ucLRs3lGYwGiAZtq3aNU8yjXfYK2MJMMMpYIsW8izn07R0iEHTwDtsDuVpeMhrlSw88SoeH7PH8hhy3CnTMp4iGHat0n79a7VnbZlmkyny1ycbVMMhwk79b4wx+c4di5HOmwzcEdCX7qrh2kIgECtkUi5LCQr1JpNEiGm8/ZAjtHIjx1apn5pTL5aoPVcp2AbREPOUwmbeJhh2TY4eCOFO/YNUKp6lGv+0QC1hsuoiqlhlex2iBXqVFr+LyWLbJ7PEqu0sqLsIMl622F9dZsu0BfyLtcWCnjG6g1PP7+pUV+ML9MImTzjl1pfv6du/F8g20JDc9nZiTKe2+duKYNsVT1mBuNMTMS5YkTWU4vlWh4BssS8Jt/7kiEeOf+DLGQQ7HmEQ/ZJCPB67Y5KqWGk28Mbs0nV65xeqnMe/aPUa17FN06u8djXf0tfVsFenvFZsCxqDd8fjh/hf/v6HmiAYvDu1LXhHnQtji4I301fOMhh7tnR4iHAldbElcLVfaOxQg7NhdXyzR8g2NZ7EhF2JEO43mGkGMRCdrckknorFypbcgSIe/WuJSvUql73DWTJhkJEA8HKFUb2uXyVhSrDS6tVqh5PpW6x5Vijd994hQBW7hvZ5JfeNeea8J8/2Ry3Zn03kyciWSY+WyBeNCBsRj3AJWaR6nWIBpyiHb0lWYSYa2VK7WNFdw6tiW8dCkPwNxoBNsSfN+Q6PLak22TMgs5l1KtQcixWSnX+Ld//Qq+b7h7R4KfPTxHwLKIBW3qnnfdMG9rz9aVUurNtFeHFl2PFy/mSEUCJMIOpWqD8Xio610uG7pJ9KBrXwR1rOZ+Kv/u669QqDa4JRPjE4fnmIiHrtbUbxTmSim1Ue36uQicypY4MBWn1vAZi4eIBO2uXhCFbRDoay+C/ta3TnJuxWUmHeJDt00wkQoRcCwsgZmRqIa5UqprLBE841OueWSLNfZl4oQCNrHW6vBul2KHOtA7L4JaAn/+9Hl+dHqF8ViADx6Y4D23ZrAtoeDWmU5H9KKlUqqrCm6dcs3jyPwVAO6aTQGGpWK16+UWGOIa+tqLoK9cLvBXz14iEbK5f1eaD9w+AUDIsYmFHKZSuoWtUqp72vXzK4Uaz53PEQ3aZOIhjGnu6dLtDhcY4hl650XQxUKVz/z9SUKOxV07Enz4zmkCloVjWc09W3T5vVKqywpunWyhSjRkM79U4o7pJLlKnWjQIZMIdb3DBYY00DsvglYbHv/+b47jG9g3EeOn75655iLojnRUw1wp1XWxkIMtwuW8S7ZQZU8mRjToMBoLbkr9HIYw0NdeBP3st15jpVxnbiTMe/eN60VQpVRPWCIEHYsfnVoG4NDONMmIQ7Xhb0r9HDYY6CJyWkSeF5FjInJ0ndffLyK51uvHROTXuz/UG2vXzduB/dfPX+KZs6tMJIK8Z9+4XgRVSvVEe/+W5VKN5y/kGI8HmUiGsKS5w2J7K91uu5k5/weMMUtv8voTxpiPvd0BvR3tujnApVyFLz59gWjQ4h1zKb0IqpTqmXb9PF+ucWKhyLv3jbNariMIc2PRTamfwxCVXBbyLrlKDceyaPg+//5vj2OM4c7pBO/ZN6EXQZVSPbVUqHI8W8Rt+BzalSYUsK4uJtqs/NlooBvgb0XkaRF59DrHvFNEnhWRr4vIwS6Nb0Pa/eY1zydgC5/7h9dYLNTYMxbh/QcmmRuL6kVQpVRPtNsVJ5Nhnj6zQsAWRmJBYq0Lops1O4eNl1zebYy5KCITwDdF5BVjzHc7Xn8G2GWMKYrIR4EvA/vXnqT1w+BRgLm5ubc38pbOMK/UPZ6cX+bIqRXGYgHedUuG/VPxq7sr6kVQpdRmK7Ru/lxreDx3Ps++iTgYCNoW6Whw0y6IwgZn6MaYi60/F4EvAQ+seT1vjCm2Hn8NCIjI+DrnedwYc9gYcziTybztwXeGuecbzi1X+IMfnCHsWDy0Z4QHbhklGnTwfKMXQZVSPbOQd3n67CrLpRr3zaXxTfM+CQ3f7/r+LZ1uGOgiEhORRPsx8JPAC2uOmRJpjlJEHmid90r3h/u6tWGeLVT5v7/xKr4x3LUjzgfvmGJHKnK1bq4XQZVSm61dbrFEODJ/BQFunYwzEg1cfX4zS74bOfMk8KVWXjvAnxpjviEinwIwxjwGfAL4ZRFpABXgEWM27/eKzmX9nm+4uFrh337tVTzP58BEjIfvmSEZdqh5PkHb0rq5Uqon2uUW3ze8dLHA7vEoQdsmHQkyldz8SeUNU84YMw/cs87zj3U8/izw2e4O7fo6l/UfXyjwf379VXzfcMt4lP/6vhl2jkSu9pvvGddbvimlemch73I8W+Ry3uUfH5q5Wm4JB61NvSAKA9i22NmemK/U+Q+t9sQ9oxE+dNsE+yfi2Jbg+YZMIqylFqVUT3SWW35wsrlk5/bpRM/KLTBggd5ZanEs+I1vnqBU89g1GuHBveMc2jN6TZhrv7lSqlc6yy0vXMgzNxolGnR6Vm6BAQv0glsHAc83fOXZi5xYLDI3Eubw7hF+4rZxDXOlVF8t5F1eWShwKefywJ6RnpZbYID2Qy9WGxTd5rL+WsPni09fIB6yObRzlMO7xogGm/+UWMjRMFdK9VRnueV7J7IIcMeOZE/LLTBAM/T2mwLw+afOUqp53L9rhLvmUkwmQ7qsXynVN+1yi+f5PHc+zy2ZGGGnd90tbQMT6MlwgEwyxIWVCt89scR0KsR/dXCKnSMRAo5FwBZtT1RK9c1C3uW5izmulGo8uHes5+UWGKCSS9t3ji/i1n1+7oE5bsnECQWs5q2c4gFtT1RK9VxnueWJ40s4lvS8u6VtoAL9cq7C+27NsGssxk/cOkHD9wGY0PZEpVSfXLt3S447diSxRHpeboEBCvS8W6da95kdifK+W5t7m2fzVQrVOvGwo6UWpVTPtZs1FgsuP5hfplTzOLx7hErN63m5BQYo0C0RxhMhYiHnmjtlR6t2T98wpZRqK7h1SrUGlZrHE8ezxEMO06kwqUjvyy0wQIEeD71xFp4MB64Jd6WU6oelossrlwvcv7u5uHE6Fe55uQUGqMtFKaW2kvbFUEH43skr+AbunUsRsi1iYafn5RbQQFdKqbekfTG06NZ55swqk8kQI5EgqUgzxHtdbgENdKWUessW8i7Hzq9wMefy4J5R4mGHSNDu23g00JVS6iZ19p5//+QVLIH75tKMRAOEAzaxoNOXZo2BuSiqlFJbRbvc0mj4vHgxz4GpBKGOpf7RkN2XVmqdoSul1FuwkHd58swyuUqDd93Sn6X+a2mgK6XUTVjIu+Qr9atL/SNBm53pCNGA05fe804a6EopdRPylTor5RrZgstLl/LcuSOJ2/BJhO2+9J530kBXSqkNKlYbREM2vg/fOZ6l7hnunEkSsC0yyXBfyy2wwUAXkdMi8ryIHBORo+u8LiLyGRE5KSLPicih7g9VKaX6q30xNBK0+PHZHCPRABPxELvHo0B/es873cxX/oAxZuk6rz0M7G99PAh8rvWnUkoNlWK1wUsXc5xaKvGe/eOEgjZhxyYR6v82JN0quXwc+CPTdARIi8h0l86tlFJbQizkUK56/MPxLAZ4/4FxJhMhqp5Pw/f7vlHgRgPdAH8rIk+LyKPrvD4DnOv4/HzruWuIyKMiclREjmaz2ZsfrVJK9Umx2mg9MpxcKDGdCjOdijCTjjIWC2Fb/S23wMYD/d3GmEM0SyufFpH3rXld1vk75g1PGPO4MeawMeZwJpO5yaEqpVT/FNw689kixWqDM8tlHto7SqXmUal7jCeCW+ImOxsKdGPMxdafi8CXgAfWHHIe2Nnx+SxwsRsDVEqprWKpUOV7J5cwBg7vHiEUsCjXGn2/GNp2w0AXkZiIJNqPgZ8EXlhz2FeAX2x1uzwE5Iwxl7o+WqWU6oP23i2xkMOz53KkI817GI/FQozFQ/0e3lUb+ZEyCXxJRNrH/6kx5hsi8ikAY8xjwNeAjwIngTLwyc0ZrlJK9V67XTFgC8cXi9y7M8Vivsod0yH2ZuJYsl7VufduGOjGmHngnnWef6zjsQE+3d2hKaXU1hALOSzmqzxzdpVKzePgdJKwY1+9ergVyi2gK0WVUuqGLBF84/OjUyuIwKG5ESZTISo1j9LV7pf+00BXSqk3Uaw2yFVquHWfVxcK7MvECQdtLJG+3sxiPRroSin1JgpunWyhylLB5dxKmbtmU6yUalRqHplEqO+LiTppoCul1A0sFaq8ulDEGLhrJkkoYBFpzdK3Sv0c9I5FSin1pmIhh8lkmOcu5Ag6FmOxIJl4mHQ0sKVm56AzdKWUuq72cv+gY3H8coF9mRiObRFyLNLRIL55w4L4vtIZulJKXUfBrbOQd7m0WuFyvsoHb5u4uty/4ftYsrUiVGfoSin1JpYKVZ48tQzAwVb9fCst9++0tUajlFJbSCzkEAs5vHypQCxos2csRiwUwLxx78EtQQNdKaXW0a6fj8WDvJYtcmAqwWqlTiYRZjIV3jLL/TtpyUUppdbR3i73zJUyS8Uad86kqNQ8lopVYOss9++kga6UUtexVKjyneOLABzc8Xr9fCst9++09X7EKKVUn3Vul/vypQLJsMNYPEgs6Gy55f6dNNCVUmoN3xgcyyLkCCcXS+yfjFN0G+wciTKdjmzJ+jloyUUppd7AEmG1XOPUUoVcpc7dM2kcW6g2fGBr1s9BA10ppd6g4NZZLtX44fwSAPfOpYgGbbIFd8vWz0EDXSmlrtGun5erHi9dzDPZ2lHRGLbU7ebWo4GulFId2tvlBh3htWyJu3c2t8uNBp0tt13uWhroSim1RqXm8crlAtWGz97xGAhEAjapSHDL1s/hJgJdRGwR+bGIfHWd194vIjkROdb6+PXuDlMppTZfu9wSDTr84LUlbEuYG4sSdiwQttzuimvdzI+aXwVeBpLXef0JY8zH3v6QlFKqP9rtikW3zksXC+wZjxELOkynIiRCAUrVBslBL7mIyCzw08Dvbe5wlFKqf9rtipdyLguFKvfvGsGxBce2CAetLV0/h42XXH4T+DXAf5Nj3ikiz4rI10Xk4NsemVJK9Vi7XfHJ01cAuH/PyNV2xa24Xe5aNwx0EfkYsGiMefpNDnsG2GWMuQf4LeDL1znXoyJyVESOZrPZtzJepZTaFJ3tis+fzzOVDJOOBgeiXbFtIzP0dwM/IyKngS8AHxSRP+48wBiTN8YUW4+/BgREZHztiYwxjxtjDhtjDmcymbc/eqWU6pJ2u6IInFwscmhXemDaFdtuGOjGmH9ljJk1xuwGHgG+ZYz5553HiMiUSHNzAxF5oHXeK5swXqWU2jSVmsex86s0fMOtk/GBaVdse8sjFJFPARhjHgM+AfyyiDSACvCIMVu8v0cppVo62xW/f3KJWNBmRzoyMO2KbTcV6MaYbwPfbj1+rOP5zwKf7ebAlFKqVwpunUrNI1eu8dLFAgd3JGl4hnQkOBDtim26UlQppYCFvMvTZ1eo1D3um0vjG4NlyUC0K7Zt/aKQUkptona5xRLhqVPLOJawZzxKKhK4+vwg1M9BZ+hKqW2uXW7xPJ9XLhfYPxEHhHQkyFQy0u/h3RQNdKXUthYLOZSqHq8sFlgp17l3Lk3YsYmFnYEqt4CWXJRS25wlgm98fnwmB8ADu0eZSIao1LyBKreABnpXLeRd5rMFylXv6nOlWgMQYqHXbywbDTrszcSZTIb7MEqlVFux2iBXqeHWfV68mGP3WJRUNIAlsqVvBn09Guhv03y2yKlsEQDP+OQqDV68kCNbrFKuNahUGxgRUkGHHSNRMokQk8kwBbdGIhzUYFeqj9qrQxdzLmeWy/zsfTOslGoQDTI3Fh2ocgtooL9l7SBv+D5LxRoLqxWqns9SscpiocLZKy6rlQY1z8cSCDs2C4Ua7711jEDAYrFQI19u4PnN/c401JXqj6VClecv5TAGDs2lCQUsIkF74MotoIF+04rVBvPZApdWKywVa2DAEnjy9AonFosUqw1qXnNVWcAWkuEAdc9nuVznSrnO2dUK7791nHffMk4qFqDm+ZxYyAMa6kr1UrtdcTIZ5ukzq6QiAYIBi1jQYTQWHLjZOWig35RitcHJxQJnrpQI2BapiMMfP3mOH51axjNgC6QiDmPxECPRAPGQjVv3sAxYlsXpK2XOrbp89bnLRII2H75jEs831PDJVWoa6Er1ULtdsVJr8PKlPHfPpqg3DEHbIh0NDsxy/04a6BvUDvNswSURdji9VOZz35knW6iSDDtMJoJk4gEqDUOt7mNjcGwhYQcQmntB7BoNEw5YzF+p8OdPXyAUsHnv/nFGYyGmUoPV76rUMFjIuzx1ehm37nPvztdXhzZ8H0sGLx4Hb8R9spBzyRZcbEs4v1LhN755gkrdYzIeJB62GYsFCDs2O9JBbMui6DaIhxwS0SBgcGsGZ0S4bUaYupTn+/Mr/NmPzjMeC/IL79ozEPtEKDVMYiEHS4SnT69gW8JtUwlGWjPzQayfgwb6hizkXXKVGslwkPMrJf7jN0/g1j0mYg6jsQAHZ1Jk4iE835BJhJkdjeDYzTVbsdb/FEW3jgFsS7hrJsVINMQz51a5UqxxcqHAoV2jffwXKrW9FKsNAMIBixMLRfZNxAgHbEaig1k7b9NAv4FitcGl1Qo1z8exhMe+c4pcpc50Ish0OsLP3DdDKhIgYFvYAo5tsWc8zt5M/A3naZds4mGHT753D58EXjif4/RSmclUmJl0tD//SKW2mYJbZyHvcmGlwkKhyofvmGzW0+semeRg3MxiPRroN7CQc1uLg+DzT53lxGKR6WSIvZkI/+zB3YQcC9sSGp7PvonkG4K8LR5y2DeRuPr53kycZDhAJhHi7JUybu3NbteqlOq2pUKV77/WvA/PvTtThAIW5VpjYMstoIH+porVBg3fx7EsXrq0yl89e4nRaIA7d8T5qYM7roZ50LY4uCN9wy6Vdqj7xlytmc+km4sXrOYNn5RSm6zdrhgLObx4Ic9oLMhoLEg06Azk6tBOGuhvYiHnUql7JCMOv/vd0636d4JDc+PsnYhT9wx1z2P/ZHLDLYfr/eTXC6JK9Y5vDI5lEbCFE9ki986mKLgNZkeiTKcjAz250kC/jvaF0Lpn+PyTZ7mYc7l3Nsme8QQzo2Fqnk/Qttg9vvEwV0r1nyXCarnGK5cLVGoe9+5M49hCtdEsew5quQV0+9zrylfq1Dyf1XKVLx+7SCYe5PapJLMjEcZaHS3JSEDDXKkBU3DrLJdqHJlv1s/vm0sTDdpkCy6lVvfLoNJAX0ex2iAasokEHL7wo/NUGz737x5hbizGoV0jOJZFNGjrYiClBky7fl6uerx8qcDusSiObWEMjMVD/R7e27bhQBcRW0R+LCJfXec1EZHPiMhJEXlORA51d5i91VxEVKXmeXz/5BV2jUaYGYmQiDhYlpCOBtiRjg70r2ZKbUft3RUtC05fKXPXTIqVUo1o0CGTGNx2xbabmaH/KvDydV57GNjf+ngU+NzbHFfftDtbqnWfx779GjXP58HdIyTCDpl4kGrdR0Q30lJqEMVCDrYIr1wu4PmGXWNRoq3NuFKR4MBP0jYU6CIyC/w08HvXOeTjwB+ZpiNAWkSmuzTGniq4dWxLKNfqHJlfZjYdZu9EgulkhFQ0SMAWUpFgv4eplHoLLBGCjsWPz65iW8LdMymSEYdqwx/IzbjW2ugM/TeBXwOut/plBjjX8fn51nPXEJFHReSoiBzNZrM3M86eKlYbfOfVJUo1j/fuzxAMWOyfTBAJOHohVKkB1b470XKpxsuX8uyfiOM4VusWdGbgL4jCBgJdRD4GLBpjnn6zw9Z57g0/7owxjxtjDhtjDmcymZsYZm+0L5gIwj+8ushoNMC+yRghu7mCbDwR1AuhSg2odv18qeByfrXCwR1JVko1KjVvKOrnsLEZ+ruBnxGR08AXgA+KyB+vOeY8sLPj81ngYldG2EPt/ZFfvLDKmeUKh3aNEAk4TCRC2JZFqdoY+BqbUttVLORQqXkcXyxiDBzckWyuEo0HB3q5f6cbBrox5l8ZY2aNMbuBR4BvGWP++ZrDvgL8Yqvb5SEgZ4y51P3hbp727LxU9fj2iSUEeGjvKMYYMskw6WhAa+dKDTBLhLF4kFcvFwjYws6RKCOxILGgMxSzc3gbK0VF5FMAxpjHgK8BHwVOAmXgk10ZXQ+1Z+cN3+Po6RX2TcSJBh0mk83eVK2dKzW42vXzSs3npUsFDkwmsG2hUvOIh5yhuCAKNxnoxphvA99uPX6s43kDfLqbA+uHYrXBU6dWWC7V+MjBSUIBi7FYiERoOH56K7VdtevnZ5ZKXFip8M5bxlgp1SAavHpD6GEw+EWjLui8GPqD15awRTg4kyTsWCAQDlpD8yuZUttRu35+YrGI4fX6+UhseOrnoEv/gdfLLUW3ziuXitwyEUMQ0pEgiVBgqP6DK7Udtevnxxea9fPZdGTo6ueggX7VQt7leLZItljlno6bxersXKnB1lk/f/lygf0TcSyrWT8XYWjq56CBfrXcYonwVGv3tVsn44xEAwN9s1ilVJNvDG7N59xyifMrFW6bTlKtexhjhqp+DhroV8stvm949XKRqWSYWNAhHQkyldRFREoNOkuEvFvjwqqLMXBo5wjJSIB4ePjKqds+0KFZbrmYr3D6Sol7dqa03KLUEGnvz/TSxRyWwOxoGNsSfN8M3ff3tg70znLLj04t4xsttyg1TNrf40XX48VLBfaMx/ANzVXf4eHpP2/b1oG+ttwSD9lMJsNablFqSLTr557vc+ZKiQNTCap1j7F4aOjq57DNAz0WcihVPa6UaxxfKHLnTIpowCEWdrTcotQQsETwjM/FnEvdM+wdjxEK2MSCzlDsf77Wtg705raZPq9cKlCpe9y/a4TJVIhKzdNyi1JDoODWKdc8jp5ZAeDOmRRgWCpWh67cAts40Nu9qW7d58WLORxLuH1HEkuESNDu9/CUUl0QCzlcKdR46WKe6VRzk72w4xAJ2kOx//la2zbQ23s7lKsNXr1c4OCOJJWaN1R7Iyu1nRWrDQpunfFEgDNXyhzckaRca14M7cf3eLHaIO/Wr3ku79YpdvEHy7YNdIClQpWFgsvlfJVDu9KEAtbVCyVablFqsBXcOleKVbKFGsVqg72ZGG7dx/dNz+vnr69W9fi7lxdYKdW4sFpmqdDd0s+2DPR2K9NkMsyPTjdrazvSEWKtm8Xq7FypwRcLORgjfP+15grwA5MJIgEb+rDc/+p+UdU6n/6TZ/g3X32Rc8tlPN+Q7GLebMtpaPvNrXs+z53PMZ1qrg4N2hbpaHAoL5Yotd0kwwEiQYtXL+eJhxz2TyYYiwdxaz6laqOrQboRxWqDFy/kqTZ8bptKUK557BrrbgRvyxl6u13xtWyRU0sl7plNEXZsYmGHhu8PXW+qUttVIhwgX2lw+3QCS4REOEAm2dv6ebsikAgF+LtXFgg6FqloAKH7vylsyxl6u13x2LkcvoEH9oxqu6JSQybv1ilVG/ynR+7DsYWGZ1jMu0wkwz39Hm9XBHLlGsfOrrJ/Io7vQ9C2cCyLvFvv2m8L226GvrZdMRUJMDcW1XZFpYZMqdpAEDLJELvGYmSSIQTpS7viQt7lmXOrrJTr1+wX1e2KwLabirbbFfOVOq9eLvLg3lFy5ToWwtxYVC+IKjUkEuEAsZBzdfbb/rOXJdVrtuc+tQzAvszm7Rd1wxm6iIRF5CkReVZEXhSRf73OMe8XkZyIHGt9/HrXRrgJlgpVTmaLVOoe79B2RaWGUrwjzNuS4UBfyi2+bzh+uchsOkI4YG/aflEb+ZdVgQ8aY4oiEgC+JyJfN8YcWXPcE8aYj3V9hF3U2a74p0+dJWALY/GQtisqpTZFLOSwmK9ybrXM2eUyD981dbUBYzP2i7phoBtjDFBsfRpofQxkX19nu+ILF/LsHY+BQdsVlVKbot2A8eMzqxjgoU1uwNjQRVERsUXkGLAIfNMY8+Q6h72zVZb5uogc7OYgu2kh7/LCxRyLhSp3zW7exQml1PbW2YDx/IUcmXiQmZHIpjZgbCjQjTGeMeZeYBZ4QETuXHPIM8AuY8w9wG8BX17vPCLyqIgcFZGj2Wz2rY/6LYqFHCwRjrZWh94xnWQmHdGbWSilum4h53J6qcSVYpXjC0UO7x7lUs5luVjbtL1kbqpt0RizCnwb+Mia5/PGmGLr8deAgIiMr/P3HzfGHDbGHM5kMm950G9FewOccMDi5GKRsViQyWSIkajezEIp1V3FaoOG75Or1Dl6ZoWGb7htKo4FpGObdy/TjXS5ZEQk3XocAT4MvLLmmCmRZr1CRB5onfdK10f7NhTcOvPZIkW3wXy2xH1zady6T6Xu6c0slFJd1b6P6XQqzNHTKyTDza1FplIRdo/HNi1vNvIjYhr4QxGxaQb1nxljvioinwIwxjwGfAL4ZRFpABXgkdbF1C1lqVDluQuruA2fe3emCAUsyrWGlluUUl1XrDbIFqq8fLnA4V1pQkGb0VgQx7I2rQFjI10uzwH3rfP8Yx2PPwt8trtD6552u2Is5PD8+Ty2JezJxBmNBnV1qFKqq9p5Iwh/eewinm+4czZFyG5OIJsNGJszgdwW01LfGBzLIhywOL5Q4JZMjHrDZzQWZDod0e4WpVTXtNujF/IVnjufYzweZO9YjIlECNuyKFUbzKSjm/K1t8VeLpYIq+Ua2UKNC6su98ymcWyh2vABtNyilOqKYrVB0W2wkHeZXypxbqXCA3tGces+8XCAdDRAKhLctK+/LQK94NZZLtU4cqp5nfbunSmiQZtswR3K+woqpfqj4NYp1RpUah5PnMhiCRyYipOKNPduSUYCTCbDm/b1hz7Q2/WsctXjlUsFwgGLyWQIY2AsHur38JRSm6QX9/Bc+/WKbvPcq+UqT59pbpUbtGymU+GetEcPfaC3d1eMhmxOL5W4bSpBodIgGuzPjWKVUr1RcOucWSpxYbUMNMM8m69yabWyKaG+kHNZbP3W//evZHHrPndMJ0HMpu3dstbQF49jIQdbhOVSlYs5lwf2jBJtbcbV6xvFKqV6JxZyOJUt8pfHLpCOBnn4zmkK1eaMveDWu/q9v5B3yVVqOJbFy5dy/MOrWaZTIVKRwNULoL1ojx76NLNECDoWz5xZBeCe2RTJiEO14etmXEoNsWQ4wHgixHdPLHF2uczusSizo81wLboNiuFGVwJ2Plvk5GKeZCRIveHzpR9fxK377MvEmB2JMDe2OR0t6xnqQG9vjrNcqvHSpTyRgM3saLS1A5rpy41ilVK9Ews5fOjABI99d54//MEZfvkDexmNhZqlkVqDfROJDYX6fLbIqWzxmucurJTIlup4vo/B0PDglUt5nj2fYzoZYs9YjNt3JJvjCDo9Ke8OdaC36+flaoNTS2Vum06Qr9SxRe9OpNSwy7t13JrPbTsS7JuI8aMzK9z60iIP7h0lHnYo15oz9H0TiXX/fmeIN3yfpWKNFy/kyLl1CpUalbqP7zfbnqMBi1NXyryyWCIatHhwzwjvv33i6rniYacn5d2hDvRYyKFS81h1a1zOu3z4jglGY0FGYkFd7q/UkCtVGxSqdXaNxfjEO2b5jW+e4MvHLhINOtw1m2QiGebSagVLhL2ZONCshc9nC5Sr3tUQP7FQaK5lqdR4LVskm69R93wCjkXItricd8m7DQpVj0TI5r23jPGPDu0kEXaoewZjTM8mj0OdaJYIY/Eg3351EWjdyy8W7NmvP0qp/kmEAxTdBqVagwf3jvHh21b56xcW+POj56hUp5hIhvCBI68tYdnNhj/f9ylXPVYqzYumBsPz53LMXylTqnrXvbNPLGizZyzCXTMpPnj7JLlKjVDAImhb7EhHezZ5HNpAb9fPKzWfFy7miQZtZkciVGoe8ZCjF0SVGnLxkEM87FCqNShVG/zjw7OcXi7z4sUCf/n8Je7flSbiWJRqDQpuc9V42LGIBm1ybp0zyxWWS3XqviHkWEwlg0wmw8RCNo4lFMp1DFDzfBqeYSIR4p7ZNJGAhW9gMe9yx47Upi4kWmtoA903Brfms1RwObFQ5PapBHXPxxhz9YbQSqnhlggHWMi5VBsenm/4X3/6dv6Pv3qZFy8X+P5rK+xMh3Es8Hwo1z3KNY9SzaPmGQRIRRxm0mFiQYuqB55nCEhzRi4YCq5PxLYZjTjsycTJlWuEAzbjiSC7x+NMpXp7r4WhDXRLhLxbo9rwWSxU+Zl7dpCMBIiHN29zeaXU1hIPOUynIxSrdZygRb3h82sP38bvPvEaR0+vcnKpvOZ4m7F4kFQkQDQgeEYQIB502JsME7Atlks1RqPNwLZsi/F4iNmRa4N7z3j8al2+l4Y21dobzD9/IQfALRMxbEvw/d5doFBK9V+75HH8ch7fgFtv8PCd04Rt4fRyBd9ALGARdizqvqFW9xEg7NhMp8Mkws3NtPZPJBhPBHFa9fZ+hfabGcpAb+/fUnQ9nj2fIxayySRClKoNxuMhrZ8rtc1MJsOUqg1OLORZKtZYWK1wx3SKkGOxWKzh++ADjiVEYw7xoM14IswtE3EyydDVMu1WDPFOQxno7fq5CJxYLHL7VJJ6w2c6HdH6uVLbVDuIHavIVGvWfs/cyNUFQgCJsMN0KkK048Y3mUSYvZn4QJRpt/4I3wJLBM/4lKoe2UKVn7x9glDAJhZ0dP8WpbaxvZmtPcN+u4Zyt8WCW6dc8/jh/BLQ3P8cDEvFqpZblFJDa+gCvV0/v1Ko8dz5HPGQw1i8uf95JGjrDS2UUkPrhoEuImEReUpEnhWRF0XkX69zjIjIZ0TkpIg8JyKHNme4N9aun0dDNqeWStw+naDe8BmLh3T/c6XUUNvIDL0KfNAYcw9wL/AREXlozTEPA/tbH48Cn+vmIG9Gu35ecBssFWscmExo/VwptS3cMNBNU3vfyEDrY20h+uPAH7WOPQKkRWS6u0PdmHb9/Mj86/cP1fq5Umo72FANXURsETkGLALfNMY8ueaQGeBcx+fnW8+tPc+jInJURI5ms9m3OOTr66yfP3tulWTYYSwW1Pq5Umpb2FCgG2M8Y8y9wCzwgIjcueaQ9Rq73zAdNsY8bow5bIw5nMlkbnqwN9Kun0eCFq8tlTi4I0lN6+dKqW3iprpcjDGrwLeBj6x56Tyws+PzWeDi2xnYW9Gun6+U66yW69w2ldT6uVJq29hIl0tGRNKtxxHgw8Araw77CvCLrW6Xh4CcMeZStwd7I6/3nzfr5/fMaf1cKbV9bGTKOg38oYjYNH8A/Jkx5qsi8ikAY8xjwNeAjwIngTLwyU0a73WtrZ9n4kESIeea+rneP1QpNcxuGOjGmOeA+9Z5/rGOxwb4dHeHdnPa9w8NBy3msyXu3z3KarnOjnRE6+dKqW1hqFaKVmoep5ZKlGoeu8ejIBAJ2Fo/V0ptC0MT6LGQQzTo8P2Tzf1bDkwlGI0GQdD6uVJqWxiKQC+2+st94/PSxQJzoxFSkQAj0SCJUED7z5VS28JQBHrBrTOfLZItVDm7Uub+3aNUah6Vukc4aGn9XCm1LQxFoAMsFap8/7UrGAP3zaUJBSzKtYbeP1QptW0MfNK12xVjIYfnzudIhh2mUmFiQYdIx11HlFJq2A38DL3g1qnUPAK2cPxygdunkyzmq0QCNnszcS23KKW2jYGfoQMs5F1euJCjVPO4cyaJbwyVugeg5Ral1LYx0DP0drnFEuGJE0vYlrBnPMZINIBvjHa3KKW2lYEO9Ha5xfN8XryYZ/9EHEuEdCTIVDLS7+EppVRPDXSgQ6vccinPSrnOO3aNNGfslmi7olJq2xnYQO8stxyZv4II3DoZv1pu0XZFpdR2M7CB3i63+L7h5YsF9o7HCNiWlluUUtvWwAY6NMstry4WWChUOaTlFqXUNjeQgd5Zbvnha82bWdw2peUWpdT2NpCB3lluaW7GFSUScLTcopTa1gYy0KFZbpm/UuLCaoVDc2kttyiltr2BC/TOcsv3TzT3Pr99OqHlFqXUtjdwgd5Zbnn+Qo6dIxES4YCWW5RS294NA11EdorIP4jIyyLyooj86jrHvF9EciJyrPXx65sz3KaFvMvxxQIXVl0e2DOq5RallGJjm3M1gP/JGPOMiCSAp0Xkm8aYl9Yc94Qx5mPdH+Lr1u7dIsDBHUkttyilFBuYoRtjLhljnmk9LgAvAzObPbD1dO7d8vz5PHszMcIBW8stSinFTdbQRWQ3cB/w5Dovv1NEnhWRr4vIwW4Mbj3tvVuyxaqWW5RSqsOG6xMiEgf+C/A/GmPya15+BthljCmKyEeBLwP71znHo8CjAHNzczc10M5yy/dOLGGJdrcopVSnDc3QRSRAM8z/xBjzF2tfN8bkjTHF1uOvAQERGV/nuMeNMYeNMYczmcxNDdQ3BseyaHg+z1/Ic2AqQTIcYDoV0XKLUkqxsS4XAf4z8LIx5jeuc8xU6zhE5IHWea90c6DJcICG7/PypQK5Sp337c+QjDgkIwEttyilFBsrubwb+AXgeRE51nrufwHmAIwxjwGfAH5ZRBpABXjEGGO6PVhLBDDcuzPFh2+fZDQWpFCtEws5Wm5RSm17N0xBY8z3ALnBMZ8FPtutQV1Pwa1zz84RPnT7FPGwQ8P3AZ2ZK6UUDNBNovNuHceymB2NMJOOknfrVGoQDqLlFqWUYoAC3RJhPBEi2Qrv9p+WaLlFKaVggAJ9vdBO6sxcKaWuGrjNuZRSSq1PA10ppYaEBrpSSg0JDXSllBoSGuhKKTUkZBMWdG7sC4tkgTN9+eJb1ziw1O9BbGH6/lyfvjdvbpjen13GmHU3w+pboKs3EpGjxpjD/R7HVqXvz/Xpe/Pmtsv7oyUXpZQaEhroSik1JDTQt5bH+z2ALU7fn+vT9+bNbYv3R2voSik1JHSGrpRSQ0IDXSmlhoQGeh+IyEdE5FUROSki/3Kd11Mi8lci8qyIvCgin+zHOPtBRH5fRBZF5IXrvC4i8pnWe/eciBzq9Rj7ZQPvzc+33pPnROQHInJPr8fYTzd6fzqOu19EPBH5RK/G1isa6D0mIjbw28DDwB3Az4nIHWsO+zTwkjHmHuD9wH8QkWBPB9o/fwB85E1efxjY3/p4FPhcD8a0VfwBb/7enAJ+whhzN/C/s00uBHb4A978/Wl///074G96MaBe00DvvQeAk8aYeWNMDfgC8PE1xxgg0brxdhxYBhq9HWZ/GGO+S/Pfez0fB/7INB0B0iIy3ZvR9deN3htjzA+MMSutT48Asz0Z2Baxgf93AH4F+C/A4uaPqPc00HtvBjjX8fn51nOdPgvcDlwEngd+1Rjj92Z4W95G3j8FvwR8vd+D2EpEZAb4R8Bj/R7LZhmYOxYNkfVuuL22d/SngGPAB4FbgG+KyBPGmPwmj20QbOT929ZE5AM0A/09/R7LFvObwL8wxnjNX36HjwZ6750HdnZ8PktzJt7pk8D/ZZqLBE6KyCngNuCp3gxxS9vI+7dticjdwO8BDxtjrvR7PFvMYeALrTAfBz4qIg1jzJf7Oqou0pJL7/0I2C8ie1oXOh8BvrLmmLPAhwBEZBI4AMz3dJRb11eAX2x1uzwE5Iwxl/o9qK1AROaAvwB+wRhzvN/j2WqMMXuMMbuNMbuBLwL//TCFOegMveeMMQ0R+R9oXmW3gd83xrwoIp9qvf4YzQ6FPxCR52mWGP6FMWZYtv58UyLyeZqdPeMich7434AAXH1vvgZ8FDgJlGn+NrMtbOC9+XVgDPid1iy0sR12GGzbwPsz9HTpv1JKDQktuSil1JDQQFdKqSGhga6UUkNCA10ppYaEBrpSSvXARjcPax37H0XkWOvjuIisbuhraJeLUkptPhF5H1CkuRfRnTfx934FuM8Y89/d6FidoSulVA+st3mYiNwiIt8QkadF5AkRuW2dv/pzwOc38jV0YZFSSvXP48CnjDEnRORB4Hdo7uEEgIjsAvYA39rIyTTQlVKqD0QkDrwL+POOzcJCaw57BPiiMcbbyDk10JVSqj8sYNUYc++bHPMIzRvebPiESimleqy1HfYpEfkncPX2ildvGygiB4AR4IcbPacGulJK9UBr87AfAgdE5LyI/BLw88AvicizwItce/eynwO+YG6iFVHbFpVSakjoDF0ppYaEBrpSSg0JDXSllBoSGuhKKTUkNNCVUmpIaKArpdSQ0EBXSqkh8f8DIkEuX2Fv3vUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "data_r2" + "data = my_lockin.measure_program(return_raw=False)#(wait=False, fail_if_incomplete=False)\n", + "if data is not None:\n", + " for d in data:\n", + " plot_windows(d)\n", + "else:\n", + " print(\"RETURNED NONE\")" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "c894793c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23d79a08", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e61a3cf1", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "453ec743", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1eae59e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d8716e9b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15826bae", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": 88, - "id": "75068d8d", + "id": "cc324843", "metadata": {}, "outputs": [ { @@ -1555,7 +1695,7 @@ { "cell_type": "code", "execution_count": 77, - "id": "69e61de7", + "id": "20bb0981", "metadata": {}, "outputs": [ { @@ -2577,7 +2717,7 @@ { "cell_type": "code", "execution_count": 75, - "id": "3717ff32", + "id": "974e560e", "metadata": {}, "outputs": [ { @@ -2910,7 +3050,7 @@ { "cell_type": "code", "execution_count": 48, - "id": "90131f4e", + "id": "c29511b9", "metadata": {}, "outputs": [ { @@ -3095,7 +3235,7 @@ { "cell_type": "code", "execution_count": 84, - "id": "0eb17aad", + "id": "76dd008a", "metadata": {}, "outputs": [ { @@ -3116,7 +3256,7 @@ { "cell_type": "code", "execution_count": 71, - "id": "2453eef6", + "id": "8816fccf", "metadata": {}, "outputs": [ { diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index 9408d82b4..191f2fb67 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -164,9 +164,9 @@ def reset(self): self.reset_daq_module() - def reset_daq_module(): + def reset_daq_module(self): self.daq.finish() - self.daq.close() + self.daq.clear() self._init_daq_module() def register_measurement_channel(self, program_name:str=None, channel_path:Union[str, List[str]]=[], window_name:str=None): @@ -383,7 +383,7 @@ def arm_program(self, program_name: str, force:bool=True) -> None: # # if the program is changed, the not returned data is removed to not have conflicts with the data parsing operations. The cleaner way would be to keep track of the time the program is changed. # if self.currently_set_program != program_name: # self.read() - # self.daq.close() + # self.daq.clear() # self._init_daq_module() # TODO TODO TODO TODO TODO TODO TODO TODO From 61201f6d206bcf9b71d0149287a9940a36e26fb9 Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Thu, 6 Oct 2022 16:22:01 +0200 Subject: [PATCH 15/25] Added some documentation to the example notebook and performed some small changes to the code. --- ...struments_lockin_mfli_daq-checkpoint.ipynb | 5482 ++-------------- .../zurich_instruments_lockin_mfli_daq.ipynb | 5484 ++--------------- qupulse/hardware/dacs/mfli.py | 101 +- 3 files changed, 891 insertions(+), 10176 deletions(-) diff --git a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb index 611b9079d..b0d441f4c 100644 --- a/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb +++ b/qupulse/examples/.ipynb_checkpoints/zurich_instruments_lockin_mfli_daq-checkpoint.ipynb @@ -8,13 +8,31 @@ "# Zurich Instruments Lock-In MFLI Data Aquesition" ] }, + { + "cell_type": "markdown", + "id": "d11c4c6c", + "metadata": {}, + "source": [ + "This notebook was used to develop the qupulse MFLI driver and is now intended as a documentation with examples." + ] + }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 131, "id": "37894582", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ + "# this function let's jupyter/ipython reload changes made in the source code automatically.\n", "%load_ext autoreload\n", "%autoreload 2" ] @@ -51,41 +69,30 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "624c2d4f", + "execution_count": 6, + "id": "76ba4dc7", "metadata": {}, "outputs": [], "source": [ - "from zhinst import ziPython as zhinst_core" + "import qupulse" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "76ba4dc7", + "execution_count": 146, + "id": "65986db0", "metadata": {}, "outputs": [], "source": [ - "import qupulse" + "from qupulse.hardware.dacs.mfli import MFLIDAQ" ] }, { - "cell_type": "code", - "execution_count": 7, - "id": "65986db0", + "cell_type": "markdown", + "id": "cdcb0f9d", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\awgs\\tektronix.py:13: UserWarning: Could not import Tektronix driver backend. If you wish to use it execute qupulse.hardware.awgs.install_requirements('tektronix')\n", - " warnings.warn(\"Could not import Tektronix driver backend. \"\n" - ] - } - ], "source": [ - "from qupulse.hardware.dacs.mfli import MFLIDAQ" + "Now we instanciate the MFLIDAQ instance. This object contains all funcitons necessary to work with qupulse. At this point, it only get information about how to talk to the device, there are not functional settings passed (other then resetting the device if ```reset=True``` is given.)." ] }, { @@ -98,6 +105,14 @@ "my_lockin = MFLIDAQ(device_serial=\"dev3442\", device_interface=\"PCIe\", data_server_addr=\"192.168.53.202\")" ] }, + { + "cell_type": "markdown", + "id": "4e5e5266", + "metadata": {}, + "source": [ + "With ```my_lockin.api_session``` the the zhinst api session for that driver instance is adressed. In the following cell, this is doen to set the debug log level to the lowest level, logging everything. Thing will then be logged into the terminal where the jupyter notebook is running and into some file, whose path is stated in the terminal after calling the command. " + ] + }, { "cell_type": "code", "execution_count": 9, @@ -108,6 +123,22 @@ "my_lockin.api_session.setDebugLevel(0)" ] }, + { + "cell_type": "markdown", + "id": "41396548", + "metadata": {}, + "source": [ + "In the following, we will set the default settings of the device. It is recomended to also set all the other important settings here. E.g. the reference oscillatiors frequency and amplitude." + ] + }, + { + "cell_type": "markdown", + "id": "6e9a76ba", + "metadata": {}, + "source": [ + "If the api does not allow for quering a sample rate for a certain gate, then eather the ```assumed_minimal_sample_rate``` is used (if not None) or the first demodulator is activated. This is done to have some sample rate to set the number of samples to record for certain measurement. The measurements define the regions to measure in units of nano seconds." + ] + }, { "cell_type": "code", "execution_count": 10, @@ -119,6 +150,14 @@ "my_lockin.assumed_minimal_sample_rate = None" ] }, + { + "cell_type": "markdown", + "id": "3d273882", + "metadata": {}, + "source": [ + "qupulse allows for defining multiple measurement windows for one measurement. The windows are identified by their name, a string. To set which channels to recorde in which window, the following dict is created. There the key defines the string for the window and the list for that key defined the paths that are to be measured. Internaly the device name is added in front. One can measure multiple channels in one window." + ] + }, { "cell_type": "code", "execution_count": 11, @@ -135,6 +174,14 @@ "}" ] }, + { + "cell_type": "markdown", + "id": "a12e287d", + "metadata": {}, + "source": [ + "When registerin these windows, one can give a program name under which these windows are saved. If this name is None, then they are used as a default. When then a other progarm is called which asks for a measurement window which has not been registered with that program name, then the default settings are used for that window." + ] + }, { "cell_type": "code", "execution_count": 12, @@ -146,6 +193,14 @@ " my_lockin.register_measurement_channel(program_name=None, channel_path=v, window_name=k)" ] }, + { + "cell_type": "markdown", + "id": "e684b4f8", + "metadata": {}, + "source": [ + "Here are the currently saved informations for the default program ```None```" + ] + }, { "cell_type": "code", "execution_count": 13, @@ -174,21 +229,38 @@ "my_lockin.programs[None]" ] }, + { + "cell_type": "markdown", + "id": "732bb4a2", + "metadata": {}, + "source": [ + "Now measurement windows are defined. This is usually done by qupuls when registering a program. But one can also to this by hand.\n", + "\n", + "The windows define for which period, after the beginning of the pulse, some data is to be returned. The windows are defined by a tuple of two lists, where the first gives the point after the pulse started of when the measurement should start in ns. The second give the duration of this window in ns. One can specify multiple regions for one window by adding multiple entries into these lists. (Here the naming might not be consistant engough. Occationally the word *mask* is used.)\n", + "\n", + "It is noteworthy that, in the current qupulse implementation, the point in them when a trigger signal is send to the measurement device has the managed by the user and is not checked to be at the correct point in time. So per default this signal is expected to be send out at the beginning of the pulse, and then the measurement equpment will measure the cover all windows (the duration is extracted from the defined windows.). But one can play tricks with that. But one needs to be careful. " + ] + }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 132, "id": "bc46a01c", "metadata": {}, "outputs": [], "source": [ - "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"A\": (np.array([0, 3])*1, np.array([1, 10])*1), \"many\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" + "my_lockin.register_measurement_windows(program_name=\"test\", windows={\n", + " \"A\": (np.array([0, 3])*1, np.array([1, 10])*1), \n", + " \"many\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)\n", + " })" ] }, { "cell_type": "code", "execution_count": 15, "id": "f45534ef", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { @@ -219,6 +291,14 @@ "my_lockin.programs" ] }, + { + "cell_type": "markdown", + "id": "9a22699a", + "metadata": {}, + "source": [ + "Ok, now that we have registered a program, we can delete it." + ] + }, { "cell_type": "code", "execution_count": 16, @@ -273,6 +353,16 @@ "## Defining a simple qupulse pulse with a measurement window." ] }, + { + "cell_type": "markdown", + "id": "a3bc5453", + "metadata": {}, + "source": [ + "Now we will define a simple pulse.\n", + "\n", + "Here only the measurement related stuff is commented. Later things get more interesting again." + ] + }, { "cell_type": "code", "execution_count": 18, @@ -330,6 +420,14 @@ " measurements=[('A', \"dt*3\", \"dt*1.5\"), ('A', \"dt*12\", \"dt*3\"), ('R', \"dt*6.5\", \"dt*1.4\"), ('R', \"dt*14\", \"dt*1\"), ('T', \"dt*10\", \"dt*3\")])" ] }, + { + "cell_type": "markdown", + "id": "97c66abd", + "metadata": {}, + "source": [ + "As one sees in the prior cell, one can also specify measurement windows with variables." + ] + }, { "cell_type": "code", "execution_count": 22, @@ -373,23 +471,35 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 142, "id": "eeeee0ec", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\site-packages\\ipykernel_launcher.py:1: DeprecationWarning: This is only a hack until https://github.com/qutech/qupulse/issues/578 is resolved. Do not call this method directly\n", + " \"\"\"Entry point for launching an IPython kernel.\n" + ] + }, { "data": { "text/plain": [ - "" + "[('A', 300000000.0, 150000000.0),\n", + " ('A', 1200000000.0, 300000000.0),\n", + " ('R', 650000000.0, 140000000.0),\n", + " ('R', 1400000000.0, 100000000.0),\n", + " ('T', 1000000000.0, 300000000.0)]" ] }, - "execution_count": 24, + "execution_count": 142, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "combined_pulse.get_measurement_windows" + "combined_pulse.get_measurement_windows(parameters={\"dt\": 1e8}, measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"T\"})" ] }, { @@ -476,11 +586,61 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "f5280e48", + "execution_count": 138, + "id": "d5c5f40f", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "{'A', 'R', 'T'}" + ] + }, + "execution_count": 138, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rep.measurement_names" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "id": "c547473f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 136, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rep.get_measurement_windows(parameters={\"dt\": 1e8}, measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"T\"})" + ] + }, + { + "cell_type": "markdown", + "id": "3bd81101", + "metadata": {}, + "source": [ + "(When writing this documentation the prior cell did not return the expected measurement windows, but an empty list. When compining that pulse and registering the program, the correct windows are written into the driver's memory.)" + ] + }, + { + "cell_type": "markdown", + "id": "b23c7772", + "metadata": {}, + "source": [ + "For repetitions like this, all windows are defined in relation to the beginning of the total pulse, when one want to trigger that more elegently, which might be the case if there are long durations in which one might not want to measure, one might need to become a bit creative. One solution would be to only define the first set of measurement windows, then let the trigger trigger the lock-in on every iteration of the pulse's loop, and then when defining the trigger settings later, allow for multiple triggers. Then the driver takes the windows with respect to the correpsonding trigger. " + ] }, { "cell_type": "markdown", @@ -523,6 +683,14 @@ "from qupulse.hardware.setup import HardwareSetup, MeasurementMask, PlaybackChannel" ] }, + { + "cell_type": "markdown", + "id": "d4514092", + "metadata": {}, + "source": [ + "As we also have a pulse, that contains some outputs, a virtual awg is used." + ] + }, { "cell_type": "code", "execution_count": 32, @@ -533,6 +701,14 @@ "my_awg = VirtualAWG(\"awg\", channels=3)" ] }, + { + "cell_type": "markdown", + "id": "4146568f", + "metadata": {}, + "source": [ + "The ```HardwareSetup``` is the central qupulse object that contains all devices for this setup. " + ] + }, { "cell_type": "code", "execution_count": 33, @@ -543,6 +719,14 @@ "setup = HardwareSetup()" ] }, + { + "cell_type": "markdown", + "id": "dd09864c", + "metadata": {}, + "source": [ + "We now register the link between the measurement window names and the driverse measurement window names. Similarly for the playback channels (i.e. outputs). " + ] + }, { "cell_type": "code", "execution_count": 34, @@ -565,6 +749,14 @@ " setup.set_channel(f\"{c}\", PlaybackChannel(my_awg, i))" ] }, + { + "cell_type": "markdown", + "id": "8b1d4e21", + "metadata": {}, + "source": [ + "Now the pulses are compiled into programs. This contains the measurement mapping and the parameters. When a measurment window is mapped to ```None``` it is omitted." + ] + }, { "cell_type": "code", "execution_count": 67, @@ -572,17 +764,35 @@ "metadata": {}, "outputs": [], "source": [ - "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e6})" + "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"}, parameters={\"dt\": 1e6})" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "b3d52873", + "metadata": {}, + "outputs": [], + "source": [ + "test_rep_program = rep.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"}, parameters={\"dt\": 1e6})" ] }, { "cell_type": "code", "execution_count": 112, - "id": "d02ed4aa", + "id": "e35f0e2f", "metadata": {}, "outputs": [], "source": [ - "test_program_single = combined_pulse.create_program(measurement_mapping={\"A\":None, \"R\":\"R\", \"T\":None},parameters={\"dt\": 1e6})" + "test_program_single = combined_pulse.create_program(measurement_mapping={\"A\":None, \"R\":\"R\", \"T\":None}, parameters={\"dt\": 1e6})" + ] + }, + { + "cell_type": "markdown", + "id": "965a3992", + "metadata": {}, + "source": [ + "a helper function for plotting the returned data. The measured data can also be returned in a raw format, where the data is not cropped to the measurement windows. For that call ```my_lockin.measure_program(return_raw=True)```." ] }, { @@ -604,16 +814,30 @@ { "cell_type": "code", "execution_count": 38, - "id": "cd8f83e8", + "id": "176c260b", "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, + { + "cell_type": "markdown", + "id": "564e8107", + "metadata": {}, + "source": [ + "Now we will register the trigger settings for the lock-in. They are program specific. \n", + "Also the devices name is added to the ```trigger_input``` strings. \n", + "The zurich instruments lock-ins have a funny naming convention, where the AUXIN inputs start at 0 and the TRUGINs at 1.\n", + "\n", + "Inside the driver, some input specific things are set regarding if certain strings are present in the ```trigger_input``` path. The parameters in ```other_settings``` are set after all the other trigger specific things and thus can be used to set more things. If the count is set to np.inf, the aquesition will only finish, if ```my_lockin.stop_acquisition()``` is called. The ```measure_program``` can be called such that is waits for the daq to finish the acquesition, or to already read what had been recorded, or to return partial measurements.\n", + "\n", + "For further informations, see to the docstring of that function." + ] + }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 143, "id": "d0c8669f", "metadata": {}, "outputs": [], @@ -623,20 +847,29 @@ " edge=\"rising\",\n", " trigger_count=3, # this defines the number of triggers to capture in one element (i.e. rows)\n", " level=.5, # this sets the trigger level\n", - " count=np.inf, # this defined the number of rounds that are to be measured (e.g. how often the \"single\" button should be pressed)\n", + " measurement_count=np.inf, # this defined the number of rounds that are to be measured (e.g. how often the \"single\" button should be pressed)\n", " other_settings={\"holdoff/time\": 1e-3} # this sets the duration for which new triggers are ignored\n", " )\n", "\n", + "# this will overwrite the earlier set settings\n", "my_lockin.register_trigger_settings(program_name=\"test\",\n", - " trigger_input=f\"demods/0/sample.TrigIn1\", # here TrigInN referese to the printer label N\n", + " trigger_input=f\"demods/0/sample.TrigIn1\", # here TrigInN referrers to the printer label N\n", " edge=\"rising\",\n", " trigger_count=3,\n", " level=.5,\n", - " count=3,\n", + " measurement_count=3,\n", " other_settings={\"holdoff/time\": 1e-3}\n", " )" ] }, + { + "cell_type": "markdown", + "id": "5e6a3516", + "metadata": {}, + "source": [ + "And now the program is going to be registered. The run_callback is the function call that is called when the ```setup.run_program(program_name_goes_here)``` function is called. If one want to trigger the lockin via software, one can call ```my_lockin.force_trigger()``` here." + ] + }, { "cell_type": "code", "execution_count": 69, @@ -646,20 +879,102 @@ }, "outputs": [], "source": [ - "# setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(None), update=True)\n", + "# setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(), update=True)\n", "setup.register_program('test', test_program, run_callback=lambda *a, **b: None, update=True)" ] }, + { + "cell_type": "code", + "execution_count": 140, + "id": "b037496c", + "metadata": {}, + "outputs": [], + "source": [ + "setup.register_program('test_rep', test_rep_program, run_callback=lambda *a, **b: None, update=True)" + ] + }, + { + "cell_type": "markdown", + "id": "9c3f8ac9", + "metadata": {}, + "source": [ + "And after that call, the lock-in is armed and the settings should have been updated. If one does not want the settings to update every time, one can set the ```self.force_update_on_arm``` field to ```False```. Within the update call, the sample rate is queried and the window dimensions are updated. Only later in the read call the information is applied and the data is then cropped (but it is not checked if the selected program is the one corresponding to the retrived data)." + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "id": "d38e253f", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'windows': {'X': (array([1.0e+07, 3.0e+07, 5.0e+07, 7.0e+07, 9.0e+07, 1.1e+08, 1.3e+08,\n", + " 1.5e+08, 1.7e+08, 1.9e+08]),\n", + " array([3000000., 3000000., 3000000., 3000000., 3000000., 3000000.,\n", + " 3000000., 3000000., 3000000., 3000000.])),\n", + " 'R': (array([6.500e+06, 1.400e+07, 2.650e+07, 3.400e+07, 4.650e+07, 5.400e+07,\n", + " 6.650e+07, 7.400e+07, 8.650e+07, 9.400e+07, 1.065e+08, 1.140e+08,\n", + " 1.265e+08, 1.340e+08, 1.465e+08, 1.540e+08, 1.665e+08, 1.740e+08,\n", + " 1.865e+08, 1.940e+08]),\n", + " array([1400000., 1000000., 1400000., 1000000., 1400000., 1000000.,\n", + " 1400000., 1000000., 1400000., 1000000., 1400000., 1000000.,\n", + " 1400000., 1000000., 1400000., 1000000., 1400000., 1000000.,\n", + " 1400000., 1000000.])),\n", + " 'A': (array([3.00e+06, 1.20e+07, 2.30e+07, 3.20e+07, 4.30e+07, 5.20e+07,\n", + " 6.30e+07, 7.20e+07, 8.30e+07, 9.20e+07, 1.03e+08, 1.12e+08,\n", + " 1.23e+08, 1.32e+08, 1.43e+08, 1.52e+08, 1.63e+08, 1.72e+08,\n", + " 1.83e+08, 1.92e+08]),\n", + " array([1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", + " 1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", + " 1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", + " 1500000., 3000000.]))},\n", + " 'windows_from_start_max': {'X': 193000000.0,\n", + " 'R': 195000000.0,\n", + " 'A': 195000000.0},\n", + " 'all_channels': {'auxins/0/sample.auxin0.avg',\n", + " 'demods/0/sample.r',\n", + " 'demods/0/sample.x'}}" + ] + }, + "execution_count": 141, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.programs[\"test_rep\"]" + ] + }, + { + "cell_type": "markdown", + "id": "710102b3", + "metadata": {}, + "source": [ + "As also incomplete data is returned, when the driver asks the lock-in for new data and the lock-in (or the data server) deletes the returned data, some form of memory is needed to peace data from different calles together. This is done in the ```my_lockin.read_memory``` field. If the programs are changed, and as things are not tracked in that regard, one might need to clear that ever so ofter. This can be done using ```my_lockin.clear_memory()```." + ] + }, { "cell_type": "code", "execution_count": 89, - "id": "0e0ddc37", + "id": "060a1a4c", "metadata": {}, "outputs": [], "source": [ "my_lockin.read_memory = {}" ] }, + { + "cell_type": "markdown", + "id": "0ecd69a6", + "metadata": {}, + "source": [ + "And now the program is run:" + ] + }, { "cell_type": "code", "execution_count": 88, @@ -690,6 +1005,14 @@ "setup.run_program(\"test\")" ] }, + { + "cell_type": "markdown", + "id": "358f204c", + "metadata": {}, + "source": [ + "For testing purposes the following two cells contain different ways to trigger things. The first using force_trigger calls. And the second using the auxilery output, which is connected to the earlier specified trigger input using a coaxial cable." + ] + }, { "cell_type": "code", "execution_count": 79, @@ -717,8 +1040,16 @@ ] }, { - "cell_type": "code", - "execution_count": 85, + "cell_type": "markdown", + "id": "5ae3314c", + "metadata": {}, + "source": [ + "The ```stop_acquisition()``` is called to stop the acquisition when the count in the trigger_count configuration is set to np.inf." + ] + }, + { + "cell_type": "code", + "execution_count": 85, "id": "8ab20ee5", "metadata": {}, "outputs": [], @@ -726,6 +1057,14 @@ "my_lockin.stop_acquisition()" ] }, + { + "cell_type": "markdown", + "id": "cf3104cc", + "metadata": {}, + "source": [ + "And then we read some data back from the device." + ] + }, { "cell_type": "code", "execution_count": 99, @@ -766,10 +1105,18 @@ " print(\"RETURNED NONE\")" ] }, + { + "cell_type": "markdown", + "id": "1ec2e091", + "metadata": {}, + "source": [ + "and here a different measurement, left in this notebook." + ] + }, { "cell_type": "code", "execution_count": 111, - "id": "dfc88289", + "id": "066a4fe1", "metadata": {}, "outputs": [ { @@ -821,7 +1168,7 @@ { "cell_type": "code", "execution_count": 108, - "id": "d34c362a", + "id": "e7af816c", "metadata": {}, "outputs": [ { @@ -1051,23 +1398,23 @@ { "cell_type": "code", "execution_count": null, - "id": "e0279a45", + "id": "b715a334", "metadata": {}, "outputs": [], "source": [] }, { - "cell_type": "code", - "execution_count": null, - "id": "6d96d4b0", + "cell_type": "markdown", + "id": "b0b4daa3", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "And now, let's look at again a different program" + ] }, { "cell_type": "code", "execution_count": 116, - "id": "00f4e282", + "id": "1ac65d7f", "metadata": {}, "outputs": [], "source": [ @@ -1078,7 +1425,7 @@ { "cell_type": "code", "execution_count": 117, - "id": "28689c4e", + "id": "fe7ace96", "metadata": { "scrolled": true }, @@ -1091,7 +1438,7 @@ { "cell_type": "code", "execution_count": 118, - "id": "d5934ebe", + "id": "be1c9ade", "metadata": {}, "outputs": [], "source": [ @@ -1108,7 +1455,7 @@ { "cell_type": "code", "execution_count": 119, - "id": "ad0ed003", + "id": "58dee40c", "metadata": {}, "outputs": [ { @@ -1130,7 +1477,7 @@ { "cell_type": "code", "execution_count": 129, - "id": "46a571d7", + "id": "dc4dc54f", "metadata": {}, "outputs": [], "source": [ @@ -1144,7 +1491,7 @@ { "cell_type": "code", "execution_count": 130, - "id": "57df3ce1", + "id": "d206d097", "metadata": {}, "outputs": [ { @@ -1196,5014 +1543,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c894793c", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "23d79a08", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e61a3cf1", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "453ec743", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a1eae59e", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d8716e9b", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "15826bae", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 88, - "id": "cc324843", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[-0.0005597 , -0.000469 , -0.0003783 , ..., -0.00186879,\n", - " -0.00185745, -0.00184611],\n", - " [-0.00098405, -0.00088201, -0.00077997, ..., -0.0012212 ,\n", - " -0.00115317, -0.00108514],\n", - " [-0.00097637, -0.00101038, -0.0010444 , ..., -0.00090118,\n", - " -0.0008785 , -0.00085583]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886364795117]\n", - " createdtimestamp: [1091745849803]\n", - " changedtimestamp: [1091986551243]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 024 14:26:04.7949\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[-8.42900002e-04, -8.65575612e-04, -8.88251222e-04, ...,\n", - " -2.31813318e-03, -2.37482220e-03, -2.43151123e-03],\n", - " [-7.22152379e-05, -3.82018229e-05, -4.18840788e-06, ...,\n", - " -1.90278484e-03, -1.86877143e-03, -1.83475801e-03],\n", - " [-8.78525512e-04, -8.89863317e-04, -9.01201122e-04, ...,\n", - " -9.62771983e-04, -1.00812320e-03, -1.05347442e-03]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886370722229]\n", - " createdtimestamp: [1092107045323]\n", - " changedtimestamp: [1092347961803]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 025 14:26:10.7220\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[-1.87361530e-03, -1.81692628e-03, -1.76023725e-03, ...,\n", - " -2.81537691e-03, -2.87206594e-03, -2.92875496e-03],\n", - " [-1.33956419e-03, -1.46428005e-03, -1.58899590e-03, ...,\n", - " -2.70161419e-03, -2.66760077e-03, -2.63358736e-03],\n", - " [-1.73439819e-03, -1.79108722e-03, -1.84777624e-03, ...,\n", - " 1.23551705e-05, 8.03820006e-05, 1.48408831e-04]])\n", - " Coordinates:\n", - " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886376646618]\n", - " createdtimestamp: [1092468384203]\n", - " changedtimestamp: [1092709085643]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 026 14:26:16.6464\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.r': [\n", - " array([[3.67919224e-07, 2.83155155e-07, 1.98424922e-07, ...,\n", - " 3.46452632e-07, 8.21098062e-07, 9.25034948e-07],\n", - " [1.96074040e-07, 2.21383078e-07, 4.68834272e-07, ...,\n", - " 9.52262078e-07, 4.83415782e-07, 5.52015728e-07],\n", - " [3.55882336e-07, 3.27200774e-07, 4.19314029e-07, ...,\n", - " 2.92538330e-07, 5.21568235e-07, 5.05150107e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886364795192]\n", - " createdtimestamp: [1091745849803]\n", - " changedtimestamp: [1091986551243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 024 14:26:04.7949\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[2.92395192e-07, 2.25222683e-07, 1.21325519e-07, ...,\n", - " 5.39336686e-07, 3.84301196e-07, 3.74622534e-07],\n", - " [3.05529466e-07, 9.36520953e-08, 3.03995805e-07, ...,\n", - " 1.02236696e-06, 9.93392222e-07, 5.19542514e-07],\n", - " [3.01692648e-07, 3.83754234e-07, 2.70232334e-07, ...,\n", - " 5.81183641e-07, 6.24799778e-07, 4.31362127e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886370722270]\n", - " createdtimestamp: [1092107045323]\n", - " changedtimestamp: [1092347961803]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 025 14:26:10.7220\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[7.93975965e-07, 8.93030872e-07, 1.23001589e-06, ...,\n", - " 3.67492049e-07, 2.34827369e-07, 2.35706276e-07],\n", - " [3.61742908e-07, 4.48546210e-07, 2.31477247e-07, ...,\n", - " 5.86607223e-07, 5.45344640e-07, 3.19530491e-07],\n", - " [1.80878244e-07, 1.47223775e-07, 1.42378570e-07, ...,\n", - " 1.75339378e-07, 3.28294689e-07, 8.26655524e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886376646657]\n", - " createdtimestamp: [1092468384203]\n", - " changedtimestamp: [1092709085643]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 026 14:26:16.6464\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.trigin1': [\n", - " array([[0., 1., 1., ..., 0., 0., 0.],\n", - " [0., 1., 1., ..., 0., 0., 0.],\n", - " [0., 1., 1., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886364795316]\n", - " createdtimestamp: [1091745849803]\n", - " changedtimestamp: [1091986551243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 024 14:26:04.7949\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 1., 1., ..., 0., 0., 0.],\n", - " [0., 1., 1., ..., 0., 0., 0.],\n", - " [0., 1., 1., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886370722345]\n", - " createdtimestamp: [1092107045323]\n", - " changedtimestamp: [1092347961803]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 025 14:26:10.7220\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 1., 1., ..., 0., 0., 0.],\n", - " [0., 1., 1., ..., 0., 0., 0.],\n", - " [0., 1., 1., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886376646733]\n", - " createdtimestamp: [1092468384203]\n", - " changedtimestamp: [1092709085643]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 026 14:26:16.6464\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.x': [\n", - " array([[ 6.65674270e-08, -1.10711122e-07, -1.75238995e-07, ...,\n", - " 3.00088872e-07, 5.42731804e-07, 6.73676425e-07],\n", - " [ 1.76368493e-07, 2.20327427e-07, -3.09841778e-07, ...,\n", - " 2.28058119e-07, 2.14299053e-07, 3.54935591e-07],\n", - " [-3.51589550e-07, -3.15060548e-07, -3.47898502e-07, ...,\n", - " 1.59659817e-07, 1.15966965e-07, -5.18576454e-08]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886364795245]\n", - " createdtimestamp: [1091745849803]\n", - " changedtimestamp: [1091986551243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 024 14:26:04.7949\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[-4.09052830e-08, 2.13295121e-08, 5.33865634e-08, ...,\n", - " -4.00140619e-07, -3.50272899e-07, -3.20757666e-07],\n", - " [-1.21754969e-07, -7.33503936e-08, 2.64174546e-07, ...,\n", - " -1.00753722e-06, -7.90096025e-07, -2.52642785e-07],\n", - " [-2.68055140e-07, -2.78390434e-07, -9.46063598e-08, ...,\n", - " -5.33591780e-07, -5.72202191e-07, -4.30658588e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886370722308]\n", - " createdtimestamp: [1092107045323]\n", - " changedtimestamp: [1092347961803]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 025 14:26:10.7220\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[ 1.55824069e-07, 4.11162940e-07, 4.66974725e-07, ...,\n", - " 2.71678622e-07, 2.18573685e-07, -1.56646826e-07],\n", - " [ 3.33768717e-07, 4.47974167e-07, 2.30547319e-07, ...,\n", - " -2.92901103e-07, -1.49833963e-07, 1.35891929e-07],\n", - " [ 1.80673620e-07, 1.28038062e-07, 4.32264639e-08, ...,\n", - " 1.68609698e-07, -3.28192979e-07, -8.26423523e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886376646697]\n", - " createdtimestamp: [1092468384203]\n", - " changedtimestamp: [1092709085643]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 026 14:26:16.6464\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}" - ] - }, - "execution_count": 88, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "id": "20bb0981", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885494031060]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885499560433]\n", - " createdtimestamp: [1039013445533]\n", - " changedtimestamp: [1039023023213]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 002 14:11:39.5600\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886126694424]\n", - " createdtimestamp: [1076950339563]\n", - " changedtimestamp: [1077288735243]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 019 14:22:06.6936\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.r': [\n", - " array([[ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [3.83335709e-07, 3.83594719e-07, 3.83857600e-07, ...,\n", - " nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885494088087]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885499593310]\n", - " createdtimestamp: [1039013445533]\n", - " changedtimestamp: [1039023023213]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 002 14:11:39.5600\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[8.60182422e-08, 8.74794163e-08, 8.90240508e-08, ...,\n", - " nan, nan, nan],\n", - " [6.62406884e-08, 6.46201620e-08, 6.30831144e-08, ...,\n", - " nan, nan, nan],\n", - " [5.27267604e-07, 5.28614361e-07, 5.30040283e-07, ...,\n", - " nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886126698076]\n", - " createdtimestamp: [1076950339563]\n", - " changedtimestamp: [1077288735243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 019 14:22:06.6936\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.trigin1': [\n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885489547296]\n", - " createdtimestamp: [1038982525553]\n", - " changedtimestamp: [1038993876613]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 000 14:11:29.2195\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [ 0., 0., 0., ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885494168868]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885499657769]\n", - " createdtimestamp: [1039013445533]\n", - " changedtimestamp: [1039023023213]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 002 14:11:39.5600\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.747e+13 1.747e+13 ... 1.748e+13 1.748e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885639072999]\n", - " createdtimestamp: [1048217067723]\n", - " changedtimestamp: [1048455009483]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 003 14:13:59.0712\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.748e+13 1.748e+13 ... 1.748e+13 1.748e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885644955400]\n", - " createdtimestamp: [1048575557323]\n", - " changedtimestamp: [1048816518603]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 004 14:14:04.9542\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.748e+13 1.748e+13 ... 1.749e+13 1.749e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885651071285]\n", - " createdtimestamp: [1048934683083]\n", - " changedtimestamp: [1049175017163]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 005 14:14:11.0700\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.762e+13 1.762e+13 ... 1.763e+13 1.763e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885791762410]\n", - " createdtimestamp: [1057372530123]\n", - " changedtimestamp: [1057611081163]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 006 14:16:31.7604\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.763e+13 1.763e+13 ... 1.763e+13 1.763e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885797604338]\n", - " createdtimestamp: [1057731646923]\n", - " changedtimestamp: [1057971963083]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 007 14:16:37.5946\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.763e+13 1.763e+13 ... 1.764e+13 1.764e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885803622668]\n", - " createdtimestamp: [1058092555723]\n", - " changedtimestamp: [1058331088843]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 008 14:16:43.6214\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.77e+13 1.77e+13 ... 1.771e+13 1.771e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885871598865]\n", - " createdtimestamp: [1062162716363]\n", - " changedtimestamp: [1062400613323]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 009 14:17:51.5969\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.771e+13 1.771e+13 ... 1.771e+13 1.771e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885877429641]\n", - " createdtimestamp: [1062521824203]\n", - " changedtimestamp: [1062762167243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 010 14:17:57.4282\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.771e+13 1.771e+13 ... 1.772e+13 1.772e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885883413040]\n", - " createdtimestamp: [1062882741963]\n", - " changedtimestamp: [1063120674763]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 011 14:18:03.4118\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.782e+13 1.782e+13 ... 1.782e+13 1.782e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885985636933]\n", - " createdtimestamp: [1069007968203]\n", - " changedtimestamp: [1069245453003]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 012 14:19:45.6351\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.782e+13 1.782e+13 ... 1.783e+13 1.783e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885991611307]\n", - " createdtimestamp: [1069365866443]\n", - " changedtimestamp: [1069607607243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 013 14:19:51.6101\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.783e+13 1.783e+13 ... 1.783e+13 1.783e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885997735588]\n", - " createdtimestamp: [1069727993803]\n", - " changedtimestamp: [1069966114763]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 014 14:19:57.7343\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.789e+13 1.789e+13 ... 1.79e+13 1.79e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886060607309]\n", - " createdtimestamp: [1073499831243]\n", - " changedtimestamp: [1073737351883]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 015 14:21:00.6054\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.79e+13 1.79e+13 1.79e+13 ... 1.79e+13 1.79e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886066623023]\n", - " createdtimestamp: [1073858338763]\n", - " changedtimestamp: [1074098852043]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 016 14:21:06.6218\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.79e+13 1.79e+13 ... 1.791e+13 1.791e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886072592296]\n", - " createdtimestamp: [1074219838923]\n", - " changedtimestamp: [1074457977803]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 017 14:21:12.5911\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[ 0., 0., 0., ..., nan, nan, nan],\n", - " [ 0., 0., 0., ..., nan, nan, nan],\n", - " [ 0., 0., 0., ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886120155827]\n", - " createdtimestamp: [1076891918123]\n", - " changedtimestamp: [1076929715883]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 018 14:22:00.1345\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[ 0., 0., 0., ..., nan, nan, nan],\n", - " [ 0., 0., 0., ..., nan, nan, nan],\n", - " [ 0., 0., 0., ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886126705825]\n", - " createdtimestamp: [1076950339563]\n", - " changedtimestamp: [1077288735243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 019 14:22:06.6936\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[ 0., 0., 0., ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 1.796e+13 1.796e+13 1.796e+13 ... 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886132860354]\n", - " createdtimestamp: [1077609510523]\n", - " changedtimestamp: [1077652213403]\n", - " flags: [1848]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 020 14:22:12.8482\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.x': [\n", - " array([[ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [-3.79128012e-07, -3.79368980e-07, -3.79612937e-07, ...,\n", - " nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885494133030]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885499625269]\n", - " createdtimestamp: [1039013445533]\n", - " changedtimestamp: [1039023023213]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 002 14:11:39.5600\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[ 5.15736266e-08, 5.26349600e-08, 5.37237984e-08, ...,\n", - " nan, nan, nan],\n", - " [-6.12978321e-08, -5.92433298e-08, -5.72438376e-08, ...,\n", - " nan, nan, nan],\n", - " [-4.08640255e-08, -3.73170793e-08, -3.38018236e-08, ...,\n", - " nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886126701691]\n", - " createdtimestamp: [1076950339563]\n", - " changedtimestamp: [1077288735243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 019 14:22:06.6936\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.read_memory" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "id": "974e560e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'X': {'/dev3442/demods/0/sample.x': [\n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886120147957]\n", - " createdtimestamp: [1076891918123]\n", - " changedtimestamp: [1076929715883]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 018 14:22:00.1345\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]},\n", - " 'R': {'/dev3442/demods/0/sample.r': [\n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886120141796]\n", - " createdtimestamp: [1076891918123]\n", - " changedtimestamp: [1076929715883]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 018 14:22:00.1345\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886120141796]\n", - " createdtimestamp: [1076891918123]\n", - " changedtimestamp: [1076929715883]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 018 14:22:00.1345\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]},\n", - " 'A': {'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[-0.00221065, -0.00221092, -0.00221119, ..., -0.00150499,\n", - " -0.00150526, -0.00150552]])\n", - " Coordinates:\n", - " time (row, col) float64 3e+08 3e+08 3e+08 ... 4.5e+08 4.5e+08 4.5e+08\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886120135151]\n", - " createdtimestamp: [1076891918123]\n", - " changedtimestamp: [1076929715883]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 018 14:22:00.1345\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886120135151]\n", - " createdtimestamp: [1076891918123]\n", - " changedtimestamp: [1076929715883]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 018 14:22:00.1345\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}},\n", - " {'X': {'/dev3442/demods/0/sample.x': [\n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886132856158]\n", - " createdtimestamp: [1077609510523]\n", - " changedtimestamp: [1077652213403]\n", - " flags: [1848]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 020 14:22:12.8482\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]},\n", - " 'R': {'/dev3442/demods/0/sample.r': [\n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886132852379]\n", - " createdtimestamp: [1077609510523]\n", - " changedtimestamp: [1077652213403]\n", - " flags: [1848]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 020 14:22:12.8482\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886132852379]\n", - " createdtimestamp: [1077609510523]\n", - " changedtimestamp: [1077652213403]\n", - " flags: [1848]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 020 14:22:12.8482\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]},\n", - " 'A': {'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[-0.00127274, -0.00127318, -0.00127363, ..., -0.00089014,\n", - " -0.00088996, -0.00088978]])\n", - " Coordinates:\n", - " time (row, col) float64 3e+08 3e+08 3e+08 ... 4.5e+08 4.5e+08 4.5e+08\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886132848581]\n", - " createdtimestamp: [1077609510523]\n", - " changedtimestamp: [1077652213403]\n", - " flags: [824]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 020 14:22:12.8482\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[-0.00359344, -0.00359255, -0.00359166, ..., -0.00202245,\n", - " -0.00202272, -0.00202298]])\n", - " Coordinates:\n", - " time (row, col) float64 1.2e+09 1.2e+09 1.2e+09 ... 1.5e+09 1.5e+09\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886132848581]\n", - " createdtimestamp: [1077609510523]\n", - " changedtimestamp: [1077652213403]\n", - " flags: [824]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 020 14:22:12.8482\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}}]" - ] - }, - "execution_count": 75, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "c29511b9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m(1160)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 1158 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1159 \u001b[1;33m \u001b[0marray\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_indexing_array_and_key\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m-> 1160 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0marray\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1161 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1162 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\variable.py\u001b[0m(786)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 784 \u001b[1;33m \"\"\"\n", - "\u001b[0m\u001b[1;32m 785 \u001b[1;33m \u001b[0mdims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnew_order\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_broadcast_indexes\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 786 \u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mas_indexable\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_data\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 787 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mnew_order\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 788 \u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmoveaxis\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnew_order\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnew_order\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\variable.py\u001b[0m(1193)\u001b[0;36misel\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 1191 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1192 \u001b[1;33m \u001b[0mkey\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtuple\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdim\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mslice\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mdim\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdims\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m-> 1193 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1194 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1195 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0msqueeze\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> uu\n", - "*** NameError: name 'uu' is not defined\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(1208)\u001b[0;36misel\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 1206 \u001b[1;33m \u001b[1;31m# lists, or zero or one-dimensional np.ndarray's\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1207 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m-> 1208 \u001b[1;33m \u001b[0mvariable\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_variable\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmissing_dims\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmissing_dims\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1209 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1210 \u001b[1;33m \u001b[0mcoords\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(745)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 743 \u001b[1;33m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 744 \u001b[1;33m \u001b[1;31m# xarray-style array indexing\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 745 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_item_key_to_dict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 746 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 747 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mAny\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mAny\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(593)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 591 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ml\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0m_wind\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 592 \u001b[1;33m \u001b[1;31m# _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)[\"time\"][:, 0].values\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 593 \u001b[1;33m \u001b[0m_time_of_first_not_nan_value\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mapplicable_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"time\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 594 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 595 \u001b[1;33m \u001b[0mtime_of_trigger\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mapplicable_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mattrs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"gridcoloffset\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m1e9\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0m_time_of_first_not_nan_value\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(735)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 733 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 734 \u001b[1;33m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 735 \u001b[1;33m \u001b[0mthat_shot_parsed\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mthat_shot\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcurrently_set_program\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 736 \u001b[1;33m \u001b[1;31m# except KeyError:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 737 \u001b[1;33m \u001b[1;31m# print(f\"Error\")\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> that_shot\n", - "{'/dev3442/demods/0/sample.r': [\n", - "array([[ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [3.83335709e-07, 3.83594719e-07, 3.83857600e-07, ...,\n", - " nan, nan, nan]])\n", - "Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664885494088087]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]], '/dev3442/demods/0/sample.x': [\n", - "array([[ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [-3.79128012e-07, -3.79368980e-07, -3.79612937e-07, ...,\n", - " nan, nan, nan]])\n", - "Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664885494133030]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]], '/dev3442/auxins/0/sample.auxin0.avg': [\n", - "array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - "Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664885494031060]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 84, - "id": "76dd008a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'auxins/0/sample.auxin0.avg', 'demods/0/sample.r', 'demods/0/sample.x'}" - ] - }, - "execution_count": 84, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin._get_channels_for_window(program_name='test', window_name=None)" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "id": "8816fccf", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[autoreload of qupulse.hardware.dacs.mfli failed: Traceback (most recent call last):\n", - " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\site-packages\\IPython\\extensions\\autoreload.py\", line 245, in check\n", - " superreload(m, reload, self.old_objects)\n", - " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\site-packages\\IPython\\extensions\\autoreload.py\", line 394, in superreload\n", - " module = reload(module)\n", - " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\imp.py\", line 314, in reload\n", - " return importlib.reload(module)\n", - " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\importlib\\__init__.py\", line 169, in reload\n", - " _bootstrap._exec(spec, module)\n", - " File \"\", line 630, in _exec\n", - " File \"\", line 724, in exec_module\n", - " File \"\", line 860, in get_code\n", - " File \"\", line 791, in source_to_code\n", - " File \"\", line 219, in _call_with_frames_removed\n", - " File \"z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\", line 660\n", - " for k, v in recorded_data.items()\n", - " ^\n", - "SyntaxError: invalid syntax\n", - "]\n" - ] - }, - { - "data": { - "text/plain": [ - "{'X': {'/dev3442/demods/0/sample.x': [\n", - " array([[ 2.69279111e-07, 3.76000218e-07, 4.24689409e-07, ...,\n", - " -9.44849792e-08, -5.75667221e-08, -2.49266848e-08],\n", - " [ 6.31987250e-07, 4.11887636e-07, 2.38855616e-07, ...,\n", - " 2.93972004e-07, 3.04276206e-07, 4.01271313e-07],\n", - " [ 2.96471967e-07, 2.15771765e-07, 6.63772839e-08, ...,\n", - " 4.10635562e-07, 3.79404258e-07, 2.66680489e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1e+09 1.001e+09 1.002e+09 ... 1.299e+09 1.3e+09\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664873312419283]\n", - " createdtimestamp: [308605257163]\n", - " changedtimestamp: [309086050763]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 10:48:32.4190\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [2512]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]},\n", - " 'R': {'/dev3442/demods/0/sample.r': [\n", - " array([[3.50875860e-07, 2.70602397e-07, 3.22289289e-07, 3.21639020e-07,\n", - " 3.32765766e-07, 3.65126975e-07, 3.12966538e-07, 1.64027162e-07,\n", - " 2.45165536e-07, 4.19091366e-07, 4.14326504e-07, 3.29614134e-07,\n", - " 3.98556089e-07, 6.03632644e-07, 6.03304127e-07, 5.94617891e-07,\n", - " 5.10234580e-07, 3.35210733e-07, 2.30888648e-07, 2.51064516e-07,\n", - " 2.76974768e-07, 1.91823303e-07, 1.49521913e-07, 1.75328687e-07,\n", - " 2.78571123e-07, 2.10951086e-07, 2.16255281e-07, 3.16839491e-07,\n", - " 2.76141363e-07, 2.81573604e-07, 1.37238391e-07, 2.12871898e-07,\n", - " 3.62986060e-07, 4.29124663e-07, 3.16040404e-07, 2.67266655e-07,\n", - " 3.65657304e-07, 4.48666830e-07, 5.83573620e-07, 6.42626010e-07,\n", - " 6.11464599e-07, 5.49052360e-07, 5.86160132e-07, 5.82156228e-07,\n", - " 6.03255004e-07, 7.89091970e-07, 7.84022056e-07, 6.62303305e-07,\n", - " 5.03959286e-07, 4.49465035e-07, 4.43046704e-07, 5.90456587e-07,\n", - " 6.21792060e-07, 5.72738852e-07, 5.41391892e-07, 6.26158439e-07,\n", - " 4.59861745e-07, 2.12973843e-07, 2.37172460e-07, 3.72531488e-07,\n", - " 4.36279699e-07, 4.85907475e-07, 4.92556374e-07, 4.65265233e-07,\n", - " 3.19733747e-07, 3.04607663e-07, 2.94144267e-07, 2.45885864e-07,\n", - " 3.16028078e-08, 1.85243058e-07, 2.02642415e-07, 1.80417555e-07,\n", - " 3.17077909e-07, 5.14676889e-07, 6.35520404e-07, 6.37312376e-07,\n", - " 7.26135275e-07, 7.20081269e-07, 6.00586796e-07, 4.64989563e-07,\n", - " ...\n", - " 4.50349728e-07, 4.64176142e-07, 4.07156112e-07, 3.00673748e-07,\n", - " 3.72114091e-07, 3.60206239e-07, 3.14711484e-07, 3.11498318e-07,\n", - " 3.19263711e-07, 4.13087658e-07, 5.53255690e-07, 6.62389429e-07,\n", - " 5.97159565e-07, 3.48292585e-07, 4.04279527e-07, 5.47591484e-07,\n", - " 5.15210639e-07, 3.36606101e-07, 3.26182141e-07, 3.48923075e-07,\n", - " 2.78243634e-07, 2.82163333e-07, 5.26134267e-07, 7.70090420e-07,\n", - " 7.76728207e-07, 5.89799838e-07, 3.04388253e-07, 2.47766692e-07,\n", - " 1.58789395e-07, 3.03364830e-08, 1.49812292e-07, 2.22399343e-07,\n", - " 3.88711488e-07, 3.20814441e-07, 2.11552399e-07, 4.36760799e-07,\n", - " 5.85246465e-07, 5.98170037e-07, 5.50512150e-07, 3.43713482e-07,\n", - " 1.71207817e-07, 8.49430082e-08, 3.30555288e-07, 3.34163350e-07,\n", - " 3.26281110e-07, 4.09983188e-07, 4.57014174e-07, 4.68563630e-07,\n", - " 3.69464867e-07, 5.94835249e-07, 7.14685065e-07, 6.94255244e-07,\n", - " 7.13042485e-07, 4.59999172e-07, 2.51558505e-07, 2.28146965e-07,\n", - " 3.82364839e-07, 5.39785539e-07, 5.77188043e-07, 4.28624053e-07,\n", - " 2.29961114e-07, 2.83972207e-07, 3.65491624e-07, 3.50174319e-07,\n", - " 2.72091187e-07, 3.20505843e-07, 4.70595140e-07, 5.27882868e-07,\n", - " 4.16385393e-07, 1.06342650e-07, 1.75540360e-07, 3.57477226e-07,\n", - " 5.66663118e-07, 6.23191013e-07, 4.74268790e-07, 5.57135024e-07,\n", - " 6.78589995e-07, 6.83960121e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 6.503e+08 6.509e+08 ... 7.889e+08 7.895e+08\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664873312419223]\n", - " createdtimestamp: [308605257163]\n", - " changedtimestamp: [309086050763]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 10:48:32.4190\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [2512]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[1.83064221e-07, 1.61855467e-07, 2.49241466e-07, 3.39376135e-07,\n", - " 4.36536798e-07, 5.18693392e-07, 6.30735429e-07, 5.74835074e-07,\n", - " 4.36776420e-07, 2.63859894e-07, 1.30624147e-07, 9.70415274e-08,\n", - " 1.44476414e-07, 3.81813606e-07, 6.38447230e-07, 7.45571057e-07,\n", - " 8.22906422e-07, 9.18075754e-07, 8.43259013e-07, 7.61613607e-07,\n", - " 7.57270048e-07, 6.88958757e-07, 4.83349759e-07, 3.55754578e-07,\n", - " 3.63642255e-07, 4.22655755e-07, 3.87072095e-07, 3.70289162e-07,\n", - " 3.62161548e-07, 2.70584201e-07, 2.87656239e-07, 3.19854380e-07,\n", - " 2.08389908e-07, 1.96618982e-08, 3.33132395e-07, 4.70787632e-07,\n", - " 5.12829988e-07, 6.21235123e-07, 6.78234168e-07, 8.17913035e-07,\n", - " 8.18258618e-07, 7.54368146e-07, 7.46640882e-07, 5.50770744e-07,\n", - " 5.12319511e-07, 6.08510609e-07, 6.62309838e-07, 6.44205313e-07,\n", - " 5.95868712e-07, 6.51155602e-07, 6.31010157e-07, 7.74893720e-07,\n", - " 7.73539311e-07, 7.74910192e-07, 8.02652723e-07, 8.23684689e-07,\n", - " 8.68193990e-07, 8.62732478e-07, 8.01325476e-07, 6.25764502e-07,\n", - " 5.04780975e-07, 5.93346931e-07, 6.10683738e-07, 4.86562387e-07,\n", - " 3.12983135e-07, 3.68123599e-07, 5.59757155e-07, 7.12527556e-07,\n", - " 8.47038984e-07, 9.42978974e-07, 8.63359915e-07, 6.06673635e-07,\n", - " 4.27951356e-07, 3.59254470e-07, 2.99652089e-07, 1.79138376e-07,\n", - " 2.32503549e-07, 2.27449770e-07, 2.62303298e-07, 3.27436843e-07,\n", - " ...\n", - " 1.34507520e-07, 1.02082212e-07, 1.12642947e-07, 2.57615087e-07,\n", - " 2.52001240e-07, 8.39497095e-08, 7.44285860e-08, 3.41073852e-07,\n", - " 5.83489122e-07, 6.96472052e-07, 6.53976255e-07, 5.88986968e-07,\n", - " 4.49598566e-07, 2.98920279e-07, 2.12782307e-07, 2.95983869e-07,\n", - " 4.05101586e-07, 3.98188629e-07, 4.47104691e-07, 5.23768048e-07,\n", - " 3.36085570e-07, 9.03901955e-08, 3.48991273e-07, 5.33593138e-07,\n", - " 5.62695854e-07, 4.58134554e-07, 3.08202787e-07, 2.11030979e-07,\n", - " 2.51420702e-07, 1.01853724e-07, 2.07736971e-07, 4.68642977e-07,\n", - " 7.63032151e-07, 7.22946677e-07, 4.32578803e-07, 3.27013842e-07,\n", - " 3.40702093e-07, 4.66298330e-07, 7.43736291e-07, 8.69379562e-07,\n", - " 8.87377110e-07, 7.33472718e-07, 5.23308094e-07, 4.26309170e-07,\n", - " 4.31965940e-07, 2.58649504e-07, 1.33946849e-07, 4.47104352e-07,\n", - " 6.18007476e-07, 5.56577597e-07, 5.28093625e-07, 4.13845425e-07,\n", - " 3.33008003e-07, 2.89431379e-07, 1.47540020e-07, 1.70592255e-07,\n", - " 3.10416178e-07, 5.25815591e-07, 5.15154408e-07, 2.60636244e-07,\n", - " 7.17283923e-08, 9.54203553e-08, 2.61190363e-07, 2.57871195e-07,\n", - " 7.60343295e-08, 3.05941060e-07, 4.40774851e-07, 3.01379243e-07,\n", - " 2.00560156e-07, 2.19666114e-07, 2.69370619e-07, 2.87369645e-07,\n", - " 2.86037423e-07, 3.27678416e-07, 2.66341497e-07, 1.00779122e-07,\n", - " 1.75057650e-07, 2.29900763e-07, 2.45636684e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.401e+09 1.401e+09 ... 1.499e+09 1.5e+09\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664873312419223]\n", - " createdtimestamp: [308605257163]\n", - " changedtimestamp: [309086050763]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 10:48:32.4190\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [2512]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]},\n", - " 'A': {'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[-1.60287965e-03, -1.63122416e-03, -1.65956868e-03,\n", - " -1.68791319e-03, -1.71625770e-03, -1.74460221e-03,\n", - " -1.77294673e-03, -1.80129124e-03, -1.82963575e-03,\n", - " -1.85798026e-03, -1.88632478e-03, -1.91466929e-03,\n", - " -1.94301380e-03, -1.97135831e-03, -1.99970283e-03,\n", - " -2.02804734e-03, -2.05639185e-03, -2.08473636e-03,\n", - " -2.11308088e-03, -2.14142539e-03, -2.16976990e-03,\n", - " -2.19811441e-03, -2.22645893e-03, -2.25480344e-03,\n", - " -2.28314795e-03, -2.31149246e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " ...\n", - " -1.21943914e-03, -1.20243243e-03, -1.18542572e-03,\n", - " -1.16841901e-03, -1.15141231e-03, -1.13440560e-03,\n", - " -1.11739889e-03, -1.10039218e-03, -1.08338548e-03,\n", - " -1.06637877e-03, -1.04937206e-03, -1.03236535e-03,\n", - " -1.01535865e-03, -9.98351938e-04, -9.81345231e-04,\n", - " -9.64338523e-04, -9.47331816e-04, -9.30325108e-04,\n", - " -9.13318401e-04, -8.96311693e-04, -8.79304986e-04,\n", - " -8.62298278e-04, -8.45291571e-04, -8.28284863e-04,\n", - " -8.11278156e-04, -7.94271448e-04, -7.77264741e-04,\n", - " -7.60258033e-04, -7.43251326e-04, -7.26244618e-04,\n", - " -7.09237911e-04, -6.92231203e-04, -6.75224496e-04,\n", - " -6.58217788e-04, -6.41211081e-04, -6.24204373e-04,\n", - " -6.07197666e-04, -5.90190958e-04, -5.73184251e-04,\n", - " -5.56177543e-04, -5.39170836e-04, -5.22164128e-04,\n", - " -5.05157420e-04, -4.88150713e-04, -4.71144005e-04,\n", - " -4.54137298e-04, -4.37130590e-04, -4.20123883e-04,\n", - " -4.03117175e-04, -3.86110468e-04, -3.69103760e-04,\n", - " -3.52097053e-04, -3.35090345e-04, -3.27169066e-04,\n", - " -3.21500164e-04, -3.15831261e-04, -3.10162359e-04,\n", - " -3.04493456e-04, -2.98824554e-04]])\n", - " Coordinates:\n", - " time (row, col) float64 3.003e+08 3.009e+08 ... 4.49e+08 4.496e+08\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664873312419159]\n", - " createdtimestamp: [308605257163]\n", - " changedtimestamp: [309086050763]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 10:48:32.4190\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [2512]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[-0.0018963 , -0.00187362, -0.00185095, ..., -0.0027846 ,\n", - " -0.00280727, -0.00282995],\n", - " [-0.00225985, -0.0023052 , -0.00231484, ..., nan,\n", - " nan, nan],\n", - " [-0.00135823, -0.00132989, -0.00130154, ..., -0.00036784,\n", - " -0.00037351, -0.00037918]])\n", - " Coordinates:\n", - " time (row, col) float64 1.2e+09 1.201e+09 ... 1.499e+09 1.5e+09\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664873312419159]\n", - " createdtimestamp: [308605257163]\n", - " changedtimestamp: [309086050763]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 10:48:32.4190\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [2512]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}}" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "e36fb677", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32m<__array_function__ internals>\u001b[0m(6)\u001b[0;36mconcatenate\u001b[1;34m()\u001b[0m\n", - "\n", - "ipdb> u\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(707)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 705 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 706 \u001b[1;33m \u001b[0mcreation_ts\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mattrs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"createdtimestamp\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0me\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mv\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread_memory\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 707 \u001b[1;33m \u001b[0mall_ts\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0munique\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcreation_ts\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 708 \u001b[1;33m \u001b[1;32massert\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mall_ts\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 709 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> creation_ts\n", - "{}\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "id": "7ea34368", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'awgcontrol': array([0], dtype=int64),\n", - " 'bandwidth': array([0.]),\n", - " 'bitmask': array([1], dtype=int64),\n", - " 'bits': array([1], dtype=int64),\n", - " 'buffercount': array([10], dtype=int64),\n", - " 'buffersize': array([0.2]),\n", - " 'clearhistory': array([0], dtype=int64),\n", - " 'count': array([3], dtype=int64),\n", - " 'delay': array([-0.001]),\n", - " 'dev3442': {'demods': {'0': {'sample.x': [{'header': {'systemtime': array([1664558103553351], dtype=uint64),\n", - " 'createdtimestamp': array([2050547636776], dtype=uint64),\n", - " 'changedtimestamp': array([2050906036776], dtype=uint64),\n", - " 'flags': array([1849], dtype=uint32),\n", - " 'moduleflags': array([0], dtype=uint32),\n", - " 'chunksizebytes': array([0], dtype=uint64),\n", - " 'name': '003 19:15:03.5532',\n", - " 'status': array([0], dtype=uint32),\n", - " 'groupindex': array([0], dtype=uint32),\n", - " 'color': array([0], dtype=uint32),\n", - " 'activerow': array([2], dtype=uint32),\n", - " 'triggernumber': array([0], dtype=uint64),\n", - " 'gridrows': array([3], dtype=uint32),\n", - " 'gridcols': array([1256], dtype=uint32),\n", - " 'gridmode': array([4], dtype=uint32),\n", - " 'gridoperation': array([1], dtype=uint32),\n", - " 'griddirection': array([0], dtype=uint32),\n", - " 'gridrepetitions': array([1], dtype=uint32),\n", - " 'gridcoldelta': array([0.00119467]),\n", - " 'gridcoloffset': array([-0.001]),\n", - " 'gridrowdelta': array([1.]),\n", - " 'gridrowoffset': array([0.]),\n", - " 'bandwidth': array([nan]),\n", - " 'center': array([0.]),\n", - " 'nenbw': array([nan])},\n", - " 'timestamp': array([[2050547625096, 2050547696776, 2050547768456, ..., 2050637440136,\n", - " 2050637511816, 2050637583496],\n", - " [2050728258696, 2050728330376, 2050728402056, ..., 2050818073736,\n", - " 2050818145416, 2050818217096],\n", - " [2050906025096, 2050906096776, 2050906168456, ..., 2050995840136,\n", - " 2050995911816, 2050995983496]], dtype=uint64),\n", - " 'value': array([[-3.19561798e-07, 1.67769002e-07, 5.44787502e-07, ...,\n", - " 4.46304136e-08, -5.92941542e-08, 2.84974289e-07],\n", - " [-3.30585912e-07, 9.90783104e-08, 4.78993204e-08, ...,\n", - " -7.80902188e-10, -3.75496757e-08, -1.17205286e-07],\n", - " [-4.02696190e-07, -1.92283112e-07, -2.46849998e-07, ...,\n", - " 2.75505401e-07, -2.89131128e-08, 7.18154963e-08]])}]}}},\n", - " 'device': ['dev3442'],\n", - " 'duration': array([1.50050133]),\n", - " 'edge': array([1], dtype=int64),\n", - " 'enable': array([1], dtype=int64),\n", - " 'endless': array([0], dtype=int64),\n", - " 'eventcount': {'mode': array([1], dtype=int64)},\n", - " 'fft': {'absolute': array([0], dtype=int64),\n", - " 'window': array([1], dtype=int64)},\n", - " 'findlevel': array([0], dtype=int64),\n", - " 'flags': array([8], dtype=int64),\n", - " 'forcetrigger': array([0], dtype=int64),\n", - " 'grid': {'cols': array([1256], dtype=int64),\n", - " 'direction': array([0], dtype=int64),\n", - " 'mode': array([4], dtype=int64),\n", - " 'overwrite': array([0], dtype=int64),\n", - " 'repetitions': array([1], dtype=int64),\n", - " 'rowrepetition': array([0], dtype=int64),\n", - " 'rows': array([3], dtype=int64),\n", - " 'waterfall': array([0], dtype=int64)},\n", - " 'historylength': array([100000], dtype=int64),\n", - " 'holdoff': {'count': array([0], dtype=int64), 'time': array([0.2])},\n", - " 'hysteresis': array([0.]),\n", - " 'level': array([0.5]),\n", - " 'preview': array([0], dtype=int64),\n", - " 'pulse': {'max': array([0.001]), 'min': array([0.])},\n", - " 'refreshrate': array([5.]),\n", - " 'save': {'csvlocale': ['C'],\n", - " 'csvseparator': [';'],\n", - " 'directory': ['C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer'],\n", - " 'fileformat': array([0], dtype=int64),\n", - " 'filename': ['dataAcquisitionModule'],\n", - " 'save': array([0], dtype=int64),\n", - " 'saveonread': array([0], dtype=int64)},\n", - " 'spectrum': {'autobandwidth': array([0], dtype=int64),\n", - " 'enable': array([0], dtype=int64),\n", - " 'frequencyspan': array([13000.]),\n", - " 'overlapped': array([1], dtype=int64)},\n", - " 'triggered': array([0], dtype=int64),\n", - " 'triggernode': ['/dev3442/demods/0/sample.TrigIn1'],\n", - " 'type': array([6], dtype=int64)}" - ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq_read_return" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "8ad94d37", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(544)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 542 \u001b[1;33m \u001b[0mcn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34mf\"/{self.serial}/{_cn}\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlower\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 543 \u001b[1;33m \u001b[1;31m# print(cn)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 544 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mcn\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m<=\u001b[0m \u001b[0mshot_index\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 545 \u001b[1;33m \u001b[1;31m# then we do not have data for this shot_index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 546 \u001b[1;33m \u001b[0mwarnings\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwarn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{shot_index}]\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(640)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 636 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mrecorded_data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 637 \u001b[1;33m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 638 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 639 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 640 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcurrently_set_program\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\appdata\\local\\temp\\ipykernel_27380\\3532927405.py\u001b[0m(1)\u001b[0;36m\u001b[1;34m()\u001b[0m\n", - "\n", - "ipdb> d\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(640)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 636 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mrecorded_data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 637 \u001b[1;33m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 638 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 639 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 640 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcurrently_set_program\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> recorded_data\n", - "{'/dev3442/demods/0/sample.x': [\n", - "array([[-3.19561798e-07, 1.67769002e-07, 5.44787502e-07, ...,\n", - " 4.46304136e-08, -5.92941542e-08, 2.84974289e-07],\n", - " [-3.30585912e-07, 9.90783104e-08, 4.78993204e-08, ...,\n", - " -7.80902188e-10, -3.75496757e-08, -1.17205286e-07],\n", - " [-4.02696190e-07, -1.92283112e-07, -2.46849998e-07, ...,\n", - " 2.75505401e-07, -2.89131128e-08, 7.18154963e-08]])\n", - "Coordinates:\n", - " time (row, col) float64 3.418e+13 3.418e+13 ... 3.418e+13 3.418e+13\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664558103553351]\n", - " createdtimestamp: [2050547636776]\n", - " changedtimestamp: [2050906036776]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 003 19:15:03.5532\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 101, - "id": "168c5a85", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1.])" - ] - }, - "execution_count": 101, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq.progress()" - ] - }, - { - "cell_type": "code", - "execution_count": 167, - "id": "c3a053dd", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_windows(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 88, - "id": "e8877df8", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.finish()" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "d3be623b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m(83)\u001b[0;36mgroup_indexers_by_index\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 81 \u001b[1;33m \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 82 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mkey\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcoords\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m---> 83 \u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"no index found for coordinate {key}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 84 \u001b[1;33m \u001b[1;32melif\u001b[0m \u001b[0mkey\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdims\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 85 \u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"{key} is not a valid dimension or coordinate\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m(110)\u001b[0;36mremap_label_indexers\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 108 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 109 \u001b[1;33m indexes, grouped_indexers = group_indexers_by_index(\n", - "\u001b[0m\u001b[1;32m--> 110 \u001b[1;33m \u001b[0mdata_obj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 111 \u001b[1;33m )\n", - "\u001b[0m\u001b[1;32m 112 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\coordinates.py\u001b[0m(422)\u001b[0;36mremap_label_indexers\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 420 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 421 \u001b[1;33m pos_indexers, new_indexes = indexing.remap_label_indexers(\n", - "\u001b[0m\u001b[1;32m--> 422 \u001b[1;33m \u001b[0mobj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv_indexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 423 \u001b[1;33m )\n", - "\u001b[0m\u001b[1;32m 424 \u001b[1;33m \u001b[1;31m# attach indexer's coordinate to pos_indexers\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataset.py\u001b[0m(2505)\u001b[0;36msel\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 2503 \u001b[1;33m \u001b[0mindexers\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0meither_dict_or_kwargs\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers_kwargs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"sel\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 2504 \u001b[1;33m pos_indexers, new_indexes = remap_label_indexers(\n", - "\u001b[0m\u001b[1;32m-> 2505 \u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 2506 \u001b[1;33m )\n", - "\u001b[0m\u001b[1;32m 2507 \u001b[1;33m \u001b[1;31m# TODO: benbovy - flexible indexes: also use variables returned by Index.query\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(1337)\u001b[0;36msel\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 1335 \u001b[1;33m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1336 \u001b[1;33m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m-> 1337 \u001b[1;33m \u001b[1;33m**\u001b[0m\u001b[0mindexers_kwargs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1338 \u001b[1;33m )\n", - "\u001b[0m\u001b[1;32m 1339 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_from_temp_dataset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(201)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 199 \u001b[1;33m \u001b[0mlabels\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mindexing\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexpanded_indexer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata_array\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndim\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 200 \u001b[1;33m \u001b[0mkey\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata_array\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 201 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata_array\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 202 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 203 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(488)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 486 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"time_of_trigger={time_of_trigger}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 487 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 488 \u001b[1;33m \u001b[0mextracted_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mapplicable_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m\"row\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mrow_index\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m\"timestamp\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mslice\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtime_of_trigger\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtime_of_trigger\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 489 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 490 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"extracted_data={extracted_data}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> applicable_data.where(~np.isnan(applicable_data), drop=True)\n", - "\n", - "array([[-1.54233563e-07, -1.53747443e-07, -1.63328742e-07, ...,\n", - " 1.12498946e-07, 5.47050085e-08, 5.14905138e-08]])\n", - "Coordinates:\n", - " timestamp (row, col) uint64 129659709576 129659745416 ... 130556892296\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664526103384841]\n", - " createdtimestamp: [129656925736]\n", - " changedtimestamp: [129656925736]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 000 10:21:43.3824\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "5c20f912", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "ename": "KeyError", - "evalue": "0", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_32508\\1360584380.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mKeyError\u001b[0m: 0" - ] - } - ], - "source": [ - "data[0][0].values" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cef17340", - "metadata": {}, - "outputs": [], - "source": [ - "data[0][0].timestamp.values" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "637ecff1", - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "id": "fbdc56bb", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray '/dev3442/demods/0/sample.r' (col: 1, row: 25112)>\n",
-       "array([[7.03522854e-07, 6.92340419e-07, 7.21439685e-07, ...,\n",
-       "        3.06968651e-07, 3.77702425e-07, 4.19837064e-07]])\n",
-       "Coordinates:\n",
-       "    timestamp  (col, row) uint64 2303061427353 2303061463193 ... 2303961405593\n",
-       "Dimensions without coordinates: col, row\n",
-       "Attributes:\n",
-       "    systemtime:        [1664476581306703]\n",
-       "    createdtimestamp:  [2303061439033]\n",
-       "    changedtimestamp:  [2303061439033]\n",
-       "    flags:             [1849]\n",
-       "    moduleflags:       [0]\n",
-       "    chunksizebytes:    [0]\n",
-       "    name:              009 20:36:21.3054\n",
-       "    status:            [0]\n",
-       "    groupindex:        [0]\n",
-       "    color:             [0]\n",
-       "    activerow:         [0]\n",
-       "    triggernumber:     [0]\n",
-       "    gridrows:          [1]\n",
-       "    gridcols:          [25112]\n",
-       "    gridmode:          [4]\n",
-       "    gridoperation:     [1]\n",
-       "    griddirection:     [0]\n",
-       "    gridrepetitions:   [1]\n",
-       "    gridcoldelta:      [0.00059733]\n",
-       "    gridcoloffset:     [-0.001]\n",
-       "    gridrowdelta:      [1.]\n",
-       "    gridrowoffset:     [0.]\n",
-       "    bandwidth:         [nan]\n",
-       "    center:            [0.]\n",
-       "    nenbw:             [nan]
" - ], - "text/plain": [ - "\n", - "array([[7.03522854e-07, 6.92340419e-07, 7.21439685e-07, ...,\n", - " 3.06968651e-07, 3.77702425e-07, 4.19837064e-07]])\n", - "Coordinates:\n", - " timestamp (col, row) uint64 2303061427353 2303061463193 ... 2303961405593\n", - "Dimensions without coordinates: col, row\n", - "Attributes:\n", - " systemtime: [1664476581306703]\n", - " createdtimestamp: [2303061439033]\n", - " changedtimestamp: [2303061439033]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 009 20:36:21.3054\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data['/dev3442/demods/0/sample.r'][0]" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "a94dfaf4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "13.000597371565114" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "21763/1.674e3" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "id": "8805f40b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "for name, d in data.items():\n", - " plt.plot(d[0].timestamp.values.reshape((-1)), d[0].values.reshape((-1)), label=d[0].name)\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "id": "52e6aa2b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(385)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 383 \u001b[1;33m \u001b[0mchannel_name\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34mf\"/{device_name}/{input_name}/{signal_name}/{final_level_name}\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 384 \u001b[1;33m\t\t\t\t\t\t\tchannel_data = xr.DataArray(\n", - "\u001b[0m\u001b[1;32m--> 385 \u001b[1;33m \u001b[0mdata\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mfinal_level_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"value\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 386 \u001b[1;33m \u001b[0mcords\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m'timestamp'\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mfinal_level_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'timestamp'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 387 \u001b[1;33m \u001b[0mdims\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'col'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'row'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> final_level_data\n", - "[{'header': {'systemtime': array([1664382261279112], dtype=uint64), 'createdtimestamp': array([1312194966056], dtype=uint64), 'changedtimestamp': array([1312194966056], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '007 18:24:21.2784', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1312194954376, 1312194990216, 1312195026056, ..., 1312974832776,\n", - " 1312974868616, 1312974904456]], dtype=uint64), 'value': array([[-0.00083702, -0.00081435, -0.00079167, ..., -0.00066342,\n", - " -0.00066342, -0.00066342]])}]\n", - "ipdb> final_level_data['values']\n", - "*** TypeError: list indices must be integers or slices, not str\n", - "ipdb> final_level_data['value']\n", - "*** TypeError: list indices must be integers or slices, not str\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "id": "27dad9d5", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'forcetrigger': array([0], dtype=int64), 'triggered': array([1], dtype=int64)}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664381184448982], dtype=uint64), 'createdtimestamp': array([1247600892456], dtype=uint64), 'changedtimestamp': array([1247600892456], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 18:06:24.4482', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1247600880776, 1247600916616, 1247600952456, ..., 1248380759176,\n", - " 1248380795016, 1248380830856]], dtype=uint64), 'value': array([[-2.43316761e-05, -5.26761886e-05, -8.10207011e-05, ...,\n", - " 4.80435375e-04, 5.08779887e-04, 5.37124400e-04]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664381184449458], dtype=uint64), 'createdtimestamp': array([1247600892456], dtype=uint64), 'changedtimestamp': array([1247600892456], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 18:06:24.4482', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1247600880776, 1247600916616, 1247600952456, ..., 1248380759176,\n", - " 1248380795016, 1248380830856]], dtype=uint64), 'value': array([[1.78793064e-07, 2.95350018e-07, 3.64539359e-07, ...,\n", - " 3.68635535e-07, 4.18934422e-07, 6.62816282e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664381184449892], dtype=uint64), 'createdtimestamp': array([1247600892456], dtype=uint64), 'changedtimestamp': array([1247600892456], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 18:06:24.4482', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1247600880776, 1247600916616, 1247600952456, ..., 1248380759176,\n", - " 1248380795016, 1248380830856]], dtype=uint64), 'value': array([[1.52127041e-07, 2.01588166e-07, 1.77798752e-07, ...,\n", - " 3.64727363e-07, 3.53522672e-07, 3.08946072e-07]])}]}}}, 'triggered': array([0], dtype=int64)}\n", - "Progress [1.]\n" - ] - } - ], - "source": [ - "while not my_lockin.daq.finished():\n", - " time.sleep(1)\n", - " result = my_lockin.daq.read()\n", - " print(result)\n", - " print(f\"Progress {my_lockin.daq.progress()}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "id": "811091f9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(376)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 374 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 375 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mdevice_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdevice_data\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 376 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0minput_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput_data\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdevice_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 377 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0msignal_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msignal_data\u001b[0m \u001b[1;32min\u001b[0m \u001b[0minput_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 378 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msignal_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> device_data\n", - "array([0], dtype=int64)\n", - "ipdb> data\n", - "{'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664381558471132], dtype=uint64), 'createdtimestamp': array([1270042036776], dtype=uint64), 'changedtimestamp': array([1270042036776], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '005 18:12:38.4705', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1270042025096, 1270042060936, 1270042096776, ..., 1270821903496,\n", - " 1270821939336, 1270821975176]], dtype=uint64), 'value': array([[-0.00225105, -0.00225672, -0.00226239, ..., -0.00142828,\n", - " -0.00145662, -0.00148496]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664381558471577], dtype=uint64), 'createdtimestamp': array([1270042036776], dtype=uint64), 'changedtimestamp': array([1270042036776], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '005 18:12:38.4705', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1270042025096, 1270042060936, 1270042096776, ..., 1270821903496,\n", - " 1270821939336, 1270821975176]], dtype=uint64), 'value': array([[7.96188229e-07, 1.00931080e-06, 9.46633590e-07, ...,\n", - " 4.39649550e-07, 4.78960669e-07, 5.21563402e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664381558471999], dtype=uint64), 'createdtimestamp': array([1270042036776], dtype=uint64), 'changedtimestamp': array([1270042036776], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '005 18:12:38.4705', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1270042025096, 1270042060936, 1270042096776, ..., 1270821903496,\n", - " 1270821939336, 1270821975176]], dtype=uint64), 'value': array([[-7.14710861e-08, -1.44757501e-07, -2.49910226e-07, ...,\n", - " 5.42141045e-08, 1.21691587e-08, -4.78550733e-08]])}]}}}, 'forcetrigger': array([0], dtype=int64), 'triggered': array([0], dtype=int64)}\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 192, - "id": "52865ab1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'awgcontrol': array([0], dtype=int64),\n", - " 'bandwidth': array([0.]),\n", - " 'bitmask': array([1], dtype=int64),\n", - " 'bits': array([1], dtype=int64),\n", - " 'buffercount': array([2], dtype=int64),\n", - " 'buffersize': array([0.2]),\n", - " 'clearhistory': array([0], dtype=int64),\n", - " 'count': array([1], dtype=int64),\n", - " 'delay': array([-0.001]),\n", - " 'device': [''],\n", - " 'duration': array([0.]),\n", - " 'edge': array([1], dtype=int64),\n", - " 'enable': array([1], dtype=int64),\n", - " 'endless': array([0], dtype=int64),\n", - " 'eventcount': {'mode': array([1], dtype=int64)},\n", - " 'fft': {'absolute': array([0], dtype=int64),\n", - " 'window': array([1], dtype=int64)},\n", - " 'findlevel': array([0], dtype=int64),\n", - " 'flags': array([8], dtype=int64),\n", - " 'forcetrigger': array([0], dtype=int64),\n", - " 'grid': {'cols': array([21763], dtype=int64),\n", - " 'direction': array([0], dtype=int64),\n", - " 'mode': array([4], dtype=int64),\n", - " 'overwrite': array([0], dtype=int64),\n", - " 'repetitions': array([1], dtype=int64),\n", - " 'rowrepetition': array([0], dtype=int64),\n", - " 'rows': array([1], dtype=int64),\n", - " 'waterfall': array([0], dtype=int64)},\n", - " 'historylength': array([100000], dtype=int64),\n", - " 'holdoff': {'count': array([0], dtype=int64), 'time': array([0.2])},\n", - " 'hysteresis': array([0.]),\n", - " 'level': array([0.]),\n", - " 'preview': array([0], dtype=int64),\n", - " 'pulse': {'max': array([0.001]), 'min': array([0.])},\n", - " 'refreshrate': array([5.]),\n", - " 'save': {'csvlocale': ['C'],\n", - " 'csvseparator': [';'],\n", - " 'directory': ['C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer'],\n", - " 'fileformat': array([0], dtype=int64),\n", - " 'filename': ['dataAcquisitionModule'],\n", - " 'save': array([0], dtype=int64),\n", - " 'saveonread': array([0], dtype=int64)},\n", - " 'spectrum': {'autobandwidth': array([0], dtype=int64),\n", - " 'enable': array([0], dtype=int64),\n", - " 'frequencyspan': array([13000.]),\n", - " 'overlapped': array([1], dtype=int64)},\n", - " 'triggered': array([1], dtype=int64),\n", - " 'triggernode': [''],\n", - " 'type': array([1], dtype=int64)}" - ] - }, - "execution_count": 192, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq_read_return" - ] - }, - { - "cell_type": "code", - "execution_count": 174, - "id": "543ff392", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(357)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 355 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 356 \u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 357 \u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq_read_return\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 358 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 359 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> data\n", - "{'forcetrigger': array([0], dtype=int64), 'triggered': array([1], dtype=int64)}\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 123, - "id": "ac680e56", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.clear()" - ] - }, - { - "cell_type": "code", - "execution_count": 145, - "id": "dd7e1cee", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{}" - ] - }, - "execution_count": 145, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq.read(flat=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 119, - "id": "0d1c6fa7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{}" - ] - }, - "execution_count": 119, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq.read()" - ] - }, - { - "cell_type": "code", - "execution_count": 110, - "id": "ec8c9d7a", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.force_trigger(None)" - ] - }, - { - "cell_type": "code", - "execution_count": 111, - "id": "20bace43", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['__class__',\n", - " '__delattr__',\n", - " '__dir__',\n", - " '__doc__',\n", - " '__eq__',\n", - " '__format__',\n", - " '__ge__',\n", - " '__getattribute__',\n", - " '__gt__',\n", - " '__hash__',\n", - " '__init__',\n", - " '__init_subclass__',\n", - " '__le__',\n", - " '__lt__',\n", - " '__module__',\n", - " '__ne__',\n", - " '__new__',\n", - " '__reduce__',\n", - " '__reduce_ex__',\n", - " '__repr__',\n", - " '__setattr__',\n", - " '__sizeof__',\n", - " '__str__',\n", - " '__subclasshook__',\n", - " 'clear',\n", - " 'execute',\n", - " 'finish',\n", - " 'finished',\n", - " 'get',\n", - " 'getDouble',\n", - " 'getInt',\n", - " 'getString',\n", - " 'getStringUnicode',\n", - " 'help',\n", - " 'listNodes',\n", - " 'listNodesJSON',\n", - " 'progress',\n", - " 'read',\n", - " 'save',\n", - " 'set',\n", - " 'subscribe',\n", - " 'trigger',\n", - " 'unsubscribe']" - ] - }, - "execution_count": 111, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dir(my_lockin.daq)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "c3800665", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.finish()" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "id": "d06129a4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1.])" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq.progress()" - ] - }, - { - "cell_type": "code", - "execution_count": 202, - "id": "24513c96", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.set('forcetrigger', 1)" - ] - }, - { - "cell_type": "code", - "execution_count": 114, - "id": "9e35f6c6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.])" - ] - }, - "execution_count": 114, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq.progress()" - ] - }, - { - "cell_type": "code", - "execution_count": 117, - "id": "1849020f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'triggered': array([0], dtype=int64)}" - ] - }, - "execution_count": 117, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq.read()" - ] - }, - { - "cell_type": "code", - "execution_count": 116, - "id": "83a442ce", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.finish()" - ] - }, - { - "cell_type": "code", - "execution_count": 193, - "id": "88477813", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.execute()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7f0085dc", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "19a6e2a0", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e43a3a28", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "2a2ed4e9", - "metadata": {}, - "outputs": [], - "source": [ - "import time" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "acf9f6a3", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.clear()\n", - "my_lockin.daq = my_lockin.api_session.dataAcquisitionModule()" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "cf0c1df9", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.api_session.setDebugLevel(0)" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "6fd7b881", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'forcetrigger': array([0], dtype=int64), 'triggered': array([1], dtype=int64)}\n", - "Progress [0.] %\n", - "{'dev3442': {'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664380454830777], dtype=uint64), 'createdtimestamp': array([1204630954536], dtype=uint64), 'changedtimestamp': array([1204630954536], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '100 17:54:14.8306', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([1000], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1204630942856, 1204630978696, 1204631014536, 1204631050376,\n", - " 1204631086216, 1204631122056, 1204631157896, 1204631193736,\n", - " 1204631229576, 1204631265416, 1204631301256, 1204631337096,\n", - " 1204631372936, 1204631408776, 1204631444616, 1204631480456,\n", - " 1204631516296, 1204631552136, 1204631587976, 1204631623816,\n", - " 1204631659656, 1204631695496, 1204631731336, 1204631767176,\n", - " 1204631803016, 1204631838856, 1204631874696, 1204631910536,\n", - " 1204631946376, 1204631982216, 1204632018056, 1204632053896,\n", - " 1204632089736, 1204632125576, 1204632161416, 1204632197256,\n", - " 1204632233096, 1204632268936, 1204632304776, 1204632340616,\n", - " 1204632376456, 1204632412296, 1204632448136, 1204632483976,\n", - " 1204632519816, 1204632555656, 1204632591496, 1204632627336,\n", - " 1204632663176, 1204632699016, 1204632734856, 1204632770696,\n", - " 1204632806536, 1204632842376, 1204632878216, 1204632914056,\n", - " 1204632949896, 1204632985736, 1204633021576, 1204633057416,\n", - " 1204633093256, 1204633129096, 1204633164936, 1204633200776,\n", - " 1204633236616, 1204633272456, 1204633308296, 1204633344136,\n", - " 1204633379976, 1204633415816, 1204633451656, 1204633487496,\n", - " 1204633523336, 1204633559176, 1204633595016, 1204633630856,\n", - " 1204633666696, 1204633702536, 1204633738376, 1204633774216,\n", - " 1204633810056, 1204633845896, 1204633881736, 1204633917576,\n", - " 1204633953416, 1204633989256, 1204634025096, 1204634060936,\n", - " 1204634096776, 1204634132616, 1204634168456, 1204634204296,\n", - " 1204634240136, 1204634275976, 1204634311816, 1204634347656,\n", - " 1204634383496, 1204634419336, 1204634455176, 1204634491016,\n", - " 1204634526856, 1204634562696, 1204634598536, 1204634634376,\n", - " 1204634670216, 1204634706056, 1204634741896, 1204634777736,\n", - " 1204634813576, 1204634849416, 1204634885256, 1204634921096,\n", - " 1204634956936, 1204634992776, 1204635028616, 1204635064456,\n", - " 1204635100296, 1204635136136, 1204635171976, 1204635207816,\n", - " 1204635243656, 1204635279496, 1204635315336, 1204635351176,\n", - " 1204635387016, 1204635422856, 1204635458696, 1204635494536,\n", - " 1204635530376, 1204635566216, 1204635602056, 1204635637896,\n", - " 1204635673736, 1204635709576, 1204635745416, 1204635781256,\n", - " 1204635817096, 1204635852936, 1204635888776, 1204635924616,\n", - " 1204635960456, 1204635996296, 1204636032136, 1204636067976,\n", - " 1204636103816, 1204636139656, 1204636175496, 1204636211336,\n", - " 1204636247176, 1204636283016, 1204636318856, 1204636354696,\n", - " 1204636390536, 1204636426376, 1204636462216, 1204636498056,\n", - " 1204636533896, 1204636569736, 1204636605576, 1204636641416,\n", - " 1204636677256, 1204636713096, 1204636748936, 1204636784776,\n", - " 1204636820616, 1204636856456, 1204636892296, 1204636928136,\n", - " 1204636963976, 1204636999816, 1204637035656, 1204637071496,\n", - " 1204637107336, 1204637143176, 1204637179016, 1204637214856,\n", - " 1204637250696, 1204637286536, 1204637322376, 1204637358216,\n", - " 1204637394056, 1204637429896, 1204637465736, 1204637501576,\n", - " 1204637537416, 1204637573256, 1204637609096, 1204637644936,\n", - " 1204637680776, 1204637716616, 1204637752456, 1204637788296,\n", - " 1204637824136, 1204637859976, 1204637895816, 1204637931656,\n", - " 1204637967496, 1204638003336, 1204638039176, 1204638075016,\n", - " 1204638110856, 1204638146696, 1204638182536, 1204638218376,\n", - " 1204638254216, 1204638290056, 1204638325896, 1204638361736,\n", - " 1204638397576, 1204638433416, 1204638469256, 1204638505096,\n", - " 1204638540936, 1204638576776, 1204638612616, 1204638648456,\n", - " 1204638684296, 1204638720136, 1204638755976, 1204638791816,\n", - " 1204638827656, 1204638863496, 1204638899336, 1204638935176,\n", - " 1204638971016, 1204639006856, 1204639042696, 1204639078536,\n", - " 1204639114376, 1204639150216, 1204639186056, 1204639221896,\n", - " 1204639257736, 1204639293576, 1204639329416, 1204639365256,\n", - " 1204639401096, 1204639436936, 1204639472776, 1204639508616,\n", - " 1204639544456, 1204639580296, 1204639616136, 1204639651976,\n", - " 1204639687816, 1204639723656, 1204639759496, 1204639795336,\n", - " 1204639831176, 1204639867016, 1204639902856, 1204639938696,\n", - " 1204639974536, 1204640010376, 1204640046216, 1204640082056,\n", - " 1204640117896, 1204640153736, 1204640189576, 1204640225416,\n", - " 1204640261256, 1204640297096, 1204640332936, 1204640368776,\n", - " 1204640404616, 1204640440456, 1204640476296, 1204640512136,\n", - " 1204640547976, 1204640583816, 1204640619656, 1204640655496,\n", - " 1204640691336, 1204640727176, 1204640763016, 1204640798856,\n", - " 1204640834696, 1204640870536, 1204640906376, 1204640942216,\n", - " 1204640978056, 1204641013896, 1204641049736, 1204641085576,\n", - " 1204641121416, 1204641157256, 1204641193096, 1204641228936,\n", - " 1204641264776, 1204641300616, 1204641336456, 1204641372296,\n", - " 1204641408136, 1204641443976, 1204641479816, 1204641515656,\n", - " 1204641551496, 1204641587336, 1204641623176, 1204641659016,\n", - " 1204641694856, 1204641730696, 1204641766536, 1204641802376,\n", - " 1204641838216, 1204641874056, 1204641909896, 1204641945736,\n", - " 1204641981576, 1204642017416, 1204642053256, 1204642089096,\n", - " 1204642124936, 1204642160776, 1204642196616, 1204642232456,\n", - " 1204642268296, 1204642304136, 1204642339976, 1204642375816,\n", - " 1204642411656, 1204642447496, 1204642483336, 1204642519176,\n", - " 1204642555016, 1204642590856, 1204642626696, 1204642662536,\n", - " 1204642698376, 1204642734216, 1204642770056, 1204642805896,\n", - " 1204642841736, 1204642877576, 1204642913416, 1204642949256,\n", - " 1204642985096, 1204643020936, 1204643056776, 1204643092616,\n", - " 1204643128456, 1204643164296, 1204643200136, 1204643235976,\n", - " 1204643271816, 1204643307656, 1204643343496, 1204643379336,\n", - " 1204643415176, 1204643451016, 1204643486856, 1204643522696,\n", - " 1204643558536, 1204643594376, 1204643630216, 1204643666056,\n", - " 1204643701896, 1204643737736, 1204643773576, 1204643809416,\n", - " 1204643845256, 1204643881096, 1204643916936, 1204643952776,\n", - " 1204643988616, 1204644024456, 1204644060296, 1204644096136,\n", - " 1204644131976, 1204644167816, 1204644203656, 1204644239496,\n", - " 1204644275336, 1204644311176, 1204644347016, 1204644382856,\n", - " 1204644418696, 1204644454536, 1204644490376, 1204644526216,\n", - " 1204644562056, 1204644597896, 1204644633736, 1204644669576,\n", - " 1204644705416, 1204644741256, 1204644777096, 1204644812936,\n", - " 1204644848776, 1204644884616, 1204644920456, 1204644956296,\n", - " 1204644992136, 1204645027976, 1204645063816, 1204645099656,\n", - " 1204645135496, 1204645171336, 1204645207176, 1204645243016,\n", - " 1204645278856, 1204645314696, 1204645350536, 1204645386376,\n", - " 1204645422216, 1204645458056, 1204645493896, 1204645529736,\n", - " 1204645565576, 1204645601416, 1204645637256, 1204645673096,\n", - " 1204645708936, 1204645744776, 1204645780616, 1204645816456,\n", - " 1204645852296, 1204645888136, 1204645923976, 1204645959816,\n", - " 1204645995656, 1204646031496, 1204646067336, 1204646103176,\n", - " 1204646139016, 1204646174856, 1204646210696, 1204646246536,\n", - " 1204646282376, 1204646318216, 1204646354056, 1204646389896,\n", - " 1204646425736, 1204646461576, 1204646497416, 1204646533256,\n", - " 1204646569096, 1204646604936, 1204646640776, 1204646676616,\n", - " 1204646712456, 1204646748296, 1204646784136, 1204646819976,\n", - " 1204646855816, 1204646891656, 1204646927496, 1204646963336,\n", - " 1204646999176, 1204647035016, 1204647070856, 1204647106696,\n", - " 1204647142536, 1204647178376, 1204647214216, 1204647250056,\n", - " 1204647285896, 1204647321736, 1204647357576, 1204647393416,\n", - " 1204647429256, 1204647465096, 1204647500936, 1204647536776,\n", - " 1204647572616, 1204647608456, 1204647644296, 1204647680136,\n", - " 1204647715976, 1204647751816, 1204647787656, 1204647823496,\n", - " 1204647859336, 1204647895176, 1204647931016, 1204647966856,\n", - " 1204648002696, 1204648038536, 1204648074376, 1204648110216,\n", - " 1204648146056, 1204648181896, 1204648217736, 1204648253576,\n", - " 1204648289416, 1204648325256, 1204648361096, 1204648396936,\n", - " 1204648432776, 1204648468616, 1204648504456, 1204648540296,\n", - " 1204648576136, 1204648611976, 1204648647816, 1204648683656,\n", - " 1204648719496, 1204648755336, 1204648791176, 1204648827016,\n", - " 1204648862856, 1204648898696, 1204648934536, 1204648970376,\n", - " 1204649006216, 1204649042056, 1204649077896, 1204649113736,\n", - " 1204649149576, 1204649185416, 1204649221256, 1204649257096,\n", - " 1204649292936, 1204649328776, 1204649364616, 1204649400456,\n", - " 1204649436296, 1204649472136, 1204649507976, 1204649543816,\n", - " 1204649579656, 1204649615496, 1204649651336, 1204649687176,\n", - " 1204649723016, 1204649758856, 1204649794696, 1204649830536,\n", - " 1204649866376, 1204649902216, 1204649938056, 1204649973896,\n", - " 1204650009736, 1204650045576, 1204650081416, 1204650117256,\n", - " 1204650153096, 1204650188936, 1204650224776, 1204650260616,\n", - " 1204650296456, 1204650332296, 1204650368136, 1204650403976,\n", - " 1204650439816, 1204650475656, 1204650511496, 1204650547336,\n", - " 1204650583176, 1204650619016, 1204650654856, 1204650690696,\n", - " 1204650726536, 1204650762376, 1204650798216, 1204650834056,\n", - " 1204650869896, 1204650905736, 1204650941576, 1204650977416,\n", - " 1204651013256, 1204651049096, 1204651084936, 1204651120776,\n", - " 1204651156616, 1204651192456, 1204651228296, 1204651264136,\n", - " 1204651299976, 1204651335816, 1204651371656, 1204651407496,\n", - " 1204651443336, 1204651479176, 1204651515016, 1204651550856,\n", - " 1204651586696, 1204651622536, 1204651658376, 1204651694216,\n", - " 1204651730056, 1204651765896, 1204651801736, 1204651837576,\n", - " 1204651873416, 1204651909256, 1204651945096, 1204651980936,\n", - " 1204652016776, 1204652052616, 1204652088456, 1204652124296,\n", - " 1204652160136, 1204652195976, 1204652231816, 1204652267656,\n", - " 1204652303496, 1204652339336, 1204652375176, 1204652411016,\n", - " 1204652446856, 1204652482696, 1204652518536, 1204652554376,\n", - " 1204652590216, 1204652626056, 1204652661896, 1204652697736,\n", - " 1204652733576, 1204652769416, 1204652805256, 1204652841096,\n", - " 1204652876936, 1204652912776, 1204652948616, 1204652984456,\n", - " 1204653020296, 1204653056136, 1204653091976, 1204653127816,\n", - " 1204653163656, 1204653199496, 1204653235336, 1204653271176,\n", - " 1204653307016, 1204653342856, 1204653378696, 1204653414536,\n", - " 1204653450376, 1204653486216, 1204653522056, 1204653557896,\n", - " 1204653593736, 1204653629576, 1204653665416, 1204653701256,\n", - " 1204653737096, 1204653772936, 1204653808776, 1204653844616,\n", - " 1204653880456, 1204653916296, 1204653952136, 1204653987976,\n", - " 1204654023816, 1204654059656, 1204654095496, 1204654131336,\n", - " 1204654167176, 1204654203016, 1204654238856, 1204654274696,\n", - " 1204654310536, 1204654346376, 1204654382216, 1204654418056,\n", - " 1204654453896, 1204654489736, 1204654525576, 1204654561416,\n", - " 1204654597256, 1204654633096, 1204654668936, 1204654704776,\n", - " 1204654740616, 1204654776456, 1204654812296, 1204654848136,\n", - " 1204654883976, 1204654919816, 1204654955656, 1204654991496,\n", - " 1204655027336, 1204655063176, 1204655099016, 1204655134856,\n", - " 1204655170696, 1204655206536, 1204655242376, 1204655278216,\n", - " 1204655314056, 1204655349896, 1204655385736, 1204655421576,\n", - " 1204655457416, 1204655493256, 1204655529096, 1204655564936,\n", - " 1204655600776, 1204655636616, 1204655672456, 1204655708296,\n", - " 1204655744136, 1204655779976, 1204655815816, 1204655851656,\n", - " 1204655887496, 1204655923336, 1204655959176, 1204655995016,\n", - " 1204656030856, 1204656066696, 1204656102536, 1204656138376,\n", - " 1204656174216, 1204656210056, 1204656245896, 1204656281736,\n", - " 1204656317576, 1204656353416, 1204656389256, 1204656425096,\n", - " 1204656460936, 1204656496776, 1204656532616, 1204656568456,\n", - " 1204656604296, 1204656640136, 1204656675976, 1204656711816,\n", - " 1204656747656, 1204656783496, 1204656819336, 1204656855176,\n", - " 1204656891016, 1204656926856, 1204656962696, 1204656998536,\n", - " 1204657034376, 1204657070216, 1204657106056, 1204657141896,\n", - " 1204657177736, 1204657213576, 1204657249416, 1204657285256,\n", - " 1204657321096, 1204657356936, 1204657392776, 1204657428616,\n", - " 1204657464456, 1204657500296, 1204657536136, 1204657571976,\n", - " 1204657607816, 1204657643656, 1204657679496, 1204657715336,\n", - " 1204657751176, 1204657787016, 1204657822856, 1204657858696,\n", - " 1204657894536, 1204657930376, 1204657966216, 1204658002056,\n", - " 1204658037896, 1204658073736, 1204658109576, 1204658145416,\n", - " 1204658181256, 1204658217096, 1204658252936, 1204658288776,\n", - " 1204658324616, 1204658360456, 1204658396296, 1204658432136,\n", - " 1204658467976, 1204658503816, 1204658539656, 1204658575496,\n", - " 1204658611336, 1204658647176, 1204658683016, 1204658718856,\n", - " 1204658754696, 1204658790536, 1204658826376, 1204658862216,\n", - " 1204658898056, 1204658933896, 1204658969736, 1204659005576,\n", - " 1204659041416, 1204659077256, 1204659113096, 1204659148936,\n", - " 1204659184776, 1204659220616, 1204659256456, 1204659292296,\n", - " 1204659328136, 1204659363976, 1204659399816, 1204659435656,\n", - " 1204659471496, 1204659507336, 1204659543176, 1204659579016,\n", - " 1204659614856, 1204659650696, 1204659686536, 1204659722376,\n", - " 1204659758216, 1204659794056, 1204659829896, 1204659865736,\n", - " 1204659901576, 1204659937416, 1204659973256, 1204660009096,\n", - " 1204660044936, 1204660080776, 1204660116616, 1204660152456,\n", - " 1204660188296, 1204660224136, 1204660259976, 1204660295816,\n", - " 1204660331656, 1204660367496, 1204660403336, 1204660439176,\n", - " 1204660475016, 1204660510856, 1204660546696, 1204660582536,\n", - " 1204660618376, 1204660654216, 1204660690056, 1204660725896,\n", - " 1204660761736, 1204660797576, 1204660833416, 1204660869256,\n", - " 1204660905096, 1204660940936, 1204660976776, 1204661012616,\n", - " 1204661048456, 1204661084296, 1204661120136, 1204661155976,\n", - " 1204661191816, 1204661227656, 1204661263496, 1204661299336,\n", - " 1204661335176, 1204661371016, 1204661406856, 1204661442696,\n", - " 1204661478536, 1204661514376, 1204661550216, 1204661586056,\n", - " 1204661621896, 1204661657736, 1204661693576, 1204661729416,\n", - " 1204661765256, 1204661801096, 1204661836936, 1204661872776,\n", - " 1204661908616, 1204661944456, 1204661980296, 1204662016136,\n", - " 1204662051976, 1204662087816, 1204662123656, 1204662159496,\n", - " 1204662195336, 1204662231176, 1204662267016, 1204662302856,\n", - " 1204662338696, 1204662374536, 1204662410376, 1204662446216,\n", - " 1204662482056, 1204662517896, 1204662553736, 1204662589576,\n", - " 1204662625416, 1204662661256, 1204662697096, 1204662732936,\n", - " 1204662768776, 1204662804616, 1204662840456, 1204662876296,\n", - " 1204662912136, 1204662947976, 1204662983816, 1204663019656,\n", - " 1204663055496, 1204663091336, 1204663127176, 1204663163016,\n", - " 1204663198856, 1204663234696, 1204663270536, 1204663306376,\n", - " 1204663342216, 1204663378056, 1204663413896, 1204663449736,\n", - " 1204663485576, 1204663521416, 1204663557256, 1204663593096,\n", - " 1204663628936, 1204663664776, 1204663700616, 1204663736456,\n", - " 1204663772296, 1204663808136, 1204663843976, 1204663879816,\n", - " 1204663915656, 1204663951496, 1204663987336, 1204664023176,\n", - " 1204664059016, 1204664094856, 1204664130696, 1204664166536,\n", - " 1204664202376, 1204664238216, 1204664274056, 1204664309896,\n", - " 1204664345736, 1204664381576, 1204664417416, 1204664453256,\n", - " 1204664489096, 1204664524936, 1204664560776, 1204664596616,\n", - " 1204664632456, 1204664668296, 1204664704136, 1204664739976,\n", - " 1204664775816, 1204664811656, 1204664847496, 1204664883336,\n", - " 1204664919176, 1204664955016, 1204664990856, 1204665026696,\n", - " 1204665062536, 1204665098376, 1204665134216, 1204665170056,\n", - " 1204665205896, 1204665241736, 1204665277576, 1204665313416,\n", - " 1204665349256, 1204665385096, 1204665420936, 1204665456776,\n", - " 1204665492616, 1204665528456, 1204665564296, 1204665600136,\n", - " 1204665635976, 1204665671816, 1204665707656, 1204665743496,\n", - " 1204665779336, 1204665815176, 1204665851016, 1204665886856,\n", - " 1204665922696, 1204665958536, 1204665994376, 1204666030216,\n", - " 1204666066056, 1204666101896, 1204666137736, 1204666173576,\n", - " 1204666209416, 1204666245256, 1204666281096, 1204666316936,\n", - " 1204666352776, 1204666388616, 1204666424456, 1204666460296,\n", - " 1204666496136, 1204666531976, 1204666567816, 1204666603656,\n", - " 1204666639496, 1204666675336, 1204666711176, 1204666747016]],\n", - " dtype=uint64), 'value': array([[1.10172382e-06, 9.00993372e-07, 6.85672291e-07, 5.05722310e-07,\n", - " 2.63556648e-07, 2.84944932e-07, 3.43998598e-07, 3.56673579e-07,\n", - " 4.30376278e-07, 3.80952694e-07, 4.10249181e-07, 4.03857472e-07,\n", - " 3.59043179e-07, 3.51889392e-07, 5.21878583e-07, 6.58856069e-07,\n", - " 6.23421580e-07, 5.82284234e-07, 5.37666393e-07, 2.95894822e-07,\n", - " 1.12301962e-08, 3.05695226e-07, 6.04882662e-07, 9.20686311e-07,\n", - " 1.13660529e-06, 1.19092367e-06, 9.76087500e-07, 6.15055004e-07,\n", - " 3.13769275e-07, 1.81930674e-07, 2.39599186e-07, 2.50579467e-07,\n", - " 2.97543602e-07, 3.24700912e-07, 2.81532788e-07, 3.05032989e-07,\n", - " 5.97171120e-07, 7.96912833e-07, 7.64501338e-07, 6.77978549e-07,\n", - " 6.23856189e-07, 5.55979018e-07, 3.88805118e-07, 2.57782050e-07,\n", - " 1.68561224e-07, 1.32007622e-07, 7.78802425e-08, 1.63811875e-07,\n", - " 3.47639782e-07, 2.50012698e-07, 8.94291151e-08, 8.03697325e-08,\n", - " 1.30349154e-07, 2.19107313e-07, 4.69253203e-07, 6.39894882e-07,\n", - " 6.57779206e-07, 5.09883973e-07, 4.76852062e-07, 5.10156623e-07,\n", - " 6.23915346e-07, 5.94415979e-07, 4.12425406e-07, 2.67075364e-07,\n", - " 9.69192031e-08, 4.97695649e-08, 6.58232731e-08, 1.23616393e-07,\n", - " 2.54326451e-07, 2.70416881e-07, 1.38021070e-07, 8.80823575e-08,\n", - " 5.45155700e-08, 2.21586304e-07, 3.09675449e-07, 2.78693839e-07,\n", - " 2.33244356e-07, 2.13303117e-07, 3.95575820e-07, 5.10217416e-07,\n", - " 5.55577809e-07, 5.54332627e-07, 4.60837489e-07, 3.45195816e-07,\n", - " 4.08619026e-07, 3.29004646e-07, 1.99000774e-07, 6.32831896e-08,\n", - " 1.10443827e-07, 1.25044715e-07, 5.80890342e-08, 6.50742469e-08,\n", - " 3.18526981e-07, 5.52935197e-07, 6.18173192e-07, 6.35119098e-07,\n", - " 6.52850575e-07, 7.50804686e-07, 8.00443590e-07, 7.44553393e-07,\n", - " 5.48159761e-07, 3.03408876e-07, 3.71190485e-07, 4.09963545e-07,\n", - " 2.14933673e-07, 1.25808499e-07, 2.63823650e-07, 3.78668448e-07,\n", - " 4.21149267e-07, 4.30933377e-07, 3.88958810e-07, 3.39340699e-07,\n", - " 2.99199090e-07, 2.38414859e-07, 9.79969920e-08, 1.71532624e-07,\n", - " 4.15741660e-07, 6.09098279e-07, 7.58500603e-07, 8.81326664e-07,\n", - " 9.27644427e-07, 8.78532515e-07, 7.24006467e-07, 5.27521366e-07,\n", - " 3.13078440e-07, 1.78492138e-07, 1.02943885e-07, 9.00787678e-08,\n", - " 2.23117015e-07, 3.52778792e-07, 3.64945691e-07, 2.71476053e-07,\n", - " 1.50592943e-07, 9.85347571e-08, 1.37514951e-07, 2.62132523e-07,\n", - " 5.61961763e-07, 7.62610677e-07, 7.61311804e-07, 7.51694936e-07,\n", - " 6.75334372e-07, 6.38306937e-07, 6.09471814e-07, 5.06948147e-07,\n", - " 3.77760478e-07, 4.62184582e-07, 5.50134840e-07, 5.93225916e-07,\n", - " 5.70856045e-07, 4.45811062e-07, 2.64324269e-07, 1.74873117e-07,\n", - " 1.41081115e-07, 1.34482520e-07, 9.52025471e-08, 5.85520569e-08,\n", - " 1.73440558e-07, 2.22078318e-07, 2.33007683e-07, 3.03478090e-07,\n", - " 4.05284261e-07, 6.13934440e-07, 7.63735737e-07, 6.12481949e-07,\n", - " 3.23829195e-07, 1.47620966e-07, 1.72441448e-07, 3.74744625e-07,\n", - " 2.70861242e-07, 3.20812078e-08, 1.87066335e-07, 3.01109457e-07,\n", - " 4.91104778e-07, 4.33183644e-07, 2.82325730e-07, 2.97699066e-07,\n", - " 5.17974675e-07, 5.91289304e-07, 3.46911982e-07, 1.78438744e-07,\n", - " 1.02194575e-07, 1.57912315e-07, 2.22870560e-07, 3.24817655e-07,\n", - " 3.50475580e-07, 4.29146299e-07, 3.44077590e-07, 1.72237873e-07,\n", - " 9.22907941e-09, 2.21248674e-07, 3.25739808e-07, 2.14661637e-07,\n", - " 1.64524065e-07, 2.52054707e-07, 4.70487339e-07, 4.74727628e-07,\n", - " 3.43503301e-07, 5.03108132e-07, 5.68300504e-07, 4.01165899e-07,\n", - " 2.44321059e-07, 3.00103881e-07, 3.72187270e-07, 3.47736345e-07,\n", - " 3.10355839e-07, 2.75364159e-07, 4.09862560e-07, 5.73371383e-07,\n", - " 6.27081190e-07, 5.77312744e-07, 6.05007397e-07, 7.27155688e-07,\n", - " 5.92057189e-07, 1.91106106e-07, 2.56967975e-07, 2.92111836e-07,\n", - " 3.90146251e-07, 4.82477848e-07, 5.32305439e-07, 3.44347786e-07,\n", - " 1.72010907e-07, 1.73923000e-07, 2.50814343e-07, 3.89090037e-07,\n", - " 4.75643228e-07, 3.88711305e-07, 1.97222847e-07, 2.46780284e-07,\n", - " 2.64668826e-07, 2.89501174e-07, 4.01518224e-07, 6.74135688e-07,\n", - " 6.18645069e-07, 4.37556495e-07, 2.20923047e-07, 1.14419556e-07,\n", - " 1.26856734e-07, 1.00089621e-07, 1.19525727e-07, 2.57526231e-07,\n", - " 2.26675326e-07, 3.10498070e-07, 3.31654109e-07, 2.14005446e-07,\n", - " 1.86077339e-07, 2.48257635e-07, 3.22971276e-07, 2.40623303e-07,\n", - " 1.11573253e-07, 1.79141024e-07, 2.04903808e-07, 1.84530491e-07,\n", - " 2.06834505e-07, 3.85550780e-07, 4.17616354e-07, 4.10810334e-07,\n", - " 4.15976585e-07, 5.94376739e-07, 7.45402668e-07, 7.06737766e-07,\n", - " 5.06713546e-07, 4.63435309e-07, 5.54252429e-07, 6.89894794e-07,\n", - " 7.03826561e-07, 6.46166485e-07, 6.09534471e-07, 6.27221407e-07,\n", - " 6.25122666e-07, 6.02095574e-07, 5.38525279e-07, 4.77109918e-07,\n", - " 4.68633768e-07, 5.49740086e-07, 6.68247982e-07, 6.83298293e-07,\n", - " 5.75904493e-07, 4.71106274e-07, 2.62474890e-07, 2.08783763e-07,\n", - " 8.82209886e-08, 1.15886977e-08, 5.56766077e-08, 2.55647020e-07,\n", - " 4.29921534e-07, 3.63903429e-07, 2.24994979e-07, 6.40724979e-08,\n", - " 2.18174975e-07, 3.90993800e-07, 3.26305621e-07, 7.97413743e-08,\n", - " 2.02468614e-07, 2.89155193e-07, 3.85857853e-07, 5.37231927e-07,\n", - " 7.73238741e-07, 7.68905833e-07, 6.50909665e-07, 6.70089472e-07,\n", - " 6.39205529e-07, 4.08252469e-07, 2.21792694e-07, 1.14801932e-07,\n", - " 1.13725462e-07, 4.44966872e-07, 8.28901844e-07, 1.01473163e-06,\n", - " 9.24568619e-07, 6.14258722e-07, 3.35031847e-07, 1.85673215e-07,\n", - " 1.52792186e-07, 3.15459204e-07, 3.88451031e-07, 4.23969453e-07,\n", - " 4.50853976e-07, 4.95974133e-07, 4.31684977e-07, 1.04238612e-07,\n", - " 2.50071162e-07, 3.77273337e-07, 4.51408268e-07, 5.05259783e-07,\n", - " 5.63401662e-07, 6.04346571e-07, 5.15800601e-07, 4.71134910e-07,\n", - " 6.03224967e-07, 5.31633718e-07, 3.53417994e-07, 1.39320333e-07,\n", - " 1.22904463e-07, 1.90635450e-07, 3.05044716e-07, 3.71255569e-07,\n", - " 4.28827198e-07, 4.35061635e-07, 3.83926620e-07, 2.93598126e-07,\n", - " 3.03978936e-07, 3.76574453e-07, 4.38974518e-07, 3.67454943e-07,\n", - " 1.85178407e-07, 1.62951258e-07, 2.02209877e-07, 1.03071540e-07,\n", - " 8.78383533e-08, 2.79744145e-07, 3.49905868e-07, 3.96674925e-07,\n", - " 5.90938110e-07, 7.02573590e-07, 6.73909212e-07, 5.14048070e-07,\n", - " 3.30404926e-07, 1.62184815e-07, 2.37903294e-07, 4.85346027e-07,\n", - " 4.03753378e-07, 3.27056394e-07, 2.55584118e-07, 3.05960649e-07,\n", - " 3.83446085e-07, 5.74046413e-07, 6.27709939e-07, 4.78470426e-07,\n", - " 4.65230034e-07, 3.58294942e-07, 1.73612183e-07, 1.92023326e-07,\n", - " 2.54248171e-07, 3.19083436e-07, 1.38770681e-07, 5.41525005e-08,\n", - " 2.77540914e-07, 3.61662365e-07, 3.70860352e-07, 4.06588683e-07,\n", - " 3.85190720e-07, 3.84275516e-07, 3.16298031e-07, 2.21499569e-07,\n", - " 1.53273756e-07, 8.76957469e-08, 1.98060853e-07, 3.91326256e-07,\n", - " 4.25993278e-07, 3.35671756e-07, 5.19576302e-08, 1.70884313e-07,\n", - " 2.15189768e-07, 2.79358661e-07, 3.15516474e-07, 3.76591686e-07,\n", - " 3.18433151e-07, 2.40545801e-07, 2.08688055e-07, 2.82018612e-07,\n", - " 4.53363506e-07, 5.80581909e-07, 5.93196116e-07, 5.40983376e-07,\n", - " 5.58967494e-07, 5.55660148e-07, 6.35585684e-07, 6.20240423e-07,\n", - " 6.81962130e-07, 6.74469772e-07, 6.12472606e-07, 5.11543210e-07,\n", - " 5.75453913e-07, 6.05407513e-07, 5.33758830e-07, 4.72757988e-07,\n", - " 3.75739332e-07, 1.62924315e-07, 2.01131427e-07, 9.05138952e-08,\n", - " 7.45520615e-09, 2.17270471e-07, 2.89617935e-07, 1.30100758e-07,\n", - " 1.30095319e-07, 1.64433901e-07, 1.10164649e-07, 2.98595620e-07,\n", - " 3.83649826e-07, 2.78758448e-07, 2.28737139e-07, 1.84545341e-07,\n", - " 1.44420273e-07, 4.57294424e-07, 6.68904526e-07, 7.24629512e-07,\n", - " 6.92990602e-07, 5.50788691e-07, 3.61729826e-07, 1.54338849e-07,\n", - " 9.36556041e-08, 3.84913625e-07, 6.74676961e-07, 7.49737854e-07,\n", - " 7.91698334e-07, 6.41507399e-07, 6.01816832e-07, 7.41940247e-07,\n", - " 8.15793327e-07, 7.48879176e-07, 5.83365556e-07, 4.20656161e-07,\n", - " 3.18818747e-07, 2.04860203e-07, 2.77391239e-07, 3.67076249e-07,\n", - " 4.10224823e-07, 3.07760784e-07, 3.95908324e-07, 5.47137366e-07,\n", - " 6.51749747e-07, 7.29113815e-07, 7.38477703e-07, 7.71924829e-07,\n", - " 8.09991899e-07, 7.31862177e-07, 4.80444342e-07, 3.75488325e-07,\n", - " 2.30663163e-07, 1.25087616e-07, 1.81723196e-07, 1.51660581e-07,\n", - " 1.45726213e-07, 2.56302335e-07, 3.22508638e-07, 2.97016756e-07,\n", - " 2.46639946e-07, 1.80873620e-07, 1.10603196e-07, 4.11544779e-07,\n", - " 7.00062907e-07, 6.97734300e-07, 5.37358877e-07, 4.43892359e-07,\n", - " 4.13851719e-07, 4.61548999e-07, 4.83614804e-07, 5.09572495e-07,\n", - " 4.97111450e-07, 3.07411792e-07, 1.60220721e-07, 2.50309182e-07,\n", - " 3.48249997e-07, 2.60791915e-07, 1.46551304e-08, 2.78461321e-07,\n", - " 3.72349704e-07, 4.30719884e-07, 4.45666767e-07, 3.27599352e-07,\n", - " 1.23808373e-07, 6.23509798e-08, 1.75828335e-07, 3.04169271e-07,\n", - " 2.93007656e-07, 2.23771779e-07, 2.38133733e-07, 2.32698141e-07,\n", - " 3.81322503e-07, 4.33507591e-07, 4.77924413e-07, 4.98704734e-07,\n", - " 5.11102151e-07, 5.30412445e-07, 5.88101932e-07, 5.25820025e-07,\n", - " 3.64397164e-07, 1.28373792e-07, 1.67656421e-07, 3.26175983e-07,\n", - " 3.98572683e-07, 3.18682353e-07, 1.23289791e-07, 2.31347164e-07,\n", - " 4.30995051e-07, 4.94945496e-07, 5.00033328e-07, 2.90503592e-07,\n", - " 2.36491774e-07, 3.29661022e-07, 4.14656961e-07, 4.73994058e-07,\n", - " 3.92556499e-07, 3.58857059e-07, 3.39263702e-07, 1.55860375e-07,\n", - " 1.45640380e-07, 2.38803777e-07, 3.50502161e-07, 3.89760610e-07,\n", - " 2.96614664e-07, 3.38885974e-07, 4.63940538e-07, 4.33276263e-07,\n", - " 2.50469351e-07, 2.37320277e-07, 3.68405627e-07, 6.17641452e-07,\n", - " 8.84763346e-07, 9.17253173e-07, 7.06064935e-07, 4.99665046e-07,\n", - " 2.86683710e-07, 2.30685990e-07, 1.97848786e-07, 1.78313368e-07,\n", - " 2.21611128e-07, 3.62535608e-07, 5.24055643e-07, 5.77170078e-07,\n", - " 4.67761382e-07, 5.22425933e-07, 4.52543367e-07, 3.79985241e-07,\n", - " 2.77172847e-07, 1.49777161e-07, 1.15214658e-07, 3.59981435e-07,\n", - " 6.03369756e-07, 6.67961744e-07, 5.94612510e-07, 4.16769794e-07,\n", - " 2.58266120e-07, 3.39543432e-07, 4.73534940e-07, 4.96254211e-07,\n", - " 3.71374416e-07, 2.92820765e-07, 4.17394871e-07, 6.16769871e-07,\n", - " 6.53420767e-07, 6.01329267e-07, 5.84599318e-07, 5.32087815e-07,\n", - " 5.11893352e-07, 3.93062658e-07, 1.51709865e-07, 2.12522162e-08,\n", - " 8.89926409e-08, 2.71148514e-07, 5.10614147e-07, 5.86233899e-07,\n", - " 4.56926837e-07, 3.34114450e-07, 3.66266238e-07, 4.64055009e-07,\n", - " 4.71204388e-07, 4.68161087e-07, 4.35620452e-07, 4.07623605e-07,\n", - " 4.27871698e-07, 5.59862233e-07, 6.05468102e-07, 6.36568208e-07,\n", - " 6.54980918e-07, 6.15334462e-07, 3.32778868e-07, 2.44608204e-08,\n", - " 1.28116423e-07, 1.21720857e-07, 1.06496458e-07, 2.26547081e-07,\n", - " 3.03950013e-07, 2.72227746e-07, 2.15457545e-07, 2.44805478e-07,\n", - " 4.37398264e-07, 6.24068867e-07, 6.10211264e-07, 5.84822469e-07,\n", - " 5.59034655e-07, 5.62235625e-07, 5.81709446e-07, 5.34074456e-07,\n", - " 4.31861549e-07, 1.99938765e-07, 1.48787174e-07, 1.20190864e-07,\n", - " 2.57822474e-07, 4.45790132e-07, 4.20567341e-07, 3.44484166e-07,\n", - " 2.73959165e-07, 1.71478123e-07, 7.83323773e-08, 9.37151918e-08,\n", - " 2.49811716e-07, 3.09317789e-07, 3.02401749e-07, 2.48652746e-07,\n", - " 2.39160349e-07, 4.73779328e-07, 5.82964207e-07, 5.28841215e-07,\n", - " 5.67864881e-07, 6.37154438e-07, 6.33173841e-07, 4.17288629e-07,\n", - " 5.18028416e-07, 6.47880325e-07, 7.42836657e-07, 7.70841690e-07,\n", - " 6.62514309e-07, 5.13944815e-07, 3.45391554e-07, 1.26703549e-07,\n", - " 4.91374190e-08, 5.58747034e-08, 1.81795476e-07, 5.04145382e-07,\n", - " 6.36718257e-07, 6.19121328e-07, 5.05161528e-07, 4.23852618e-07,\n", - " 4.07100383e-07, 5.52901048e-07, 5.73362020e-07, 4.64448810e-07,\n", - " 4.09242005e-07, 4.58095006e-07, 4.36634270e-07, 3.77672928e-07,\n", - " 3.26387651e-07, 3.19701485e-07, 3.36957607e-07, 2.76393757e-07,\n", - " 2.33877207e-07, 5.99739826e-08, 3.87451598e-07, 5.06846618e-07,\n", - " 2.73912143e-07, 1.69720831e-07, 4.97385909e-07, 4.49638096e-07,\n", - " 2.75734554e-07, 2.83083828e-07, 3.61067130e-07, 2.82104562e-07,\n", - " 7.75347440e-08, 5.64334566e-08, 1.85022021e-07, 3.03871562e-07,\n", - " 3.10899044e-07, 2.72303530e-07, 2.21233625e-07, 2.48180434e-07,\n", - " 2.78723931e-07, 3.22697810e-07, 5.54059670e-07, 6.19390567e-07,\n", - " 5.51157971e-07, 3.76065087e-07, 4.20955015e-08, 1.22463307e-07,\n", - " 7.62915335e-08, 1.76891360e-07, 2.81819575e-07, 3.15055046e-07,\n", - " 3.26917003e-07, 2.59225916e-07, 1.12111201e-07, 3.54231417e-08,\n", - " 1.30066101e-07, 3.77238140e-07, 6.62036199e-07, 7.23178983e-07,\n", - " 6.28532827e-07, 4.20225381e-07, 1.97549962e-07, 3.35634207e-07,\n", - " 3.66089416e-07, 2.72458372e-07, 1.52055798e-07, 2.29626293e-07,\n", - " 2.16658080e-07, 1.38513811e-07, 2.10525809e-07, 2.35135964e-07,\n", - " 3.75240077e-07, 4.43467112e-07, 1.79198796e-07, 2.34808419e-07,\n", - " 5.07529421e-07, 6.96410096e-07, 6.45342656e-07, 4.42581123e-07,\n", - " 3.07838187e-07, 3.22290837e-07, 2.47777651e-07, 3.71568152e-07,\n", - " 4.23185003e-07, 3.48936635e-07, 2.53383478e-07, 3.81561622e-07,\n", - " 5.49555713e-07, 7.35642765e-07, 8.92304125e-07, 9.49032819e-07,\n", - " 8.15547663e-07, 6.47913144e-07, 5.53582472e-07, 5.82332542e-07,\n", - " 5.28295282e-07, 4.83346357e-07, 5.09975635e-07, 3.61859401e-07,\n", - " 1.87085701e-07, 1.00685767e-07, 6.48184726e-08, 2.51909657e-07,\n", - " 3.41402645e-07, 3.61064978e-07, 3.29101330e-07, 3.09282468e-07,\n", - " 3.56624640e-07, 3.56407153e-07, 4.19803216e-07, 5.20763489e-07,\n", - " 5.84085817e-07, 5.51045302e-07, 6.62566213e-07, 6.34141819e-07,\n", - " 4.17268796e-07, 3.84569151e-07, 4.20606084e-07, 3.47259006e-07,\n", - " 3.13524207e-07, 3.00912440e-07, 2.97730333e-07, 1.80344993e-07,\n", - " 5.71022710e-08, 1.61224854e-07, 1.54991875e-07, 2.70976776e-07,\n", - " 4.12883459e-07, 3.49212288e-07, 1.78077072e-07, 8.46431259e-08,\n", - " 2.16470941e-07, 4.71058132e-07, 5.17018370e-07, 4.12778655e-07,\n", - " 3.59922374e-07, 2.88825818e-07, 1.60507626e-07, 2.56569859e-07,\n", - " 3.94164341e-07, 4.51043831e-07, 4.16377396e-07, 3.41116493e-07,\n", - " 1.87434013e-07, 2.73445796e-07, 3.69698843e-07, 3.89326346e-07,\n", - " 2.05621253e-07, 6.39084693e-08, 2.03270487e-08, 2.19618890e-07,\n", - " 4.09822299e-07, 4.53437598e-07, 6.04374490e-07, 6.71124535e-07,\n", - " 5.35008768e-07, 3.31273048e-07, 1.86286264e-07, 7.87992030e-08,\n", - " 7.33899804e-08, 5.46788003e-08, 7.82461988e-08, 2.89594445e-07,\n", - " 4.71009109e-07, 6.25776587e-07, 7.29467199e-07, 7.03004149e-07,\n", - " 7.15162244e-07, 6.40278175e-07, 4.81499008e-07, 3.26249199e-07,\n", - " 2.51090617e-07, 3.26096355e-07, 4.67166693e-07, 4.49483618e-07,\n", - " 4.44373646e-07, 5.33181373e-07, 5.04411615e-07, 2.90559870e-07,\n", - " 1.76062043e-08, 6.63463654e-08, 6.20297987e-08, 1.36291039e-07,\n", - " 1.64785161e-07, 1.32513331e-07, 1.91439409e-07, 2.02623515e-07,\n", - " 2.60582721e-07, 3.29594684e-07, 3.19847083e-07, 4.86802232e-07,\n", - " 5.06645747e-07, 4.63002082e-07, 4.45252041e-07, 3.29432378e-07,\n", - " 1.33060167e-07, 1.12901016e-07, 5.26525262e-08, 2.23240071e-07,\n", - " 2.15720374e-07, 1.78089833e-07, 9.07086483e-08, 1.85874627e-07,\n", - " 3.43056815e-07, 5.23815412e-07, 5.41483621e-07, 5.34903506e-07,\n", - " 6.87934277e-07, 6.35206008e-07, 5.30810105e-07, 5.86690328e-07,\n", - " 5.96205596e-07, 4.76265283e-07, 2.59530478e-07, 1.74668642e-07,\n", - " 2.20707690e-07, 1.48224947e-07, 7.76568209e-08, 1.49773341e-07,\n", - " 1.78680352e-07, 1.50650345e-07, 1.71730188e-07, 1.91727303e-07,\n", - " 2.55737209e-07, 4.01336506e-07, 4.90735809e-07, 6.14103359e-07,\n", - " 7.46771362e-07, 7.70136971e-07, 7.22502224e-07, 6.80766422e-07,\n", - " 4.75239918e-07, 2.77572849e-07, 2.05658903e-07, 2.15890173e-07,\n", - " 3.81961906e-07, 5.64244747e-07, 6.73058541e-07, 6.74224365e-07,\n", - " 5.94286990e-07, 5.01544846e-07, 3.92881635e-07, 3.41382951e-07,\n", - " 3.33890182e-07, 1.99711452e-07, 2.42957717e-07, 3.43601866e-07,\n", - " 3.29441193e-07, 2.52072739e-07, 2.95682939e-07, 3.75249375e-07,\n", - " 3.42851182e-07, 3.24730227e-07, 2.39156456e-07, 1.41895006e-07,\n", - " 2.08806816e-07, 2.25333412e-07, 2.89249900e-07, 4.32962675e-07,\n", - " 3.95274135e-07, 2.61367467e-07, 2.59601271e-07, 3.31315463e-07,\n", - " 4.64020000e-07, 4.42235952e-07, 2.78579548e-07, 4.32860594e-08,\n", - " 1.19422155e-07, 2.20370440e-07, 2.72269130e-07, 1.95321901e-07,\n", - " 2.49038024e-07, 2.20263688e-07, 1.09444566e-07, 1.19985084e-07,\n", - " 1.64712500e-07, 2.54279504e-07, 5.21125581e-07, 5.99847999e-07,\n", - " 5.50143097e-07, 5.38032710e-07, 5.75328278e-07, 5.84995137e-07,\n", - " 5.91818588e-07, 6.61172483e-07, 5.09732156e-07, 3.38181717e-07,\n", - " 1.90165818e-07, 9.16482454e-08, 2.16879324e-07, 2.71869259e-07,\n", - " 2.34202087e-07, 1.64473707e-07, 1.85627516e-07, 4.21186435e-07,\n", - " 7.20099193e-07, 8.49382786e-07, 8.55383445e-07, 8.06922724e-07,\n", - " 8.86273143e-07, 1.09564047e-06, 1.02477921e-06, 7.71886033e-07,\n", - " 4.82086127e-07, 1.55281914e-07, 2.88683618e-07, 4.12018350e-07,\n", - " 3.66836577e-07, 3.69618906e-07, 3.32524375e-07, 2.48514935e-07,\n", - " 1.59734486e-07, 1.87519651e-07, 1.90979404e-07, 1.35212486e-07,\n", - " 1.37459873e-07, 2.72669989e-07, 3.34520602e-07, 4.73230690e-07,\n", - " 7.20279987e-07, 8.29459769e-07, 8.65655251e-07, 6.95763571e-07,\n", - " 3.59860664e-07, 3.39939569e-07, 4.08631101e-07, 4.24498281e-07,\n", - " 4.20614116e-07, 2.52512024e-07, 3.18811094e-07, 4.74561047e-07,\n", - " 5.65069723e-07, 5.56085131e-07, 4.72746776e-07, 2.86232741e-07,\n", - " 2.83763569e-07, 4.50330590e-07, 4.43099713e-07, 2.94279395e-07,\n", - " 1.94999411e-07, 1.30027981e-07, 7.19276390e-08, 7.09954223e-08]])}], 'sample.x': [{'header': {'systemtime': array([1664380454830796], dtype=uint64), 'createdtimestamp': array([1204630954536], dtype=uint64), 'changedtimestamp': array([1204630954536], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '100 17:54:14.8306', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([1000], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1204630942856, 1204630978696, 1204631014536, 1204631050376,\n", - " 1204631086216, 1204631122056, 1204631157896, 1204631193736,\n", - " 1204631229576, 1204631265416, 1204631301256, 1204631337096,\n", - " 1204631372936, 1204631408776, 1204631444616, 1204631480456,\n", - " 1204631516296, 1204631552136, 1204631587976, 1204631623816,\n", - " 1204631659656, 1204631695496, 1204631731336, 1204631767176,\n", - " 1204631803016, 1204631838856, 1204631874696, 1204631910536,\n", - " 1204631946376, 1204631982216, 1204632018056, 1204632053896,\n", - " 1204632089736, 1204632125576, 1204632161416, 1204632197256,\n", - " 1204632233096, 1204632268936, 1204632304776, 1204632340616,\n", - " 1204632376456, 1204632412296, 1204632448136, 1204632483976,\n", - " 1204632519816, 1204632555656, 1204632591496, 1204632627336,\n", - " 1204632663176, 1204632699016, 1204632734856, 1204632770696,\n", - " 1204632806536, 1204632842376, 1204632878216, 1204632914056,\n", - " 1204632949896, 1204632985736, 1204633021576, 1204633057416,\n", - " 1204633093256, 1204633129096, 1204633164936, 1204633200776,\n", - " 1204633236616, 1204633272456, 1204633308296, 1204633344136,\n", - " 1204633379976, 1204633415816, 1204633451656, 1204633487496,\n", - " 1204633523336, 1204633559176, 1204633595016, 1204633630856,\n", - " 1204633666696, 1204633702536, 1204633738376, 1204633774216,\n", - " 1204633810056, 1204633845896, 1204633881736, 1204633917576,\n", - " 1204633953416, 1204633989256, 1204634025096, 1204634060936,\n", - " 1204634096776, 1204634132616, 1204634168456, 1204634204296,\n", - " 1204634240136, 1204634275976, 1204634311816, 1204634347656,\n", - " 1204634383496, 1204634419336, 1204634455176, 1204634491016,\n", - " 1204634526856, 1204634562696, 1204634598536, 1204634634376,\n", - " 1204634670216, 1204634706056, 1204634741896, 1204634777736,\n", - " 1204634813576, 1204634849416, 1204634885256, 1204634921096,\n", - " 1204634956936, 1204634992776, 1204635028616, 1204635064456,\n", - " 1204635100296, 1204635136136, 1204635171976, 1204635207816,\n", - " 1204635243656, 1204635279496, 1204635315336, 1204635351176,\n", - " 1204635387016, 1204635422856, 1204635458696, 1204635494536,\n", - " 1204635530376, 1204635566216, 1204635602056, 1204635637896,\n", - " 1204635673736, 1204635709576, 1204635745416, 1204635781256,\n", - " 1204635817096, 1204635852936, 1204635888776, 1204635924616,\n", - " 1204635960456, 1204635996296, 1204636032136, 1204636067976,\n", - " 1204636103816, 1204636139656, 1204636175496, 1204636211336,\n", - " 1204636247176, 1204636283016, 1204636318856, 1204636354696,\n", - " 1204636390536, 1204636426376, 1204636462216, 1204636498056,\n", - " 1204636533896, 1204636569736, 1204636605576, 1204636641416,\n", - " 1204636677256, 1204636713096, 1204636748936, 1204636784776,\n", - " 1204636820616, 1204636856456, 1204636892296, 1204636928136,\n", - " 1204636963976, 1204636999816, 1204637035656, 1204637071496,\n", - " 1204637107336, 1204637143176, 1204637179016, 1204637214856,\n", - " 1204637250696, 1204637286536, 1204637322376, 1204637358216,\n", - " 1204637394056, 1204637429896, 1204637465736, 1204637501576,\n", - " 1204637537416, 1204637573256, 1204637609096, 1204637644936,\n", - " 1204637680776, 1204637716616, 1204637752456, 1204637788296,\n", - " 1204637824136, 1204637859976, 1204637895816, 1204637931656,\n", - " 1204637967496, 1204638003336, 1204638039176, 1204638075016,\n", - " 1204638110856, 1204638146696, 1204638182536, 1204638218376,\n", - " 1204638254216, 1204638290056, 1204638325896, 1204638361736,\n", - " 1204638397576, 1204638433416, 1204638469256, 1204638505096,\n", - " 1204638540936, 1204638576776, 1204638612616, 1204638648456,\n", - " 1204638684296, 1204638720136, 1204638755976, 1204638791816,\n", - " 1204638827656, 1204638863496, 1204638899336, 1204638935176,\n", - " 1204638971016, 1204639006856, 1204639042696, 1204639078536,\n", - " 1204639114376, 1204639150216, 1204639186056, 1204639221896,\n", - " 1204639257736, 1204639293576, 1204639329416, 1204639365256,\n", - " 1204639401096, 1204639436936, 1204639472776, 1204639508616,\n", - " 1204639544456, 1204639580296, 1204639616136, 1204639651976,\n", - " 1204639687816, 1204639723656, 1204639759496, 1204639795336,\n", - " 1204639831176, 1204639867016, 1204639902856, 1204639938696,\n", - " 1204639974536, 1204640010376, 1204640046216, 1204640082056,\n", - " 1204640117896, 1204640153736, 1204640189576, 1204640225416,\n", - " 1204640261256, 1204640297096, 1204640332936, 1204640368776,\n", - " 1204640404616, 1204640440456, 1204640476296, 1204640512136,\n", - " 1204640547976, 1204640583816, 1204640619656, 1204640655496,\n", - " 1204640691336, 1204640727176, 1204640763016, 1204640798856,\n", - " 1204640834696, 1204640870536, 1204640906376, 1204640942216,\n", - " 1204640978056, 1204641013896, 1204641049736, 1204641085576,\n", - " 1204641121416, 1204641157256, 1204641193096, 1204641228936,\n", - " 1204641264776, 1204641300616, 1204641336456, 1204641372296,\n", - " 1204641408136, 1204641443976, 1204641479816, 1204641515656,\n", - " 1204641551496, 1204641587336, 1204641623176, 1204641659016,\n", - " 1204641694856, 1204641730696, 1204641766536, 1204641802376,\n", - " 1204641838216, 1204641874056, 1204641909896, 1204641945736,\n", - " 1204641981576, 1204642017416, 1204642053256, 1204642089096,\n", - " 1204642124936, 1204642160776, 1204642196616, 1204642232456,\n", - " 1204642268296, 1204642304136, 1204642339976, 1204642375816,\n", - " 1204642411656, 1204642447496, 1204642483336, 1204642519176,\n", - " 1204642555016, 1204642590856, 1204642626696, 1204642662536,\n", - " 1204642698376, 1204642734216, 1204642770056, 1204642805896,\n", - " 1204642841736, 1204642877576, 1204642913416, 1204642949256,\n", - " 1204642985096, 1204643020936, 1204643056776, 1204643092616,\n", - " 1204643128456, 1204643164296, 1204643200136, 1204643235976,\n", - " 1204643271816, 1204643307656, 1204643343496, 1204643379336,\n", - " 1204643415176, 1204643451016, 1204643486856, 1204643522696,\n", - " 1204643558536, 1204643594376, 1204643630216, 1204643666056,\n", - " 1204643701896, 1204643737736, 1204643773576, 1204643809416,\n", - " 1204643845256, 1204643881096, 1204643916936, 1204643952776,\n", - " 1204643988616, 1204644024456, 1204644060296, 1204644096136,\n", - " 1204644131976, 1204644167816, 1204644203656, 1204644239496,\n", - " 1204644275336, 1204644311176, 1204644347016, 1204644382856,\n", - " 1204644418696, 1204644454536, 1204644490376, 1204644526216,\n", - " 1204644562056, 1204644597896, 1204644633736, 1204644669576,\n", - " 1204644705416, 1204644741256, 1204644777096, 1204644812936,\n", - " 1204644848776, 1204644884616, 1204644920456, 1204644956296,\n", - " 1204644992136, 1204645027976, 1204645063816, 1204645099656,\n", - " 1204645135496, 1204645171336, 1204645207176, 1204645243016,\n", - " 1204645278856, 1204645314696, 1204645350536, 1204645386376,\n", - " 1204645422216, 1204645458056, 1204645493896, 1204645529736,\n", - " 1204645565576, 1204645601416, 1204645637256, 1204645673096,\n", - " 1204645708936, 1204645744776, 1204645780616, 1204645816456,\n", - " 1204645852296, 1204645888136, 1204645923976, 1204645959816,\n", - " 1204645995656, 1204646031496, 1204646067336, 1204646103176,\n", - " 1204646139016, 1204646174856, 1204646210696, 1204646246536,\n", - " 1204646282376, 1204646318216, 1204646354056, 1204646389896,\n", - " 1204646425736, 1204646461576, 1204646497416, 1204646533256,\n", - " 1204646569096, 1204646604936, 1204646640776, 1204646676616,\n", - " 1204646712456, 1204646748296, 1204646784136, 1204646819976,\n", - " 1204646855816, 1204646891656, 1204646927496, 1204646963336,\n", - " 1204646999176, 1204647035016, 1204647070856, 1204647106696,\n", - " 1204647142536, 1204647178376, 1204647214216, 1204647250056,\n", - " 1204647285896, 1204647321736, 1204647357576, 1204647393416,\n", - " 1204647429256, 1204647465096, 1204647500936, 1204647536776,\n", - " 1204647572616, 1204647608456, 1204647644296, 1204647680136,\n", - " 1204647715976, 1204647751816, 1204647787656, 1204647823496,\n", - " 1204647859336, 1204647895176, 1204647931016, 1204647966856,\n", - " 1204648002696, 1204648038536, 1204648074376, 1204648110216,\n", - " 1204648146056, 1204648181896, 1204648217736, 1204648253576,\n", - " 1204648289416, 1204648325256, 1204648361096, 1204648396936,\n", - " 1204648432776, 1204648468616, 1204648504456, 1204648540296,\n", - " 1204648576136, 1204648611976, 1204648647816, 1204648683656,\n", - " 1204648719496, 1204648755336, 1204648791176, 1204648827016,\n", - " 1204648862856, 1204648898696, 1204648934536, 1204648970376,\n", - " 1204649006216, 1204649042056, 1204649077896, 1204649113736,\n", - " 1204649149576, 1204649185416, 1204649221256, 1204649257096,\n", - " 1204649292936, 1204649328776, 1204649364616, 1204649400456,\n", - " 1204649436296, 1204649472136, 1204649507976, 1204649543816,\n", - " 1204649579656, 1204649615496, 1204649651336, 1204649687176,\n", - " 1204649723016, 1204649758856, 1204649794696, 1204649830536,\n", - " 1204649866376, 1204649902216, 1204649938056, 1204649973896,\n", - " 1204650009736, 1204650045576, 1204650081416, 1204650117256,\n", - " 1204650153096, 1204650188936, 1204650224776, 1204650260616,\n", - " 1204650296456, 1204650332296, 1204650368136, 1204650403976,\n", - " 1204650439816, 1204650475656, 1204650511496, 1204650547336,\n", - " 1204650583176, 1204650619016, 1204650654856, 1204650690696,\n", - " 1204650726536, 1204650762376, 1204650798216, 1204650834056,\n", - " 1204650869896, 1204650905736, 1204650941576, 1204650977416,\n", - " 1204651013256, 1204651049096, 1204651084936, 1204651120776,\n", - " 1204651156616, 1204651192456, 1204651228296, 1204651264136,\n", - " 1204651299976, 1204651335816, 1204651371656, 1204651407496,\n", - " 1204651443336, 1204651479176, 1204651515016, 1204651550856,\n", - " 1204651586696, 1204651622536, 1204651658376, 1204651694216,\n", - " 1204651730056, 1204651765896, 1204651801736, 1204651837576,\n", - " 1204651873416, 1204651909256, 1204651945096, 1204651980936,\n", - " 1204652016776, 1204652052616, 1204652088456, 1204652124296,\n", - " 1204652160136, 1204652195976, 1204652231816, 1204652267656,\n", - " 1204652303496, 1204652339336, 1204652375176, 1204652411016,\n", - " 1204652446856, 1204652482696, 1204652518536, 1204652554376,\n", - " 1204652590216, 1204652626056, 1204652661896, 1204652697736,\n", - " 1204652733576, 1204652769416, 1204652805256, 1204652841096,\n", - " 1204652876936, 1204652912776, 1204652948616, 1204652984456,\n", - " 1204653020296, 1204653056136, 1204653091976, 1204653127816,\n", - " 1204653163656, 1204653199496, 1204653235336, 1204653271176,\n", - " 1204653307016, 1204653342856, 1204653378696, 1204653414536,\n", - " 1204653450376, 1204653486216, 1204653522056, 1204653557896,\n", - " 1204653593736, 1204653629576, 1204653665416, 1204653701256,\n", - " 1204653737096, 1204653772936, 1204653808776, 1204653844616,\n", - " 1204653880456, 1204653916296, 1204653952136, 1204653987976,\n", - " 1204654023816, 1204654059656, 1204654095496, 1204654131336,\n", - " 1204654167176, 1204654203016, 1204654238856, 1204654274696,\n", - " 1204654310536, 1204654346376, 1204654382216, 1204654418056,\n", - " 1204654453896, 1204654489736, 1204654525576, 1204654561416,\n", - " 1204654597256, 1204654633096, 1204654668936, 1204654704776,\n", - " 1204654740616, 1204654776456, 1204654812296, 1204654848136,\n", - " 1204654883976, 1204654919816, 1204654955656, 1204654991496,\n", - " 1204655027336, 1204655063176, 1204655099016, 1204655134856,\n", - " 1204655170696, 1204655206536, 1204655242376, 1204655278216,\n", - " 1204655314056, 1204655349896, 1204655385736, 1204655421576,\n", - " 1204655457416, 1204655493256, 1204655529096, 1204655564936,\n", - " 1204655600776, 1204655636616, 1204655672456, 1204655708296,\n", - " 1204655744136, 1204655779976, 1204655815816, 1204655851656,\n", - " 1204655887496, 1204655923336, 1204655959176, 1204655995016,\n", - " 1204656030856, 1204656066696, 1204656102536, 1204656138376,\n", - " 1204656174216, 1204656210056, 1204656245896, 1204656281736,\n", - " 1204656317576, 1204656353416, 1204656389256, 1204656425096,\n", - " 1204656460936, 1204656496776, 1204656532616, 1204656568456,\n", - " 1204656604296, 1204656640136, 1204656675976, 1204656711816,\n", - " 1204656747656, 1204656783496, 1204656819336, 1204656855176,\n", - " 1204656891016, 1204656926856, 1204656962696, 1204656998536,\n", - " 1204657034376, 1204657070216, 1204657106056, 1204657141896,\n", - " 1204657177736, 1204657213576, 1204657249416, 1204657285256,\n", - " 1204657321096, 1204657356936, 1204657392776, 1204657428616,\n", - " 1204657464456, 1204657500296, 1204657536136, 1204657571976,\n", - " 1204657607816, 1204657643656, 1204657679496, 1204657715336,\n", - " 1204657751176, 1204657787016, 1204657822856, 1204657858696,\n", - " 1204657894536, 1204657930376, 1204657966216, 1204658002056,\n", - " 1204658037896, 1204658073736, 1204658109576, 1204658145416,\n", - " 1204658181256, 1204658217096, 1204658252936, 1204658288776,\n", - " 1204658324616, 1204658360456, 1204658396296, 1204658432136,\n", - " 1204658467976, 1204658503816, 1204658539656, 1204658575496,\n", - " 1204658611336, 1204658647176, 1204658683016, 1204658718856,\n", - " 1204658754696, 1204658790536, 1204658826376, 1204658862216,\n", - " 1204658898056, 1204658933896, 1204658969736, 1204659005576,\n", - " 1204659041416, 1204659077256, 1204659113096, 1204659148936,\n", - " 1204659184776, 1204659220616, 1204659256456, 1204659292296,\n", - " 1204659328136, 1204659363976, 1204659399816, 1204659435656,\n", - " 1204659471496, 1204659507336, 1204659543176, 1204659579016,\n", - " 1204659614856, 1204659650696, 1204659686536, 1204659722376,\n", - " 1204659758216, 1204659794056, 1204659829896, 1204659865736,\n", - " 1204659901576, 1204659937416, 1204659973256, 1204660009096,\n", - " 1204660044936, 1204660080776, 1204660116616, 1204660152456,\n", - " 1204660188296, 1204660224136, 1204660259976, 1204660295816,\n", - " 1204660331656, 1204660367496, 1204660403336, 1204660439176,\n", - " 1204660475016, 1204660510856, 1204660546696, 1204660582536,\n", - " 1204660618376, 1204660654216, 1204660690056, 1204660725896,\n", - " 1204660761736, 1204660797576, 1204660833416, 1204660869256,\n", - " 1204660905096, 1204660940936, 1204660976776, 1204661012616,\n", - " 1204661048456, 1204661084296, 1204661120136, 1204661155976,\n", - " 1204661191816, 1204661227656, 1204661263496, 1204661299336,\n", - " 1204661335176, 1204661371016, 1204661406856, 1204661442696,\n", - " 1204661478536, 1204661514376, 1204661550216, 1204661586056,\n", - " 1204661621896, 1204661657736, 1204661693576, 1204661729416,\n", - " 1204661765256, 1204661801096, 1204661836936, 1204661872776,\n", - " 1204661908616, 1204661944456, 1204661980296, 1204662016136,\n", - " 1204662051976, 1204662087816, 1204662123656, 1204662159496,\n", - " 1204662195336, 1204662231176, 1204662267016, 1204662302856,\n", - " 1204662338696, 1204662374536, 1204662410376, 1204662446216,\n", - " 1204662482056, 1204662517896, 1204662553736, 1204662589576,\n", - " 1204662625416, 1204662661256, 1204662697096, 1204662732936,\n", - " 1204662768776, 1204662804616, 1204662840456, 1204662876296,\n", - " 1204662912136, 1204662947976, 1204662983816, 1204663019656,\n", - " 1204663055496, 1204663091336, 1204663127176, 1204663163016,\n", - " 1204663198856, 1204663234696, 1204663270536, 1204663306376,\n", - " 1204663342216, 1204663378056, 1204663413896, 1204663449736,\n", - " 1204663485576, 1204663521416, 1204663557256, 1204663593096,\n", - " 1204663628936, 1204663664776, 1204663700616, 1204663736456,\n", - " 1204663772296, 1204663808136, 1204663843976, 1204663879816,\n", - " 1204663915656, 1204663951496, 1204663987336, 1204664023176,\n", - " 1204664059016, 1204664094856, 1204664130696, 1204664166536,\n", - " 1204664202376, 1204664238216, 1204664274056, 1204664309896,\n", - " 1204664345736, 1204664381576, 1204664417416, 1204664453256,\n", - " 1204664489096, 1204664524936, 1204664560776, 1204664596616,\n", - " 1204664632456, 1204664668296, 1204664704136, 1204664739976,\n", - " 1204664775816, 1204664811656, 1204664847496, 1204664883336,\n", - " 1204664919176, 1204664955016, 1204664990856, 1204665026696,\n", - " 1204665062536, 1204665098376, 1204665134216, 1204665170056,\n", - " 1204665205896, 1204665241736, 1204665277576, 1204665313416,\n", - " 1204665349256, 1204665385096, 1204665420936, 1204665456776,\n", - " 1204665492616, 1204665528456, 1204665564296, 1204665600136,\n", - " 1204665635976, 1204665671816, 1204665707656, 1204665743496,\n", - " 1204665779336, 1204665815176, 1204665851016, 1204665886856,\n", - " 1204665922696, 1204665958536, 1204665994376, 1204666030216,\n", - " 1204666066056, 1204666101896, 1204666137736, 1204666173576,\n", - " 1204666209416, 1204666245256, 1204666281096, 1204666316936,\n", - " 1204666352776, 1204666388616, 1204666424456, 1204666460296,\n", - " 1204666496136, 1204666531976, 1204666567816, 1204666603656,\n", - " 1204666639496, 1204666675336, 1204666711176, 1204666747016]],\n", - " dtype=uint64), 'value': array([[ 3.92985139e-07, 3.83420582e-07, 2.70894730e-07,\n", - " 1.59362046e-07, 5.19425521e-09, -1.48426426e-07,\n", - " -1.43519777e-07, 8.15211657e-08, 2.37241792e-07,\n", - " 1.43174769e-07, 1.06832322e-07, 3.03419964e-07,\n", - " 3.53603991e-07, 2.79436221e-07, 2.91986862e-07,\n", - " 3.61741877e-07, 3.62849251e-07, 4.00763667e-07,\n", - " 4.44543818e-07, 2.68402540e-07, 4.07432428e-09,\n", - " -3.04182928e-07, -5.46997467e-07, -7.22909138e-07,\n", - " -8.42683151e-07, -9.57424350e-07, -8.91693433e-07,\n", - " -5.90276549e-07, -3.09874066e-07, 3.15099414e-08,\n", - " 1.17763757e-07, -2.48585203e-08, -5.14343080e-08,\n", - " -7.95461888e-08, 1.09972075e-08, 2.60788444e-07,\n", - " 5.95013983e-07, 7.90452394e-07, 7.46151442e-07,\n", - " 6.50482553e-07, 5.95991605e-07, 5.00587601e-07,\n", - " 3.03236996e-07, 9.30959778e-08, 2.06233517e-08,\n", - " 3.14812406e-09, 4.27014776e-08, 1.62276378e-07,\n", - " 3.45086417e-07, 2.49326044e-07, 8.88291187e-08,\n", - " 7.91114905e-08, 1.02013570e-07, -1.65233163e-08,\n", - " -1.17815179e-07, -2.93111576e-07, -3.76068382e-07,\n", - " -2.22642030e-07, -8.62448467e-08, 2.06532484e-08,\n", - " 7.47423847e-08, 2.17917751e-07, 2.91384742e-07,\n", - " 2.34781890e-07, 8.57551385e-08, -3.07021322e-08,\n", - " -6.35412815e-08, -4.95621757e-08, -8.56349537e-08,\n", - " -1.45087561e-07, -1.32979989e-07, -2.56436081e-08,\n", - " 3.83718354e-08, -2.08320308e-09, -1.47861378e-07,\n", - " -2.48321514e-07, -2.27038641e-07, -2.11037919e-07,\n", - " -3.84853233e-07, -5.05484683e-07, -5.41471956e-07,\n", - " -5.06235688e-07, -4.06738226e-07, -1.02136146e-07,\n", - " 1.07573163e-07, 9.34738723e-08, -4.02792458e-08,\n", - " -3.98182384e-08, -7.42580579e-08, -8.18560090e-08,\n", - " -5.80349046e-08, 4.76930331e-08, 2.96791264e-07,\n", - " 5.32980691e-07, 5.86162761e-07, 5.87198982e-07,\n", - " 6.17966886e-07, 6.79197152e-07, 5.80585828e-07,\n", - " 2.82879127e-07, 2.60759146e-08, -2.61981323e-07,\n", - " -3.43245975e-07, -3.49784985e-07, -2.03524277e-07,\n", - " -4.41544579e-08, 4.10816736e-08, 1.58254074e-07,\n", - " 1.88760681e-07, 1.04991881e-07, -5.24316624e-08,\n", - " -7.14860345e-08, -7.36427835e-08, -6.57321128e-08,\n", - " 4.97774320e-08, 1.71477989e-07, 4.10129111e-07,\n", - " 6.08990697e-07, 7.57704131e-07, 8.73352994e-07,\n", - " 9.14463967e-07, 8.71196843e-07, 7.13427694e-07,\n", - " 4.95935074e-07, 2.12877165e-07, 8.20102760e-08,\n", - " 8.16299898e-08, -8.94497745e-08, -2.09379848e-07,\n", - " -3.49057897e-07, -3.64097140e-07, -2.65484620e-07,\n", - " -1.38712385e-07, -6.69226000e-08, -6.93950583e-08,\n", - " -2.61780417e-07, -5.49814934e-07, -7.53205273e-07,\n", - " -7.45047656e-07, -7.28842440e-07, -6.66364884e-07,\n", - " -6.38251807e-07, -6.08288124e-07, -5.06938859e-07,\n", - " -3.70191884e-07, -4.39671251e-07, -5.18713381e-07,\n", - " -5.92985192e-07, -5.58427579e-07, -4.05719346e-07,\n", - " -2.36963154e-07, -1.26458320e-07, 8.08335413e-08,\n", - " 1.01863488e-07, -2.76203788e-08, -3.17000845e-08,\n", - " 9.74459498e-08, 1.39901676e-07, 7.68734225e-08,\n", - " -1.09082349e-07, -2.89064159e-07, -4.68825929e-07,\n", - " -5.44368350e-07, -4.44860723e-07, -2.66156100e-07,\n", - " -1.47009919e-07, -7.06746377e-08, -8.82742357e-08,\n", - " -1.26150981e-07, -2.56645358e-08, 1.22603437e-07,\n", - " 2.88491936e-07, 4.83080683e-07, 4.14143642e-07,\n", - " 2.74622850e-07, 2.43333546e-07, 2.92212881e-07,\n", - " 1.99867311e-07, -2.50217564e-08, -1.10268651e-07,\n", - " -3.72949557e-08, 6.92772652e-08, 1.26283125e-07,\n", - " 2.10329367e-07, 2.62502722e-07, 3.08120923e-07,\n", - " 3.12027826e-07, 1.65437058e-07, -6.38055685e-09,\n", - " -1.33220957e-07, -8.91950545e-08, 6.40501236e-08,\n", - " 1.19388943e-07, 1.93055643e-07, 3.50974276e-07,\n", - " 3.97211937e-07, 3.25983014e-07, 2.73461064e-07,\n", - " 1.98727648e-07, 1.55330175e-07, 1.90476753e-07,\n", - " 2.61940664e-07, 2.00896954e-07, 4.53180381e-08,\n", - " -1.97603532e-07, -2.75219588e-07, -2.36965546e-07,\n", - " -1.80616218e-07, -1.54334614e-07, -7.63107663e-08,\n", - " 1.61057788e-07, 2.74578005e-07, 1.63907542e-07,\n", - " -6.21654347e-08, -2.49956267e-07, -2.91821234e-07,\n", - " -3.75682715e-07, -4.41552352e-07, -4.87636344e-07,\n", - " -3.21807041e-07, -1.66438000e-07, -1.28596533e-07,\n", - " -1.44966778e-07, -1.12107299e-07, -2.19878378e-08,\n", - " 1.79218846e-08, -1.00522322e-07, -2.46749545e-07,\n", - " -2.60108593e-07, -2.75065919e-07, -2.58524067e-07,\n", - " -3.81742181e-07, -3.48997505e-07, -2.08807026e-07,\n", - " -1.16515868e-07, -1.05323136e-07, -2.41726897e-08,\n", - " 4.29286926e-08, 5.61681538e-08, 3.76722522e-08,\n", - " 1.38363789e-07, 2.03251619e-07, 2.58051101e-07,\n", - " 1.92023609e-07, 1.52896582e-07, 1.02029714e-07,\n", - " 4.03647504e-08, 5.41549090e-08, -5.61274942e-08,\n", - " -1.70893209e-07, -1.95489236e-07, -1.79434102e-07,\n", - " -1.90418753e-07, -3.48402561e-07, -3.33618635e-07,\n", - " -3.26589917e-07, -4.11926502e-07, -5.46374420e-07,\n", - " -6.52977135e-07, -6.32305351e-07, -4.91076260e-07,\n", - " -4.62341930e-07, -5.53354107e-07, -6.67683329e-07,\n", - " -6.31887993e-07, -4.50556645e-07, -2.71762332e-07,\n", - " -1.42126590e-07, 1.25963230e-07, 3.40132531e-07,\n", - " 4.29167339e-07, 4.55697086e-07, 4.59132817e-07,\n", - " 5.23494464e-07, 6.45093969e-07, 6.82350657e-07,\n", - " 5.68289907e-07, 4.45257751e-07, 2.59265506e-07,\n", - " 2.07892785e-07, 7.75227791e-08, 2.10114111e-09,\n", - " -2.04415797e-08, -1.55623761e-07, -1.85535424e-07,\n", - " -1.49825592e-07, -8.89923548e-08, 4.57419735e-09,\n", - " 5.10922895e-08, 1.40718455e-07, 1.43216026e-07,\n", - " 5.61567930e-08, 1.79643379e-08, 3.86223698e-08,\n", - " 1.53206312e-07, 1.79312124e-07, 7.49385071e-08,\n", - " -2.79522324e-08, -9.90639600e-08, -2.59066394e-07,\n", - " -3.46135792e-07, -1.63205568e-07, 1.90346403e-08,\n", - " -4.05100484e-09, -9.41662802e-08, -1.47081073e-07,\n", - " -6.07148461e-08, -3.67191450e-09, -6.38641661e-08,\n", - " -1.07170155e-07, -1.40608435e-07, -8.53814296e-08,\n", - " 9.04961595e-08, 2.52720517e-07, 2.35757719e-07,\n", - " 2.67364526e-07, 3.95856420e-07, 4.95924909e-07,\n", - " 4.23995806e-07, 1.04117103e-07, -2.16378668e-07,\n", - " -3.11306119e-07, -2.60955268e-07, -7.30400657e-08,\n", - " 2.12508838e-07, 3.22259079e-07, 4.08452504e-07,\n", - " 4.70284889e-07, 5.51629066e-07, 4.34274894e-07,\n", - " 2.41514032e-07, 6.07967631e-08, -1.20032320e-07,\n", - " -1.90575412e-07, -2.92648177e-07, -3.14663520e-07,\n", - " -3.62121565e-07, -3.63577535e-07, -3.71738142e-07,\n", - " -2.93161205e-07, -2.25049314e-07, -1.51070491e-07,\n", - " 7.38030299e-09, 6.07818148e-08, -4.18972560e-08,\n", - " -1.33020649e-07, -1.94261677e-07, -8.04209666e-08,\n", - " -8.10990241e-08, -1.87267041e-07, -2.94979523e-07,\n", - " -3.96578127e-07, -5.46681160e-07, -5.69697445e-07,\n", - " -5.55555103e-07, -4.79262275e-07, -3.06220090e-07,\n", - " -1.15504163e-07, 2.28751723e-07, 4.22506351e-07,\n", - " 2.75850409e-07, 7.17802182e-08, -1.52670563e-07,\n", - " -2.67373495e-07, -3.23360474e-07, -4.74308389e-07,\n", - " -4.85272710e-07, -2.15499705e-07, 2.99624875e-09,\n", - " 9.53585612e-09, -1.37725196e-07, -1.88432415e-07,\n", - " -2.43055507e-07, -2.71423304e-07, -1.12316576e-07,\n", - " -5.20812729e-08, -2.77504893e-07, -3.56383787e-07,\n", - " -3.37075293e-07, -3.63530896e-07, -2.98915127e-07,\n", - " -2.23851651e-07, -1.60337875e-07, -1.63355649e-07,\n", - " -1.03609456e-07, -1.25081875e-08, 1.97007989e-07,\n", - " 3.81623192e-07, 4.15189429e-07, 2.83439989e-07,\n", - " 3.52171340e-08, -5.29291437e-09, 2.70027127e-08,\n", - " 8.30094242e-08, 2.37340451e-07, 3.69867804e-07,\n", - " 3.11326449e-07, 2.07639261e-07, 1.38845724e-07,\n", - " 3.49929087e-08, 2.85627233e-08, 1.99058306e-07,\n", - " 3.25536357e-07, 4.24391040e-07, 5.15305754e-07,\n", - " 5.54799314e-07, 6.02066618e-07, 5.56236150e-07,\n", - " 5.88164047e-07, 5.98419816e-07, 5.44714554e-07,\n", - " 4.76758126e-07, 5.39173497e-07, 5.82523733e-07,\n", - " 5.20635740e-07, 4.53664707e-07, 3.73594130e-07,\n", - " 9.79225034e-08, -1.64556301e-07, -6.45308628e-08,\n", - " -2.53225173e-09, -7.11942426e-08, -6.92868322e-08,\n", - " -1.83482117e-08, -5.87386733e-08, -3.65385688e-08,\n", - " 1.03064140e-07, 2.30992781e-07, 2.62640247e-07,\n", - " 7.88806879e-08, -1.76595708e-07, -1.84531492e-07,\n", - " 1.14630581e-07, 4.46794442e-07, 6.63414078e-07,\n", - " 7.22672357e-07, 6.75053467e-07, 5.45177355e-07,\n", - " 3.61184602e-07, 1.39103434e-07, -8.15002380e-08,\n", - " -3.84913624e-07, -6.68408026e-07, -6.90710377e-07,\n", - " -6.50547728e-07, -5.83720200e-07, -5.99011771e-07,\n", - " -6.59074271e-07, -6.13119433e-07, -5.01846851e-07,\n", - " -3.28521843e-07, -3.56619972e-08, 4.30500733e-08,\n", - " -4.95508149e-09, 5.33895531e-08, 1.68351988e-07,\n", - " 1.90788874e-07, 3.30179317e-08, -2.65245447e-07,\n", - " -4.54763113e-07, -5.42195457e-07, -5.84733100e-07,\n", - " -6.18889499e-07, -6.64385124e-07, -6.42400873e-07,\n", - " -5.23666071e-07, -4.33743928e-07, -3.57675923e-07,\n", - " -2.17862143e-07, -5.70602717e-08, 2.77303987e-08,\n", - " 1.37077035e-07, 1.36061144e-07, 2.01107427e-07,\n", - " 2.33071798e-07, 2.38902255e-07, 1.93699021e-07,\n", - " 1.33213781e-07, -2.10454933e-08, -4.07932301e-07,\n", - " -6.97150727e-07, -6.85435400e-07, -4.98341760e-07,\n", - " -3.69193334e-07, -2.30489918e-07, -1.65074112e-07,\n", - " -1.73244286e-07, -3.12409308e-07, -4.17552466e-07,\n", - " -2.76978711e-07, -1.01703840e-07, 4.00203402e-08,\n", - " 7.96801261e-08, 5.91327120e-08, -5.31025446e-09,\n", - " -3.70498026e-08, -1.22080245e-08, -1.04164937e-07,\n", - " -1.12687893e-07, 2.26682870e-08, 7.39250085e-08,\n", - " 3.86630294e-08, -1.57473769e-07, -2.77513264e-07,\n", - " -2.34415954e-07, -9.34774599e-08, 1.13495702e-07,\n", - " 2.30309940e-07, 2.77524625e-07, 2.54816277e-07,\n", - " 1.46039472e-07, 1.39078919e-07, 1.50235177e-07,\n", - " 6.14425322e-08, -6.96551597e-08, -4.93481152e-08,\n", - " -3.38221533e-08, -1.24280643e-08, -1.38384119e-07,\n", - " -1.30164914e-07, -9.61938754e-08, -1.49727531e-07,\n", - " -1.22355295e-07, -7.24708323e-08, -1.90739246e-07,\n", - " -3.05289704e-07, -4.30052282e-07, -2.88965500e-07,\n", - " -1.99357871e-07, -2.45945323e-07, -2.01812391e-07,\n", - " -1.75720332e-07, -2.87410273e-07, -3.58312126e-07,\n", - " -3.25443080e-07, -9.20071395e-08, 1.06721107e-07,\n", - " 2.36255798e-07, 3.48033635e-07, 3.71790162e-07,\n", - " 2.44360200e-07, -3.30041792e-08, -1.65477718e-07,\n", - " -2.09568795e-07, -1.90201105e-07, -2.05444244e-07,\n", - " -2.42772684e-07, -2.99709183e-07, -4.29494409e-07,\n", - " -4.59779183e-07, -4.38130374e-07, -3.70995508e-07,\n", - " -2.59954326e-07, -2.12623043e-07, -1.96560136e-07,\n", - " -9.51660263e-08, -8.87185008e-08, -1.39274443e-07,\n", - " -9.18026459e-08, -1.22325398e-07, -7.09897490e-08,\n", - " -1.93013190e-09, 8.98390297e-08, 2.15450674e-07,\n", - " 1.84958417e-07, 1.07249680e-07, 1.05097715e-07,\n", - " 1.84560193e-07, 1.00563579e-07, 6.71581861e-08,\n", - " 1.28528368e-07, 7.91252430e-08, -1.03254284e-07,\n", - " -3.00204273e-07, -4.21055763e-07, -4.41529033e-07,\n", - " -3.30959621e-07, -2.49891092e-07, -4.16851089e-07,\n", - " -5.84338464e-07, -5.04995573e-07, -2.83871100e-07,\n", - " -1.08966350e-07, 7.49971047e-08, 2.59871811e-07,\n", - " 2.35015085e-07, 5.78046999e-08, 1.89616923e-08,\n", - " 5.20639328e-08, 2.52515425e-07, 5.02891442e-07,\n", - " 5.86196246e-07, 4.50872952e-07, 3.32533982e-07,\n", - " 3.62297358e-07, 4.60746043e-07, 4.70768618e-07,\n", - " 4.65780650e-07, 3.85436219e-07, 3.07193527e-07,\n", - " 1.69756536e-07, -1.12962943e-07, -3.10589196e-07,\n", - " -4.24860419e-07, -4.91873905e-07, -4.46859617e-07,\n", - " -2.48426153e-07, -1.17500068e-08, 8.72451907e-08,\n", - " 8.76894559e-08, 1.03219005e-07, 2.25426610e-07,\n", - " 2.74669489e-07, 1.74889802e-07, 9.11700314e-08,\n", - " 1.26579700e-07, 2.19670895e-07, 2.72036784e-07,\n", - " 1.76660285e-07, 4.93636615e-08, 7.17258061e-08,\n", - " 4.75489309e-08, -1.28243154e-07, -3.22162214e-07,\n", - " -3.43309954e-07, -1.01288276e-07, 6.92969970e-08,\n", - " 9.49148939e-08, 2.00153721e-07, 3.68585833e-07,\n", - " 3.84339607e-07, 3.28500915e-07, 2.73623702e-07,\n", - " 1.64186180e-07, 7.31961266e-08, 6.60735333e-08,\n", - " 9.36717885e-08, 1.02275465e-07, -2.02699726e-10,\n", - " -1.48580095e-07, -2.13070896e-07, -4.68278819e-07,\n", - " -5.81437287e-07, -5.20804358e-07, -5.67430676e-07,\n", - " -6.15038802e-07, -5.96161419e-07, -3.53384549e-07,\n", - " -2.65704062e-07, -1.59498375e-07, -3.02076405e-09,\n", - " 1.15199217e-07, 2.82614242e-07, 1.88842598e-07,\n", - " 6.59521526e-09, -4.59996832e-08, -4.59883224e-08,\n", - " 4.34303595e-08, 1.69507795e-07, 3.57003247e-07,\n", - " 5.25516080e-07, 6.08550019e-07, 4.93009382e-07,\n", - " 4.03527319e-07, 3.93266169e-07, 3.88992134e-07,\n", - " 3.42486599e-07, 2.64011310e-07, 3.28545761e-07,\n", - " 4.39363913e-07, 4.25984535e-07, 3.74664433e-07,\n", - " 2.42144853e-07, 7.68674431e-08, 3.01484450e-08,\n", - " -9.57824966e-08, -1.44516533e-07, 3.92926542e-08,\n", - " 3.85308859e-07, 5.05405158e-07, 2.73567496e-07,\n", - " -1.47725647e-07, -3.63148218e-07, -2.02561005e-07,\n", - " -8.18243184e-08, -1.13539351e-07, -2.34597128e-07,\n", - " -2.11553339e-07, -5.91261347e-08, 5.44197939e-08,\n", - " -6.64006033e-08, -2.31789229e-07, -3.09711428e-07,\n", - " -2.70477970e-07, -2.18363810e-07, -2.43894409e-07,\n", - " -2.57952442e-07, -1.65912416e-07, 8.97977722e-08,\n", - " 2.25512115e-07, 2.48212092e-07, 1.24256726e-07,\n", - " 4.20180387e-08, 5.78292152e-08, 5.49848418e-08,\n", - " -1.33292709e-07, -2.81195344e-07, -2.61471883e-07,\n", - " -9.86579626e-08, 1.99112120e-09, -6.98746016e-09,\n", - " 2.15441705e-08, 3.71580288e-08, -1.20388091e-07,\n", - " -4.02575408e-07, -5.37950123e-07, -5.66455445e-07,\n", - " -4.17524363e-07, -8.54322540e-08, 8.19755958e-08,\n", - " 1.78326728e-07, 2.05387440e-07, 1.44143422e-07,\n", - " 1.79644575e-07, 1.47876326e-07, 4.88093764e-08,\n", - " -8.83184828e-08, 2.13462543e-10, 2.12627229e-07,\n", - " 2.80647038e-07, 1.25450800e-07, -5.96834095e-08,\n", - " -3.59005729e-07, -6.50030515e-07, -6.45321185e-07,\n", - " -3.91315707e-07, -9.13422365e-08, 4.67758019e-08,\n", - " -1.67632673e-07, -3.60025805e-07, -3.91212264e-07,\n", - " -3.39129198e-07, -2.34033276e-07, -1.98976389e-07,\n", - " 9.53663343e-08, 3.86565119e-07, 6.78102334e-07,\n", - " 7.94773067e-07, 6.75312971e-07, 5.18205137e-07,\n", - " 3.61853690e-07, 3.49845376e-07, 4.18397945e-07,\n", - " 4.49034902e-07, 5.09952448e-07, 3.28503307e-07,\n", - " 7.95724979e-08, -5.88815796e-08, -2.76963165e-09,\n", - " 2.11172455e-08, -8.00992780e-09, -1.54857807e-07,\n", - " -2.87621344e-07, -3.06567490e-07, -3.45380601e-07,\n", - " -3.47566648e-07, -4.19708617e-07, -4.64905274e-07,\n", - " -5.27758333e-07, -5.50948617e-07, -6.16901368e-07,\n", - " -6.01836413e-07, -3.79309784e-07, -1.16091335e-07,\n", - " 8.04855436e-08, 2.60922382e-07, 3.05965968e-07,\n", - " 1.51118326e-07, 1.70321584e-07, 1.11500993e-07,\n", - " 4.55560159e-08, 2.46934905e-08, 1.16256365e-08,\n", - " 7.68345568e-09, 4.35810389e-08, 6.55874127e-08,\n", - " 6.65997154e-08, 7.96059822e-08, 1.25218802e-07,\n", - " 1.69880308e-07, 2.97179323e-07, 3.40381870e-07,\n", - " 3.24701043e-07, 2.83566153e-07, 1.47797399e-07,\n", - " 1.72691197e-07, 2.29566707e-07, 1.78815838e-07,\n", - " 2.06524113e-07, 2.74380089e-07, 1.67206346e-07,\n", - " 2.06466712e-08, -1.03414530e-07, -7.01406823e-08,\n", - " 3.54150503e-08, 5.66315528e-08, 1.05236436e-10,\n", - " -4.27116425e-08, -3.81930530e-08, 1.01061658e-07,\n", - " 2.33339673e-07, 3.38343512e-07, 3.08279376e-07,\n", - " 2.23005574e-07, 1.46063987e-07, 7.48111471e-08,\n", - " 1.67899950e-08, 1.64683063e-08, 6.33337983e-08,\n", - " 2.63583787e-07, 3.62437274e-07, 3.46500532e-07,\n", - " 4.43665452e-07, 5.54326946e-07, 6.36912435e-07,\n", - " 5.88680663e-07, 4.56565287e-07, 3.25703779e-07,\n", - " 1.71597575e-07, -2.70140735e-08, -1.29319435e-07,\n", - " -1.24364354e-07, -1.00961206e-07, -1.60780944e-07,\n", - " -1.77396342e-07, -1.33214379e-07, -3.57684295e-09,\n", - " 6.09462467e-08, 6.19531681e-08, -1.58237332e-08,\n", - " -1.52174278e-09, 8.21759038e-08, 1.54579767e-07,\n", - " 1.52723779e-07, 9.63068850e-08, -2.47652426e-08,\n", - " -2.51300423e-07, -4.81848938e-07, -5.06587274e-07,\n", - " -4.40668008e-07, -3.73317885e-07, -2.15470406e-07,\n", - " 4.91711267e-08, 1.11269593e-07, -4.26937044e-08,\n", - " -1.86128575e-07, -2.14070642e-07, -1.47656884e-07,\n", - " -8.93218165e-08, -9.35886757e-09, 1.35206696e-07,\n", - " 2.87461097e-07, 3.51993156e-07, 2.32537245e-07,\n", - " 1.60774965e-07, 2.04713568e-07, 3.08541869e-07,\n", - " 2.90892642e-07, 2.93433863e-07, 2.42301512e-07,\n", - " 1.02518824e-07, 6.95122534e-08, 1.91951857e-07,\n", - " 1.29419888e-07, -7.00438170e-08, -1.35923620e-07,\n", - " -1.42971471e-07, -1.42289228e-07, -4.13615068e-08,\n", - " 5.64115130e-08, 1.29904813e-07, 2.10795756e-07,\n", - " 1.88795362e-07, 1.14082276e-07, 2.61978931e-08,\n", - " -2.28488632e-08, -1.12846345e-07, -2.38474732e-07,\n", - " -2.81456641e-07, -2.74899096e-07, -9.95267611e-08,\n", - " 1.31155691e-07, 3.42233074e-07, 5.11480170e-07,\n", - " 6.33651899e-07, 6.29492668e-07, 5.71221579e-07,\n", - " 4.80191464e-07, 2.60756754e-07, -8.36031730e-09,\n", - " -1.07722049e-07, -1.67486179e-07, -2.31938713e-07,\n", - " -3.18197312e-07, -3.20214144e-07, -2.18911518e-07,\n", - " -1.07631163e-07, 4.35535340e-09, 9.73634349e-08,\n", - " 9.48682551e-09, -2.62690473e-08, -7.19613923e-08,\n", - " -2.08782511e-07, -2.02599871e-07, -2.28978340e-07,\n", - " -3.80279634e-07, -3.92481081e-07, -2.32316607e-07,\n", - " -2.01331054e-07, -3.21509270e-07, -4.52587230e-07,\n", - " -3.64860104e-07, -1.95073672e-07, -4.32581544e-08,\n", - " 3.76268092e-08, -7.76459536e-08, -1.42308362e-07,\n", - " -4.10481893e-09, 2.16926974e-07, 1.53687649e-07,\n", - " 1.06774921e-07, 6.36459200e-08, 5.98998617e-08,\n", - " -1.60623089e-08, 8.54603569e-08, 1.16995412e-07,\n", - " 1.21679031e-07, 1.92005671e-07, 2.41701784e-07,\n", - " 6.02873231e-08, -2.91312990e-07, -4.71218862e-07,\n", - " -3.52183897e-07, -2.15410015e-07, -1.35076347e-07,\n", - " -8.62358777e-08, -5.95530598e-08, -3.03487530e-08,\n", - " 8.98456070e-09, -3.20104124e-08, -9.66178108e-08,\n", - " -3.88782259e-07, -6.41902196e-07, -6.68480376e-07,\n", - " -5.54219916e-07, -4.27331681e-07, -2.97937504e-07,\n", - " -2.48852480e-07, -1.43612457e-07, 8.00119796e-08,\n", - " 2.20572580e-07, 1.43064749e-07, 3.75084183e-08,\n", - " -1.07341164e-07, -1.40729815e-07, -1.94001575e-07,\n", - " -1.92580884e-07, -9.88289718e-08, -1.16050675e-07,\n", - " -1.86615891e-07, -1.86427542e-07, -4.54729030e-08,\n", - " 7.93171799e-08, 2.37748242e-07, 3.21543352e-07,\n", - " 4.72589328e-07, 7.19963714e-07, 8.07619686e-07,\n", - " 7.82908257e-07, 5.77874794e-07, 1.71552132e-07,\n", - " -2.18546778e-07, -4.07964589e-07, -3.67413283e-07,\n", - " -3.21461435e-07, -2.51965924e-07, -2.42406748e-07,\n", - " -3.32600951e-07, -4.32792615e-07, -4.44281922e-07,\n", - " -3.81532306e-07, -2.55676704e-07, -2.79632344e-07,\n", - " -3.65262514e-07, -2.75049775e-07, -1.84903407e-07,\n", - " -1.84206814e-07, -1.25358121e-07, -7.17850016e-08,\n", - " -6.69752182e-08]])}]}}}, 'triggered': array([0], dtype=int64)}\n", - "Progress [1.] %\n" - ] - } - ], - "source": [ - "my_lockin.daq.set('device', 'dev3442')\n", - "# my_lockin.daq.set('save/directory', 'C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer')\n", - "my_lockin.daq.set('type', 1)\n", - "my_lockin.daq.set('triggernode', '/dev3442/demods/0/sample.AuxIn0')\n", - "my_lockin.daq.set('endless', 0)\n", - "my_lockin.daq.set('grid/cols', 1000)\n", - "# my_lockin.daq.subscribe('/dev3442/demods/0/sample.R.avg')\n", - "my_lockin.daq.subscribe('/dev3442/demods/0/sample.R')\n", - "my_lockin.daq.subscribe('/dev3442/demods/0/sample.X')\n", - "my_lockin.daq.execute()\n", - "my_lockin.daq.set('forcetrigger', 1)\n", - "result = 0\n", - "while not my_lockin.daq.finished():\n", - " time.sleep(1)\n", - " result = my_lockin.daq.read()\n", - " print(result)\n", - " print(f\"Progress {my_lockin.daq.progress()} %\\r\")" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "94f249a8", - "metadata": {}, - "outputs": [ - { - "ename": "RuntimeError", - "evalue": "Timeout during set in dataAcquisitionModule module.", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mRuntimeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_12728\\3516131054.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mwhile\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mmy_lockin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfinished\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmy_lockin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Progress {my_lockin.daq.progress()} %\\r\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mRuntimeError\u001b[0m: Timeout during set in dataAcquisitionModule module." - ] - } - ], - "source": [ - "while not my_lockin.daq.finished():\n", - " time.sleep(1)\n", - " result = my_lockin.daq.read()\n", - " print(result)\n", - " print(f\"Progress {my_lockin.daq.progress()} %\\r\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "79514940", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "4b9be78c", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.finish()\n", - "my_lockin.daq.unsubscribe('*')" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "60433d76", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.clear()" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "id": "3a268246", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(270)\u001b[0;36marm_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 268 \u001b[1;33m \u001b[0mdemod\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_get_demod\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 269 \u001b[1;33m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 270 \u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mapi_session\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'/{self.serial}/{demod}/enable'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 271 \u001b[1;33m \u001b[1;32mexcept\u001b[0m \u001b[0mRuntimeError\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 272 \u001b[1;33m \u001b[1;32mraise\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> self.api_session.setInt('/dev3442/demods/0/enable', 0)\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7a251206", + "id": "94e01138", "metadata": {}, "outputs": [], "source": [] @@ -6211,7 +1551,7 @@ { "cell_type": "code", "execution_count": null, - "id": "aee44ece", + "id": "eb3982ba", "metadata": {}, "outputs": [], "source": [] @@ -6219,7 +1559,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ab4f5c02", + "id": "0c875430", "metadata": {}, "outputs": [], "source": [] @@ -6227,7 +1567,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c3e129c7", + "id": "4ae8bf57", "metadata": {}, "outputs": [], "source": [] @@ -6235,7 +1575,7 @@ { "cell_type": "code", "execution_count": null, - "id": "cc7cf2f4", + "id": "bef6b06c", "metadata": {}, "outputs": [], "source": [] diff --git a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb index 611b9079d..02988cc55 100644 --- a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb +++ b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb @@ -5,16 +5,34 @@ "id": "6b0bdb5f", "metadata": {}, "source": [ - "# Zurich Instruments Lock-In MFLI Data Aquesition" + "# Zurich Instruments Lock-In MFLI Data Acquisition" + ] + }, + { + "cell_type": "markdown", + "id": "d11c4c6c", + "metadata": {}, + "source": [ + "This notebook was used to develop the qupulse MFLI driver and is now intended as a documentation with examples." ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 131, "id": "37894582", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ + "# this function let's jupyter/ipython reload changes made in the source code automatically.\n", "%load_ext autoreload\n", "%autoreload 2" ] @@ -51,41 +69,30 @@ }, { "cell_type": "code", - "execution_count": 5, - "id": "624c2d4f", + "execution_count": 6, + "id": "76ba4dc7", "metadata": {}, "outputs": [], "source": [ - "from zhinst import ziPython as zhinst_core" + "import qupulse" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "76ba4dc7", + "execution_count": 146, + "id": "65986db0", "metadata": {}, "outputs": [], "source": [ - "import qupulse" + "from qupulse.hardware.dacs.mfli import MFLIDAQ" ] }, { - "cell_type": "code", - "execution_count": 7, - "id": "65986db0", + "cell_type": "markdown", + "id": "cdcb0f9d", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\awgs\\tektronix.py:13: UserWarning: Could not import Tektronix driver backend. If you wish to use it execute qupulse.hardware.awgs.install_requirements('tektronix')\n", - " warnings.warn(\"Could not import Tektronix driver backend. \"\n" - ] - } - ], "source": [ - "from qupulse.hardware.dacs.mfli import MFLIDAQ" + "Now we instantiate the MFLIDAQ instance. This object contains all functions necessary to work with qupulse. At this point, it only get information about how to talk to the device, there are not functional settings passed (other then resetting the device if ```reset=True``` is given.)." ] }, { @@ -98,6 +105,14 @@ "my_lockin = MFLIDAQ(device_serial=\"dev3442\", device_interface=\"PCIe\", data_server_addr=\"192.168.53.202\")" ] }, + { + "cell_type": "markdown", + "id": "4e5e5266", + "metadata": {}, + "source": [ + "With ```my_lockin.api_session``` the the zhinst API session for that driver instance is addressed. In the following cell, this is done to set the debug log level to the lowest level, logging everything. Thing will then be logged into the terminal where the jupyter notebook is running and into some file, whose path is stated in the terminal after calling the command. " + ] + }, { "cell_type": "code", "execution_count": 9, @@ -108,6 +123,22 @@ "my_lockin.api_session.setDebugLevel(0)" ] }, + { + "cell_type": "markdown", + "id": "41396548", + "metadata": {}, + "source": [ + "In the following, we will set the default settings of the device. It is recommended to also set all the other important settings here. E.g. the reference oscillator frequency and amplitude." + ] + }, + { + "cell_type": "markdown", + "id": "6e9a76ba", + "metadata": {}, + "source": [ + "If the API does not allow for querying a sample rate for a certain gate, then ether the ```assumed_minimal_sample_rate``` is used (if not None) or the first demodulator is activated. This is done to have some sample rate to set the number of samples to record for certain measurement. The measurements define the regions to measure in units of nano seconds." + ] + }, { "cell_type": "code", "execution_count": 10, @@ -119,6 +150,14 @@ "my_lockin.assumed_minimal_sample_rate = None" ] }, + { + "cell_type": "markdown", + "id": "3d273882", + "metadata": {}, + "source": [ + "qupulse allows for defining multiple measurement windows for one measurement. The windows are identified by their name, a string. To set which channels to record in which window, the following dict is created. There the key defines the string for the window and the list for that key defined the paths that are to be measured. Internally the device name is added in front. One can measure multiple channels in one window." + ] + }, { "cell_type": "code", "execution_count": 11, @@ -135,6 +174,14 @@ "}" ] }, + { + "cell_type": "markdown", + "id": "a12e287d", + "metadata": {}, + "source": [ + "When registering these windows, one can give a program name under which these windows are saved. If this name is None, then they are used as a default. When then a other program is called which asks for a measurement window which has not been registered with that program name, then the default settings are used for that window." + ] + }, { "cell_type": "code", "execution_count": 12, @@ -146,6 +193,14 @@ " my_lockin.register_measurement_channel(program_name=None, channel_path=v, window_name=k)" ] }, + { + "cell_type": "markdown", + "id": "e684b4f8", + "metadata": {}, + "source": [ + "Here are the currently saved information for the default program ```None```" + ] + }, { "cell_type": "code", "execution_count": 13, @@ -174,21 +229,38 @@ "my_lockin.programs[None]" ] }, + { + "cell_type": "markdown", + "id": "732bb4a2", + "metadata": {}, + "source": [ + "Now measurement windows are defined. This is usually done by qupulse when registering a program. But one can also to this by hand.\n", + "\n", + "The windows define for which period, after the beginning of the pulse, some data is to be returned. The windows are defined by a tuple of two lists, where the first gives the point after the pulse started of when the measurement should start in ns. The second give the duration of this window in ns. One can specify multiple regions for one window by adding multiple entries into these lists. (Here the naming might not be consistent enough. Occasionally the word *mask* is used.)\n", + "\n", + "It is noteworthy that, in the current qupulse implementation, the point in them when a trigger signal is send to the measurement device has the managed by the user and is not checked to be at the correct point in time. So per default this signal is expected to be send out at the beginning of the pulse, and then the measurement equipment will measure the cover all windows (the duration is extracted from the defined windows.). But one can play tricks with that. But one needs to be careful. " + ] + }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 132, "id": "bc46a01c", "metadata": {}, "outputs": [], "source": [ - "my_lockin.register_measurement_windows(program_name=\"test\", windows={\"A\": (np.array([0, 3])*1, np.array([1, 10])*1), \"many\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)})" + "my_lockin.register_measurement_windows(program_name=\"test\", windows={\n", + " \"A\": (np.array([0, 3])*1, np.array([1, 10])*1), \n", + " \"many\": (np.array([0, 2, 4])*1e-3, np.array([1, 4, 6.1])*1e-3)\n", + " })" ] }, { "cell_type": "code", "execution_count": 15, "id": "f45534ef", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { @@ -219,6 +291,14 @@ "my_lockin.programs" ] }, + { + "cell_type": "markdown", + "id": "9a22699a", + "metadata": {}, + "source": [ + "Ok, now that we have registered a program, we can delete it." + ] + }, { "cell_type": "code", "execution_count": 16, @@ -273,6 +353,16 @@ "## Defining a simple qupulse pulse with a measurement window." ] }, + { + "cell_type": "markdown", + "id": "a3bc5453", + "metadata": {}, + "source": [ + "Now we will define a simple pulse.\n", + "\n", + "Here only the measurement related stuff is commented. Later things get more interesting again." + ] + }, { "cell_type": "code", "execution_count": 18, @@ -330,6 +420,14 @@ " measurements=[('A', \"dt*3\", \"dt*1.5\"), ('A', \"dt*12\", \"dt*3\"), ('R', \"dt*6.5\", \"dt*1.4\"), ('R', \"dt*14\", \"dt*1\"), ('T', \"dt*10\", \"dt*3\")])" ] }, + { + "cell_type": "markdown", + "id": "97c66abd", + "metadata": {}, + "source": [ + "As one sees in the prior cell, one can also specify measurement windows with variables." + ] + }, { "cell_type": "code", "execution_count": 22, @@ -373,23 +471,35 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 142, "id": "eeeee0ec", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\site-packages\\ipykernel_launcher.py:1: DeprecationWarning: This is only a hack until https://github.com/qutech/qupulse/issues/578 is resolved. Do not call this method directly\n", + " \"\"\"Entry point for launching an IPython kernel.\n" + ] + }, { "data": { "text/plain": [ - "" + "[('A', 300000000.0, 150000000.0),\n", + " ('A', 1200000000.0, 300000000.0),\n", + " ('R', 650000000.0, 140000000.0),\n", + " ('R', 1400000000.0, 100000000.0),\n", + " ('T', 1000000000.0, 300000000.0)]" ] }, - "execution_count": 24, + "execution_count": 142, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "combined_pulse.get_measurement_windows" + "combined_pulse.get_measurement_windows(parameters={\"dt\": 1e8}, measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"T\"})" ] }, { @@ -476,11 +586,61 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "f5280e48", + "execution_count": 138, + "id": "d5c5f40f", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "{'A', 'R', 'T'}" + ] + }, + "execution_count": 138, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rep.measurement_names" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "id": "c547473f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 136, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rep.get_measurement_windows(parameters={\"dt\": 1e8}, measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"T\"})" + ] + }, + { + "cell_type": "markdown", + "id": "3bd81101", + "metadata": {}, + "source": [ + "(When writing this documentation the prior cell did not return the expected measurement windows, but an empty list. When compiling that pulse and registering the program, the correct windows are written into the driver's memory.)" + ] + }, + { + "cell_type": "markdown", + "id": "b23c7772", + "metadata": {}, + "source": [ + "For repetitions like this, all windows are defined in relation to the beginning of the total pulse, when one want to trigger that more elegantly, which might be the case if there are long duration in which one might not want to measure, one might need to become a bit creative. One solution would be to only define the first set of measurement windows, then let the trigger trigger the lock-in on every iteration of the pulse's loop, and then when defining the trigger settings later, allow for multiple triggers. Then the driver takes the windows with respect to the corresponding trigger. " + ] }, { "cell_type": "markdown", @@ -523,6 +683,14 @@ "from qupulse.hardware.setup import HardwareSetup, MeasurementMask, PlaybackChannel" ] }, + { + "cell_type": "markdown", + "id": "d4514092", + "metadata": {}, + "source": [ + "As we also have a pulse, that contains some outputs, a virtual awg is used." + ] + }, { "cell_type": "code", "execution_count": 32, @@ -533,6 +701,14 @@ "my_awg = VirtualAWG(\"awg\", channels=3)" ] }, + { + "cell_type": "markdown", + "id": "4146568f", + "metadata": {}, + "source": [ + "The ```HardwareSetup``` is the central qupulse object that contains all devices for this setup. " + ] + }, { "cell_type": "code", "execution_count": 33, @@ -543,6 +719,14 @@ "setup = HardwareSetup()" ] }, + { + "cell_type": "markdown", + "id": "dd09864c", + "metadata": {}, + "source": [ + "We now register the link between the measurement window names and the drivers measurement window names. Similarly for the playback channels (i.e. outputs). " + ] + }, { "cell_type": "code", "execution_count": 34, @@ -565,6 +749,14 @@ " setup.set_channel(f\"{c}\", PlaybackChannel(my_awg, i))" ] }, + { + "cell_type": "markdown", + "id": "8b1d4e21", + "metadata": {}, + "source": [ + "Now the pulses are compiled into programs. This contains the measurement mapping and the parameters. When a measurement window is mapped to ```None``` it is omitted." + ] + }, { "cell_type": "code", "execution_count": 67, @@ -572,17 +764,35 @@ "metadata": {}, "outputs": [], "source": [ - "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"},parameters={\"dt\": 1e6})" + "test_program = combined_pulse.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"}, parameters={\"dt\": 1e6})" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "b3d52873", + "metadata": {}, + "outputs": [], + "source": [ + "test_rep_program = rep.create_program(measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"X\"}, parameters={\"dt\": 1e6})" ] }, { "cell_type": "code", "execution_count": 112, - "id": "d02ed4aa", + "id": "e35f0e2f", "metadata": {}, "outputs": [], "source": [ - "test_program_single = combined_pulse.create_program(measurement_mapping={\"A\":None, \"R\":\"R\", \"T\":None},parameters={\"dt\": 1e6})" + "test_program_single = combined_pulse.create_program(measurement_mapping={\"A\":None, \"R\":\"R\", \"T\":None}, parameters={\"dt\": 1e6})" + ] + }, + { + "cell_type": "markdown", + "id": "965a3992", + "metadata": {}, + "source": [ + "a helper function for plotting the returned data. The measured data can also be returned in a raw format, where the data is not cropped to the measurement windows. For that call ```my_lockin.measure_program(return_raw=True)```." ] }, { @@ -604,16 +814,30 @@ { "cell_type": "code", "execution_count": 38, - "id": "cd8f83e8", + "id": "176c260b", "metadata": {}, "outputs": [], "source": [ "import numpy as np" ] }, + { + "cell_type": "markdown", + "id": "564e8107", + "metadata": {}, + "source": [ + "Now we will register the trigger settings for the lock-in. They are program specific. \n", + "Also the devices name is added to the ```trigger_input``` strings. \n", + "The zurich instruments lock-ins have a funny naming convention, where the AUXIN inputs start at 0 and the TRUGINs at 1.\n", + "\n", + "Inside the driver, some input specific things are set regarding if certain strings are present in the ```trigger_input``` path. The parameters in ```other_settings``` are set after all the other trigger specific things and thus can be used to set more things. If the count is set to np.inf, the acquisition will only finish, if ```my_lockin.stop_acquisition()``` is called. The ```measure_program``` can be called such that is waits for the daq to finish the acquisition, or to already read what had been recorded, or to return partial measurements.\n", + "\n", + "For further information, see to the doc-string of that function." + ] + }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 143, "id": "d0c8669f", "metadata": {}, "outputs": [], @@ -623,20 +847,29 @@ " edge=\"rising\",\n", " trigger_count=3, # this defines the number of triggers to capture in one element (i.e. rows)\n", " level=.5, # this sets the trigger level\n", - " count=np.inf, # this defined the number of rounds that are to be measured (e.g. how often the \"single\" button should be pressed)\n", + " measurement_count=np.inf, # this defined the number of rounds that are to be measured (e.g. how often the \"single\" button should be pressed)\n", " other_settings={\"holdoff/time\": 1e-3} # this sets the duration for which new triggers are ignored\n", " )\n", "\n", + "# this will overwrite the earlier set settings\n", "my_lockin.register_trigger_settings(program_name=\"test\",\n", - " trigger_input=f\"demods/0/sample.TrigIn1\", # here TrigInN referese to the printer label N\n", + " trigger_input=f\"demods/0/sample.TrigIn1\", # here TrigInN referrers to the printer label N\n", " edge=\"rising\",\n", " trigger_count=3,\n", " level=.5,\n", - " count=3,\n", + " measurement_count=3,\n", " other_settings={\"holdoff/time\": 1e-3}\n", " )" ] }, + { + "cell_type": "markdown", + "id": "5e6a3516", + "metadata": {}, + "source": [ + "And now the program is going to be registered. The run_callback is the function call that is called when the ```setup.run_program(program_name_goes_here)``` function is called. If one want to trigger the lock-in via software, one can call ```my_lockin.force_trigger()``` here." + ] + }, { "cell_type": "code", "execution_count": 69, @@ -646,20 +879,102 @@ }, "outputs": [], "source": [ - "# setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(None), update=True)\n", + "# setup.register_program('test', test_program, run_callback=lambda *a, **b: my_lockin.force_trigger(), update=True)\n", "setup.register_program('test', test_program, run_callback=lambda *a, **b: None, update=True)" ] }, + { + "cell_type": "code", + "execution_count": 140, + "id": "b037496c", + "metadata": {}, + "outputs": [], + "source": [ + "setup.register_program('test_rep', test_rep_program, run_callback=lambda *a, **b: None, update=True)" + ] + }, + { + "cell_type": "markdown", + "id": "9c3f8ac9", + "metadata": {}, + "source": [ + "And after that call, the lock-in is armed and the settings should have been updated. If one does not want the settings to update every time, one can set the ```self.force_update_on_arm``` field to ```False```. Within the update call, the sample rate is queried and the window dimensions are updated. Only later in the read call the information is applied and the data is then cropped (but it is not checked if the selected program is the one corresponding to the retrieved data)." + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "id": "d38e253f", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'windows': {'X': (array([1.0e+07, 3.0e+07, 5.0e+07, 7.0e+07, 9.0e+07, 1.1e+08, 1.3e+08,\n", + " 1.5e+08, 1.7e+08, 1.9e+08]),\n", + " array([3000000., 3000000., 3000000., 3000000., 3000000., 3000000.,\n", + " 3000000., 3000000., 3000000., 3000000.])),\n", + " 'R': (array([6.500e+06, 1.400e+07, 2.650e+07, 3.400e+07, 4.650e+07, 5.400e+07,\n", + " 6.650e+07, 7.400e+07, 8.650e+07, 9.400e+07, 1.065e+08, 1.140e+08,\n", + " 1.265e+08, 1.340e+08, 1.465e+08, 1.540e+08, 1.665e+08, 1.740e+08,\n", + " 1.865e+08, 1.940e+08]),\n", + " array([1400000., 1000000., 1400000., 1000000., 1400000., 1000000.,\n", + " 1400000., 1000000., 1400000., 1000000., 1400000., 1000000.,\n", + " 1400000., 1000000., 1400000., 1000000., 1400000., 1000000.,\n", + " 1400000., 1000000.])),\n", + " 'A': (array([3.00e+06, 1.20e+07, 2.30e+07, 3.20e+07, 4.30e+07, 5.20e+07,\n", + " 6.30e+07, 7.20e+07, 8.30e+07, 9.20e+07, 1.03e+08, 1.12e+08,\n", + " 1.23e+08, 1.32e+08, 1.43e+08, 1.52e+08, 1.63e+08, 1.72e+08,\n", + " 1.83e+08, 1.92e+08]),\n", + " array([1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", + " 1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", + " 1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", + " 1500000., 3000000.]))},\n", + " 'windows_from_start_max': {'X': 193000000.0,\n", + " 'R': 195000000.0,\n", + " 'A': 195000000.0},\n", + " 'all_channels': {'auxins/0/sample.auxin0.avg',\n", + " 'demods/0/sample.r',\n", + " 'demods/0/sample.x'}}" + ] + }, + "execution_count": 141, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.programs[\"test_rep\"]" + ] + }, + { + "cell_type": "markdown", + "id": "710102b3", + "metadata": {}, + "source": [ + "As also incomplete data is returned, when the driver asks the lock-in for new data and the lock-in (or the data server) deletes the returned data, some form of memory is needed to peace data from different calls together. This is done in the ```my_lockin.read_memory``` field. If the programs are changed, and as things are not tracked in that regard, one might need to clear that ever so often. This can be done using ```my_lockin.clear_memory()```." + ] + }, { "cell_type": "code", "execution_count": 89, - "id": "0e0ddc37", + "id": "060a1a4c", "metadata": {}, "outputs": [], "source": [ "my_lockin.read_memory = {}" ] }, + { + "cell_type": "markdown", + "id": "0ecd69a6", + "metadata": {}, + "source": [ + "And now the program is run:" + ] + }, { "cell_type": "code", "execution_count": 88, @@ -690,6 +1005,14 @@ "setup.run_program(\"test\")" ] }, + { + "cell_type": "markdown", + "id": "358f204c", + "metadata": {}, + "source": [ + "For testing purposes the following two cells contain different ways to trigger things. The first using force_trigger calls. And the second using the auxiliary output, which is connected to the earlier specified trigger input using a coaxial cable." + ] + }, { "cell_type": "code", "execution_count": 79, @@ -717,8 +1040,16 @@ ] }, { - "cell_type": "code", - "execution_count": 85, + "cell_type": "markdown", + "id": "5ae3314c", + "metadata": {}, + "source": [ + "The ```stop_acquisition()``` is called to stop the acquisition when the count in the trigger_count configuration is set to np.inf." + ] + }, + { + "cell_type": "code", + "execution_count": 85, "id": "8ab20ee5", "metadata": {}, "outputs": [], @@ -726,6 +1057,14 @@ "my_lockin.stop_acquisition()" ] }, + { + "cell_type": "markdown", + "id": "cf3104cc", + "metadata": {}, + "source": [ + "And then we read some data back from the device." + ] + }, { "cell_type": "code", "execution_count": 99, @@ -766,10 +1105,18 @@ " print(\"RETURNED NONE\")" ] }, + { + "cell_type": "markdown", + "id": "1ec2e091", + "metadata": {}, + "source": [ + "and here a different measurement, left in this notebook." + ] + }, { "cell_type": "code", "execution_count": 111, - "id": "dfc88289", + "id": "066a4fe1", "metadata": {}, "outputs": [ { @@ -821,7 +1168,7 @@ { "cell_type": "code", "execution_count": 108, - "id": "d34c362a", + "id": "e7af816c", "metadata": {}, "outputs": [ { @@ -1051,23 +1398,23 @@ { "cell_type": "code", "execution_count": null, - "id": "e0279a45", + "id": "b715a334", "metadata": {}, "outputs": [], "source": [] }, { - "cell_type": "code", - "execution_count": null, - "id": "6d96d4b0", + "cell_type": "markdown", + "id": "b0b4daa3", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "And now, let's look at again a different program" + ] }, { "cell_type": "code", "execution_count": 116, - "id": "00f4e282", + "id": "1ac65d7f", "metadata": {}, "outputs": [], "source": [ @@ -1078,7 +1425,7 @@ { "cell_type": "code", "execution_count": 117, - "id": "28689c4e", + "id": "fe7ace96", "metadata": { "scrolled": true }, @@ -1091,7 +1438,7 @@ { "cell_type": "code", "execution_count": 118, - "id": "d5934ebe", + "id": "be1c9ade", "metadata": {}, "outputs": [], "source": [ @@ -1108,7 +1455,7 @@ { "cell_type": "code", "execution_count": 119, - "id": "ad0ed003", + "id": "58dee40c", "metadata": {}, "outputs": [ { @@ -1130,7 +1477,7 @@ { "cell_type": "code", "execution_count": 129, - "id": "46a571d7", + "id": "dc4dc54f", "metadata": {}, "outputs": [], "source": [ @@ -1144,7 +1491,7 @@ { "cell_type": "code", "execution_count": 130, - "id": "57df3ce1", + "id": "d206d097", "metadata": {}, "outputs": [ { @@ -1196,5014 +1543,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c894793c", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "23d79a08", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e61a3cf1", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "453ec743", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a1eae59e", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d8716e9b", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "15826bae", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 88, - "id": "cc324843", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[-0.0005597 , -0.000469 , -0.0003783 , ..., -0.00186879,\n", - " -0.00185745, -0.00184611],\n", - " [-0.00098405, -0.00088201, -0.00077997, ..., -0.0012212 ,\n", - " -0.00115317, -0.00108514],\n", - " [-0.00097637, -0.00101038, -0.0010444 , ..., -0.00090118,\n", - " -0.0008785 , -0.00085583]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886364795117]\n", - " createdtimestamp: [1091745849803]\n", - " changedtimestamp: [1091986551243]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 024 14:26:04.7949\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[-8.42900002e-04, -8.65575612e-04, -8.88251222e-04, ...,\n", - " -2.31813318e-03, -2.37482220e-03, -2.43151123e-03],\n", - " [-7.22152379e-05, -3.82018229e-05, -4.18840788e-06, ...,\n", - " -1.90278484e-03, -1.86877143e-03, -1.83475801e-03],\n", - " [-8.78525512e-04, -8.89863317e-04, -9.01201122e-04, ...,\n", - " -9.62771983e-04, -1.00812320e-03, -1.05347442e-03]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886370722229]\n", - " createdtimestamp: [1092107045323]\n", - " changedtimestamp: [1092347961803]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 025 14:26:10.7220\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[-1.87361530e-03, -1.81692628e-03, -1.76023725e-03, ...,\n", - " -2.81537691e-03, -2.87206594e-03, -2.92875496e-03],\n", - " [-1.33956419e-03, -1.46428005e-03, -1.58899590e-03, ...,\n", - " -2.70161419e-03, -2.66760077e-03, -2.63358736e-03],\n", - " [-1.73439819e-03, -1.79108722e-03, -1.84777624e-03, ...,\n", - " 1.23551705e-05, 8.03820006e-05, 1.48408831e-04]])\n", - " Coordinates:\n", - " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886376646618]\n", - " createdtimestamp: [1092468384203]\n", - " changedtimestamp: [1092709085643]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 026 14:26:16.6464\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.r': [\n", - " array([[3.67919224e-07, 2.83155155e-07, 1.98424922e-07, ...,\n", - " 3.46452632e-07, 8.21098062e-07, 9.25034948e-07],\n", - " [1.96074040e-07, 2.21383078e-07, 4.68834272e-07, ...,\n", - " 9.52262078e-07, 4.83415782e-07, 5.52015728e-07],\n", - " [3.55882336e-07, 3.27200774e-07, 4.19314029e-07, ...,\n", - " 2.92538330e-07, 5.21568235e-07, 5.05150107e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886364795192]\n", - " createdtimestamp: [1091745849803]\n", - " changedtimestamp: [1091986551243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 024 14:26:04.7949\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[2.92395192e-07, 2.25222683e-07, 1.21325519e-07, ...,\n", - " 5.39336686e-07, 3.84301196e-07, 3.74622534e-07],\n", - " [3.05529466e-07, 9.36520953e-08, 3.03995805e-07, ...,\n", - " 1.02236696e-06, 9.93392222e-07, 5.19542514e-07],\n", - " [3.01692648e-07, 3.83754234e-07, 2.70232334e-07, ...,\n", - " 5.81183641e-07, 6.24799778e-07, 4.31362127e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886370722270]\n", - " createdtimestamp: [1092107045323]\n", - " changedtimestamp: [1092347961803]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 025 14:26:10.7220\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[7.93975965e-07, 8.93030872e-07, 1.23001589e-06, ...,\n", - " 3.67492049e-07, 2.34827369e-07, 2.35706276e-07],\n", - " [3.61742908e-07, 4.48546210e-07, 2.31477247e-07, ...,\n", - " 5.86607223e-07, 5.45344640e-07, 3.19530491e-07],\n", - " [1.80878244e-07, 1.47223775e-07, 1.42378570e-07, ...,\n", - " 1.75339378e-07, 3.28294689e-07, 8.26655524e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886376646657]\n", - " createdtimestamp: [1092468384203]\n", - " changedtimestamp: [1092709085643]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 026 14:26:16.6464\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.trigin1': [\n", - " array([[0., 1., 1., ..., 0., 0., 0.],\n", - " [0., 1., 1., ..., 0., 0., 0.],\n", - " [0., 1., 1., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886364795316]\n", - " createdtimestamp: [1091745849803]\n", - " changedtimestamp: [1091986551243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 024 14:26:04.7949\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 1., 1., ..., 0., 0., 0.],\n", - " [0., 1., 1., ..., 0., 0., 0.],\n", - " [0., 1., 1., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886370722345]\n", - " createdtimestamp: [1092107045323]\n", - " changedtimestamp: [1092347961803]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 025 14:26:10.7220\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 1., 1., ..., 0., 0., 0.],\n", - " [0., 1., 1., ..., 0., 0., 0.],\n", - " [0., 1., 1., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886376646733]\n", - " createdtimestamp: [1092468384203]\n", - " changedtimestamp: [1092709085643]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 026 14:26:16.6464\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.x': [\n", - " array([[ 6.65674270e-08, -1.10711122e-07, -1.75238995e-07, ...,\n", - " 3.00088872e-07, 5.42731804e-07, 6.73676425e-07],\n", - " [ 1.76368493e-07, 2.20327427e-07, -3.09841778e-07, ...,\n", - " 2.28058119e-07, 2.14299053e-07, 3.54935591e-07],\n", - " [-3.51589550e-07, -3.15060548e-07, -3.47898502e-07, ...,\n", - " 1.59659817e-07, 1.15966965e-07, -5.18576454e-08]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 1.82e+13 ... 1.82e+13 1.82e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886364795245]\n", - " createdtimestamp: [1091745849803]\n", - " changedtimestamp: [1091986551243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 024 14:26:04.7949\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[-4.09052830e-08, 2.13295121e-08, 5.33865634e-08, ...,\n", - " -4.00140619e-07, -3.50272899e-07, -3.20757666e-07],\n", - " [-1.21754969e-07, -7.33503936e-08, 2.64174546e-07, ...,\n", - " -1.00753722e-06, -7.90096025e-07, -2.52642785e-07],\n", - " [-2.68055140e-07, -2.78390434e-07, -9.46063598e-08, ...,\n", - " -5.33591780e-07, -5.72202191e-07, -4.30658588e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.82e+13 1.82e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886370722308]\n", - " createdtimestamp: [1092107045323]\n", - " changedtimestamp: [1092347961803]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 025 14:26:10.7220\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[ 1.55824069e-07, 4.11162940e-07, 4.66974725e-07, ...,\n", - " 2.71678622e-07, 2.18573685e-07, -1.56646826e-07],\n", - " [ 3.33768717e-07, 4.47974167e-07, 2.30547319e-07, ...,\n", - " -2.92901103e-07, -1.49833963e-07, 1.35891929e-07],\n", - " [ 1.80673620e-07, 1.28038062e-07, 4.32264639e-08, ...,\n", - " 1.68609698e-07, -3.28192979e-07, -8.26423523e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.821e+13 1.821e+13 ... 1.821e+13 1.821e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886376646697]\n", - " createdtimestamp: [1092468384203]\n", - " changedtimestamp: [1092709085643]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 026 14:26:16.6464\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}" - ] - }, - "execution_count": 88, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "id": "20bb0981", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885494031060]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885499560433]\n", - " createdtimestamp: [1039013445533]\n", - " changedtimestamp: [1039023023213]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 002 14:11:39.5600\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886126694424]\n", - " createdtimestamp: [1076950339563]\n", - " changedtimestamp: [1077288735243]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 019 14:22:06.6936\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.r': [\n", - " array([[ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [3.83335709e-07, 3.83594719e-07, 3.83857600e-07, ...,\n", - " nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885494088087]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885499593310]\n", - " createdtimestamp: [1039013445533]\n", - " changedtimestamp: [1039023023213]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 002 14:11:39.5600\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[8.60182422e-08, 8.74794163e-08, 8.90240508e-08, ...,\n", - " nan, nan, nan],\n", - " [6.62406884e-08, 6.46201620e-08, 6.30831144e-08, ...,\n", - " nan, nan, nan],\n", - " [5.27267604e-07, 5.28614361e-07, 5.30040283e-07, ...,\n", - " nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886126698076]\n", - " createdtimestamp: [1076950339563]\n", - " changedtimestamp: [1077288735243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 019 14:22:06.6936\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.trigin1': [\n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885489547296]\n", - " createdtimestamp: [1038982525553]\n", - " changedtimestamp: [1038993876613]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 000 14:11:29.2195\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [ 0., 0., 0., ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885494168868]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885499657769]\n", - " createdtimestamp: [1039013445533]\n", - " changedtimestamp: [1039023023213]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 002 14:11:39.5600\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.747e+13 1.747e+13 ... 1.748e+13 1.748e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885639072999]\n", - " createdtimestamp: [1048217067723]\n", - " changedtimestamp: [1048455009483]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 003 14:13:59.0712\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.748e+13 1.748e+13 ... 1.748e+13 1.748e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885644955400]\n", - " createdtimestamp: [1048575557323]\n", - " changedtimestamp: [1048816518603]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 004 14:14:04.9542\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.748e+13 1.748e+13 ... 1.749e+13 1.749e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885651071285]\n", - " createdtimestamp: [1048934683083]\n", - " changedtimestamp: [1049175017163]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 005 14:14:11.0700\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.762e+13 1.762e+13 ... 1.763e+13 1.763e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885791762410]\n", - " createdtimestamp: [1057372530123]\n", - " changedtimestamp: [1057611081163]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 006 14:16:31.7604\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.763e+13 1.763e+13 ... 1.763e+13 1.763e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885797604338]\n", - " createdtimestamp: [1057731646923]\n", - " changedtimestamp: [1057971963083]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 007 14:16:37.5946\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.763e+13 1.763e+13 ... 1.764e+13 1.764e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885803622668]\n", - " createdtimestamp: [1058092555723]\n", - " changedtimestamp: [1058331088843]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 008 14:16:43.6214\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.77e+13 1.77e+13 ... 1.771e+13 1.771e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885871598865]\n", - " createdtimestamp: [1062162716363]\n", - " changedtimestamp: [1062400613323]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 009 14:17:51.5969\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.771e+13 1.771e+13 ... 1.771e+13 1.771e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885877429641]\n", - " createdtimestamp: [1062521824203]\n", - " changedtimestamp: [1062762167243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 010 14:17:57.4282\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.771e+13 1.771e+13 ... 1.772e+13 1.772e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885883413040]\n", - " createdtimestamp: [1062882741963]\n", - " changedtimestamp: [1063120674763]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 011 14:18:03.4118\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.782e+13 1.782e+13 ... 1.782e+13 1.782e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885985636933]\n", - " createdtimestamp: [1069007968203]\n", - " changedtimestamp: [1069245453003]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 012 14:19:45.6351\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.782e+13 1.782e+13 ... 1.783e+13 1.783e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885991611307]\n", - " createdtimestamp: [1069365866443]\n", - " changedtimestamp: [1069607607243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 013 14:19:51.6101\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.783e+13 1.783e+13 ... 1.783e+13 1.783e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885997735588]\n", - " createdtimestamp: [1069727993803]\n", - " changedtimestamp: [1069966114763]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 014 14:19:57.7343\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.789e+13 1.789e+13 ... 1.79e+13 1.79e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886060607309]\n", - " createdtimestamp: [1073499831243]\n", - " changedtimestamp: [1073737351883]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 015 14:21:00.6054\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.79e+13 1.79e+13 1.79e+13 ... 1.79e+13 1.79e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886066623023]\n", - " createdtimestamp: [1073858338763]\n", - " changedtimestamp: [1074098852043]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 016 14:21:06.6218\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.],\n", - " [0., 0., 0., ..., 0., 0., 0.]])\n", - " Coordinates:\n", - " time (row, col) float64 1.79e+13 1.79e+13 ... 1.791e+13 1.791e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886072592296]\n", - " createdtimestamp: [1074219838923]\n", - " changedtimestamp: [1074457977803]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 017 14:21:12.5911\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [10045]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00014933]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[ 0., 0., 0., ..., nan, nan, nan],\n", - " [ 0., 0., 0., ..., nan, nan, nan],\n", - " [ 0., 0., 0., ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886120155827]\n", - " createdtimestamp: [1076891918123]\n", - " changedtimestamp: [1076929715883]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 018 14:22:00.1345\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[ 0., 0., 0., ..., nan, nan, nan],\n", - " [ 0., 0., 0., ..., nan, nan, nan],\n", - " [ 0., 0., 0., ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886126705825]\n", - " createdtimestamp: [1076950339563]\n", - " changedtimestamp: [1077288735243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 019 14:22:06.6936\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[ 0., 0., 0., ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 1.796e+13 1.796e+13 1.796e+13 ... 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886132860354]\n", - " createdtimestamp: [1077609510523]\n", - " changedtimestamp: [1077652213403]\n", - " flags: [1848]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 020 14:22:12.8482\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.x': [\n", - " array([[ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [-3.79128012e-07, -3.79368980e-07, -3.79612937e-07, ...,\n", - " nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885494133030]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664885499625269]\n", - " createdtimestamp: [1039013445533]\n", - " changedtimestamp: [1039023023213]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 002 14:11:39.5600\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[ 5.15736266e-08, 5.26349600e-08, 5.37237984e-08, ...,\n", - " nan, nan, nan],\n", - " [-6.12978321e-08, -5.92433298e-08, -5.72438376e-08, ...,\n", - " nan, nan, nan],\n", - " [-4.08640255e-08, -3.73170793e-08, -3.38018236e-08, ...,\n", - " nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 1.795e+13 1.795e+13 1.795e+13 ... 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886126701691]\n", - " createdtimestamp: [1076950339563]\n", - " changedtimestamp: [1077288735243]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 019 14:22:06.6936\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}" - ] - }, - "execution_count": 77, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.read_memory" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "id": "974e560e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[{'X': {'/dev3442/demods/0/sample.x': [\n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886120147957]\n", - " createdtimestamp: [1076891918123]\n", - " changedtimestamp: [1076929715883]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 018 14:22:00.1345\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]},\n", - " 'R': {'/dev3442/demods/0/sample.r': [\n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886120141796]\n", - " createdtimestamp: [1076891918123]\n", - " changedtimestamp: [1076929715883]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 018 14:22:00.1345\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886120141796]\n", - " createdtimestamp: [1076891918123]\n", - " changedtimestamp: [1076929715883]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 018 14:22:00.1345\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]},\n", - " 'A': {'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[-0.00221065, -0.00221092, -0.00221119, ..., -0.00150499,\n", - " -0.00150526, -0.00150552]])\n", - " Coordinates:\n", - " time (row, col) float64 3e+08 3e+08 3e+08 ... 4.5e+08 4.5e+08 4.5e+08\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886120135151]\n", - " createdtimestamp: [1076891918123]\n", - " changedtimestamp: [1076929715883]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 018 14:22:00.1345\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886120135151]\n", - " createdtimestamp: [1076891918123]\n", - " changedtimestamp: [1076929715883]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 018 14:22:00.1345\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}},\n", - " {'X': {'/dev3442/demods/0/sample.x': [\n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886132856158]\n", - " createdtimestamp: [1077609510523]\n", - " changedtimestamp: [1077652213403]\n", - " flags: [1848]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 020 14:22:12.8482\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]},\n", - " 'R': {'/dev3442/demods/0/sample.r': [\n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886132852379]\n", - " createdtimestamp: [1077609510523]\n", - " changedtimestamp: [1077652213403]\n", - " flags: [1848]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 020 14:22:12.8482\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([], shape=(0, 0), dtype=float64)\n", - " Coordinates:\n", - " time (row, col) float64 \n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886132852379]\n", - " createdtimestamp: [1077609510523]\n", - " changedtimestamp: [1077652213403]\n", - " flags: [1848]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 020 14:22:12.8482\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]},\n", - " 'A': {'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[-0.00127274, -0.00127318, -0.00127363, ..., -0.00089014,\n", - " -0.00088996, -0.00088978]])\n", - " Coordinates:\n", - " time (row, col) float64 3e+08 3e+08 3e+08 ... 4.5e+08 4.5e+08 4.5e+08\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886132848581]\n", - " createdtimestamp: [1077609510523]\n", - " changedtimestamp: [1077652213403]\n", - " flags: [824]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 020 14:22:12.8482\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[-0.00359344, -0.00359255, -0.00359166, ..., -0.00202245,\n", - " -0.00202272, -0.00202298]])\n", - " Coordinates:\n", - " time (row, col) float64 1.2e+09 1.2e+09 1.2e+09 ... 1.5e+09 1.5e+09\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664886132848581]\n", - " createdtimestamp: [1077609510523]\n", - " changedtimestamp: [1077652213403]\n", - " flags: [824]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 020 14:22:12.8482\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [160715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}}]" - ] - }, - "execution_count": 75, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "c29511b9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m(1160)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 1158 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__getitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1159 \u001b[1;33m \u001b[0marray\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_indexing_array_and_key\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m-> 1160 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0marray\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1161 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1162 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\variable.py\u001b[0m(786)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 784 \u001b[1;33m \"\"\"\n", - "\u001b[0m\u001b[1;32m 785 \u001b[1;33m \u001b[0mdims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexer\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnew_order\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_broadcast_indexes\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 786 \u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mas_indexable\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_data\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 787 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mnew_order\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 788 \u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmoveaxis\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnew_order\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnew_order\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\variable.py\u001b[0m(1193)\u001b[0;36misel\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 1191 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1192 \u001b[1;33m \u001b[0mkey\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtuple\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdim\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mslice\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mdim\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdims\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m-> 1193 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1194 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1195 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0msqueeze\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> uu\n", - "*** NameError: name 'uu' is not defined\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(1208)\u001b[0;36misel\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 1206 \u001b[1;33m \u001b[1;31m# lists, or zero or one-dimensional np.ndarray's\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1207 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m-> 1208 \u001b[1;33m \u001b[0mvariable\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_variable\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmissing_dims\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmissing_dims\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1209 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1210 \u001b[1;33m \u001b[0mcoords\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(745)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 743 \u001b[1;33m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 744 \u001b[1;33m \u001b[1;31m# xarray-style array indexing\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 745 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_item_key_to_dict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 746 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 747 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mAny\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mAny\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(593)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 591 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ml\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0m_wind\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 592 \u001b[1;33m \u001b[1;31m# _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)[\"time\"][:, 0].values\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 593 \u001b[1;33m \u001b[0m_time_of_first_not_nan_value\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mapplicable_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"time\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 594 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 595 \u001b[1;33m \u001b[0mtime_of_trigger\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mapplicable_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mattrs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"gridcoloffset\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m1e9\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0m_time_of_first_not_nan_value\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(735)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 733 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 734 \u001b[1;33m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 735 \u001b[1;33m \u001b[0mthat_shot_parsed\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mthat_shot\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcurrently_set_program\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 736 \u001b[1;33m \u001b[1;31m# except KeyError:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 737 \u001b[1;33m \u001b[1;31m# print(f\"Error\")\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> that_shot\n", - "{'/dev3442/demods/0/sample.r': [\n", - "array([[ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [3.83335709e-07, 3.83594719e-07, 3.83857600e-07, ...,\n", - " nan, nan, nan]])\n", - "Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664885494088087]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]], '/dev3442/demods/0/sample.x': [\n", - "array([[ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [ nan, nan, nan, ...,\n", - " nan, nan, nan],\n", - " [-3.79128012e-07, -3.79368980e-07, -3.79612937e-07, ...,\n", - " nan, nan, nan]])\n", - "Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664885494133030]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]], '/dev3442/auxins/0/sample.auxin0.avg': [\n", - "array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - "Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664885494031060]\n", - " createdtimestamp: [1038999074673]\n", - " changedtimestamp: [1039009255333]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 14:11:34.0307\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1285715]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [1.16666667e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 84, - "id": "76dd008a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'auxins/0/sample.auxin0.avg', 'demods/0/sample.r', 'demods/0/sample.x'}" - ] - }, - "execution_count": 84, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin._get_channels_for_window(program_name='test', window_name=None)" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "id": "8816fccf", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[autoreload of qupulse.hardware.dacs.mfli failed: Traceback (most recent call last):\n", - " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\site-packages\\IPython\\extensions\\autoreload.py\", line 245, in check\n", - " superreload(m, reload, self.old_objects)\n", - " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\site-packages\\IPython\\extensions\\autoreload.py\", line 394, in superreload\n", - " module = reload(module)\n", - " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\imp.py\", line 314, in reload\n", - " return importlib.reload(module)\n", - " File \"C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\importlib\\__init__.py\", line 169, in reload\n", - " _bootstrap._exec(spec, module)\n", - " File \"\", line 630, in _exec\n", - " File \"\", line 724, in exec_module\n", - " File \"\", line 860, in get_code\n", - " File \"\", line 791, in source_to_code\n", - " File \"\", line 219, in _call_with_frames_removed\n", - " File \"z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\", line 660\n", - " for k, v in recorded_data.items()\n", - " ^\n", - "SyntaxError: invalid syntax\n", - "]\n" - ] - }, - { - "data": { - "text/plain": [ - "{'X': {'/dev3442/demods/0/sample.x': [\n", - " array([[ 2.69279111e-07, 3.76000218e-07, 4.24689409e-07, ...,\n", - " -9.44849792e-08, -5.75667221e-08, -2.49266848e-08],\n", - " [ 6.31987250e-07, 4.11887636e-07, 2.38855616e-07, ...,\n", - " 2.93972004e-07, 3.04276206e-07, 4.01271313e-07],\n", - " [ 2.96471967e-07, 2.15771765e-07, 6.63772839e-08, ...,\n", - " 4.10635562e-07, 3.79404258e-07, 2.66680489e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1e+09 1.001e+09 1.002e+09 ... 1.299e+09 1.3e+09\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664873312419283]\n", - " createdtimestamp: [308605257163]\n", - " changedtimestamp: [309086050763]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 10:48:32.4190\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [2512]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]},\n", - " 'R': {'/dev3442/demods/0/sample.r': [\n", - " array([[3.50875860e-07, 2.70602397e-07, 3.22289289e-07, 3.21639020e-07,\n", - " 3.32765766e-07, 3.65126975e-07, 3.12966538e-07, 1.64027162e-07,\n", - " 2.45165536e-07, 4.19091366e-07, 4.14326504e-07, 3.29614134e-07,\n", - " 3.98556089e-07, 6.03632644e-07, 6.03304127e-07, 5.94617891e-07,\n", - " 5.10234580e-07, 3.35210733e-07, 2.30888648e-07, 2.51064516e-07,\n", - " 2.76974768e-07, 1.91823303e-07, 1.49521913e-07, 1.75328687e-07,\n", - " 2.78571123e-07, 2.10951086e-07, 2.16255281e-07, 3.16839491e-07,\n", - " 2.76141363e-07, 2.81573604e-07, 1.37238391e-07, 2.12871898e-07,\n", - " 3.62986060e-07, 4.29124663e-07, 3.16040404e-07, 2.67266655e-07,\n", - " 3.65657304e-07, 4.48666830e-07, 5.83573620e-07, 6.42626010e-07,\n", - " 6.11464599e-07, 5.49052360e-07, 5.86160132e-07, 5.82156228e-07,\n", - " 6.03255004e-07, 7.89091970e-07, 7.84022056e-07, 6.62303305e-07,\n", - " 5.03959286e-07, 4.49465035e-07, 4.43046704e-07, 5.90456587e-07,\n", - " 6.21792060e-07, 5.72738852e-07, 5.41391892e-07, 6.26158439e-07,\n", - " 4.59861745e-07, 2.12973843e-07, 2.37172460e-07, 3.72531488e-07,\n", - " 4.36279699e-07, 4.85907475e-07, 4.92556374e-07, 4.65265233e-07,\n", - " 3.19733747e-07, 3.04607663e-07, 2.94144267e-07, 2.45885864e-07,\n", - " 3.16028078e-08, 1.85243058e-07, 2.02642415e-07, 1.80417555e-07,\n", - " 3.17077909e-07, 5.14676889e-07, 6.35520404e-07, 6.37312376e-07,\n", - " 7.26135275e-07, 7.20081269e-07, 6.00586796e-07, 4.64989563e-07,\n", - " ...\n", - " 4.50349728e-07, 4.64176142e-07, 4.07156112e-07, 3.00673748e-07,\n", - " 3.72114091e-07, 3.60206239e-07, 3.14711484e-07, 3.11498318e-07,\n", - " 3.19263711e-07, 4.13087658e-07, 5.53255690e-07, 6.62389429e-07,\n", - " 5.97159565e-07, 3.48292585e-07, 4.04279527e-07, 5.47591484e-07,\n", - " 5.15210639e-07, 3.36606101e-07, 3.26182141e-07, 3.48923075e-07,\n", - " 2.78243634e-07, 2.82163333e-07, 5.26134267e-07, 7.70090420e-07,\n", - " 7.76728207e-07, 5.89799838e-07, 3.04388253e-07, 2.47766692e-07,\n", - " 1.58789395e-07, 3.03364830e-08, 1.49812292e-07, 2.22399343e-07,\n", - " 3.88711488e-07, 3.20814441e-07, 2.11552399e-07, 4.36760799e-07,\n", - " 5.85246465e-07, 5.98170037e-07, 5.50512150e-07, 3.43713482e-07,\n", - " 1.71207817e-07, 8.49430082e-08, 3.30555288e-07, 3.34163350e-07,\n", - " 3.26281110e-07, 4.09983188e-07, 4.57014174e-07, 4.68563630e-07,\n", - " 3.69464867e-07, 5.94835249e-07, 7.14685065e-07, 6.94255244e-07,\n", - " 7.13042485e-07, 4.59999172e-07, 2.51558505e-07, 2.28146965e-07,\n", - " 3.82364839e-07, 5.39785539e-07, 5.77188043e-07, 4.28624053e-07,\n", - " 2.29961114e-07, 2.83972207e-07, 3.65491624e-07, 3.50174319e-07,\n", - " 2.72091187e-07, 3.20505843e-07, 4.70595140e-07, 5.27882868e-07,\n", - " 4.16385393e-07, 1.06342650e-07, 1.75540360e-07, 3.57477226e-07,\n", - " 5.66663118e-07, 6.23191013e-07, 4.74268790e-07, 5.57135024e-07,\n", - " 6.78589995e-07, 6.83960121e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 6.503e+08 6.509e+08 ... 7.889e+08 7.895e+08\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664873312419223]\n", - " createdtimestamp: [308605257163]\n", - " changedtimestamp: [309086050763]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 10:48:32.4190\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [2512]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[1.83064221e-07, 1.61855467e-07, 2.49241466e-07, 3.39376135e-07,\n", - " 4.36536798e-07, 5.18693392e-07, 6.30735429e-07, 5.74835074e-07,\n", - " 4.36776420e-07, 2.63859894e-07, 1.30624147e-07, 9.70415274e-08,\n", - " 1.44476414e-07, 3.81813606e-07, 6.38447230e-07, 7.45571057e-07,\n", - " 8.22906422e-07, 9.18075754e-07, 8.43259013e-07, 7.61613607e-07,\n", - " 7.57270048e-07, 6.88958757e-07, 4.83349759e-07, 3.55754578e-07,\n", - " 3.63642255e-07, 4.22655755e-07, 3.87072095e-07, 3.70289162e-07,\n", - " 3.62161548e-07, 2.70584201e-07, 2.87656239e-07, 3.19854380e-07,\n", - " 2.08389908e-07, 1.96618982e-08, 3.33132395e-07, 4.70787632e-07,\n", - " 5.12829988e-07, 6.21235123e-07, 6.78234168e-07, 8.17913035e-07,\n", - " 8.18258618e-07, 7.54368146e-07, 7.46640882e-07, 5.50770744e-07,\n", - " 5.12319511e-07, 6.08510609e-07, 6.62309838e-07, 6.44205313e-07,\n", - " 5.95868712e-07, 6.51155602e-07, 6.31010157e-07, 7.74893720e-07,\n", - " 7.73539311e-07, 7.74910192e-07, 8.02652723e-07, 8.23684689e-07,\n", - " 8.68193990e-07, 8.62732478e-07, 8.01325476e-07, 6.25764502e-07,\n", - " 5.04780975e-07, 5.93346931e-07, 6.10683738e-07, 4.86562387e-07,\n", - " 3.12983135e-07, 3.68123599e-07, 5.59757155e-07, 7.12527556e-07,\n", - " 8.47038984e-07, 9.42978974e-07, 8.63359915e-07, 6.06673635e-07,\n", - " 4.27951356e-07, 3.59254470e-07, 2.99652089e-07, 1.79138376e-07,\n", - " 2.32503549e-07, 2.27449770e-07, 2.62303298e-07, 3.27436843e-07,\n", - " ...\n", - " 1.34507520e-07, 1.02082212e-07, 1.12642947e-07, 2.57615087e-07,\n", - " 2.52001240e-07, 8.39497095e-08, 7.44285860e-08, 3.41073852e-07,\n", - " 5.83489122e-07, 6.96472052e-07, 6.53976255e-07, 5.88986968e-07,\n", - " 4.49598566e-07, 2.98920279e-07, 2.12782307e-07, 2.95983869e-07,\n", - " 4.05101586e-07, 3.98188629e-07, 4.47104691e-07, 5.23768048e-07,\n", - " 3.36085570e-07, 9.03901955e-08, 3.48991273e-07, 5.33593138e-07,\n", - " 5.62695854e-07, 4.58134554e-07, 3.08202787e-07, 2.11030979e-07,\n", - " 2.51420702e-07, 1.01853724e-07, 2.07736971e-07, 4.68642977e-07,\n", - " 7.63032151e-07, 7.22946677e-07, 4.32578803e-07, 3.27013842e-07,\n", - " 3.40702093e-07, 4.66298330e-07, 7.43736291e-07, 8.69379562e-07,\n", - " 8.87377110e-07, 7.33472718e-07, 5.23308094e-07, 4.26309170e-07,\n", - " 4.31965940e-07, 2.58649504e-07, 1.33946849e-07, 4.47104352e-07,\n", - " 6.18007476e-07, 5.56577597e-07, 5.28093625e-07, 4.13845425e-07,\n", - " 3.33008003e-07, 2.89431379e-07, 1.47540020e-07, 1.70592255e-07,\n", - " 3.10416178e-07, 5.25815591e-07, 5.15154408e-07, 2.60636244e-07,\n", - " 7.17283923e-08, 9.54203553e-08, 2.61190363e-07, 2.57871195e-07,\n", - " 7.60343295e-08, 3.05941060e-07, 4.40774851e-07, 3.01379243e-07,\n", - " 2.00560156e-07, 2.19666114e-07, 2.69370619e-07, 2.87369645e-07,\n", - " 2.86037423e-07, 3.27678416e-07, 2.66341497e-07, 1.00779122e-07,\n", - " 1.75057650e-07, 2.29900763e-07, 2.45636684e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.401e+09 1.401e+09 ... 1.499e+09 1.5e+09\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664873312419223]\n", - " createdtimestamp: [308605257163]\n", - " changedtimestamp: [309086050763]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 10:48:32.4190\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [2512]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]},\n", - " 'A': {'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[-1.60287965e-03, -1.63122416e-03, -1.65956868e-03,\n", - " -1.68791319e-03, -1.71625770e-03, -1.74460221e-03,\n", - " -1.77294673e-03, -1.80129124e-03, -1.82963575e-03,\n", - " -1.85798026e-03, -1.88632478e-03, -1.91466929e-03,\n", - " -1.94301380e-03, -1.97135831e-03, -1.99970283e-03,\n", - " -2.02804734e-03, -2.05639185e-03, -2.08473636e-03,\n", - " -2.11308088e-03, -2.14142539e-03, -2.16976990e-03,\n", - " -2.19811441e-03, -2.22645893e-03, -2.25480344e-03,\n", - " -2.28314795e-03, -2.31149246e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " -2.32198247e-03, -2.32198247e-03, -2.32198247e-03,\n", - " ...\n", - " -1.21943914e-03, -1.20243243e-03, -1.18542572e-03,\n", - " -1.16841901e-03, -1.15141231e-03, -1.13440560e-03,\n", - " -1.11739889e-03, -1.10039218e-03, -1.08338548e-03,\n", - " -1.06637877e-03, -1.04937206e-03, -1.03236535e-03,\n", - " -1.01535865e-03, -9.98351938e-04, -9.81345231e-04,\n", - " -9.64338523e-04, -9.47331816e-04, -9.30325108e-04,\n", - " -9.13318401e-04, -8.96311693e-04, -8.79304986e-04,\n", - " -8.62298278e-04, -8.45291571e-04, -8.28284863e-04,\n", - " -8.11278156e-04, -7.94271448e-04, -7.77264741e-04,\n", - " -7.60258033e-04, -7.43251326e-04, -7.26244618e-04,\n", - " -7.09237911e-04, -6.92231203e-04, -6.75224496e-04,\n", - " -6.58217788e-04, -6.41211081e-04, -6.24204373e-04,\n", - " -6.07197666e-04, -5.90190958e-04, -5.73184251e-04,\n", - " -5.56177543e-04, -5.39170836e-04, -5.22164128e-04,\n", - " -5.05157420e-04, -4.88150713e-04, -4.71144005e-04,\n", - " -4.54137298e-04, -4.37130590e-04, -4.20123883e-04,\n", - " -4.03117175e-04, -3.86110468e-04, -3.69103760e-04,\n", - " -3.52097053e-04, -3.35090345e-04, -3.27169066e-04,\n", - " -3.21500164e-04, -3.15831261e-04, -3.10162359e-04,\n", - " -3.04493456e-04, -2.98824554e-04]])\n", - " Coordinates:\n", - " time (row, col) float64 3.003e+08 3.009e+08 ... 4.49e+08 4.496e+08\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664873312419159]\n", - " createdtimestamp: [308605257163]\n", - " changedtimestamp: [309086050763]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 10:48:32.4190\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [2512]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[-0.0018963 , -0.00187362, -0.00185095, ..., -0.0027846 ,\n", - " -0.00280727, -0.00282995],\n", - " [-0.00225985, -0.0023052 , -0.00231484, ..., nan,\n", - " nan, nan],\n", - " [-0.00135823, -0.00132989, -0.00130154, ..., -0.00036784,\n", - " -0.00037351, -0.00037918]])\n", - " Coordinates:\n", - " time (row, col) float64 1.2e+09 1.201e+09 ... 1.499e+09 1.5e+09\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664873312419159]\n", - " createdtimestamp: [308605257163]\n", - " changedtimestamp: [309086050763]\n", - " flags: [825]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 10:48:32.4190\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [2512]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}}" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "e36fb677", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32m<__array_function__ internals>\u001b[0m(6)\u001b[0;36mconcatenate\u001b[1;34m()\u001b[0m\n", - "\n", - "ipdb> u\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(707)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 705 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 706 \u001b[1;33m \u001b[0mcreation_ts\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0me\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mattrs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"createdtimestamp\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0me\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mv\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread_memory\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 707 \u001b[1;33m \u001b[0mall_ts\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0munique\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcreation_ts\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 708 \u001b[1;33m \u001b[1;32massert\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mall_ts\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 709 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> creation_ts\n", - "{}\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "id": "7ea34368", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'awgcontrol': array([0], dtype=int64),\n", - " 'bandwidth': array([0.]),\n", - " 'bitmask': array([1], dtype=int64),\n", - " 'bits': array([1], dtype=int64),\n", - " 'buffercount': array([10], dtype=int64),\n", - " 'buffersize': array([0.2]),\n", - " 'clearhistory': array([0], dtype=int64),\n", - " 'count': array([3], dtype=int64),\n", - " 'delay': array([-0.001]),\n", - " 'dev3442': {'demods': {'0': {'sample.x': [{'header': {'systemtime': array([1664558103553351], dtype=uint64),\n", - " 'createdtimestamp': array([2050547636776], dtype=uint64),\n", - " 'changedtimestamp': array([2050906036776], dtype=uint64),\n", - " 'flags': array([1849], dtype=uint32),\n", - " 'moduleflags': array([0], dtype=uint32),\n", - " 'chunksizebytes': array([0], dtype=uint64),\n", - " 'name': '003 19:15:03.5532',\n", - " 'status': array([0], dtype=uint32),\n", - " 'groupindex': array([0], dtype=uint32),\n", - " 'color': array([0], dtype=uint32),\n", - " 'activerow': array([2], dtype=uint32),\n", - " 'triggernumber': array([0], dtype=uint64),\n", - " 'gridrows': array([3], dtype=uint32),\n", - " 'gridcols': array([1256], dtype=uint32),\n", - " 'gridmode': array([4], dtype=uint32),\n", - " 'gridoperation': array([1], dtype=uint32),\n", - " 'griddirection': array([0], dtype=uint32),\n", - " 'gridrepetitions': array([1], dtype=uint32),\n", - " 'gridcoldelta': array([0.00119467]),\n", - " 'gridcoloffset': array([-0.001]),\n", - " 'gridrowdelta': array([1.]),\n", - " 'gridrowoffset': array([0.]),\n", - " 'bandwidth': array([nan]),\n", - " 'center': array([0.]),\n", - " 'nenbw': array([nan])},\n", - " 'timestamp': array([[2050547625096, 2050547696776, 2050547768456, ..., 2050637440136,\n", - " 2050637511816, 2050637583496],\n", - " [2050728258696, 2050728330376, 2050728402056, ..., 2050818073736,\n", - " 2050818145416, 2050818217096],\n", - " [2050906025096, 2050906096776, 2050906168456, ..., 2050995840136,\n", - " 2050995911816, 2050995983496]], dtype=uint64),\n", - " 'value': array([[-3.19561798e-07, 1.67769002e-07, 5.44787502e-07, ...,\n", - " 4.46304136e-08, -5.92941542e-08, 2.84974289e-07],\n", - " [-3.30585912e-07, 9.90783104e-08, 4.78993204e-08, ...,\n", - " -7.80902188e-10, -3.75496757e-08, -1.17205286e-07],\n", - " [-4.02696190e-07, -1.92283112e-07, -2.46849998e-07, ...,\n", - " 2.75505401e-07, -2.89131128e-08, 7.18154963e-08]])}]}}},\n", - " 'device': ['dev3442'],\n", - " 'duration': array([1.50050133]),\n", - " 'edge': array([1], dtype=int64),\n", - " 'enable': array([1], dtype=int64),\n", - " 'endless': array([0], dtype=int64),\n", - " 'eventcount': {'mode': array([1], dtype=int64)},\n", - " 'fft': {'absolute': array([0], dtype=int64),\n", - " 'window': array([1], dtype=int64)},\n", - " 'findlevel': array([0], dtype=int64),\n", - " 'flags': array([8], dtype=int64),\n", - " 'forcetrigger': array([0], dtype=int64),\n", - " 'grid': {'cols': array([1256], dtype=int64),\n", - " 'direction': array([0], dtype=int64),\n", - " 'mode': array([4], dtype=int64),\n", - " 'overwrite': array([0], dtype=int64),\n", - " 'repetitions': array([1], dtype=int64),\n", - " 'rowrepetition': array([0], dtype=int64),\n", - " 'rows': array([3], dtype=int64),\n", - " 'waterfall': array([0], dtype=int64)},\n", - " 'historylength': array([100000], dtype=int64),\n", - " 'holdoff': {'count': array([0], dtype=int64), 'time': array([0.2])},\n", - " 'hysteresis': array([0.]),\n", - " 'level': array([0.5]),\n", - " 'preview': array([0], dtype=int64),\n", - " 'pulse': {'max': array([0.001]), 'min': array([0.])},\n", - " 'refreshrate': array([5.]),\n", - " 'save': {'csvlocale': ['C'],\n", - " 'csvseparator': [';'],\n", - " 'directory': ['C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer'],\n", - " 'fileformat': array([0], dtype=int64),\n", - " 'filename': ['dataAcquisitionModule'],\n", - " 'save': array([0], dtype=int64),\n", - " 'saveonread': array([0], dtype=int64)},\n", - " 'spectrum': {'autobandwidth': array([0], dtype=int64),\n", - " 'enable': array([0], dtype=int64),\n", - " 'frequencyspan': array([13000.]),\n", - " 'overlapped': array([1], dtype=int64)},\n", - " 'triggered': array([0], dtype=int64),\n", - " 'triggernode': ['/dev3442/demods/0/sample.TrigIn1'],\n", - " 'type': array([6], dtype=int64)}" - ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq_read_return" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "8ad94d37", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(544)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 542 \u001b[1;33m \u001b[0mcn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34mf\"/{self.serial}/{_cn}\"\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlower\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 543 \u001b[1;33m \u001b[1;31m# print(cn)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 544 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mcn\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m<=\u001b[0m \u001b[0mshot_index\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 545 \u001b[1;33m \u001b[1;31m# then we do not have data for this shot_index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 546 \u001b[1;33m \u001b[0mwarnings\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwarn\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{shot_index}]\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(640)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 636 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mrecorded_data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 637 \u001b[1;33m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 638 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 639 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 640 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcurrently_set_program\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\appdata\\local\\temp\\ipykernel_27380\\3532927405.py\u001b[0m(1)\u001b[0;36m\u001b[1;34m()\u001b[0m\n", - "\n", - "ipdb> d\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(640)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 636 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mrecorded_data\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 637 \u001b[1;33m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 638 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 639 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 640 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_parse_data\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mrecorded_data\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcurrently_set_program\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> recorded_data\n", - "{'/dev3442/demods/0/sample.x': [\n", - "array([[-3.19561798e-07, 1.67769002e-07, 5.44787502e-07, ...,\n", - " 4.46304136e-08, -5.92941542e-08, 2.84974289e-07],\n", - " [-3.30585912e-07, 9.90783104e-08, 4.78993204e-08, ...,\n", - " -7.80902188e-10, -3.75496757e-08, -1.17205286e-07],\n", - " [-4.02696190e-07, -1.92283112e-07, -2.46849998e-07, ...,\n", - " 2.75505401e-07, -2.89131128e-08, 7.18154963e-08]])\n", - "Coordinates:\n", - " time (row, col) float64 3.418e+13 3.418e+13 ... 3.418e+13 3.418e+13\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664558103553351]\n", - " createdtimestamp: [2050547636776]\n", - " changedtimestamp: [2050906036776]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 003 19:15:03.5532\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1256]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00119467]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 101, - "id": "168c5a85", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1.])" - ] - }, - "execution_count": 101, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq.progress()" - ] - }, - { - "cell_type": "code", - "execution_count": 167, - "id": "c3a053dd", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_windows(data)" - ] - }, - { - "cell_type": "code", - "execution_count": 88, - "id": "e8877df8", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.finish()" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "d3be623b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m(83)\u001b[0;36mgroup_indexers_by_index\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 81 \u001b[1;33m \u001b[1;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 82 \u001b[1;33m \u001b[1;32mif\u001b[0m \u001b[0mkey\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcoords\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m---> 83 \u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"no index found for coordinate {key}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 84 \u001b[1;33m \u001b[1;32melif\u001b[0m \u001b[0mkey\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata_obj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdims\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 85 \u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"{key} is not a valid dimension or coordinate\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\indexing.py\u001b[0m(110)\u001b[0;36mremap_label_indexers\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 108 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 109 \u001b[1;33m indexes, grouped_indexers = group_indexers_by_index(\n", - "\u001b[0m\u001b[1;32m--> 110 \u001b[1;33m \u001b[0mdata_obj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 111 \u001b[1;33m )\n", - "\u001b[0m\u001b[1;32m 112 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\coordinates.py\u001b[0m(422)\u001b[0;36mremap_label_indexers\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 420 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 421 \u001b[1;33m pos_indexers, new_indexes = indexing.remap_label_indexers(\n", - "\u001b[0m\u001b[1;32m--> 422 \u001b[1;33m \u001b[0mobj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv_indexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 423 \u001b[1;33m )\n", - "\u001b[0m\u001b[1;32m 424 \u001b[1;33m \u001b[1;31m# attach indexer's coordinate to pos_indexers\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataset.py\u001b[0m(2505)\u001b[0;36msel\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 2503 \u001b[1;33m \u001b[0mindexers\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0meither_dict_or_kwargs\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers_kwargs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"sel\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 2504 \u001b[1;33m pos_indexers, new_indexes = remap_label_indexers(\n", - "\u001b[0m\u001b[1;32m-> 2505 \u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mindexers\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mindexers\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 2506 \u001b[1;33m )\n", - "\u001b[0m\u001b[1;32m 2507 \u001b[1;33m \u001b[1;31m# TODO: benbovy - flexible indexes: also use variables returned by Index.query\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(1337)\u001b[0;36msel\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 1335 \u001b[1;33m \u001b[0mmethod\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1336 \u001b[1;33m \u001b[0mtolerance\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m-> 1337 \u001b[1;33m \u001b[1;33m**\u001b[0m\u001b[0mindexers_kwargs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 1338 \u001b[1;33m )\n", - "\u001b[0m\u001b[1;32m 1339 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_from_temp_dataset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mds\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\miniconda3\\envs\\py37\\lib\\site-packages\\xarray\\core\\dataarray.py\u001b[0m(201)\u001b[0;36m__getitem__\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 199 \u001b[1;33m \u001b[0mlabels\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mindexing\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexpanded_indexer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata_array\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mndim\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 200 \u001b[1;33m \u001b[0mkey\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata_array\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdims\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 201 \u001b[1;33m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata_array\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 202 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 203 \u001b[1;33m \u001b[1;32mdef\u001b[0m \u001b[0m__setitem__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m->\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> u\n", - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(488)\u001b[0;36m_parse_data\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 486 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"time_of_trigger={time_of_trigger}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 487 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 488 \u001b[1;33m \u001b[0mextracted_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mapplicable_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m\"row\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mrow_index\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m\"timestamp\"\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mslice\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtime_of_trigger\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtime_of_trigger\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 489 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 490 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"extracted_data={extracted_data}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> applicable_data.where(~np.isnan(applicable_data), drop=True)\n", - "\n", - "array([[-1.54233563e-07, -1.53747443e-07, -1.63328742e-07, ...,\n", - " 1.12498946e-07, 5.47050085e-08, 5.14905138e-08]])\n", - "Coordinates:\n", - " timestamp (row, col) uint64 129659709576 129659745416 ... 130556892296\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1664526103384841]\n", - " createdtimestamp: [129656925736]\n", - " changedtimestamp: [129656925736]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 000 10:21:43.3824\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "5c20f912", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "ename": "KeyError", - "evalue": "0", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_32508\\1360584380.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mKeyError\u001b[0m: 0" - ] - } - ], - "source": [ - "data[0][0].values" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cef17340", - "metadata": {}, - "outputs": [], - "source": [ - "data[0][0].timestamp.values" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "637ecff1", - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "id": "fbdc56bb", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray '/dev3442/demods/0/sample.r' (col: 1, row: 25112)>\n",
-       "array([[7.03522854e-07, 6.92340419e-07, 7.21439685e-07, ...,\n",
-       "        3.06968651e-07, 3.77702425e-07, 4.19837064e-07]])\n",
-       "Coordinates:\n",
-       "    timestamp  (col, row) uint64 2303061427353 2303061463193 ... 2303961405593\n",
-       "Dimensions without coordinates: col, row\n",
-       "Attributes:\n",
-       "    systemtime:        [1664476581306703]\n",
-       "    createdtimestamp:  [2303061439033]\n",
-       "    changedtimestamp:  [2303061439033]\n",
-       "    flags:             [1849]\n",
-       "    moduleflags:       [0]\n",
-       "    chunksizebytes:    [0]\n",
-       "    name:              009 20:36:21.3054\n",
-       "    status:            [0]\n",
-       "    groupindex:        [0]\n",
-       "    color:             [0]\n",
-       "    activerow:         [0]\n",
-       "    triggernumber:     [0]\n",
-       "    gridrows:          [1]\n",
-       "    gridcols:          [25112]\n",
-       "    gridmode:          [4]\n",
-       "    gridoperation:     [1]\n",
-       "    griddirection:     [0]\n",
-       "    gridrepetitions:   [1]\n",
-       "    gridcoldelta:      [0.00059733]\n",
-       "    gridcoloffset:     [-0.001]\n",
-       "    gridrowdelta:      [1.]\n",
-       "    gridrowoffset:     [0.]\n",
-       "    bandwidth:         [nan]\n",
-       "    center:            [0.]\n",
-       "    nenbw:             [nan]
" - ], - "text/plain": [ - "\n", - "array([[7.03522854e-07, 6.92340419e-07, 7.21439685e-07, ...,\n", - " 3.06968651e-07, 3.77702425e-07, 4.19837064e-07]])\n", - "Coordinates:\n", - " timestamp (col, row) uint64 2303061427353 2303061463193 ... 2303961405593\n", - "Dimensions without coordinates: col, row\n", - "Attributes:\n", - " systemtime: [1664476581306703]\n", - " createdtimestamp: [2303061439033]\n", - " changedtimestamp: [2303061439033]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 009 20:36:21.3054\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [0]\n", - " triggernumber: [0]\n", - " gridrows: [1]\n", - " gridcols: [25112]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [0.00059733]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data['/dev3442/demods/0/sample.r'][0]" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "a94dfaf4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "13.000597371565114" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "21763/1.674e3" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "id": "8805f40b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAEFCAYAAADew/HIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAACPKElEQVR4nO19d9wUxf3/e/bunsJDV1SKVEGkgxQVCwqKiGLsLRYi1hi/aQZMNLEkUfMz0cQYjcYWY+wajaIgCBorRQHpTZAmvTwPT7my8/tjd3ZnZ2d29+6557l7cN6v1/N67vam78x85lOHUEqhoaGhoaGRbxiFboCGhoaGxoEJTWA0NDQ0NBoEmsBoaGhoaDQINIHR0NDQ0GgQaAKjoaGhodEgiBe6AfnEwQcfTLt27VroZmhoaGg0KcyfP38HpbRdvss9oAhM165dMW/evEI3Q0NDQ6NJgRCyviHK1SIyDQ0NDY0GgSYwGhoaGhoNAk1gNDQ0NDQaBAeUDkajOJFKpbBx40bU1tYWuikaGt9plJWVoVOnTkgkEo1SX14IDCHkdAB/BhAD8A9K6b3C78T+/QwA1QCuopR+EZSXEPL/AJwFIAlgDYCJlNI9+WivRuNi48aNaNGiBbp27QprKmhoaDQ2KKXYuXMnNm7ciG7dujVKnfUWkRFCYgAeBjAOQB8AlxBC+gjJxgHoaf9dC+CRCHnfA9CPUjoAwEoAt9a3rRqFQW1tLQ466CBNXDQ0CghCCA466KBGlSTkQwczHMBqSulaSmkSwAsAzhbSnA3gn9TCZwBaE0LaB+WllE6nlKbt/J8B6JSHtmoUCJq4aGgUHo29DvNBYDoC2MB932g/i5ImSl4A+AGAd+rdUg2NJo6q2jRqU5lCN0NDIxLyQWBkJFG8ZEaVJjQvIeRXANIAnpNWTsi1hJB5hJB527dvj9Bcje8qrrvuOnz88ceeZ+vWrUO/fv08zxZt3IN1O/aHljdnzhwMGjQIgwYNwsCBA/H666/70kyYMMFXPgC88sorIIQ4jsELFizAsccei759+2LAgAF48cUXPemff/55/O53v8PaHVVYubUytG1RcNxxx+Wcd8uWLTjttNMAAM888wx69uyJnj174plnnvGkY+1uTMjeaWPh0UcfxT//+c/QdPfccw+OOOIIHHnkkZg2bVojtKwwyIeSfyOAw7nvnQBsjpimJCgvIeRKAGcCGE0VN6NRSh8D8BgADB06VN+epqHE559/jr/97W+R0u6rTYWm6devH+bNm4d4PI4tW7Zg4MCBOOussxCPW8vqtddeQ/PmzX35Kisr8Ze//AUjRoxwnjVr1gz//Oc/0bNnT2zevBlHH300xo4di9atWwMA3n33Xdx8882R2h4Vn3zySc553333XYwdOxa7du3CnXfeiXnz5oEQgqOPPhoTJkxAmzZtnHT5bncx4/rrrw9Ns3TpUrzwwgtYsmQJNm/ejDFjxmDlypWIxWKN0MLGRT44mLkAehJCuhFCSgBcDOBNIc2bAK4gFo4BsJdSuiUor21dNhnABEppdR7aqfEdxrJly9CrVy/EYjHMnz8fAwcOxLHHHouHH37YSZPJZHDLLbfg0vGn4PxTR+Lvf/87AOCiiy7C1KlTnXRXXXUVXn31VTRr1swhJrW1tR75dlVVFf70pz/htttu87Xl9ttvxy9+8QuUlZU5z3r16oWePXsCADp06IBDDjkEjCOnlGLBggUYMmQIvvpyPq743mkYPHgwjjvuOKxYsQIA8PTTT+Omm25yyjvzzDMxe/ZsrF+/Hj179sSOHTtgmiZOOOEETJ8+HQAc4jd79myMGjUK559/Pnr37o3LLrsM7Dw3ZcoU9OnTBwMGDMDPf/5zp/x3330X48aNw7Rp03Dqqaeibdu2aNOmDU499VS8++67vnZ/8MEHDrc3ePBgVFZWoqqqCqNHj8aQIUPQv39/vPHGGwAsDqR3796YNGkS+vXrh8suuwwzZszAyJEj0bNnT8yZMwcAcMcdd+Dyyy/HKaecgp49e+Lxxx/3jTV7p8OGDcOAAQOcdyrihhtuwNChQ9G3b1/85je/cZ537doVO3bsAADMmzcPo0aNAgDcfPPNuOuuuwAA06ZNw4knngjTNHHHHXfg/vvvBwCMGjUKkydPxvDhw9GrVy/873//AwC88cYbuPjii1FaWopu3brhiCOOcPrE4/HHH8ewYcMwcOBAnHfeeaiursbevXvRtWtXmKYJAKiursbhhx+OVCqFuXPnYsCAATj22GNxyy23FIyL41FvDoZSmiaE3ARgGixT4ycppUsIIdfbvz8KYCosE+XVsMyUJwbltYv+K4BSAO/ZC/czSmn48UCjqHHnf5dg6eZ9eS2zT4eW+M1ZfQPTvPPOOzj99NMBABMnTsRDDz2Ek046CbfccouT5oknnkCrVq3w77ffR7KuDtdfNB6nnXYaLr74Yrz44os444wzkEwmMXPmTDzyyCMALK7oBz/4AdavX49nn33WITi33347fvazn6FZs2aednz55ZfYsGEDzjzzTGcjEjFnzhwkk0n06NHDyTNw4EAQQtDtiJ548pWpGNL1YMyYMQO//OUv8eqrryr73aVLF0yePBnXX389RowYgT59+jiiLbFdS5YsQYcOHTBy5Eh8/PHH6NOnD15//XUsX74chBDs2bMHgLVpr1ixAn369MHUqVNx+OGuEKJTp07YtGmTr933338/Hn74YYwcORJVVVUOcX399dfRsmVL7NixA8cccwwmTJgAAFi9ejVefvllPPbYYxg2bBj+/e9/46OPPsKbb76J3//+9/jPf/4DAFi0aBE+++wz7N+/H4MHD8b48eM9/WLvdO7cuairq8PIkSNx2mmn+cx0f/e736Ft27bIZDIYPXo0Fi1ahAEDBijH9d5778WwYcNwwgkn4Oabb8bUqVNhGP7zejqdxpw5czB16lTceeedmDFjBjZt2oRjjjlGOmY8zj33XFxzzTUAgNtuuw1PPPEEfvSjH2HgwIH44IMPcPLJJ+O///0vxo4di0QigYkTJ+Kxxx7DcccdhylTpijb3pjIix8MpXQqLCLCP3uU+0wB/DBqXvv5Eflom4YGYJ0yn3rqKezduxd79uzBSSedBAC4/PLL8c47lv3I9OnTsWjRIvzreUv/UVddhVWrVmHcuHG4+eabUVdXh3fffRcnnngiysvLAQAjRozAkiVLsGzZMlx55ZUYN24cli9fjtWrV+OBBx7AunXrnDaYpomf/OQnePrpp5Xt3LJlCy6//HI888wzzobFuAUAqKrch9t+ciO2bVwHQghSqXBR3qRJk/Dyyy/j0UcfxYIFC6Rphg8fjk6dLEPNQYMGYd26dTjmmGNQVlaGSZMmYfz48TjzzDMBWESVifdkkmvGyfHtHjlyJH7605/isssuw7nnnotOnTohlUrhl7/8JT788EMYhoFNmzZh69atAIBu3bqhf//+AIC+ffti9OjRIISgf//+njE9++yzUV5ejvLycpx88smOXoyBvdNXXnkFALB3716sWrXKR2BeeuklPPbYY0in09iyZQuWLl0aSGCaNWuGxx9/HCeeeCIeeOAB5zAg4txzzwUAHH300U67g8aMx+LFi3Hbbbdhz549qKqqwtixYwFYHPWLL76Ik08+GS+88AJuvPFG7NmzB5WVlY5e7dJLL8Vbb72lbH9jQXvyazQqwjiNhkB1dTX27NmDDh06YM+ePUpTTUopHnroIbTva22eAzq1dn4bNWoUpk2bhhdffBGXXHKJL+9RRx2FiooKLF68GHPnzsX8+fPRtWtXpNNpbNu2DaNGjcIbb7yBxYsXO2KWb7/9FhMmTMCbb76JoUOHYt++fRg/fjx++9vfek6406dPd7iUh//f7zHsuBNw36/fwrp165yy4vG4IzYB4PF1qK6uxsaNGwFYorsWLVr42l9aWup8jsViSKfTiMfjmDNnDmbOnIkXXngBf/3rX/H+++97uMFOnTph9uzZTt6NGzc6beLbPWXKFIwfPx5Tp07FMcccgxkzZuCzzz7D9u3bMX/+fCQSCXTt2tVpN98ewzCc74ZhIJ1OO7+J71L8zt4p25xl+Prrr3H//fdj7ty5aNOmDa666iqnHfy4iv4jX331FQ466CBs3iyqnF2wdrMxZWO2YYNrPLtx40Z06NDBl/eqq67Cf/7zHwwcOBBPP/20M84TJkzArbfeil27dmH+/Pk45ZRTsG9ffqUC+YKORaZxwGPWrFk4+eSTAQCtW7dGq1at8NFHHwEAnnvONU4cO3YsHnnkEYcrWLlyJfbvt6zJLr74Yjz11FP43//+52xWX3/9tbNprF+/HitWrEDXrl1xww03YPPmzVi3bh0++ugj9OrVC7Nnz0arVq2wY8cOrFu3zuEQGHFJJpM455xzcMUVV+CCCy5w2rR3716k02kcdNBBAIDKyn049LD2AODhhLp27YoFCxbANE1s2LDBI9OfPHkyLrvsMtx1112OyCUKqqqqsHfvXpxxxhl48MEHHe5n5syZGD16tDNm06dPx+7du7F7925Mnz4dY8eO9bV7zZo16N+/PyZPnoyhQ4di+fLl2Lt3Lw455BAkEgnMmjUL69dnHzH+jTfeQG1tLXbu3InZs2dj2LBhnt+D3inDvn37UFFRgVatWmHr1q0ORwtY4zp//nwA8Igi169fjz/+8Y/48ssv8c477+Dzzz+P3OYJEybghRdeQF1dHb7++musWrUKw4cP96WrrKxE+/btkUqlPPO0efPmGD58OP7v//4PZ555JmKxGNq0aYMWLVrgs88+AwC88MILkdvTkNAcjMYBj3feeQfnn3++8/2pp57CD37wAzRr1sxzsp00aRLWrVuHi8edBEopDu9wmCPrP+2003DFFVdgwoQJKCkpAQB89NFHuPfee5FIJGAYBv72t7/h4IMPzqmNL730Ej788EPs3LnTIRxPP/00Vq9ejTFjxjjpJt5wM277yY149Zm/45RTTnGejxw50hEr9evXD0OGDAEAfPDBB5g7dy4+/vhjxGIxvPrqq3jqqacwceLE0DZVVlbi7LPPRm1tLSileOCBB7B9+3aUlZWhZcuWAIC2bdvi9ttvdzb2X//612jbti1eeeUVT7sffPBBzJo1C7FYDH369MG4ceNQWVmJs846C0OHDsWgQYPQu3fvrMdt+PDhGD9+PL755hvcfvvt6NChg0eExt7pkCFDQClFu3btnHc6aNAgLFiwAAMHDsTgwYPRt29fdO/eHSNHjnTy/+Y3v8HVV1+N3//+9x6x4NVXX437778fHTp0wBNPPIGrrroKc+fOjdTmvn374sILL0SfPn0Qj8fx8MMPOxZkkyZNwvXXX4+hQ4fi7rvvxogRI9ClSxf0798flZWuefpFF12ECy64wMM9PvHEE7jmmmtQUVGBUaNGoVWrVlmPZ75BFNa/TRJDhw6l+sKx4sOyZctw1FFHFaz+IUOG4PPPP48c4G/Rxj0AvCKyQmHSpEmYNGkSjjnmGFBK8dWmvQAK17Z//etf2LhxY6gSmW93Q+GOO+5A8+bNPdZt32VUVVU5loH33nsvtmzZgj//+c++dLL1SAiZTykdmu82aQ5G44DHF198Uegm5Ix//OMfzudiOAp+//vfj5SOb7dG4+Dtt9/GPffcg3Q6jS5dugQakzQWNIFRIJk28ZMXF+Anp/bCEYf4neUaGht3V6NleQItyxonrHZ98ObCzVi7vQo/HtOr0E05sFEMFKaIcMcddxS6CUWFiy66CBdddFGhm+GBVvIrsGDDHrz91Rbc+tqigtR//H2zcNZDHxWk7mxx8/Nf4sEZqwrdjAMemr5oNDVoAlPEWL9TBzDQcEE1idFoYtAERoEDyfhBIzqK+r0XcdM0NGTQBCYERBrwWUOj8aHpi0ZTgyYwGt8ZRAnXn80m3tjh+u/5/e995fDBGBsDo0aNQpgrwKeffuo4dAaFpb/nnns8DoSNgdmzZzshbzQaHtqKLARa7n3gIJtw/VHQ2OH6b7hRGs6v6PDuu+/i9NNPDw1LP336dLz00ksFbm10UEpBKZUGtdSQQ49UCLSI7MBA1HD9vyjicP2DhgzBnt27cN2l52Lw4MG47rrrPDqjf/3rXxg+fDgGDRqE6667DpmMdfNl8+bNMXnyZBx99NEYM2YM5syZg1GjRqF79+548803nfZPnDgR/fv3x+DBgzFr1iwAQE1NDS6++GIMGDAAF110EWpqapyxuuqqq9CvXz/0798fDzzwgNOOmTNnYsyYMYFh6fft24dkMol27drh5ZdfRr9+/TBw4ECceOKJACzO8oQTTsCQIUMwZMgQ5+6a2bNn46STTsKFF16IXr16YcqUKXjuuecwfPhw9O/fH2vWrHHe0fXXX48TTjgBvXr1kgZ+3L9/P37wgx9g2LBhGDx4sHNdAI9169bhqKOOwo033oghQ4Z4YohphENzMBqNi3emAN9+ld8yD+sPjLs3uNqI4fpbFnO4fhA8+sB9GDz8GPzt/t/j7bffxmOPPQbAIqAvvvgiPv74YyQSCdx444147rnncMUVV2D//v0YNWoU7rvvPpxzzjm47bbb8N5772Hp0qW48sorMWHCBIfQfvXVV1i+fDlOO+00rFy5Eo888giaNWuGRYsWYdGiRU4ImgULFmDTpk1YvHgxADih/Hfs2IFEIoFWrVoFhqWfMWOGE8/srrvuwrRp09CxY0ennEMOOQTvvfceysrKsGrVKlxyySWOaG7hwoVYtmwZ2rZti+7du2PSpEmYM2cO/vznP+Ohhx7Cgw8+CMAiDh988AHWrFmDk08+GatXr/aM8+9+9zuccsopePLJJ7Fnzx4MHz4cY8aMQUVFhSfdihUr8NRTT+WV+/2uQHMwCmjB2IGFadOm4fTTT5eG62eYPn06/vXss7hw7An4/oQx2LlzpxOu//3330ddXR3eeecdabj+uXPn4p577kFtbS0WLFiA1atX45xzzvG0gYXr/+Mf/6hsJwvX/9RTT/nC9VMAX3z+Cc4850IAwPjx452bI2fOnIn58+dj2LBhGDRoEGbOnIm1a9cCAEpKShzi2r9/f5x00klIJBKe0PcfffSRMxa9e/dGly5dsHLlSnz44YeO9/6AAQOcEPbdu3fH2rVr8aMf/QjvvvuuE5ts+vTpzn0z2YTyv+qqq/D44487XFcqlcI111yD/v3744ILLsDSpUudMoYNG4b27dujtLQUPXr0cOoTQ/lfeOGFMAwDPXv2RPfu3bF8+XJPW6ZPn457770XgwYNwqhRo1BbW4tvvvnG1+YuXbo0aMibAxmagwmDlpDlFyGcRkMgm3D9Dz74Z3QacCyA4gvX7+zXkvZTSnHllVfinnvu8f2WSCScPqtC3weZZ8vGq02bNli4cCGmTZuGhx9+GC+99BKefPJJvPPOO/jpT38KIDgs/Zw5cxwu8NFHH8Xnn3+Ot99+2wlA+dBDD+HQQw/FwoULYZqmR5yYz1D+r776Ko488khl3wH4OBqN6NAcjALF7A6RD7w8bwPeXfxt1vk+Wb0Dz3yyLv8NakBkE67/739/tIjD9VMMGXEcpr7+MgBL7Ld7924AwOjRo/HKK69g27ZtAIBdu3ZlFf7+xBNPdMZi5cqV+Oabb3DkkUd6ni9evBiLFlmRLdgVzOeddx7uvvtufPHFF6CUYtGiRc6FX6qw9EuWLEHv3r0dZf+aNWswYsQI3HXXXTj44IOxYcMG7N27F+3bt4dhGHj22WcdzgYA0ibF9sq60D69/PLLME0Ta9aswdq1a32EZOzYsXjooYcc4vrll19GGquMaSKdMcMTamgOJgwHKgNzyyvWRrHu3vEhKb249B/WvRdXHtc1301qMGQTrn/t2q+LNlw/BXD9TyZj8g8nYciQITjppJPQuXNnAECfPn3w29/+FqeddhpM00QikcDDDz+MLl26RKr/xhtvxPXXX4/+/fsjHo/j6aefRmlpKW644QZMnDgRAwYMwKBBg5x7SzZt2oSJEyc6l3Hdc889mD9/PgYPHuxwCqqw9Lw+DABuueUWrFq1CpRSjB49GgMHDsSNN96I8847Dy+//DJOPvlkDxdRnUxjy94atGtRiiAceeSROOmkk7B161Y8+uijHi4IsPRkP/7xjzFgwABQStG1a1e89dZb2Lx5MyZNmuQx7OCxdHMlKGhRRNsuejDTuwPh7+ijj6b5wierd9Auk9+iFz76Sd7KzAZdJr9Fu0x+q+jKl+ULK2vp0qVZ15NPDB48mCaTyUhpk+kMXbhhN124YXfDNioirr76avrpp59SSimtqk0VVdtE3H333fT5558PTTdmzBi6efPmnOuJMgZXXnklffnll3Ouo771FzNk6xHAPNoAe7LmYBTQ/i8HDg6UcP3FDplJtgzvvfdeA7dEo1igCYwKNn1R6IMbtuoDXQFUxCjmoS/mthUbiuEuFA2t5FeikGtZbySFRPEOvuaqNZoaNIFRIGMWbjEX6zYSxllpzktDQ4OHJjAKmPZmWYhQMWaRbtS1qWDTzCJtdlYo5i4cCOOr8d2CJjAKFHIxFyuB2VebCvy9WNudFYq4C0XcNA0NKfJCYAghpxNCVhBCVhNCpkh+J4SQv9i/LyKEDAnLSwi5gBCyhBBiEkKG5qOd2aCgIrIi3Un21gQTmEyxNtxGUw/Xf/99fi99Ha4/O+hw/Y2LeluREUJiAB4GcCqAjQDmEkLepJQu5ZKNA9DT/hsB4BEAI0LyLgZwLoC/17eNucARkRXEiqyhy8+tgppkJvD3IqcvTT5c/8Rrb8hb2xsSB2q4fo3skQ8OZjiA1ZTStZTSJIAXAJwtpDkbwD9tn57PALQmhLQPykspXUYpXZGH9uWEAjIwOYmaTJPi4Vmrsac6GZo2lcmtc2EcSkNzfXXpDDbvqcmJQEYN13/rlF94wvVnTBNnn3s+3n77bSddocL1Dxw0uMHD9ffr1w8DBzVMuP4ePY7AjA8+BqW0XuH6f3D+eNxyw8RGCdc/d+5cDBgwALW1tdi/fz/69u2LVcuX+tKFoTaViRxepjqZxq794eu4KSAffjAdAfCXJGyExaWEpekYMW8gCCHXArgWgBM2Ix8opD4hl5o/XbsT/2/aCizdvA8PXzYkMG0qxzhKYRt7lDG7b859WL5reWg6GWqSGZiUorwkBoPbzHu37Y3JwycH5o0crr+lN1x//+EnYNS47+Ffz7+A8ePHFzRcPxohXP+/3/0IX69eiSuvOD/v4frbHnIYFq/6GiOPOzbncP2UUqxcthivP/w5ju/XrcHD9Q8bNgwTJkzAbbfdhpqaGnz/+99Hz959gqaaFCu3VqIkbqD3YS1D067eVmWNV0VJ1vUUG/LBwciESOJOo0oTJW8gKKWPUUqHUkqHtmvXLpusgSgkgcml7mTaIhpVdemQlEA6Vw4mhC4VkusLQ9Rw/f/+17884frXrFmN408egw9nz/7OhOvvdkSvBgnXT6kV0ThD6xeuv+/AIWh36GGNFq7/17/+Nd577z3MmzcPv/jFL5TvLgxsjX6XkA8OZiOAw7nvnQBsjpimJELegqCgSv56zMMoOqNkjhxM2JiYEcYsjNMIwqqtlahJZdDzkOYoL4k+dbMJ13//Aw+i26DjAFjh+tfv3I+9NSkcf8KJhQ/XHxBegjaBcP1btmxCu0MPAyjNOVw/pUCixD3ZN0a4/l27dqGqqgqpVAq1tbWBaTW8yAcHMxdAT0JIN0JICYCLAbwppHkTwBW2NdkxAPZSSrdEzFsQUPVabvi6cxCSZZMnbeZGYMI4q8bi+rKtJZtw/f947O+ecP3Vdrj+cy+4oPDh+ikaJVz/urWrGyRc/7q1a9Bv0NFYunRpzuH6s5nn+QrXf+211+Luu+/GZZddhsmTcz8gfRdRbw6GUpomhNwEYBqAGIAnKaVLCCHX278/CmAqgDMArAZQDWBiUF4AIIScA+AhAO0AvE0IWUApHYtGQmFFZLnnjUIPU+ncKggnMDkV2+DIJlz/qtVrPeH6//Lkc4BRglNGn4obr7n6gA/Xf96Y4xBroHD9d933J8RiMcyY/m7O4fqzWZb5CNf/z3/+E/F4HJdeeikymQyOO+44DPz4Q4wYeWLkduRqtUkpVXLbTQYNEaK5UH/5DNf/0txvaJfJb9FLH/80b2VGxfbK2qzD6c9Y+i3tMvktetWTn4emXb2tMqdw/bOWbw0M1//t3hppvnyF61+5dR9duGE33V+XyipfNuH6xZD463ZU0YUbdtPd++uybW5ewIfr37avtsFDxden/LBw/evtsRx18ik5h+uvS7nXKZimqUxXTOH6M6aZVR6WNpNR968+0OH6iwCOiKwAoWLqwzxFOfHkakVWaBGZ07Msq9Hh+hsH4eH6rTf42lvvoE2z3CykmmTAzxyb3AR76oMmMAoU1Ey5gevO1YosTHXT8IYR1gbVkLUUs7Nok9xceeThrBb1/RRTuP5c35u1DzRtEZmORaZAIcOeNPQ+nbMVGTcmMiIYNGQNTTTzhyJuZxE3LQpy5UB58NOoqQxHrlO/IfrX2OtQExgF2CbfVKzIskHuHAxPYCS/KyZvWVkZdu7c2SSITDG3kLWtaZ9p6zfGnrVRzC+LQ87NzHP/KKXYuXOnz9ihIaFFZAoUcjOMysGs3laJ6mQGAzq1jnRKmrViG9bt2I9eh7Zwnv3pvZX48eieMIzwbcsMWdub9tRg1dYqjOlzqOd5p06dsHHjRif0CUNtKoPSuBHZUmZ7ZR3q0ibM3aUojTfM2ag2lcGOKitMxxe7SrCrKgkKIL2zBOUlsazLS5sUAEXcqH9799WksK82DQIgXlmurK+yJoWYQVAaN1CayK7NW3dboWCWKcpnoJRib00KzUvjiMe8fatNWSbFZULdu/cnsT+ZQXJHAltLc9t66tImtlfWAQDi+8p8cyeVMbGnOoWK0hiaZeErxec3CEEsYD1EHSOGjEmxdW+tk2d/XRrliRhqUhmUxA0khPFj5ZO9pXmZNzzKysrQqVOnvJYZBE1gFCiko2UUh0UAGPOnDwEA6+4dHyn9xKfmAgCenjjMefaXmatwUq92OLpLm9D8vIjMpBQx4Sx96eOfAwC+vucMz8JPJBLo1q2bJ+0na3bg0mc+x42jeuAXp/eO1P5fP/oJ5q7bjZeuOxaDurWNlCdbzFqxDdf8e67v+cOXDsH4o9pnXV7XKVYMs6jvKAh/eHc5/jZ7Q2B5E5+ag1krXEKebb3jIrZ3/vpduOSfn+LoLm3w6g3HeX5T9fkXryzES/O24L7z+uOiQbmFdfpk9Q5c85w1z5bcORYVAqF69IM1uPeddTih58F49uqsok45bW/TLIEvf32aMk3UMWLYtKcGZz77PgBg5s9Owrg/foCTerXDByu3wyDA2nu85bDyZ/98FLoeXOErrylBi8gUKFafDhWyEeX5RWTROhsmImOIQpwZl7B+V3WkugHXoq8hDTBYH4vR/SBMB9a4yP5dsPeXrsfi4vWHslJ228Fe68Ph7q4OvpYiW/BBLuvsS/u27rM4mqChyNUhupigCYwChRWR5eDJn0UW0YAhqoiKJxxBbYyygbDxzWofJ+F11xeO7k2suggIToY7GKiIeGM55rFqonLbAMCkPbnqAAFvJHDZPNhtRyEupARCRK4ENdeo58UETWAUKKiILIeqs8kibgpGxE0p6saejZVaNhsiS9mQBzv3HiAxblXD1RkVXhGlPE1j0cHc6rFy5eqHJeaVxexj3Edj7M1RD6GyvSTK/lIfQlws0ARGAdeKrPGPrjndB5MFRyByMLEcCExQG1MRosbmsmEzQtiQJuSM+EaweWh0ROEgG2u6snUhtqIurb6UjrWtPoc3nsAEcTCNIYGI2g2eUDAruKAxYOOU0iKyAxeFdbTMJY+VKUpWcXJH3ZT4gydro2whZ8PaZ7MfuhtUwy08V0QmRuJtsCojIx1JB9ZIIjJFO/bVqK+LYES7XjqYdAiBqWYEJucqIiPqHsGvN0ZsgsbAOUgVkZgvV2gCo0A2suV8g9+0o7Ph0cvPlcDIOBjZMEW594Kd5LLZuN2FFz1PtnD6WAQERYRZRBxMxjnQeNuxr1atICd5EJElPRyM//c9toisMQ6IUevglfWs70HEgxHi+oxTsUATGAUKe2Wy+znqOslkIyITCUzE3ZRfUFTyjCGKDiaXfTwfIpYwsP4Uo4gsHYXACN+ZT0q+oXoHe2vUBIYRo3op+dO8FZm3HNOkDgfTGAQm8trkxirlcDDqNcIOUloHcwDDOaEVQFTGL5yo+oZsOC5RhBU1cgC/UJiCVbbRRDl5OQQmhyN3w1qRMUJdhEp+D4GRpxENNiprw284dcrMYg6xzU8cl6D6WPvro1vg566sbtaFxjggRudgeAITzsEwJ09tpnwAo6Bmyty8inpaz2bTFRWxuZzEGFGS5c3matjsOJiGl02zsRc5mELq5Bg84x9RRFYZILLylZ9FH9nmJ2apC+CYWPvrczJPBij59ydd4tYYIu5clPxs3IJ0MMzoRpspH8BwdQzel/z52p2RTug1yQw2ZOFEKKsbAGav2IbP1+4MzZPNpisSgKibJ5/MPSnmyMFEqtELtumblGLxpr14YY7//nQen67Ziaq66Cd4wN1kRU6gMQlMOmPi2c/Wexz0gGgcjEhg9kXkYEyT4m+z1kRvo6IBqk1x9bYqrNlu3Q4q9oth8aa9ePrjr33P//35N/hkzQ67fLUOJqqVowrZHipN+86Tn720EBc++ikueewzLNiwx5eO50SSabkV2YcrtzsHPxa2SSv5D2CwecxzEws37MFFj32GP05fGZr/2mfn4YQ/zKp3O67/1xe46LHPQtNlx8GIBCZaPpknuezUG00Hk70ShiVNZyjOfOgjTHntK2XaHVV1uOTxz3Dz819GryCgXY3JwDzz6Xrc/p/FePYz75XH/Eal1sGIIrJoHMx7y7bigRnh85ohoyAkqsPFmD99gPnrd1tpFBPuzIc+wh3/Xep7/svXv3LCEHkIjFAOv1ZVc5pSiq5T3sZfZq6S/CbPowI1gcq6NF79YiO+3VeLT9fuxMerd/jSeazITK+IzCAWYb3iyTn47VvLnGeAVvIf0KASDoYF2Vu1tTI0//9W7fCUkw1yOX1lMxdFEVku5pbso8zZLTsRWXQKk40fDFNur/g2/F3xYOMotqoxOZi9tqJaVJjz71gpAhIaHtUkWDx0hIGVK5bODhdBqjUVBxMF/NwSX4kpOQCJYMMhI6bZvuMMpY7468rjulrPJOMt08GwfAYhjuXbmu1VADgdjBaRHbhgk00257J57blwubnkcazIIuzXLB4SQ1Qi6DGfhlyECESTHeeydGThSVSbVa70wLEiM0QRWW7l5RMZUy0eYhBFew2lS2QbqVg+IwDxADO8hgoV4xWRyfPTgHWd7Ts2KXXmH4t9Fua1L1qREeIV/QKcFZlW8h+4cERk9VyguUySXDaFoIUjImcRmcTRUsZNZMPaZ2dE5udgcr08TQVVjLRiUPLnYqbcUHuUal6zdx8U7l4lIouCoGCXUXQwQVVn+45NSp2+lMQMxAwSmYPhI4Uw4xX2jI2dVvIfwFAp+bNFLqe1nDiYeij5o+b16mCs/1I/mCjilhz6KONgshHHRYErG28cTkAGVU1RNlCRYDcUYXQ5GO9ztoEmAu4xqY+ILBXgyc9PYyUHEzDxstbBULc98RhBjBDpgYvnPMX9wOA4GNY07cn/HUCQp3o2yCVuVi6bGZuMkURkOepgqGSDk5opR7Iik3MKQZCFGsk3gVHdZFoIfauon0oH+IC4ebzIlcCEzcEwK7KgC+zqczL3BLsMEJGp2h/UrVw4GMbJxWMGDEOhg+H6K3L3BMS1GnPEs/K0TRGawCjgbqD1ozAqa5sg5FJj2OLgJ75IAHLzg/E/Y8jO0TJa3YC74fJ1ZqucDoM7joUzU1YhWrDL/OiOwrrrcDDCbGXvI0hEFhZLLsiHxauDkbcpZhDl+OSXwLjtKYkRxA0jVEQmrj2D8HHd7PY7OpjCz7n6QhMYBYI8gqPsiWx95cLB5OIkFpaF3/RFJX9kKzKegzHVIsRoscgsZGVFZs9Wk1JnfFUEJhcCxsoG/I6WhXC89XFREZTY+RKRheVjYi6ViCxovMI2zqBf6wJEZOxr3CA5iciyVvKb1Olv3DBgkHArMr+IjPgiUxuOFZnmYAAAhJDTCSErCCGrCSFTJL8TQshf7N8XEUKGhOUlhLQlhLxHCFll/2+Tj7ZGRdAGGmUe1keO2hA6GA+ByVHJLyN8ssNoQyn5XQ4Gzj3wKmKWSzBNQC0ia8zDpGpvjsTB+DivaHWK7zbsYKQUkaW9SmxpmpD5ETSXvX4w8nxxgygPaUHtyvYQQTkOJh4jiMfkHEyGa7Ov77wVmaD/00p+AISQGICHAYwD0AfAJYSQPkKycQB62n/XAngkQt4pAGZSSnsCmGl/bzTUVwdj1IPNlZ2ywiZ/GNfDn5xy1cF4lahqAhzJTDmXceXMORP2qlTdP5Lre1PFIiuEiEykjV4djEpE5v0eddMUN76oIjJVOYE3nobMj8C7hjxWZHIdTDxmBIjI1GVnexjkzZRLYgYMQqTr3WtF5v2dwN0rHN8yu40HgpKf1Jf1J4QcC+AOSulY+/utAEApvYdL83cAsymlz9vfVwAYBaCrKi9LQyndQghpb+c/MqgtQ4cOpfPmzcu6D2vWzsDdH/wCIARxCqQpxf5kBhQUBiGoKI0DAMwMRU0yg3iMgBoEJYZlmuhGiTURNwgICCrtECUVJTFQQ345kwpp06qHgQBoXZaACYoYCACKJChqazPIAGheEgPNmKjNUMQMoCJhtZcSa6M0QUEosLcuDQPWhE5TCgKAUKBZSQyxmAEKChMAodRi2ykQA5C0+0aoxTFQQtGsNA6DWCfF6mQalNsOS+KG9050St2dz55vqYyJ2jRFImagLOFyIzGDgFKKVIaiNGFYJyBCAEpRmzKRNk2UxA2rHQCalcSl8n6TUuyvy8AgcN5fMOxxTZuoS5swiHczKonHUJLDPe9Vtid9aSIW6BsCWJwlpdacS2asfpbE3Dqrkxln42xWEpcq0mtTGWcTI6AoS8Qcbk8KauXJUOpyb6BoXpqASSkIkeh1TIrqZAaw10czbnxrUyZSGRMEQPOyBACKupSJVCYDCgICihghKC+1fuPBAmW2KItLnlOUJ2KoTWWcXOzds/kSM6wxIsQ6HlSUxvzdpXDCB7UoS3j7RYH9dVwb+HlrtzaVNu1DDUGz0hgotcJClZdYbYsbBGUJb71sTgEUJTEDqYzpiogJQXkihupkGoZBUFESx/46K2inbx2FYESrXrjxnOcjp+dBCJlPKR2aU+YARFl5YegIYAP3fSOAERHSdAzJeyildAsA2ETmEFnlhJBrYXFF6Ny5c04diJE4YFiToo5QVNVYE4idYikICAFSBKgjQAYATZuoIxQtSuPOZlyVoogb1sTO2BtWmhhIwGIVo+obDJhIUTetCSAFIA4Ca/oTlBIDVTBhUKAqaYISu50gSBsGAGvDMOz0GWKRwTQsokHtcikBUvYiIrBMLSmxCMD+ZBplpXGYyQzSJmDECFIEMEBgwNr8KSGg1LsICAgMYrgLlHh+tDtFAGqNkmE/rEtRABTxGEE6Y4sd2AIj1p+1CcasL9TqscFXwOTZlFphBgistlgPHWLFp3WP6/Y7tygzKCWcrsjw1uPpsPw5BWDaY1OTpGheGkMiJktrPatKJwEQJOIGQAEDMcQ95r7W+IACMWK4N5FyhNAAgUHdcg0QxAPmXRpAOmO/M649MUKwvzYDQoCWZXF33AjB3rqUPZct/UGcG18DgEGt9RIHkMxQpNOUe0vEOsgBAPEeQgx7zsfc0gGw5wR1Sep523FiIA6C/am0RWASMRiUrQIgQSQEBoBhh59ICAIcExQx+50niOGPipChSKeoMxMSMGDa7UvAQIqaiMGw8nLIADAoBZtFoK7oiACIw4BBDcQoQYIYVn8pnO9RYRj+/hYa+SAwstkrHtZVaaLkDQSl9DEAjwEWB5NNXoau3Ubh6W5z3e9T3nY+92hXgVeuGwUAmL7kW1z77HwM6dwaX3yzBwCw7t7xAIANu6pxwh9moWPrcnw85RT0+fW7qE5m8N5PTkTPQ1tk1Z4PV27HFU/O8Tz74vZT0baixNturp0Mo45sh6evHO57vnF3NY6/bxYAoNvBFfh6x37nt8cuPxqn9T3Mk/7XbyzGPz9djzsn9MXzc77B8m8rMbhzayyw+z3zZyehR7vmWLm1Eqc98KEn76Tju+G2M0UpqRfPfLIOv3lzCS4Z3hn3nNvf05+ju7TB/PW7cdv4ozDphO5Onpv+/QXeWrQFN518BF6evwFb99XhiSuHYvRRh/rKX/FtJcY++CEOb1uOl687JbAtPB54byX+PHMVOrUpx8bdNc7zX57RG9ee2CNyOYAlvjvytned73ed3RdXHNtVmZ71f8LADnhz4Wb8/LReuOmUns7vJ98/G5v31KAubeLtm49H3w6tfGX85MUFeP3LTc73/3f+AFww9HBlnXPX7cIFj37qe77wN6dh4J3TAbhzXGwnAHRvV4GX7PUBADc//yXeXLgZZQkDy+8eh8c/XIvfTV3myX/koS3w0nUnKvv/1R2nOdyFaVJ0/+VUT7q4YYmi/vPDkRh0eGtc9o/PMG/tTvzolCPw0Pur0bF1OQDgpev9731PdRKD7npP2q9v99bimHtmSn8DgI9X78Bl//jc+T79Jydi/c5qXPPPefjvTcfjxn/Px9AubfHARYM8+f4ycxX+9J4VmuaS4Z3xPBek9aCKEjx2xVCc98gn6H1YC7x43Yk48Q+z8M2ualx5bBfceXY/XzuaEvKh5N8IgJ/BnQBsjpgmKO9WWzQG+/+2PLQ1a/ASRCYTjWIaW5/746NYZmWrxOQVomJI9TDFZ7MS62RUxUXmlcVqc9oaQckfeCe50y5vGvY1Qy3RGqB+F7nKr1UREXIK+WOK36PquuTpMiZ1RGZRDAGC0jGojCSitlVlRcayV0qiWYfdB8NXLVs/TGykChUTj6nNlOvjyS+rj+lgEvFoZso+PxhCfHOO1VOfiAfFgnwQmLkAehJCuhFCSgBcDOBNIc2bAK6wrcmOAbDXFn8F5X0TwJX25ysBvJGHtmYNflKxyS7b1ESpC/ufiye/bJ6LymyV8YBqY/CEDPcpdP15eOdipsOo9BAY63+ufjCOMt2R8vjLEYtx4p+ZLoFRbpAKZX14u6z/YiiUXJT8YhlBU8Eb502OjEkt8VlAe8QNOazdqsNA1P6K71o0U66SXBcQtib4sZDNr1Jbx+F3tLT+B/vBqOvOxpcMsA4QSc5MWRkqJsCC0yBuuzMCoTkQzJTrLSKjlKYJITcBmAZLOP4kpXQJIeR6+/dHAUwFcAaA1QCqAUwMymsXfS+AlwghVwP4BsAF9W1rLvCcpuwvsmtoRbNYIuTJBjIrsqh3uKjq8zgnpsSNT0JgOL2Cw8Fwp1HX4sVfF7vzIghO5IGAdvtOjKablin2lWbKOR7+2Fj4iFsDczD8T048NEG3kzZNx1BAzanKN10VUioOMGKHRWJRJ5gp75dwMGEbp3csZHXKTaHZfEkYRoAfjBphXfZztW405USM2KI7f9/4uS3uHYQzJhEtMw8ER8t86GBAKZ0Ki4jwzx7lPlMAP4ya136+E8DofLSvPjAlp6nalH8SsbnARGOOs1QufjCS9SeefFSEJMrJti4jEit1Wyi1rHUAL4EJiqYcSUQmcDBS805h82J1eUVkcjPlXESTfB1+4pZ9eWIbguaCbJ75yjPV4iFV3rBTucqkPOrwiRuqaKYsu/At7N3IpAY8atNyJ0/2jphlWVjZ2fwGyMWPrP+JiMEuRQJjEOI7rDkERvvBHPiQ6WCSkk2Nhb9gZ876OVqGb9pKEZlikfCTVTz1S0VkTHQFl4Px1MNxEyJUp2JvnXY99ojJouT6xT1uncwaS6WDEUVwUaEST+RymPSJyAJ0D1FCzWdsE22rndHef5gbQjKjINAROyzOQ0awKLXqlulgwohXGLFNpr1EzN2Yrf+WDkZReEDdYV2WiR+TvKOlIfeDCZIeGJwORvS90+H6D1Dwm5Isgq1sU2MTi4k1iPM8h3D9kmdRlfxRRGQigk5uvJLf20bvYuARRQcjtocngOyUJ/aRd0BzRGQqHUKO4gVRSe2Ul4uxhs/TXJ2WL15VVdqkoSIyPwcT3MaUQpwZ9fQspvMGo3T9gHiElcz3P1is6CUw7H9cwUlYedT1hgXL9IsfOSV/kA6Gmwi1ksMpyyLGP9Se/AcoYhyF4ScdIyKeeEiml51lOZ07HnI4hMgmt09ElqWVTKB4JqSNMoc+d1HnKCJzCLL1nd+Y2E2OYpt58RULBy+eCN201v8sGRiHkGcrapJBfEdBoqFId5lwxg3KA0aWhFH1rqLesyMeJviDEHN2FRHGVUUJiWOV4/0eyZM/MFx/MOfkP3S46z5uB7uUEeZADsZQc2IHgpJfExgJDA+BcZ/LFnVV0hIBpIUdzQ0tn/0kke0d0c2Us3uu+o23vpLVFWRFFiXYpbioPATGvkLWJ+6BWyfbKMKsoLIlCw6BydIaSwYxknawiMxflyjeS3usyBTlZMnBqN5V1HkrHgL492FS+fvJSkSWxbx1A08SZR1BdfNNlYq6pCKyCDoYnjtPy3Qw9sHJdDl0VRuaGjSBkYB3nqaUorI2hTv/uwT7k/7T2L6aFF6auwHVSeZjb5fB6WA27anB6m1Vvry79ycx+ZVFnrAwVp3+NokbgWryscn57d5aLNiwBwCw/Nt9WL5lnzS9qj5vmf5nJqWglOLO/y71/ZbKmFi/cz+WbN5rl0/xyOw12FOdxIcrt2NHVZ3TTsfmn1uETG7/wYrteHmeG+jB1cG4n1dvq8KfZ6zCw7NWY9XWSjetMD7f7KzGa19sxBMffY1tlbXKvrINQ9woXp63EV9t3KvMx2NfbQrrduz3czD2OFJK8fcP1mDDrmoAwOJNe/Gn6e4d8XzVW/bW4OFZq0EptXRPjojMK1K89bVF2MmNKwM7lX+4cjsuf+JzPPf5es+YqsSZKtGZiIxJMWv5Nny7t9ZXXi6HHavN1v891db6UEFcAs51zQEcjCgGm/rVFsdQRNT9bN1Xi/veXe4GvvWZKfNWZIYVgUIgzLv3J/Hy/I3Od1HJv2l3DWYt3+bpj2PMEkJgZq/Y5nHaLEbkxYrsQIPIwTz24Vo89fE6tG9V5kv7yvyNeHDGKgzu3BqAKxrjL8caee/7APzewf9v+gq8OG8DBh7eGpeOcMPcyJX83okZJmM++f7ZqEllsO7e8Tj9wf8F9FbBwXBRSFQRpbdV1mGphHAlMyZO+n+zAVh9/mztLtz37nIs3LAH7y75Fkce2gIn9z7EU7dMHLBiayVueWWR44nu6mBMJ997S7fivaVbAQBPffw15t12qmcc2Js8++GPsNvmjKYv+RYvXnesdCxEBTLDtso6nPXXj6Qe3iLOf+QTrNxahRk/PcnznHEwm/bU4J53luONBZsx9f9OwJkPfeRJx4tqrn92PhZu3Itx/Q7zWM/x7Zu25Fs8P2cD6tKmhKhZ3/+7cDP+t2oH/rdqBwA4Y6oiMNlcRT3x6bk4rGUZPvvlaA9hUoupgsHy/XH6Ssxasd153qo8gb01Kfz+nP745etfuQ6KYIcUl4OJch/Mx6t34sbnvsA1J3TDr8b38XFOv3hlET5YuR0nH3kIhndrK9VvpU0ThFiWazIOZpmwPmpTpidd2qR45tP1nn4HSQd4XPWUFX3kkuG5hchqDGgORgJRB8PiQe3an/Sl3WSHE9lqn+BEHUzQJGGbmRiLMJInf4CcHgBqJL46PPgAkbIm8tIZWV3WuMg1HOLpl21WbPzWbK/ixALeNEFwzZTlYjveEVRsMyMugKvjkSGpMIHNBiu3VknbwLjOaptjVZlY89n22G2l9vMSiYiMefdX1aaVIjJx7rLNWSkiy1L+/+0+a/6LIjIZwkVkkLbNNCl+MLIb+nRoKS3HCZ0fdB8M93yfbYCwYVeN77dMhjrcBuNKRO6EBdlk+kCZFRn7epFN0OvSGanRDJ9WJDRNGZrASMArtU3TtaKSWY+xTY2FdWDcT5B/B0Oak9+GQaxbKSKLOCv5oIvZ2v8D1uRX1SVunKwm5n9jcCe4qOIAwCVGpkmVG4jT5hxXZzYn9zD4/HjsRjPnQ+ZfJILfYJjJN5tX7L3x76zcnp+1Eg6GpdtV7SUwbD4lFZZKuVowpQQlv+wIEjUkizjH06YVCNW5P0Uox/Gqj6n9YHglvxsm3zsXWV3OOZMRPJ9flh1B3X4nMg6GvY9E3EpTmzJRoXjvorlyrnO4mKAJjAT86Z5SoJkk7DdDZZ11ChKtopzJG7ATMqIkhlOvXyyyqATGrTPQUgdULiKjVHnCqpJYDgEuQeVv/mPdiLKh8cQojCCpvOHDkM8rmFUczD77UFKeUJ1kGXfn+llkTO9hhN9A2XytTWaUpt0iB8P6qdTBKJ6H+9Vwvjomcgpny4tCeaRNS7wk3p8itjkW5MnPPRcJFZ8nY1Iumrpdv883iiJDqSPxiBuG0vKRj4qt4mBYTlfXqAnMAQle8mNSqtwIAGBfjW1FJrlrG4jGwYiiJpkBj3iyVpopKzYYEfw9EzJixe/LUg5G8RwAqupSvrSAe6KPcZYz2VyuxFJYd5eEnIJzpBNRLOCiQrXZMBFdWYioJEOpI5ZhBME1U+bqybhiUZVzqkhgmPhH1V8VgQkjwKmMibKQaAPhHIz1X8bBJAzizE2VFVkiQAdjSgizyE0D1tgzmsDWnjgmJqUwTepIPGQcDJvfvMRAdWBleYMCyTY1aAIjgajkNySnYHZKq6z1cjBiGUGmqbwFCg/ZtBLnmtKh0rfo5On4E1WouElmRRbARchC6QBuFF2PaWaAkl+Es/BMOffkIYoBizOIq8krgRGjL9jvYp9NYMoT8uXnXtft5uGv5rV+c/vHNr6aVMb3rkxqXaJWKQSdZAQmlTGlJ2rVvFH5HQFWf03qBqOsr5JfFpolZhjO2hKjELs6TeJEEgiqmxGYtLCxA5YOhnEwtUk2Vv72ZKjr9CuLRcbeB7/Gw0Sjoi6mKUMTGAlERy/ZRtqyLI7SuOHTwZBsdDD2b1GU/D7ZrkpEJqx/lU5B5NJUCFqo2S4AthES4i481WlVBj6tNEAnJ49xRGSScoLEPPnUwfi4TtPLwag4YzYWlojMe3ouifmV/Gzjq5GIyExqmfuKYEYgyYzpu0GSr0+EyjCBb0cpb4ggGepQJb9dtWxOxGM8B2OXZ/+W9BFhWd3uQ3bIEsW1Vt2mUw/zXZFxMBnTPUzGDOLzfWJrhCcwFSoRmUBYDgA/S01gZBDDXcjvpIihRVnCsURhk5Rt3FGsyNhpxx+5159H3MyjBrtUxQXjT/FybsD9ne8/O62ZVK5olxmWsUfMuixmEO6UbnMwEWRaPNcjJcL8CZT5nISW6kU+ORixLNY+NmdknDHgFdmwuZgURGT8HGFjVyuIyNi1z9US/y3GZaYyVHqiVhFaFXfK5ynl4qWpLBCDEMTV8joYnxUZ84Mx1CI6jw7G3v0yHEFn4NdXTdK2IvM5zloiMkY7YhIrMqmILICD4XWbuYY7KiZoAiMBzwpnFBxMadxAy/K4k1ZU8juxyAKU12zDjXJJlNgE1SIVy1KdRHln0mAlv7dMxwCCyolcq/KE7xlLxdpiEOK7+yKakt/6n1GIyJLOfenBfWosEZlYFus/09uJUa0Z0tyJ2hH/cBZS7DexnpqUl4NhokgZsWDOvcl0xuGKPG1QvA9ZdGQG1r8yR0QmP5xFFZFJORhDbUWW8o1RcN0ix+BR8lPqEDJenOhtJzxKfqkVmVREpjbuoEIbmjo0gZGAP02rRGSliRhalvk3UwbRBDKoHjGN7OAinmZUG4CYV1TKMgLhCQUj42A8ZboJXE9yed9kBIa13RWR+XUwkZT8EazI2ObthFsJKEeGfIrIRKLJ7slhRDCVNgMvqOLHV+Rg+M2HbcSikp+FgpcRTVfsQx19orft8nGolASvFNvIXykgY0zDLNGCrKhiBnHj/KkIjCHncMQ8rHxRuQ5Y64udQ2pSKh2MV8kv94NhYjtORFaqMlP2tk/rYA5AMOcp97t8opfGDansmm3cMh3MVxv34smPvgYATP1qC76w77d/+uN1+Mj2sAbkE2v5t5X4YOV2/Gn6CtQkM9FFZMJGwRY/f4qqTWXwo+e/xD3C3elOmVwRjEBRKHRTAoGZv343/jZ7td0WK71BXKKTEYiPDL98/StU1qY8J07V4mP6jaDFufzbSjw/5xv86Pkvce87y/HrNxbj1te+snQeETmYz9fuxJsLxZvBvRCjL6QcfYrbZ9nldTKRDWtXiURE5t4i6Z2rhEDJwdQmM3h/+Va8v3ybR3wjlinWtU9yQ6WYpzRuza3Fm/aGiqlk2LKnBpOemYtP1uz0/RbnRGR/nL7S4qgELjjORTv42+zVuP7Z+c684OsWDzcZgfiwoawL42AcKzLDeWeLN+21/bWs7yUeEZmag+GXFCtr5rKt2FlVJ81T7NChYgQwgjC4c2u0Lk9g1ort0s3PEpH5T+uMfZfdB3PWX62QID84vhtufO4L5/mcdbvw/Sc+d8KQyNbfjGVbMWOZFRKFEIIhXdpI2y9u+qLMvCwRQ3Uyg64HVeDGk4/Azc9/iW92VeO/9mZ56xlHedKLOij39Ogu0O7tKrB1by32JzM+Dua8Rz5xPqc5K7KMQyzk7ebx78+/QdtmJZ4NQdykzuh/GKZ+9a2j33CIokIadutrX/me/ey0XpEJzEWPfQYAmDCwgzKNWBb7nnKcHE1pxAVeRCbmlV04xh+IUhkTJ/Q8GL8afxTOefgT0AAO5gZ7DiZiBh64aCBK4zHMWLoVr325yVNm2nTv32EczB1n9cG3++rw6AdrnHRMfMYOXtc+O99TZ/+OrdCnfUu88sVGBGHe+t2YsWyb9Ld4zHDW2De7qnH/tBXOb0mBgzEp8Id3rd8njuyKEd0PknIIsvFOm9S596lG8Ojn82dMzg8mZnEwc9ftwgWPfopfnXEUDm5RAsArImsuOZiy+kVT6epkGlc/Mw/9O7bCf390vDRfMUNzMALYYhzb9zAM6Wxt4jJZsCUik0wU50ZL62sut9KFiRCq6tJKs17xxMiCcDKwDSpmEIzv395qY4iMTB5N2RV//HLcUc6pUUZ0GdimxSv5WV/Dxillm8ACfhHZgE6tcPXx3QFE42BUyJjy036uED2/HYU942TS1BfolLUD8PaBiTqdUDFcM/kDUDJtokOrcvQ+rKXDKcoOSPzBoyRu4JzBnXBG//a4xI6Jx+fhx5pZTZ41sAMGHd7aUyYb+9bN5HPggqGdcEjL0tB3I+PqGGIG8Yh3eZ2QKyLzE2HXFNkti3VRNt4mpc6Ys7ESrwJnnLToB7Nxtx3EdPNe5z3xIrIgB1tPG0y3vSu5QK5NCZrACGAEpixuuNceSxZoWdyQKkfFA7PMDybMOiTs93TGVCrFWV52ihMjQDMCY3DK0rRCHMLAczC87wF7zgL9AXIdjAhC/Is6zEw5laGuDkZYiHGDOPXuqweBCfLxyAUqJT9PaGSbqXjtMODqbUokHAz//lIZd8ML0sHwhI2fx4zzTnnKdD+z8W1RlvBZDDL9V5tmJb76AIv7JQgXkQU5c8Y5R0vA9oliVzc40ZRtMS5XjOzgIM5BUQfD5oOKg2EiSdeT3/KDcSIAcGuEF0OKkTv48jwiMko5E+ymabOsCYwANrlLEzHuMiw5ByO7iMuxcAmw5U+FmOSGbY0pkyrNetmEZousRuBgmIVPjLjiLr5/rLlumAwvt8DWIP+cJ1bNEjGpqTIPr6Ol9SzMTDnNRVDmw/UDlvihZbnFTboEhvUjOsIChGYLcWN34n9x/2V1ispnPq97ZTJXjyAiY/uXo4MJUPJb6dxRMiRznucuK+vSKEsYKIkbPjNrJp5speBgYsRV0Adx6WEcDL/ueCtPN1SM3wiA9UEmInN1Xm49GZM6Y6S2IrNFZBwH4yMQDoFxt9oSic5LbBNrg0v8lFlCJR6FhCYwApyTYsyQnuYYSuOGJ+oyg2jhIjM1DDPJDTOoSmdMtRUZY8ltMYF4oyDPwQCMrXf7xzZ6Plw/3wX20WLfbQJDvM5mqhMaQ8zwW5GFjUkq4ypAeeUpYBMY26KPKaFz4WDYRiKzqsoF4rzxicgyplREJtMJsNN0SSyYg0lzJ2rDsII+qpT8TtkcsWGbpYeD4ebHvpoUWthjbQjDxIh763I5B2MQ77xSIcjXJm4YngMMLy7loykDop7KNYRg8BEYj0jNdMa8VmFFZjIOhrMi48uhcN8hT2CCgtvyXJdJqee7J52HUCqLKzg0gRHgcjDuRJbqYOIGYpKTiHjiED17AbXzI0PYiSSdkcvV+frZpPfrYBgHw8Qo3v7JlO1eDsZdPOx5jLiWPYZBpISXBy8ic8YphIOxdDAKEVmMoCwRQ2nccHUwOaw6591HiG4dBX4C4z1ppxRKfpnZLLNIk4XrF/UlvIgsw3EwPOGs5eYgzzHIDlUeDqY27egeRX+ifTUpGAQONynC4OZJ0NsJihbAO1oC1vwR1yev5GeQiR3FmyNF7kPUwfg4GJMiQ/nDmjcyAO8rFkVEJmufyhcmE7JmiwWawAhwrXViIRxMTLqR+j3U/S8/TJ4advhOBfiBiDJfXgdjEDdsuOMPQ4hnA5FxEhnJacmk7uTnRWQWNxPcfq8VWTQOJp0xnV1JVPKz99CqPOETkWUDtrHFA0QY2SxmtRUZdb4H6WBkd7nLOBhx7PjDg0nd+VbGERiec+I9/WViYb4d+2o5DsYnIkujRVlCeU+QYbjq+SAOM0gXloh5dTAyn6h4wBjxKR0uWuEHUydakUnCwJgmBZsufg4mdxEZe3eqceL3lWL2l9EERgCvTCUBBKYsYXjC+jOwTTfIgTDMFDZswqTSphP7TIQl0nLZ9mrOyiZuGM4pyz3lyk9DHkdLnoOBy3kwpoOXi8cIkeqmeLAQJnxfwzZuS0TmppUNUUv7xkO+3GzANrYgEUaQv46vPIWSP+n8p4EcDL+JsDwlXBgWVZtiHAdDOQ6mLOH1fWLg2yAVkfFK/tq0Y4YsvuW9NSm0LI8rIyVEFpFlwcFYEadVHIxfjCi1IhP0gdZv1CciEw+GoojMjc7s9pG9S57oxkXZolAmSyOKgnkkBa61WFEvAkMIaUsIeY8Qssr+L3XOIIScTghZQQhZTQiZEpafEHIQIWQWIaSKEPLX+rQxW7BJVRrnRGQyJX88JiUwLC2bF1Ilf8ZEmSKSLhBBB2OagdGHTcrpYHgOxnA98ePcJpSS6GB4eK3I2H/qOW05IXIIkY4LD4PwF47Z9YZs3KKZskkpxH2sVbk/Nlw2YIs2XwRGTOsQFu4uFhbniofjmc/rSVJeAuPx2RDmp8eKzOS4cm7O8USlNhkiIvOYKaccU3QfB1OTQsuyhDLGmsEr+QOEZEFK/rhh+A4//Lvm9YH8GCUdAkM9eQG5DqY2nXHyuByMRMlP3ZAyjPPlwyA5OhiOe0wE6PhY++IxS7ypIsT8Oy/mkDL15WCmAJhJKe0JYKb93QNCSAzAwwDGAegD4BJCSJ+Q/LUAbgfw83q2L2uw+FClcV7JLyEwCbmS3x8Cxb+BJDMmmpeqzXmDFp+Vnwb6jfCnKl4HE+M2f0dnQkigPNciJHzb3P+OiIy4vgm8nF0Fvk7HD8akUo9yBl4Hw6x3SoWF2rIs7vPYzubCMTccizqPyH0Ghp1Ricg4QhNkuVbN/eZwMDFBzg8JB+MRkbn6urI4z8GYTj9rQnQwXjNlVwfjM1OuTaFVud982SmbMzHOVckvcjAm9VpUxvj7YjxjpBaRpSUEZi93xXYdFxiUBwsVI3IwPHfuevJzBCbgAOZyMMRjRSbCE2mhiC2Y60tgzgbwjP35GQDfk6QZDmA1pXQtpTQJ4AU7nzI/pXQ/pfQjWISmwbGvNoVbX1uET1bv4DgY19xWdqov5fxkeIgnc9mBN5Wm0jAzCzfswaKNe0J1MOmMGWjqbFLq+sHU8fJ14pzOXR2M3yR1/vpd+Hg1F7qGW0SexcOU/Nw4xAx1lGAGw/CLxtJcHdI+c2IxJiIrjXsd1lqVJ7B7fwq3vLwQv+PC3jz98deB7WFg4tFgDoZ6iErGpFi8aS++3rHfl/bl+V6PddEPRhUqhkFm6cXuWnlv6VZMX/KtVY5wKDCcd+v1g+GV/Nbd8NYcTAscAOsnQzpDsWVvDe54cwn2VCcdiz2ReM9dtzuEg3HnBj/HP1m9w4kkAVgcjCqcinVlslv+rBXbsWFXjfOdcAecV7jxd5T8/GFKmIN8m/awS+ESBjbtqcGzn67DV5v2etpiUm+oGEc0Z5e37Nt9WLW1CoBgRRbAwTz1yddO+rq0ide+2ORL8/aiLbjyyTnO9ymvLQqMEVdI1JfAHEop3QIA9v9DJGk6AtjAfd9oP4uaPxCEkGsJIfMIIfO2b9+ebXarDADPz9mApVv2ZaGDiUmVmbwSHFBxMBnf6RsAzn74Y0z468cRHC39HMzwrm3Rr2NLp27GrnsUuIDvtGVxE1557nmPfIqFG63FxOTIpYL/BS9f5he8JSILbD5iEhFZKmMiESCbFjkYk0o4mPIENu2p8WzsBMAd/10a3CAbYkBJVTvEMCpnPvQRTr5/dmj5TGbP6kmbFPsDohNXp9zfRCX/p2t3OqFYRKtE10zZOhDUZaxrjHkCXpPMOATn+WuOcZ6rRGS/fO0rPP3JOqRN93AkOw+M63+YT3TJt0um5L/0H5/jR89/6fY1baJlWQK3jD3SX4ZBQALml0Fc8+k/z1zlPGdj7uFg2BwURGUAsMfmYL43yNqqbn9jia8udshyTfRZIFLr9w27avDiPGvr4w1H4gbBf286Hp3bNvOV+fcP1jr9BID/x4XCYfj3nPVY/q3r2f/O4m/x2IdrfemKAaEEhhAygxCyWPJ3dlheVoTkWd6EhpTSxyilQymlQ9u1a5dTGRUlcRBiKTAdU9UwEVlcoeQXTkNSK7K0tUGO63eYvE/Cd7GelEQH89L1x+LsgR2dNrDJLpops4lucGKUtLBh8mCWLExBTJ3nvA7GbV8UERmFS1j4CMlB1lsW5+C2MUOpR6cARIsiEATnWuKAE2YyY3qU0GERCMYcdag3f9pLoPYFnDyrPRyMnwtx2yAq+a3/Trj+tImSmOHhOGrTVmj/7x/TGf06tuLySghMxvQYLDg6GGFeNi+N4+xBHZXvnxBORCbvstW2lEX8fnjyEb7fEobfwZNHTDH/ZH4wYpBLj4jM5mDOHNABh7ctB2CteZ6zUnEwsgMpf3hKxAz079QKI484SNmPoEOODA+9v1oZrLaQCA12SSkdo/qNELKVENKeUrqFENIegCxC3UYAh3PfOwFg/HCU/A0OwyBoXhJHZW0KyXQpAMEPRmGmLJvIohe2TNmcylhh2lULRZS7MnksQzpDpVZkhsOiq0PFsInOb0JBSn6RW/B6QsMuKzsRWTpDwaRbLgfjEkV5HtMjVpOJyIKuT4gCh8AEiOpSGdNjRivzc+IhEsE6W3lcURLD/mTGCa8iAy8iYyfw5qXWYYifImLMMzFUTMrmYPhu1SQzSJvUZ9EkM1MWiajKiqzCvms+mohMPW51aVPp7BrjTOLldRCp3k2q5OdErtZvbnpGYJqXxe15VYO2FSWOGTwrK2N6nYwBuZ9bOUeYXOKh7kjQYUulo9q8t1E0ClmhviKyNwFcaX++EsAbkjRzAfQkhHQjhJQAuNjOFzV/o6B5WRxVPAcTi4VyMLJJIFqkyE4zybQJSqEUJYi0Q4x5lsrIrchYc3giwJspg8BxDuW9vTOCvJ0HFRTqrGimaAe8Vz4bEazI+Ly8KDFQuc558rM2iuNSXw5GjGUlQypNPY6AYSFuygQiyEQvzew7QfbWBHAwnH6GGZ+UxA005+4TSab9c4G9Wz5UDB+ZArAJTMb0vaswJT8AtCiV62BYu1Svn68rzMhPdYIXdTAiCJHXz3yPoir52TXTzUvjzrxq3azE02fHD8ZuKjvUyfzc+LmZcKQIym4ofYkAtZVdUJ5Cob4E5l4ApxJCVgE41f4OQkgHQshUAKCUpgHcBGAagGUAXqKULgnKb5exDsCfAFxFCNnIWZ41CFqUxVFZm+aUqa4SP5kxfUrHsoSCgxFs6sXTJeDqE5QbsWCCK4psUhlTKpph7eU93cXrcnnCAoR78lsiMj+3QCk8IjLW3igEhneO44lGoJI/Y3IWZ3JRlsyDPBtZbF0EHUwyk/GIi8LMoUVz9J373Y0LCBaRec2UXSdQPhrvnppkiB+MRYRKhNBGVXVpm4Mh0ryqaMoAJyITXhfrk9oPhiMOIS8miIMJgmhlxsAiIcg8+d1Dk5t+jxPU0yUwbZolBCdPay7GHamAvV9IOBj+8MTmVxChDJqDKgITJjkoBOp1HwyldCeA0ZLnmwGcwX2fCmBq1Pz2b13r07Zs0aIsgaq6tOdiJ15E1qwk5tmsSxWOlqJXcFLiNJbMmB77eV8Z1GKe2XwXN4GUwkzZsf833dP+fk4HQ+ByTbwfDH91r+xGvoxJUVpmCM/hrEiDs07jfWJUyJguAWXjlDJp4KKqS5scV8jq9aaRXRWQjcNlFCuyZJp6RGRhOhiRMO+2CQwTJ+0L4GB4QuYYIAgirT3VKb+ITDBTTmaozwO+qi4NQoiPWyPOnHfL5PVfADglv8DBBCj/WdmOCbFdoGqzVIXrETkxERYR8z93OBheB0P9c52BmSk3L407otc2zUp8N72a1D2ssbGURYPmiS6bX0HrJBcRWZ4iHOUVRdikwqB5qaWDqWPiBO4klMpQjwwVsCZ6FE9+2WRLpk2YpvrEkRG4G3HDq01lpKIZN4qsu3GLHAwfM4x9TwecVpnlkyjq4f1jYgZxCZbiBCn2T2ZtF3Q6rUllfGIVsR6ZDiYbH7QofjAW9xidgxF1MLtsAsNMhPcG6GB41CnEd7v3J/0iMo8OhiKZpigRdIbsvYp6L8blJD2HDtMjrlM5WjoiMsV7jHGhYtioqTg4FtJIBK8blYE3U+bhKPm5Z7y1pml6zc/31qRAiHX7JIsOLd5zw8TH7JWwsRRFZOK8TgiGNjLIvP2ps6fIiXKQDrNQKL4WFQgtyuKorEujLuUqGF2Fp+mT94siBwZR9CNjl5kvhWqh8KaPgH/Dq01lpHohVh4fwlwVloaX03sMCCRKfkr997ZT6i5QwyDO7wYJD3aZMSkXs816lsr4xTU8alMZn2JYrEemg8mGg4lqppz2jFeIiEwgzLuqo4vIeDgExvByIrurU3aIfvehzw+GKfkl3RLHXBXskue0HCW/T0QmF53xZbO2sXepMnKQ3bUEeHWjMqiMTBiXLjNSAawx4r+nTYrmJVbYmxb2u6oojXuIJyPSfJgkwK/kF8cjHoGDkV9jzbg+zcE0OfA6mNK4V0YqcwJMxOS6BlF5LScwwSKyjBnGwciV/F4RmX/j4093/CmXt0jzBfSzTYLFCU/BBbskXrlyWCwyVibgdbgMkztblmNuGnH4ZCKybG4UjaKDSWVMr7NeiJJfxcFU2JtWMh0cNshtW8YmLgIHU51EKkM9gSx5T34rFlkGpQrRkkrJz4+bSb0EpnmJisDE7Ofy908IOD8Y67/KyEGlg7H806Q/Oe2XEVJn0+dFZNx75P2sGJo5/XHL9ovI3OsRHB1MRiQw3gYz4kmCrMgknWDlqsSKYQe7QkATGBstyhKoqrV0MD4CkzF97GdCJSITFIdKERlVixIy3KRldXnyZ0yppQp/0ZLs4M5b2PBxxIJCxVinNH8b2OkNsCY2I0AxI/wkleaV/CbTqwincGFoUhnqM7YQ11OLUr9KMZuYZK4ORr1Q69JeDiYsCnSZsFHurLIJDNePipJwVWhd2pTK5S0C4zXr9frBWG1MxF3ixI+tj4Ox8/IcjEmFkP7c4YRHRalcN+O0i/hjkSlFZCodTNxQEjBWt+x3Wbh+MdqyOFUc3y/KyvYST1fM6NXBiEYX4njEo1iRSd51Xcqy/FNxzVpEVsRoXhpHTSqD/ck0J+6xfrN8NLzpVQTGf5GWPBZZqIjMIGjfqgyA/DTH7kbnwSZyUAwjV0Th5vGKyPyKT5NSJ0QJi0NFOT2PYRBOcRkuIttWWYeNu2vs8uG0md/YpWKOtOnoLgD4rHdkBDtMhMUjmoiMBhJkEaUJL0HcXe3lYAD3pBzWNtZf/nT7wpwN2FZZ5zEm4JX8LHIAb7TCc3oqDobnvK14ZmqjEgY3jL+8D7JYZCojh1ytyAyFiKw2ZeKeqcuwvbLOefb+ctftLsVZKTIwaz1Xie8NtMkCvvKX9wHA1K++9bZJFJEFzFcxDY+6tOm5x0eEFpEVMZhceWdV0lmsfKiYGCH41RlH4fYz++DHY3qifauyQEfLIBFZMh3saMmU/K/ecBz+eulg6WSTEhiOg1Hte6xKJqISmyCKfJgis22zBP5w3gA8e/UIpw4vB+NyfX++eDCO7a72UmYoT8RcXwTBTFk1NjwHc3LvQ3D5MV3w2+/1c57dMvZI/OgU1wNc5afSqU25Jx0gj6b86g3HetJkq4PhRXrNS+OOiKx/x1Y4/oiDMejw1j5vfxXYqfYfVw7F5cd0wVXHdUWbihL0ad8SY/q4UZb4u34cPxguMgVvDCESU9dM2e0XpRQp08SATq1wz7n9nef8tDy0ZSmuOLaL/Vz+7vigqKEEJuJuecOoHvj5ab3Q69DmTh2yffvTtTvx9w/XYsprXznPlmze53xma5IHOxxccWwXXDi0E64+vptnvThXJtsPe7RrLm0jW5dv33w8fnlGb2dfEZs5oltb57PsUjL+/qAbR/VA94MrpPUUEzSBscGUrjv3Jx25uWOmbLPB15zYHVcf3w0/HtPLMvGUcjBeCyuZiIyFnledxph3cIfW5ThzQAfpgrXMTL3P2ES3fFckOhjwntSw++gtRBUqhhCCC4cdjg6trbAZFG7MJUMQkXU9uAJ/OH+AtG8M5YkYxg9o77QjZZqezU7k9gcd3hqAl8CUxA3c/b1+OKRlmfPshycfgdHchs10CTeM6uEp76rjuqL3YS09z9z7YNwx6djaGy8qWx0MfwdLC47AHNKiFP+aNAL/+eFInNonIoGxB+Wo9i1x9/f64Y4JffHGD0fiPz8cidP7tnfS8fHmqKPkj3EcTNyXlsExU+b6xcyUxxx1KC4Z3plL6+a9/4KBoSIygxPRMhEZ08GIWWSx+mSYfHpv3HRKTyeulypUTBh4JT9b1+X2PtCiLIE/nD/QNiJRi8halSdw2YjOEMHa07dDK1x7ojsPRVHei9cdiyMPbQFALqat4whMl4Oa4fazvK6BWgdTxGAEZtf+pE8Hk0rLTWjVBMI1edyf9HMaTKGomg/JtOlhd2Xp9telfac8x4rMVN8j4ehgHC98gcCobu1zTsXWcxaqHLCIQUJQXIaJMspLYo6fBmtzEAfD3gkvIlMtKH5xpiRcCWuf2EQZB+NLI+hgwowIPBxMmUtgeCfRYIc7Iv0sgm+nzw8mbdp+MO5GyKC2InP7pTKR5pvNK6xVqgDeIZcN4b7aNMoShs8CUCUiU4Gfn7nss7ySn9XNHw4Y+OFi/mb8+5MdOtVWdf5n7o2z/v7XpTOOBVlZwn+j7oHoyX/AgE2qqjpOB8MUnqYZyQKHgffzkG30lh+MWkRWl854Jo+snr01KT+BMcJ1MDyXA/hPUaJIz6RevxyeA2J1xAzitIVtvkGOYoCl/GZ+GgAzU1Zvumyx8xyMaj3xBIKJPcRramUWWbIbLUWxg6WD8Z7ug8DrRipK46iyQ/fwdQSNFO+1HzSmfDt9IrKM6blAjw81I84tGdFWOXl6g5zKn3vK5sacHcD2Vlt3yIibY7YEhs2dKMFWZUil3UMhOxSIJuYA5CIyrqkywqDaJ2TNZOtIFg+PF5HJLjzUIrIiBpN5WlZkXh2MKoyJauKYZrD/BYurpcqfTJuezU+2YKq5cOtOeySbP+CefAlnYcObGPMQL8CyOBW3DSw5u82PtY9tmMx8WnUtLNtIykpijp8G4I9FJrbL4WC4zVG1kfCbt0vwRA7Gb6ThcjDqsRc5GBaCRAXeBJnnZkoCiBgPnmMLus5AjGht/bcOCGIsspK4mmjJhpRZ14lp+WYTBbERy2Y/OTqYWusWTPFdlMTCDR948GLB+orI2PoXnasBL6fGDl/8+5NxmUGhc0SI9zXxqEubzrsoS/jNzrWIrIjBT4wofjD87yLYVaeqS5OYH4xqPtQJIjlVOpHAsP2H56AAoFV5ifNZvDhM7IPo+e/Y+nOmr1Z+ztGSEIe1ZyIpFfFk3tBltk7AiS8mKvkVJ9pm3IletTHLRAWiiCwuE5GlWdvlIjKDuJGwxTwq8BwML3Ip4TzVgw6e/CYXyMFwP3ljkfmV/DFPWu+48CH1GdwgoNE4mKANlXDzB7A4cYuD8ZYt+g+Fgb1z2X1EUfyMkmmZiMyfT+RgTJOGShtUG79snFjdsuOpT0Qmcp8hUoNCQBMYG/wGJJopA/KJIy54NsnZKb61IrqvFU2ZKideXTojhMCXp/MRGM5MmTe5LC/xb5juZWHeMkUOxjmlsbYS9pw6t3XGODNlFhdLJQ9mFkzsBMb26rTgaOlzTrP7Wh5BRCYTr4gny5jhdwh1nRndZ3yakrjhIzAyIw4eKg7GIyILOHnyoq0gPweviMx+Rtxw/YmY66AYpjMQ56UrIlNzO3z9QSIyUcm/rzaFluUJn95GZkUWpNdzTYX94ynTpYhIcRxMkA6GL5lS+AKGZqODkT1m80J26WBdyhWRWcF2vb9rDqaIwS94kYMB5C9PpYhmopbWzUp8eQB3Mqt1MGYkmba4CHnuhN8EefEWH3EZ8C/GGsEowbQNBnixi/MbJ2ZjbQnjYFhARHY/iWumHOxoyca2otTv7yFCumkKz2Rh3+tSljMj/9QbssdAUjBTrgu4Px7wEjuemymJqOQv5U6qwUp+/wZPiLUBpk3q4WBICIFh6Vh9MuMHf52Qfvam54NdWv8ZByOuL9khIUiJzQdv9envJLoUESnON80R48oIDFc2s7TjiavMvDg7EZl3ffJIZkyOg/Ff2R5mWFMIaAJjg5+8rg7G/T2KDoZNSKb4bVMh52DcC8fkbalLBW+27LcgDsakXm9x1h+/mbK3bFFExsLI8IpjwBWdWZuGy8GwkByqzYApmBP2DYuOJ7/gaCkuSkbA+M1CJSKT3Ujp86Y2/EET6zKWM6PnZM59LolJOBjOkZa3rGOIeeaVnIMJ2heal8acsQjaYFUiMhbmn78ymd8DZWI3xk0wsZXqnhyPFVmIzpClceefq+RvWRb3vUuZmXJQ//n5KSaLIiJjVmQ8gSqXEhj3M7MgDBWRKdote+zoMsM4mLjfikwTmCKG96Qp4WBkIjLFokiHcDBMrKLaIOvSGemJlIF506tOlBlHb0J8+VmVvP6ER41AYNICR+KIOGwfAPe0axMYhfkzA/OVYFdS8578Hr2TkM9x5AwgvAxS8YpkMcpEQRYHIx/7RMzwK/k9Hu/+kyefnz8RN49grMDSsXbKTseyMvhYZGxDKlGIyGRiN2eDtQ8oqggHfDl8D1Td4cfbtHV4lXXpyFZkQf1n+WPEP55RRGTM8Ia3bAwjTM61EbmKyCTPS4JEZGn3LiKpDqYICUy97oM5kCDXwXAbTQQlP/P8feaT9QCsC4pkYGKVIBFZmRBihEfL8gR2V/vNlF0RmfVntSftKYttKKbDwXgLFzmYaUu+9aRjm69oQSMq+VViAaaDsULtWGbhs1ZsQypjehS9R7VviW2V253vjCvhdUvZiMjEpDIzZeu5yMG4X0riBt5fvh01nFjs7reWOp9nLtvqXFQly88OIIkYiexI2Lw0kb2IjDtYrNtZ7bQ9WxFZq/IEdu1PeiI581CNU6Anv/3b2u1VuPed5aDUms8qcXObZtZcB0L6z/VZrL40AoGpS2Uc3zR2gJBxMHw7X/1iIwDvxi4jgkEcnQiZ5ZrTxrQJg7jET8yei/VcQ0MTGBsyEZnHvl3y8sQTA1sUT378NQCgdbmcg6m1TQ357MO7tsWCDXuQzJg+KzIRzCnNLyKz/jM/mPH9DwMFcGqfQ3H5E3MAEFwy/HAs27LPCZMidqtaouTny2bpKSzdDBuXy0Z0waINezHp+G5O3lvGHokTeh6Myto09lSnMHfdLnRqY0UCSHBmsxOfmotmJTHPBvLrs/pgxbeVuPG5L6y+OjqecAITxeIvFpOHFPE7HgIzf3YStuypxZ3/XYJvdlXjvws3S+u99tn5knrdz8wyqnlpPJJICbBCGLEyVKbfgLfPojgTAIZ2aYvFm/b62iQfK+s/45RVUaZVREVJYAy37P+t2oEZy7ZiYKdWOLbHQfjPgk2etGwNvvfTk/Dmgs24662lnv4/dMlgdG/nhkoJ1sGEE/M6+xpzg7ix+WSEiRXdqjzhRCHg9wYpwVaKyPzPfzG2NxIxA8f1OAjvLPbGNKtLm079moNpYvCIyOyNIOykpyIwDKo74pnYgp94j18xFF98sxsTn56LupRXRCbq+xgX4DdTtvIwEVlZIoZbzzgKy7/dZ/fH8qu4/4KB0j7EDeJT8ovpHAIjCZPx6OVHe/L88GRvrK/xA9rjaZv4ilFxLTNltz9liRhG9jjY+V4iGFAAQaKH8HcVN+TXLcRjxLf592jXHD3aNc/adFZsC9s0mwnRk4OC4Lbg9BO5ePIDwHE9DkKfDi2559E2RBYUk4253w/G/a7SW4npGQfMrBWfu+YYjxiQgb3vg5uXok+Hlr76zxrYwZOezR1ZsMsoIrK6tKsXZcp7qQ7G/v+z03rh128ssev0E3ce2YjIWjVL4I4JffG/Vdt9v/EWi6WS+6iKkcBoHYwNfqGx03KYiMxHYIQJqXrhbHF5ZOEx9/raZMZUTkqA42BEERmnQDWpu7kFmS+KIhxRRCam45W0/NXHUeGKe7xK9rTgaBk3vPd6OBZNaZ7ARK9cJk6QEaKEEDGXf+/i9cdRwPeRyfRFQhHGwTg6mABKxPdF1L2xjZIP18+Sy0Q6LL1DYBRXScuImtgWb3qXa+R1Q3ybGWRWdkFRrr0cjLw/QahLZxwlfybDxFBqKzL+XfCvM0jk6H+ubo8qokJdyrqvihC/mb02Uy5iJCQcjEeUIDsVK+TGDLIJZBA3ErIhTEy2yMJEZCxYodqKDJ7rAII8xfkulCZiPiU/g8PB2N9ZEMxsT0186Ba+bjGygUG8HAZvBu0G1oxetyyoo0pEplqnQRyECrzJMCNQQRu1iOalCdfHI6B+j4iMERK7GrZRumJO4kQFkG2IjENm/10RmTCGivhjSg7GcOdbbcoS96jeJX94Yh+D3jdPVP1+MBFEZClbRGYQx1AjiIPxhocJ5mCyMVP2VcS3MZ1BbSrjvE/NwTQh8GE42EYgchgixGfiCVe2sbduVuKEKBet1NjGw/udAH6v3pYqHYz9lZkpG85py0scPHl4JXYsgIMRTsUsHE22pybep0L0IUl4NhWBwMSZCbjpWKJlU7W4mAnkIrKYob5nMMxrP6heAl7J731vQY6WzTkORhafyq2H+2x4y3UJjPsO+dAqIhiH3NLW/7D3JHJQhPuqsrzztpGAzUJ2c6zDZfukAX5H1ChmyhT+Q08Y51kSN1DrcDDuIUhKmNihTSHdCIvBFxWySFNWNGX3BlSfXlETmOKFLFQM//4icTCJ8I2jdXlCasEVN7zh/wM5GPtkKZoysg2AKfkNyWIQwVdTEjdQrdDBsGSsKObJH7Q5ysCU9CVxwwn8yCCewr23errcHTPxzWZByblJ/0PmnyOD6i70IPCbMJsfop9OZCV/VDNl4TBQJnDkBnE3a9mmzSyZmpfGYRASSQfjJXBqAsN+qkuZApei5mCcg1IEDs6Kmyfvjwqlceuww0RkaVMtIjMkBNHrB+N/R+JFZlEgu8gumTZRm3Y5GLEqTWCKGN7TcjQ/GPEFRxGRteJMl/nfeWdFVX0MzIFSDOvCFmDatNh98XQo28f4BROPEV+ZDExm7l55CzuMv7KZUvA+FeKlafxmZxjyd5LKUO7mxGwIjMDBEHn+oE2MBRpk+bOplxDiOImKkZ2DimpRGlHJL9nwWHKfDsYgDvcd5BjYvMwmMEorMq4PCmIjpmfpalIZj85S3Jh57pxFrw7SwbC1J7uqIsw4ozQeQ519jTkJ08E47ZVzMEFcZjaQBctl98GUOVauaoJfLNAExobX2ieqo6V3+MQJaRDiC3jZOuC6Wn5zC7IiYxGFa0UCY5fHNgRe/i8rx/qNnXaZp7r8tLW/zru5UjuacrYiMuYnUxI3fPexiwSWfyd8pIAWTESWRb2yxSfTmQfpYHgrnqg3Ljp6D3AcTIC5r4jmZXFnngQp+WUchEpERjwcjMxvw/rfoiwBQjhP/oANTaXw96Q3vEp+/kAm0k5erMU85oOiSfNhmkRn17BQMWUJA3XpjKO3TAeJyFh7lRxM9FkZxNiIBKY8EUNdKuMRkR3w98EQQtoSQt4jhKyy/7dRpDudELKCELKaEDIlLD8h5FRCyHxCyFf2/1Pq085s4epg3GdRoqTKOBjeYxsA2nDe/aIoxmOZEsjBWGWK3AbLw4iEuAfKORj2nwSe3qvqXGJgEOLoYLK9gyLJKYyDRGTiJsU29GTGdOKZqfRFMoh7k8xfArAdLRVl8AQm6DQt1gOwUPWMExFFqer8LcrcOF3B0ZT9Gx4TszAREf+uHR1MQHj5ZiUxj4gsqM9R/GAIOCV/2nvdRBAHwzb8oDXBuCHxxlHrtzAOxhaR2ddSBCr57SZ4fF9i8s/1gXiRXXlJzI5F5nJ+4v5xIIrIpgCYSSntCWCm/d0DQkgMwMMAxgHoA+ASQkifkPw7AJxFKe0P4EoAz9aznVmhxNHBBC8av4hMjP1FfASGDx8jTgj1PSTeyca4IlEnwAiU6E2vVlt7Fb9BGwhPDAjcUOXZsuUOBxMzUCWIyPj++8Ym7vaNjWllnfw+dxnEdhqCiMw50ceIcsfnOcZcFrPsvhkg2MrPcsq0PgeZ28q4bffuECazZ6Iz4swVWUgSLzcSLVSMyieGB4U7F+tSpme9iFOPP6w54xbgMOmGaaK+OF5hZsqWiCxjRw13x0TmaOmsF8VhSK6DkddLpUH5LYivxeJgTNRyUT58IrIDkMCcDeAZ+/MzAL4nSTMcwGpK6VpKaRLAC3Y+ZX5K6ZeUUuYuvQRAGSGktJ5tjQxXROY+k+29vjssJMrbg5t7m91a0MHwBCguMc2UgZ1IUxkvgWET7rUvNzn1h4F1wSDBIgheIEUB/G32GvxnweasN9oyu+1Mj8IjZhgO8eRPiJ3alDvPyxMxtK2wiHQ2SndxLFqUJbxm4jEmMlKTY36jiNpvVi3hdBk+a8MgDqY07nCkjHOTQSYic+NWeY1WDOIeomTKZP5CMoOQiBeOqfvA0sWIK370icgClPwMLQP6z8Y0mTEdDp8hlMAkDNSlTeyvS6OiNO6sL1k4n34dWwFQi7qzEVMFicjE8Sy1xXh1qYwTmaApiMjq68l/KKV0CwBQSrcQQg6RpOkIYAP3fSOAEVnkPw/Al5TSOlkDCCHXArgWADp37pxbLwTIzAClQQGFR306tMSx3Q/Cp2t32vmBhy4djGc/XY+UaeLLb/ZgcOfWfNsx46cnYfPeGgBeBaGMOAzr2gZ3nd0PPQ9pjkuGd8ZlIzrjzIc+cn5nE2zhhj1O/QBwSItSXDT0cFx+bBdfmbziNxGXT9CDm5di8ulHOt/5TUnUA4Xh/0b3RJtmJfje4I4Y0qUNbvjXfCz/thKAdbL/zw9H4v3l25xN8q0fHY8OrcvRplkCt47rjfOP7uQQ4nMGd1TW887/nYB/froez8/5xuofscomALZX1uHIw1pg3Y79TvqEYaAWJuIxf4wnhuevOQZn/dUa75hBcPPonvjLzFXStEd3aYMbR/VASczADaN6YHz/9ujergKn9jkUt57R25NW9q4nDOyAzm2bwTCIY9knI8oMMp0AI2jlPh0MwT+uHIp/f/4NuhzUzFfWbeOPQkVJDKOPOgSEuCLXoCuT+S6UJWL488WD8H8vLAAAPPOD4VZ0by5ETm3KDLyygD+Nn9izHW4e3RM/GNlV2X+2ZpNpE50PaoYnrhyKq5+ZZ/VfYkXWsXU5Nu2x1l1ZPGZbkaXQoiyOv112HGat2Cbl6H/7vX64bERndGhdLm17vsRUp/Q+BKf0PgTvL99m9SERc5X8CiuyJqnkJ4TMIIQslvydHZaXFSF5FslujxDSF8B9AK5TpaGUPkYpHUopHdquXbuITQqG1A9G8vLEZ4e0KMXz1x6DsX0PdfIf2rIMPx97JG4ddxReuu5YdGlb4cl/WKsyDOncBoCXg+EXGDvpXDqiM45q3xLxmIF7zu2Pbge7ZQF+eTrPzt93/gDn9CXrg8GJTURMGddbGRla1KOEoVlJHNef1AMxg6DbwRW4ZaxLuGIGQa9DW+D6k3o4z/p1bIW2FSUghOC6k3rgoOalaFVuhdMICgFyVPuWOKp9C+e7YQCDDm+NgYe3xpg+hzr1ub8z/QhRihT7d2qFy4+xiHTcIPjpqb2U9U8c2RWjjzoUhBBMPr03+nVshWYlcTx+xVB0auPd1GX7wrBubfFze2yYrqlFqfo86BHn2q+Rj7wLuAuRhb+5/cw+UpPsQ1uW4d7zBqA0Hgv08eCzipvb2YNc4t+2ogQn9Wpnp7OeJTOmh0MI83H56am9lHMQcNcsC/NyfE83zJCMg3l64jA3r80dVNam0bI8gZ6HtsC1J/bw5QGssRzcuY3SuZLvx+/O6adsLxC8CSZiBn59Zh/ne3kiZpkp80p+YcyKUQcTysFQSseofiOEbCWEtLe5j/YAtkmSbQRwOPe9EwAm/lLmJ4R0AvA6gCsopWsi9CVvKJH5wUj2Xr8OxWslJNs4mvEXZgll8guYJ15sIvr1CMEscpQDDe8bobKaCTKPzZbAiOCJRJCVVC4I06F536+tnzDUHIw3XfDgZmNdJyNofH6HwEQUkbG8TLQlbrDZ7EMePZWPwASPr9MerkK+rwnFgSoXMEV+SnJHS4WEMIvXc9SmrPvuux5U4UsrQ8JjkOM+94i57TaodC1h7jH8mJYlYthWWYfadEZ6ABbbUSyob5PehKWEh/3/DUmauQB6EkK6EUJKAFxs51PmJ4S0BvA2gFsppR/Xs41Zw9HBeE4p/qHyWYHZC1AW+Zch6FrgRIgVmSzciaf+ABGGCrwfjCo4Z5DyPwcfMg94ApNLKJYghFkBypTUiQAdDMDdO6LYEJmPUjYbpiypbMhFgxFvev+JOilwMAzZSFL4tgXp6IK6qxKlhV01nA1KOSMQwDseMhEZrwdjSv7K2nQgEecRUxjkeH256tcnfrjLEjEuVIxfhA/I96hCo74tuhfAqYSQVQBOtb+DENKBEDIVACilaQA3AZgGYBmAlyilS4Ly2+mPAHA7IWSB/SfTzzQI5GbK4fnYBu/4bGT8SmiZh7KTX2lFZrchSw4myvx2LM0IcSIEiIhqkpsLeK4p3yy+yk9DVh/rYjym9oMBEOigCLiK+Gw4GDl35X8WpIORhS4RlfxBZYeVa5DgDTOoTJUxQDzAajBbMCLKiCrfHtEXDfByMGUJi4PZV5tywjCFQRV1I8jUXkSQFZmYv1mJJSKrS7vWdz4RWRHqYOql5KeU7gQwWvJ8M4AzuO9TAUzNIv9vAfy2Pm2rD6QXjkV4eewEXhJXE5ggIhKXbHiAG2pCXMTimhQ3gCgnKF5Eplpc+bLtl6Hcw8Hkl5B5N7ZgEZkbjsRwxDiyVx4UYgWwuIytqAsMwe9vZ/hhAggWkXnEfUxEZlvZhYVKidK2oDA1VrrwMgCviCyq31cUiBwMD5kOxhsaKoa9NSk7SkREDkZiVAHI17DSTDkrEZmBmlQGlHK3u/rWf4SGNzKKsEmFhxjLiX8WhLigg5EFR/Sw0EKRhJBAEYxfRBbcpignVUdERtQisqhe67mA3/wakoMJM9LwBAYl3meePIZcPMHAxFjZWPQQyfDKxiJo85N5kzP/kTBP9iCwZoSFQAnmYORzPq7YpHMBO9VLrK6lBIYf39K44Tgtq7h4X34JxyiW6wSGjVSiHzzBiMcM92bRmCt14JFvHWY+UHwtKiKoFoMKbBEyc9+k5DRFFBPTqSfmJ25sgor7fFiTouzXfORddg2Ar00NaJ3Cb37518EEc6CyAwS/SGXdDhqLsoThiMhyEUPxkGUP0sHI+lpnb5r14WCcSMb14GA8Sn6F0UB99QdB3vrSEPocJ8XnjSoiUxGVfHJl/DtNGMTheFRz8EBU8h/QUIXkVoEtQkfJn44uY2VIBJyQRfVz2CYW5VTIB8RU6mAi3h+fC7wcTJ5FZFxxsqGQERjLTNnOI1H3B4kLK0riDhGozsK6Lkw/5NatHh+ZRVxeOBi7yjDiHzQX+Z+8OphojsVRENRH+R0t8rxRRWQ8PPMoRI/KIyzKsteCz5B+VqUvFmgCE4AwEYsI596OACW/J70sOkAOl2mpEM2KzP2v8itpSBFZVF+IXJBNNGy22MtLYu5mmSUHU1EaR/NSi0hXZkFgwsyUI5UhEUMxK0Z2Qs9FVCMLTy9PF16GmC6fFldBBDBM/+bhYCKKyHjwYyNzllYRkjAdjPe6CoP7LO+rFpE1MfCy8SgbPnu/LDyMSqfhlB9Rxh82ESsUIpAoexQfi0xFkBpSyS+LmNwQZYeJyJgMvnlpnHNI9JcZxGVVlMbRtkJ+V09wO/3P6rPhivNKFvIkKlzdVJiITN1e79qRi5Nal6udKKMgiIMKFZFxHExQOBoVoliU5QJ+/wmK08dQhPSl3qFiDii8fuNx2F7pRqSJouR/9YbjUJPMYNmWfY4Z6UXDDkfMAM4b0imwPqmIzOFg3GfOViVpwp8uHOhEAohSviqNYRAc3aUNzhvSCf06tsSd/13Ktck7c394cg/069AKVXVpNCup/xS6ZPjhWL+zGoe3LQ9PnAX4VyZ7ffz48M6MLgMjEVMp5sHxRxyMO8/ui8NaliEeM3DOEHUYm6B2yJ79+eJB2L0/Gbk8hjfssDvZXgrHg2UNE5EFzTWieA/8weXq47shbhB0alOOQ1rmFnZw8um9MbxbW9/zGCH44wUDsXJbJf7+wVqnHVcf3w0DOrXyXBMeVQfDw+sH4xf7qY4aYUeQmKJc3h/p9RuPwzl/+8Sur/hEZJrAcBgsbNRhjnqAFXMK8IamiBkEFw0Lj4smE4M4Sv6Ik+XcACIW5UTD+zmUxA388cKBmLXCG5BBdLC7Zaw3llZ9cc+5A/JaHkOYDo3vFttkmpcmkMywy9X8ZarmwZ8uHIhDWpYBsDa67Nopq8f9zIddyQYD7dA49UFUM+UgGsbPc4+Sn+t4SdzANSd2z7GVFm4YJQ/vYhjAeUd3wocrtzsEhhCC2+1QLP+xg8MC9ReR8TqYMMKejZkyHyeQJ8z8nlWMfjBFyFQVDxoiiJ23fP8ztpnnY7Jkp4NRi5NUQTCLHV4OJphLYCHem5fFXT8YSZkqDqY+Iq2wthUSrFth+rGg5nr9YFyEEa18QaZH4rtTKjhdZgtPqJg8ml7z2flDnmrcipGD0QQmADLntfyWr+Zg5HLj+pcvgm2MQQYNxag8jAIS0CfVM15EJveDsZ6Jp8/6zI9sOKXGhhNCJ9RMWd1e1eGlscLLxyQExnODLUdUchEnqg6izucc7oMRy/IEHVWaKRfHnOHRNHeORkK2ZsrZQu5MKVPy5+aqFaXJzmbKzQQxX0NakTUkvKIZ/++yZ56IxZLfVQYPspsho0K2qTUEB5NLia6ILHcdjMpcvCGNR7z1qw9tgP9+nmyhiqYcbqYcXK6KGDcEF91QaJo7RyMhWzPl7Mv3P2N7udx2P7s2ZBXsMoCYNlkRGU80I45n8zL3zhK5iIyZ/Hp3h3zPj6IRkTE/mFArsqDf5IS+sS/IUo1pfazsxHJl5uK5l8t95k2hFQe+YrxwTBOYAHiU/A1w2go6ucrmSrYtiOTJT/xt8cdIa5rTJExEJoPHTFnm7NhI4oliEXdE5WCimgmrYpE1BlTvLuheoShQvStHnKrIFyaXUM1fpZlykRxKeDTNnaORkMsGlQ2CQsjLLhzLFtnEIgsy6c13CJfGQlg0ZRkqSqLpYILqygeKRSoZNVRMcBnyz409r9QisvoNttovJaR/WSxsj4hMJaYtkkMJjyKZxsWPxrIiY8+8F46xaMrZlR+FKMpOkeLCqI8fRSFheDa2aH0wPKdtPxprcRfLmLNuhQW7DC5Dzh039v0lahGZPPx9fct1Lhyr76VJiCYi02bKTRgNQ2DUeoEw7+NI5Ud4u0y/wt+NVoysdi7I1cw8KFw/2xR9VmT5FpEVyTuIKiILgsrYorGU/GH1MSuyXI1ZcuVqsyE7fNNy5pgKAE1gIiKfG4jM9yTot7YVlmdztjb6UU7BTHnLhzYpwnmaE1Qe5FHzSc3IhYJy8ZuIgoY40OQWi8z6ny8RmSoWWWNAyWnY7cj1XaoOA2EHvC7c9cyyKwU8ZfFOl0LB/Tq2DGlh4aA9+SMin6f6mEFgZqh0ArLTM7/B/O6cfhjera0TNSAI957bH1Ne+wpAtDYzOXjGQ2DcfLeNPyq0jGJFNmbmj35/CPbVWAEqWUpZDlFx+/bNJ2D++t31bKkfxcJFMiJbHxGZl1DzuoTGPd+qiHbbZiU4/+hO+P4xXXIqV1zHvzj9SPTt0CpUyX/ekI44vE05uh1cEWoqHfc4Wnr78dykY7Bpd03W7W4MaAITEfnlYAgAKj/5MA6Gq69lWQKXR5z8Fw/vjDcWbMana3dGOrWzRS4jMOWJGCadUL/wHYVENjeSnt6vvfPZ5WD86cRTd492zdGjXfPcG6lAsRju5YOD4VFIM+Ug/5H7LxhYj3K9Y3PjqCMAAKu2VgbmI4RgRPeDItWhihYAWEF1wwLrFgpFMo2LH/lcDIxYScOIszT1OMGqvM1lYHLnDJfYPXnVXzlZSPCLMrvXR+w8EhFZjOlgGnZsik4Hk6f5XwhPfqfuBqpPdRjIp6GG6m6YYkfTaWmBkVcRWYCvixs3qR7lG0xxH74JMnb7wNTBROdgvPns/5LfGmtTLBaFbT6U/Dz4UvJ9PUMYGopoq8rN5qAXBn78i9GhUgVNYCIiryKygNAV/BXGucIhMJnwmZ2QcDCs7gY+pDc4YrkSGPY/Cz+YfKNYOBjWjHw5RTZ0ANkgNFR9aiuy/NXhUfJrDubAQz4nJzuBBF2LnA8RWRQORqbkD1NONhXwQQyzsyJjIkz/b421KRaLkp+/SjofKKSZckO9u9Cw/HlYSfm8yKwxoQlMRDQEBxMUgLE+9THilIlwqyI7DUlFZE2cwvCWOdn5wdj/pSLMejYqIopHyc9EZPlvUGOHiikUV5gPSYDnWuYmFFmjSKZx8SOfkzPmnJDVZdZHBs8mYzoCgYlLRGTOXeJNnMKU5RiG3dXBqPM09MgUyymVtaI+Zso8PGHnG5uDaeT6snWMDoLndsvvioiMENKWEPIeIWSV/b+NIt3phJAVhJDVhJApYfkJIcMJIQvsv4WEkHPq0858IJ+Tk20esnvbZdGNswVbxFEsnVwRmT9/U0euYdjdWGTSX61/DUxhikUHw7qZNzNl7nNYhOZ8o7HHlFWXbw7mu6TknwJgJqW0J4CZ9ncPCCExAA8DGAegD4BLCCF9QvIvBjCUUjoIwOkA/k4IKajPTj4nZ9DEc0VkuZfPJmA6GyW/6VIYI48Lo5DIZxj2xkaxxCJjYtZ8cRuFVPIXi9gxF0S5cKwYUd8hPxvAM/bnZwB8T5JmOIDVlNK1lNIkgBfsfMr8lNJqSmnafl6GItAG5HNyHmrf3R7gZ1mvzS2elZLf72jpBOnLuQXFgVwJjCPaCFDyl9STeIWhITbfZnY4kmzC05v2HMoXt1HQaMoF4mDygXgTVfLXlys4lFK6BQAopVsIIYdI0nQEsIH7vhHAiLD8hJARAJ4E0AXA5RzBKQjyOTkf/f7ReG/pVhzetpnvN3ZyrQ+BmTKuNwxCMGFgh9C0bOLy0jrXTLlpk5goYp07zuqD9q3LvQ/V9AVdD2qGm085AhcMPbz+DQxALvPttvFHBRLVa07sDgpEjgoB1I+DmfbjE7F+537PM76Uht4oZ/18FKqT7raR7/revvl4LNm0T/n7YS3LcFKvdvjRKUfUuy7VpWbFjlACQwiZAeAwyU+/iliHbDRCdy5K6ecA+hJCjgLwDCHkHUppraR91wK4FgA6d+4csUnZI58WL+1alOLSEfK2sjVg1mNzP6h5Ke47f0CktOwknjkAHS2j4KqR3XzPgrhIQgh+etqRDdyq3DjmsLA+ZYkYbh7dM6syXQKTfYOOPKwFjjyshecZvzk2tD9Ht4MrPN/zvTH37dAKfTu0Uv4ejxl45gfD81JXU+JaeIQSGErpGNVvhJCthJD2NvfRHsA2SbKNAPjjXicAm+3PofkppcsIIfsB9AMwT/L7YwAeA4ChQ4c22JG7seS3bBFEMADLCxxx2gHoB5MrgvxgGgvF4gfjisiavh9MU0ZT0rvwqO+2+SaAK+3PVwJ4Q5JmLoCehJBuhJASABfb+ZT57bRx+3MXAEcCWFfPttYLjXWCcGtpnO39QPbkzxWOH0wezUyzRbGcWOvDwchQSCV/U0ZTteys76y5F8CphJBVAE61v4MQ0oEQMhUAbN3JTQCmAVgG4CVK6ZKg/ACOB7CQELIAwOsAbqSU7qhnW+uFRiMwjWzBJVXyN9HJnC8ERVNuLBQPB2P9z5snP/e5sc2UmzKKxWw9W9RLyU8p3QlgtOT5ZgBncN+nApiaRf5nATxbn7blG431go1GtuCSbRzfcfrC3WipORgmIstXe/ghbWzHx6aMYpkP2UIfISKisTmY+ij5s4FM9FEsp+dCISiacmOhWPYTR0SWNzNlTsmvOZjI0ATmAEdjnWbZ6bmxRGSye8i/8wSG/S/gMBSLKWreRWRayZ8TNIHRyA8aJxKJA9kib6JzOX9wQsV81wfCDWfUEEr+pmoZVQg01bmoCUyRgU2jxnJylC3ypnpayhcYF/kdHwYArnVh3syU+c9NdNMsBJoqMdYEpsjQsY3lVd66WUmj1Ce9ttl+1rdDy0ZpQ9GiETdAgwAdxYgCRYB8czCapuSGpmqmXNAAkhp+/OzUIzGwU2uc2PPgRqvz/0b3xIm9vPW9duNx6C54QjdFPDVxGL7ZWZ1VnuBoyg2DFb8dBwLgiF+903iVRgDjYFT6kr9dNgR7qlORy2uqop5C4YVrjwGlTVeqoAlMkaEkbuCM/u0btc6fnNrL92xI5zaN2oaGwslHysLjBYMI/xsDxXoNLrMiU1l8NfZc/a7hmO4HAQBqU5kCtyQ3FOes1tAoINxQMU3z1JhPmA0Yrl8jOprquGkCo6GhQNNc0vmFo+RvADNljehoqiIyTWA0NAQwC76memrMJ9hNp3lztMxLKd89NFH6ogmMhoYIJyxbE13U+QQNUfJnC020c0NTFddqAqOhIYDabq5Nc0nnF66ITJspa2QPTWA0NETYHIw+bfOxyPKlg9Fj+l2CJjAaGgKYiEzvha4VWSLgKmYNDRX0rNHQEOCIyDSBQTrED0ZDIwh61mhoCDC1iMxB57bNADRdM1mNwkJ78ofg7u/1w579yUI3Q6MRwe7iKYS+4L2fnIh9tdFDrzQ0nps0Ags27EHJASIie+SyIahNN02v+J+f1gsDD29d6GZkBU1gQnD5MV0K3QSNxgbTwRSg6p6HtihArWoc0rIMp/U9rNDNyBvGNeHQNjed0rPQTcgaB8axREMjj9A6GA2N/EATGA0NAbSAHIyGxoEETWA0NARoJb+GRn6gCYyGhgBKtYhMQyMf0ARGQ0OAe1m1pjAaGvWBJjAaGgKo9uTX0MgLNIHR0PBBB7vU0MgH6kVgCCFtCSHvEUJW2f+l9+wSQk4nhKwghKwmhEyJmp8Q0pkQUkUI+Xl92qmhkQ00B6OhkR/Ul4OZAmAmpbQngJn2dw8IITEADwMYB6APgEsIIX0i5n8AwDv1bKOGRlYw7LAoZYlYgVty4KJj6/JCN0GjEVBfT/6zAYyyPz8DYDaAyUKa4QBWU0rXAgAh5AU739Kg/ISQ7wFYC2B/PduooZEVxhx1KG4Y1QPXntC90E05IPH+z07CQRWlhW6GRiOgvhzMoZTSLQBg/z9EkqYjgA3c9432M2V+QkgFLEJzZ1gDCCHXEkLmEULmbd++PeeOaGgwxAyCyaf3RpuKkkI35YBE93bN0apZotDN0GgEhHIwhJAZAGTBiH4VsQ6ZJJtKnvG4E8ADlNKqsICDlNLHADwGAEOHDg0rV0NDQ0OjkRBKYCilY1S/EUK2EkLaU0q3EELaA9gmSbYRwOHc904ANtufVflHADifEPIHAK0BmISQWkrpX8O7pKGhoaFRDKiviOxNAFfan68E8IYkzVwAPQkh3QghJQAutvMp81NKT6CUdqWUdgXwIIDfa+KioaGh0bRQXwJzL4BTCSGrAJxqfwchpAMhZCoAUErTAG4CMA3AMgAvUUqXBOXX0NDQ0Gj6ICzu0oGAoUOH0nnz5hW6GRoaGhpNCoSQ+ZTSofkuV3vya2hoaGg0CDSB0dDQ0NBoEGgCo6GhoaHRIDigdDCEkO0A1he6HQXAwQB2FLoRRQQ9Hl7o8XChx8ILNh5dKKXt8l34AUVgvqsghMxrCAVdU4UeDy/0eLjQY+FFQ4+HFpFpaGhoaDQINIHR0NDQ0GgQaAJzYOCxQjegyKDHwws9Hi70WHjRoOOhdTAaGhoaGg0CzcFoaGhoaDQINIHR0NDQ0GgQaAJTBCCEHE4ImUUIWUYIWUII+T9JmrMJIYsIIQvsC9aO5347nRCyghCymhAyhXt+N5dnOiGkg/38VELIfELIV/b/Uxqnp+Fo7LHgfu9MCKkihPy8YXuYHQoxHoSQAYSQT+36viKElDV8T6OhAGslQQh5xh6HZYSQWxunp+FoqLHgfv85IYQSQg7mnt1qp19BCBkb2khKqf4r8B+A9gCG2J9bAFgJoI+QpjlcndkAAMvtzzEAawB0B1ACYCHLC6All/9mAI/anwcD6GB/7gdgU6HHoFBjwT17FcDLAH5e6DEo8NyIA1gEYKD9/SAAsUKPQwHH41IAL9ifmwFYB6BrocehIcfC/v1wWBHw1wM42H7Wx05XCqCbnT9wbmgOpghAKd1CKf3C/lwJ61qDjkKaKmq/ZQAVcG8FHQ5gNaV0LaU0CeAFAGfbefZxRTh5KKVfUkrZpW9LAJQRQorikvTGHgsAIIR8D8BaWGNRVCjAeJwGYBGldKGdbielNJP/nuWGAowHBVBBCIkDKAeQBMCnLRgaaixsPADgF1x62L+/QCmto5R+DWC1XY4SmsAUGQghXWFxGJ9LfjuHELIcwNsAfmA/7ghgA5dsI7hJRgj5HSFkA4DLAPxaUuV5AL6klNblpQN5RGOMBSGkAsBkWNd0FzUaaW70AkAJIdMIIV8QQn6R947kCY00Hq8A2A9gC4BvANxPKd2V357UH/kcC0LIBFhSjYVCUYHjJ4MmMEUEQkhzWKKaHwsnKgAApfR1SmlvAN8DcDfLJimKcnl+RSk9HMBzsC5+4+vrC+A+ANflpQN5RCOOxZ0AHqCUVuWx+XlHI45HHMDxsDbZ4wGcQwgZna9+5AuNOB7DAWQAdIAlFvoZIaR7vvqRD+RzLAghzQD8CvLDaOD4yaAJTJGAEJKANUmeo5S+FpSWUvohgB628m0jLHkpQycAmyXZ/g2LW2H1dQLwOoArKKVr6tn8vKKRx2IEgD8QQtYB+DGAXxJCbpLkKRgaeTw2AviAUrqDUloNYCqAIfXsQl7RyONxKYB3KaUpSuk2AB8DKJpYZg0wFj1gEdKF9proBOALQshhAXkCK9V/hVfWEQD/BPBgQJoj4CrrhgDYZOeLw9IfdIOrrOtrp+vJ5f8RgFfsz63tdOcVuu+FHguh3DtQfEr+xp4bbQB8AUuhHQcwA8D4Qo9DAcdjMoCn7PwVAJYCGFDocWjIsRDyr4Or5O8Lr5J/LUKU/HFoFANGArgcwFeEkAX2s18C6AwAlNJHYZ2oriCEpADUALiIWm89bZ+4p8GyDHmSUsqU1fcSQo4EYMKyBrnefn4TrIl3OyHkdvvZadQ6oRUajT0WxY5GHQ9K6W5CyJ8AzIUl/phKKX274bsZGY09Px6GRWAWw9qYn6KULmrYLkZGQ42FFJTSJYSQl2AR2TSAH9IQAxAdKkZDQ0NDo0GgdTAaGhoaGg0CTWA0NDQ0NBoEmsBoaGhoaDQINIHR0NDQ0GgQaAKjoaGhUeQghDxJCNlGCFkcIe2JdhSGNCHkfO75IOIGMV1ECLmoYVutCYyGhoZGU8DTAE6PmPYbAFfBchjlUQ3LsbqvXdaDhJDWeWqfFNoPRkNDQ6PIQSn90I435oAQ0gOWn047WMTjGkrpckrpOvt3UyhjJfd5MyFkm513T0O1WxMYDQ0NjaaJxwBcTyldRQgZAeBvACLd7UQIGQ7Lg79Bw0RpAqOhoaHRxGAHuDwOwMuEODEoI125QQhpD+BZAFdSSs2w9PWBJjAaGhoaTQ8GgD2U0kHZZCKEtIQVtv82SulnDdEwHlrJr6GhodHEQK2w/F8TQi4AAGJhYFAeQkgJrAjq/6SUvtwIzdSxyDQ0NDSKHYSQ5wGMAnAwgK0AfgPgfQCPwLo6OQHrtsm7CCHDYBGSNgBqAXxLKe1LCPk+rMCdfFDLqyilCxqs3ZrAaGhoaGg0BLSITENDQ0OjQaAJjIaGhoZGg0ATGA0NDQ2NBoEmMBoaGhoaDQJNYDQ0NDQ0GgSawGhoaGhoNAg0gdHQ0NDQaBD8f4zf3qXdXAJdAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "for name, d in data.items():\n", - " plt.plot(d[0].timestamp.values.reshape((-1)), d[0].values.reshape((-1)), label=d[0].name)\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "id": "52e6aa2b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(385)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 383 \u001b[1;33m \u001b[0mchannel_name\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34mf\"/{device_name}/{input_name}/{signal_name}/{final_level_name}\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 384 \u001b[1;33m\t\t\t\t\t\t\tchannel_data = xr.DataArray(\n", - "\u001b[0m\u001b[1;32m--> 385 \u001b[1;33m \u001b[0mdata\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mfinal_level_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"value\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 386 \u001b[1;33m \u001b[0mcords\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;34m'timestamp'\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mfinal_level_data\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'timestamp'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 387 \u001b[1;33m \u001b[0mdims\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'col'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'row'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> final_level_data\n", - "[{'header': {'systemtime': array([1664382261279112], dtype=uint64), 'createdtimestamp': array([1312194966056], dtype=uint64), 'changedtimestamp': array([1312194966056], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '007 18:24:21.2784', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1312194954376, 1312194990216, 1312195026056, ..., 1312974832776,\n", - " 1312974868616, 1312974904456]], dtype=uint64), 'value': array([[-0.00083702, -0.00081435, -0.00079167, ..., -0.00066342,\n", - " -0.00066342, -0.00066342]])}]\n", - "ipdb> final_level_data['values']\n", - "*** TypeError: list indices must be integers or slices, not str\n", - "ipdb> final_level_data['value']\n", - "*** TypeError: list indices must be integers or slices, not str\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "id": "27dad9d5", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'forcetrigger': array([0], dtype=int64), 'triggered': array([1], dtype=int64)}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{}\n", - "Progress [0.]\n", - "{'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664381184448982], dtype=uint64), 'createdtimestamp': array([1247600892456], dtype=uint64), 'changedtimestamp': array([1247600892456], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 18:06:24.4482', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1247600880776, 1247600916616, 1247600952456, ..., 1248380759176,\n", - " 1248380795016, 1248380830856]], dtype=uint64), 'value': array([[-2.43316761e-05, -5.26761886e-05, -8.10207011e-05, ...,\n", - " 4.80435375e-04, 5.08779887e-04, 5.37124400e-04]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664381184449458], dtype=uint64), 'createdtimestamp': array([1247600892456], dtype=uint64), 'changedtimestamp': array([1247600892456], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 18:06:24.4482', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1247600880776, 1247600916616, 1247600952456, ..., 1248380759176,\n", - " 1248380795016, 1248380830856]], dtype=uint64), 'value': array([[1.78793064e-07, 2.95350018e-07, 3.64539359e-07, ...,\n", - " 3.68635535e-07, 4.18934422e-07, 6.62816282e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664381184449892], dtype=uint64), 'createdtimestamp': array([1247600892456], dtype=uint64), 'changedtimestamp': array([1247600892456], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '002 18:06:24.4482', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1247600880776, 1247600916616, 1247600952456, ..., 1248380759176,\n", - " 1248380795016, 1248380830856]], dtype=uint64), 'value': array([[1.52127041e-07, 2.01588166e-07, 1.77798752e-07, ...,\n", - " 3.64727363e-07, 3.53522672e-07, 3.08946072e-07]])}]}}}, 'triggered': array([0], dtype=int64)}\n", - "Progress [1.]\n" - ] - } - ], - "source": [ - "while not my_lockin.daq.finished():\n", - " time.sleep(1)\n", - " result = my_lockin.daq.read()\n", - " print(result)\n", - " print(f\"Progress {my_lockin.daq.progress()}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "id": "811091f9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(376)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 374 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 375 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mdevice_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdevice_data\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 376 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0minput_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput_data\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mdevice_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 377 \u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0msignal_name\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msignal_data\u001b[0m \u001b[1;32min\u001b[0m \u001b[0minput_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 378 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msignal_data\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> device_data\n", - "array([0], dtype=int64)\n", - "ipdb> data\n", - "{'dev3442': {'auxins': {'0': {'sample.auxin0.avg': [{'header': {'systemtime': array([1664381558471132], dtype=uint64), 'createdtimestamp': array([1270042036776], dtype=uint64), 'changedtimestamp': array([1270042036776], dtype=uint64), 'flags': array([825], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '005 18:12:38.4705', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1270042025096, 1270042060936, 1270042096776, ..., 1270821903496,\n", - " 1270821939336, 1270821975176]], dtype=uint64), 'value': array([[-0.00225105, -0.00225672, -0.00226239, ..., -0.00142828,\n", - " -0.00145662, -0.00148496]])}]}}, 'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664381558471577], dtype=uint64), 'createdtimestamp': array([1270042036776], dtype=uint64), 'changedtimestamp': array([1270042036776], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '005 18:12:38.4705', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1270042025096, 1270042060936, 1270042096776, ..., 1270821903496,\n", - " 1270821939336, 1270821975176]], dtype=uint64), 'value': array([[7.96188229e-07, 1.00931080e-06, 9.46633590e-07, ...,\n", - " 4.39649550e-07, 4.78960669e-07, 5.21563402e-07]])}], 'sample.x': [{'header': {'systemtime': array([1664381558471999], dtype=uint64), 'createdtimestamp': array([1270042036776], dtype=uint64), 'changedtimestamp': array([1270042036776], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '005 18:12:38.4705', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([21763], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1270042025096, 1270042060936, 1270042096776, ..., 1270821903496,\n", - " 1270821939336, 1270821975176]], dtype=uint64), 'value': array([[-7.14710861e-08, -1.44757501e-07, -2.49910226e-07, ...,\n", - " 5.42141045e-08, 1.21691587e-08, -4.78550733e-08]])}]}}}, 'forcetrigger': array([0], dtype=int64), 'triggered': array([0], dtype=int64)}\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 192, - "id": "52865ab1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'awgcontrol': array([0], dtype=int64),\n", - " 'bandwidth': array([0.]),\n", - " 'bitmask': array([1], dtype=int64),\n", - " 'bits': array([1], dtype=int64),\n", - " 'buffercount': array([2], dtype=int64),\n", - " 'buffersize': array([0.2]),\n", - " 'clearhistory': array([0], dtype=int64),\n", - " 'count': array([1], dtype=int64),\n", - " 'delay': array([-0.001]),\n", - " 'device': [''],\n", - " 'duration': array([0.]),\n", - " 'edge': array([1], dtype=int64),\n", - " 'enable': array([1], dtype=int64),\n", - " 'endless': array([0], dtype=int64),\n", - " 'eventcount': {'mode': array([1], dtype=int64)},\n", - " 'fft': {'absolute': array([0], dtype=int64),\n", - " 'window': array([1], dtype=int64)},\n", - " 'findlevel': array([0], dtype=int64),\n", - " 'flags': array([8], dtype=int64),\n", - " 'forcetrigger': array([0], dtype=int64),\n", - " 'grid': {'cols': array([21763], dtype=int64),\n", - " 'direction': array([0], dtype=int64),\n", - " 'mode': array([4], dtype=int64),\n", - " 'overwrite': array([0], dtype=int64),\n", - " 'repetitions': array([1], dtype=int64),\n", - " 'rowrepetition': array([0], dtype=int64),\n", - " 'rows': array([1], dtype=int64),\n", - " 'waterfall': array([0], dtype=int64)},\n", - " 'historylength': array([100000], dtype=int64),\n", - " 'holdoff': {'count': array([0], dtype=int64), 'time': array([0.2])},\n", - " 'hysteresis': array([0.]),\n", - " 'level': array([0.]),\n", - " 'preview': array([0], dtype=int64),\n", - " 'pulse': {'max': array([0.001]), 'min': array([0.])},\n", - " 'refreshrate': array([5.]),\n", - " 'save': {'csvlocale': ['C'],\n", - " 'csvseparator': [';'],\n", - " 'directory': ['C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer'],\n", - " 'fileformat': array([0], dtype=int64),\n", - " 'filename': ['dataAcquisitionModule'],\n", - " 'save': array([0], dtype=int64),\n", - " 'saveonread': array([0], dtype=int64)},\n", - " 'spectrum': {'autobandwidth': array([0], dtype=int64),\n", - " 'enable': array([0], dtype=int64),\n", - " 'frequencyspan': array([13000.]),\n", - " 'overlapped': array([1], dtype=int64)},\n", - " 'triggered': array([1], dtype=int64),\n", - " 'triggernode': [''],\n", - " 'type': array([1], dtype=int64)}" - ] - }, - "execution_count": 192, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq_read_return" - ] - }, - { - "cell_type": "code", - "execution_count": 174, - "id": "543ff392", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(357)\u001b[0;36mmeasure_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 355 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 356 \u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 357 \u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq_read_return\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 358 \u001b[1;33m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 359 \u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> data\n", - "{'forcetrigger': array([0], dtype=int64), 'triggered': array([1], dtype=int64)}\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": 123, - "id": "ac680e56", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.clear()" - ] - }, - { - "cell_type": "code", - "execution_count": 145, - "id": "dd7e1cee", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{}" - ] - }, - "execution_count": 145, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq.read(flat=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 119, - "id": "0d1c6fa7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{}" - ] - }, - "execution_count": 119, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq.read()" - ] - }, - { - "cell_type": "code", - "execution_count": 110, - "id": "ec8c9d7a", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.force_trigger(None)" - ] - }, - { - "cell_type": "code", - "execution_count": 111, - "id": "20bace43", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['__class__',\n", - " '__delattr__',\n", - " '__dir__',\n", - " '__doc__',\n", - " '__eq__',\n", - " '__format__',\n", - " '__ge__',\n", - " '__getattribute__',\n", - " '__gt__',\n", - " '__hash__',\n", - " '__init__',\n", - " '__init_subclass__',\n", - " '__le__',\n", - " '__lt__',\n", - " '__module__',\n", - " '__ne__',\n", - " '__new__',\n", - " '__reduce__',\n", - " '__reduce_ex__',\n", - " '__repr__',\n", - " '__setattr__',\n", - " '__sizeof__',\n", - " '__str__',\n", - " '__subclasshook__',\n", - " 'clear',\n", - " 'execute',\n", - " 'finish',\n", - " 'finished',\n", - " 'get',\n", - " 'getDouble',\n", - " 'getInt',\n", - " 'getString',\n", - " 'getStringUnicode',\n", - " 'help',\n", - " 'listNodes',\n", - " 'listNodesJSON',\n", - " 'progress',\n", - " 'read',\n", - " 'save',\n", - " 'set',\n", - " 'subscribe',\n", - " 'trigger',\n", - " 'unsubscribe']" - ] - }, - "execution_count": 111, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dir(my_lockin.daq)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "c3800665", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.finish()" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "id": "d06129a4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1.])" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq.progress()" - ] - }, - { - "cell_type": "code", - "execution_count": 202, - "id": "24513c96", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.set('forcetrigger', 1)" - ] - }, - { - "cell_type": "code", - "execution_count": 114, - "id": "9e35f6c6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.])" - ] - }, - "execution_count": 114, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq.progress()" - ] - }, - { - "cell_type": "code", - "execution_count": 117, - "id": "1849020f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'triggered': array([0], dtype=int64)}" - ] - }, - "execution_count": 117, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.daq.read()" - ] - }, - { - "cell_type": "code", - "execution_count": 116, - "id": "83a442ce", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.finish()" - ] - }, - { - "cell_type": "code", - "execution_count": 193, - "id": "88477813", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.execute()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7f0085dc", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "19a6e2a0", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e43a3a28", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "2a2ed4e9", - "metadata": {}, - "outputs": [], - "source": [ - "import time" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "acf9f6a3", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.clear()\n", - "my_lockin.daq = my_lockin.api_session.dataAcquisitionModule()" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "cf0c1df9", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.api_session.setDebugLevel(0)" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "6fd7b881", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'forcetrigger': array([0], dtype=int64), 'triggered': array([1], dtype=int64)}\n", - "Progress [0.] %\n", - "{'dev3442': {'demods': {'0': {'sample.r': [{'header': {'systemtime': array([1664380454830777], dtype=uint64), 'createdtimestamp': array([1204630954536], dtype=uint64), 'changedtimestamp': array([1204630954536], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '100 17:54:14.8306', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([1000], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1204630942856, 1204630978696, 1204631014536, 1204631050376,\n", - " 1204631086216, 1204631122056, 1204631157896, 1204631193736,\n", - " 1204631229576, 1204631265416, 1204631301256, 1204631337096,\n", - " 1204631372936, 1204631408776, 1204631444616, 1204631480456,\n", - " 1204631516296, 1204631552136, 1204631587976, 1204631623816,\n", - " 1204631659656, 1204631695496, 1204631731336, 1204631767176,\n", - " 1204631803016, 1204631838856, 1204631874696, 1204631910536,\n", - " 1204631946376, 1204631982216, 1204632018056, 1204632053896,\n", - " 1204632089736, 1204632125576, 1204632161416, 1204632197256,\n", - " 1204632233096, 1204632268936, 1204632304776, 1204632340616,\n", - " 1204632376456, 1204632412296, 1204632448136, 1204632483976,\n", - " 1204632519816, 1204632555656, 1204632591496, 1204632627336,\n", - " 1204632663176, 1204632699016, 1204632734856, 1204632770696,\n", - " 1204632806536, 1204632842376, 1204632878216, 1204632914056,\n", - " 1204632949896, 1204632985736, 1204633021576, 1204633057416,\n", - " 1204633093256, 1204633129096, 1204633164936, 1204633200776,\n", - " 1204633236616, 1204633272456, 1204633308296, 1204633344136,\n", - " 1204633379976, 1204633415816, 1204633451656, 1204633487496,\n", - " 1204633523336, 1204633559176, 1204633595016, 1204633630856,\n", - " 1204633666696, 1204633702536, 1204633738376, 1204633774216,\n", - " 1204633810056, 1204633845896, 1204633881736, 1204633917576,\n", - " 1204633953416, 1204633989256, 1204634025096, 1204634060936,\n", - " 1204634096776, 1204634132616, 1204634168456, 1204634204296,\n", - " 1204634240136, 1204634275976, 1204634311816, 1204634347656,\n", - " 1204634383496, 1204634419336, 1204634455176, 1204634491016,\n", - " 1204634526856, 1204634562696, 1204634598536, 1204634634376,\n", - " 1204634670216, 1204634706056, 1204634741896, 1204634777736,\n", - " 1204634813576, 1204634849416, 1204634885256, 1204634921096,\n", - " 1204634956936, 1204634992776, 1204635028616, 1204635064456,\n", - " 1204635100296, 1204635136136, 1204635171976, 1204635207816,\n", - " 1204635243656, 1204635279496, 1204635315336, 1204635351176,\n", - " 1204635387016, 1204635422856, 1204635458696, 1204635494536,\n", - " 1204635530376, 1204635566216, 1204635602056, 1204635637896,\n", - " 1204635673736, 1204635709576, 1204635745416, 1204635781256,\n", - " 1204635817096, 1204635852936, 1204635888776, 1204635924616,\n", - " 1204635960456, 1204635996296, 1204636032136, 1204636067976,\n", - " 1204636103816, 1204636139656, 1204636175496, 1204636211336,\n", - " 1204636247176, 1204636283016, 1204636318856, 1204636354696,\n", - " 1204636390536, 1204636426376, 1204636462216, 1204636498056,\n", - " 1204636533896, 1204636569736, 1204636605576, 1204636641416,\n", - " 1204636677256, 1204636713096, 1204636748936, 1204636784776,\n", - " 1204636820616, 1204636856456, 1204636892296, 1204636928136,\n", - " 1204636963976, 1204636999816, 1204637035656, 1204637071496,\n", - " 1204637107336, 1204637143176, 1204637179016, 1204637214856,\n", - " 1204637250696, 1204637286536, 1204637322376, 1204637358216,\n", - " 1204637394056, 1204637429896, 1204637465736, 1204637501576,\n", - " 1204637537416, 1204637573256, 1204637609096, 1204637644936,\n", - " 1204637680776, 1204637716616, 1204637752456, 1204637788296,\n", - " 1204637824136, 1204637859976, 1204637895816, 1204637931656,\n", - " 1204637967496, 1204638003336, 1204638039176, 1204638075016,\n", - " 1204638110856, 1204638146696, 1204638182536, 1204638218376,\n", - " 1204638254216, 1204638290056, 1204638325896, 1204638361736,\n", - " 1204638397576, 1204638433416, 1204638469256, 1204638505096,\n", - " 1204638540936, 1204638576776, 1204638612616, 1204638648456,\n", - " 1204638684296, 1204638720136, 1204638755976, 1204638791816,\n", - " 1204638827656, 1204638863496, 1204638899336, 1204638935176,\n", - " 1204638971016, 1204639006856, 1204639042696, 1204639078536,\n", - " 1204639114376, 1204639150216, 1204639186056, 1204639221896,\n", - " 1204639257736, 1204639293576, 1204639329416, 1204639365256,\n", - " 1204639401096, 1204639436936, 1204639472776, 1204639508616,\n", - " 1204639544456, 1204639580296, 1204639616136, 1204639651976,\n", - " 1204639687816, 1204639723656, 1204639759496, 1204639795336,\n", - " 1204639831176, 1204639867016, 1204639902856, 1204639938696,\n", - " 1204639974536, 1204640010376, 1204640046216, 1204640082056,\n", - " 1204640117896, 1204640153736, 1204640189576, 1204640225416,\n", - " 1204640261256, 1204640297096, 1204640332936, 1204640368776,\n", - " 1204640404616, 1204640440456, 1204640476296, 1204640512136,\n", - " 1204640547976, 1204640583816, 1204640619656, 1204640655496,\n", - " 1204640691336, 1204640727176, 1204640763016, 1204640798856,\n", - " 1204640834696, 1204640870536, 1204640906376, 1204640942216,\n", - " 1204640978056, 1204641013896, 1204641049736, 1204641085576,\n", - " 1204641121416, 1204641157256, 1204641193096, 1204641228936,\n", - " 1204641264776, 1204641300616, 1204641336456, 1204641372296,\n", - " 1204641408136, 1204641443976, 1204641479816, 1204641515656,\n", - " 1204641551496, 1204641587336, 1204641623176, 1204641659016,\n", - " 1204641694856, 1204641730696, 1204641766536, 1204641802376,\n", - " 1204641838216, 1204641874056, 1204641909896, 1204641945736,\n", - " 1204641981576, 1204642017416, 1204642053256, 1204642089096,\n", - " 1204642124936, 1204642160776, 1204642196616, 1204642232456,\n", - " 1204642268296, 1204642304136, 1204642339976, 1204642375816,\n", - " 1204642411656, 1204642447496, 1204642483336, 1204642519176,\n", - " 1204642555016, 1204642590856, 1204642626696, 1204642662536,\n", - " 1204642698376, 1204642734216, 1204642770056, 1204642805896,\n", - " 1204642841736, 1204642877576, 1204642913416, 1204642949256,\n", - " 1204642985096, 1204643020936, 1204643056776, 1204643092616,\n", - " 1204643128456, 1204643164296, 1204643200136, 1204643235976,\n", - " 1204643271816, 1204643307656, 1204643343496, 1204643379336,\n", - " 1204643415176, 1204643451016, 1204643486856, 1204643522696,\n", - " 1204643558536, 1204643594376, 1204643630216, 1204643666056,\n", - " 1204643701896, 1204643737736, 1204643773576, 1204643809416,\n", - " 1204643845256, 1204643881096, 1204643916936, 1204643952776,\n", - " 1204643988616, 1204644024456, 1204644060296, 1204644096136,\n", - " 1204644131976, 1204644167816, 1204644203656, 1204644239496,\n", - " 1204644275336, 1204644311176, 1204644347016, 1204644382856,\n", - " 1204644418696, 1204644454536, 1204644490376, 1204644526216,\n", - " 1204644562056, 1204644597896, 1204644633736, 1204644669576,\n", - " 1204644705416, 1204644741256, 1204644777096, 1204644812936,\n", - " 1204644848776, 1204644884616, 1204644920456, 1204644956296,\n", - " 1204644992136, 1204645027976, 1204645063816, 1204645099656,\n", - " 1204645135496, 1204645171336, 1204645207176, 1204645243016,\n", - " 1204645278856, 1204645314696, 1204645350536, 1204645386376,\n", - " 1204645422216, 1204645458056, 1204645493896, 1204645529736,\n", - " 1204645565576, 1204645601416, 1204645637256, 1204645673096,\n", - " 1204645708936, 1204645744776, 1204645780616, 1204645816456,\n", - " 1204645852296, 1204645888136, 1204645923976, 1204645959816,\n", - " 1204645995656, 1204646031496, 1204646067336, 1204646103176,\n", - " 1204646139016, 1204646174856, 1204646210696, 1204646246536,\n", - " 1204646282376, 1204646318216, 1204646354056, 1204646389896,\n", - " 1204646425736, 1204646461576, 1204646497416, 1204646533256,\n", - " 1204646569096, 1204646604936, 1204646640776, 1204646676616,\n", - " 1204646712456, 1204646748296, 1204646784136, 1204646819976,\n", - " 1204646855816, 1204646891656, 1204646927496, 1204646963336,\n", - " 1204646999176, 1204647035016, 1204647070856, 1204647106696,\n", - " 1204647142536, 1204647178376, 1204647214216, 1204647250056,\n", - " 1204647285896, 1204647321736, 1204647357576, 1204647393416,\n", - " 1204647429256, 1204647465096, 1204647500936, 1204647536776,\n", - " 1204647572616, 1204647608456, 1204647644296, 1204647680136,\n", - " 1204647715976, 1204647751816, 1204647787656, 1204647823496,\n", - " 1204647859336, 1204647895176, 1204647931016, 1204647966856,\n", - " 1204648002696, 1204648038536, 1204648074376, 1204648110216,\n", - " 1204648146056, 1204648181896, 1204648217736, 1204648253576,\n", - " 1204648289416, 1204648325256, 1204648361096, 1204648396936,\n", - " 1204648432776, 1204648468616, 1204648504456, 1204648540296,\n", - " 1204648576136, 1204648611976, 1204648647816, 1204648683656,\n", - " 1204648719496, 1204648755336, 1204648791176, 1204648827016,\n", - " 1204648862856, 1204648898696, 1204648934536, 1204648970376,\n", - " 1204649006216, 1204649042056, 1204649077896, 1204649113736,\n", - " 1204649149576, 1204649185416, 1204649221256, 1204649257096,\n", - " 1204649292936, 1204649328776, 1204649364616, 1204649400456,\n", - " 1204649436296, 1204649472136, 1204649507976, 1204649543816,\n", - " 1204649579656, 1204649615496, 1204649651336, 1204649687176,\n", - " 1204649723016, 1204649758856, 1204649794696, 1204649830536,\n", - " 1204649866376, 1204649902216, 1204649938056, 1204649973896,\n", - " 1204650009736, 1204650045576, 1204650081416, 1204650117256,\n", - " 1204650153096, 1204650188936, 1204650224776, 1204650260616,\n", - " 1204650296456, 1204650332296, 1204650368136, 1204650403976,\n", - " 1204650439816, 1204650475656, 1204650511496, 1204650547336,\n", - " 1204650583176, 1204650619016, 1204650654856, 1204650690696,\n", - " 1204650726536, 1204650762376, 1204650798216, 1204650834056,\n", - " 1204650869896, 1204650905736, 1204650941576, 1204650977416,\n", - " 1204651013256, 1204651049096, 1204651084936, 1204651120776,\n", - " 1204651156616, 1204651192456, 1204651228296, 1204651264136,\n", - " 1204651299976, 1204651335816, 1204651371656, 1204651407496,\n", - " 1204651443336, 1204651479176, 1204651515016, 1204651550856,\n", - " 1204651586696, 1204651622536, 1204651658376, 1204651694216,\n", - " 1204651730056, 1204651765896, 1204651801736, 1204651837576,\n", - " 1204651873416, 1204651909256, 1204651945096, 1204651980936,\n", - " 1204652016776, 1204652052616, 1204652088456, 1204652124296,\n", - " 1204652160136, 1204652195976, 1204652231816, 1204652267656,\n", - " 1204652303496, 1204652339336, 1204652375176, 1204652411016,\n", - " 1204652446856, 1204652482696, 1204652518536, 1204652554376,\n", - " 1204652590216, 1204652626056, 1204652661896, 1204652697736,\n", - " 1204652733576, 1204652769416, 1204652805256, 1204652841096,\n", - " 1204652876936, 1204652912776, 1204652948616, 1204652984456,\n", - " 1204653020296, 1204653056136, 1204653091976, 1204653127816,\n", - " 1204653163656, 1204653199496, 1204653235336, 1204653271176,\n", - " 1204653307016, 1204653342856, 1204653378696, 1204653414536,\n", - " 1204653450376, 1204653486216, 1204653522056, 1204653557896,\n", - " 1204653593736, 1204653629576, 1204653665416, 1204653701256,\n", - " 1204653737096, 1204653772936, 1204653808776, 1204653844616,\n", - " 1204653880456, 1204653916296, 1204653952136, 1204653987976,\n", - " 1204654023816, 1204654059656, 1204654095496, 1204654131336,\n", - " 1204654167176, 1204654203016, 1204654238856, 1204654274696,\n", - " 1204654310536, 1204654346376, 1204654382216, 1204654418056,\n", - " 1204654453896, 1204654489736, 1204654525576, 1204654561416,\n", - " 1204654597256, 1204654633096, 1204654668936, 1204654704776,\n", - " 1204654740616, 1204654776456, 1204654812296, 1204654848136,\n", - " 1204654883976, 1204654919816, 1204654955656, 1204654991496,\n", - " 1204655027336, 1204655063176, 1204655099016, 1204655134856,\n", - " 1204655170696, 1204655206536, 1204655242376, 1204655278216,\n", - " 1204655314056, 1204655349896, 1204655385736, 1204655421576,\n", - " 1204655457416, 1204655493256, 1204655529096, 1204655564936,\n", - " 1204655600776, 1204655636616, 1204655672456, 1204655708296,\n", - " 1204655744136, 1204655779976, 1204655815816, 1204655851656,\n", - " 1204655887496, 1204655923336, 1204655959176, 1204655995016,\n", - " 1204656030856, 1204656066696, 1204656102536, 1204656138376,\n", - " 1204656174216, 1204656210056, 1204656245896, 1204656281736,\n", - " 1204656317576, 1204656353416, 1204656389256, 1204656425096,\n", - " 1204656460936, 1204656496776, 1204656532616, 1204656568456,\n", - " 1204656604296, 1204656640136, 1204656675976, 1204656711816,\n", - " 1204656747656, 1204656783496, 1204656819336, 1204656855176,\n", - " 1204656891016, 1204656926856, 1204656962696, 1204656998536,\n", - " 1204657034376, 1204657070216, 1204657106056, 1204657141896,\n", - " 1204657177736, 1204657213576, 1204657249416, 1204657285256,\n", - " 1204657321096, 1204657356936, 1204657392776, 1204657428616,\n", - " 1204657464456, 1204657500296, 1204657536136, 1204657571976,\n", - " 1204657607816, 1204657643656, 1204657679496, 1204657715336,\n", - " 1204657751176, 1204657787016, 1204657822856, 1204657858696,\n", - " 1204657894536, 1204657930376, 1204657966216, 1204658002056,\n", - " 1204658037896, 1204658073736, 1204658109576, 1204658145416,\n", - " 1204658181256, 1204658217096, 1204658252936, 1204658288776,\n", - " 1204658324616, 1204658360456, 1204658396296, 1204658432136,\n", - " 1204658467976, 1204658503816, 1204658539656, 1204658575496,\n", - " 1204658611336, 1204658647176, 1204658683016, 1204658718856,\n", - " 1204658754696, 1204658790536, 1204658826376, 1204658862216,\n", - " 1204658898056, 1204658933896, 1204658969736, 1204659005576,\n", - " 1204659041416, 1204659077256, 1204659113096, 1204659148936,\n", - " 1204659184776, 1204659220616, 1204659256456, 1204659292296,\n", - " 1204659328136, 1204659363976, 1204659399816, 1204659435656,\n", - " 1204659471496, 1204659507336, 1204659543176, 1204659579016,\n", - " 1204659614856, 1204659650696, 1204659686536, 1204659722376,\n", - " 1204659758216, 1204659794056, 1204659829896, 1204659865736,\n", - " 1204659901576, 1204659937416, 1204659973256, 1204660009096,\n", - " 1204660044936, 1204660080776, 1204660116616, 1204660152456,\n", - " 1204660188296, 1204660224136, 1204660259976, 1204660295816,\n", - " 1204660331656, 1204660367496, 1204660403336, 1204660439176,\n", - " 1204660475016, 1204660510856, 1204660546696, 1204660582536,\n", - " 1204660618376, 1204660654216, 1204660690056, 1204660725896,\n", - " 1204660761736, 1204660797576, 1204660833416, 1204660869256,\n", - " 1204660905096, 1204660940936, 1204660976776, 1204661012616,\n", - " 1204661048456, 1204661084296, 1204661120136, 1204661155976,\n", - " 1204661191816, 1204661227656, 1204661263496, 1204661299336,\n", - " 1204661335176, 1204661371016, 1204661406856, 1204661442696,\n", - " 1204661478536, 1204661514376, 1204661550216, 1204661586056,\n", - " 1204661621896, 1204661657736, 1204661693576, 1204661729416,\n", - " 1204661765256, 1204661801096, 1204661836936, 1204661872776,\n", - " 1204661908616, 1204661944456, 1204661980296, 1204662016136,\n", - " 1204662051976, 1204662087816, 1204662123656, 1204662159496,\n", - " 1204662195336, 1204662231176, 1204662267016, 1204662302856,\n", - " 1204662338696, 1204662374536, 1204662410376, 1204662446216,\n", - " 1204662482056, 1204662517896, 1204662553736, 1204662589576,\n", - " 1204662625416, 1204662661256, 1204662697096, 1204662732936,\n", - " 1204662768776, 1204662804616, 1204662840456, 1204662876296,\n", - " 1204662912136, 1204662947976, 1204662983816, 1204663019656,\n", - " 1204663055496, 1204663091336, 1204663127176, 1204663163016,\n", - " 1204663198856, 1204663234696, 1204663270536, 1204663306376,\n", - " 1204663342216, 1204663378056, 1204663413896, 1204663449736,\n", - " 1204663485576, 1204663521416, 1204663557256, 1204663593096,\n", - " 1204663628936, 1204663664776, 1204663700616, 1204663736456,\n", - " 1204663772296, 1204663808136, 1204663843976, 1204663879816,\n", - " 1204663915656, 1204663951496, 1204663987336, 1204664023176,\n", - " 1204664059016, 1204664094856, 1204664130696, 1204664166536,\n", - " 1204664202376, 1204664238216, 1204664274056, 1204664309896,\n", - " 1204664345736, 1204664381576, 1204664417416, 1204664453256,\n", - " 1204664489096, 1204664524936, 1204664560776, 1204664596616,\n", - " 1204664632456, 1204664668296, 1204664704136, 1204664739976,\n", - " 1204664775816, 1204664811656, 1204664847496, 1204664883336,\n", - " 1204664919176, 1204664955016, 1204664990856, 1204665026696,\n", - " 1204665062536, 1204665098376, 1204665134216, 1204665170056,\n", - " 1204665205896, 1204665241736, 1204665277576, 1204665313416,\n", - " 1204665349256, 1204665385096, 1204665420936, 1204665456776,\n", - " 1204665492616, 1204665528456, 1204665564296, 1204665600136,\n", - " 1204665635976, 1204665671816, 1204665707656, 1204665743496,\n", - " 1204665779336, 1204665815176, 1204665851016, 1204665886856,\n", - " 1204665922696, 1204665958536, 1204665994376, 1204666030216,\n", - " 1204666066056, 1204666101896, 1204666137736, 1204666173576,\n", - " 1204666209416, 1204666245256, 1204666281096, 1204666316936,\n", - " 1204666352776, 1204666388616, 1204666424456, 1204666460296,\n", - " 1204666496136, 1204666531976, 1204666567816, 1204666603656,\n", - " 1204666639496, 1204666675336, 1204666711176, 1204666747016]],\n", - " dtype=uint64), 'value': array([[1.10172382e-06, 9.00993372e-07, 6.85672291e-07, 5.05722310e-07,\n", - " 2.63556648e-07, 2.84944932e-07, 3.43998598e-07, 3.56673579e-07,\n", - " 4.30376278e-07, 3.80952694e-07, 4.10249181e-07, 4.03857472e-07,\n", - " 3.59043179e-07, 3.51889392e-07, 5.21878583e-07, 6.58856069e-07,\n", - " 6.23421580e-07, 5.82284234e-07, 5.37666393e-07, 2.95894822e-07,\n", - " 1.12301962e-08, 3.05695226e-07, 6.04882662e-07, 9.20686311e-07,\n", - " 1.13660529e-06, 1.19092367e-06, 9.76087500e-07, 6.15055004e-07,\n", - " 3.13769275e-07, 1.81930674e-07, 2.39599186e-07, 2.50579467e-07,\n", - " 2.97543602e-07, 3.24700912e-07, 2.81532788e-07, 3.05032989e-07,\n", - " 5.97171120e-07, 7.96912833e-07, 7.64501338e-07, 6.77978549e-07,\n", - " 6.23856189e-07, 5.55979018e-07, 3.88805118e-07, 2.57782050e-07,\n", - " 1.68561224e-07, 1.32007622e-07, 7.78802425e-08, 1.63811875e-07,\n", - " 3.47639782e-07, 2.50012698e-07, 8.94291151e-08, 8.03697325e-08,\n", - " 1.30349154e-07, 2.19107313e-07, 4.69253203e-07, 6.39894882e-07,\n", - " 6.57779206e-07, 5.09883973e-07, 4.76852062e-07, 5.10156623e-07,\n", - " 6.23915346e-07, 5.94415979e-07, 4.12425406e-07, 2.67075364e-07,\n", - " 9.69192031e-08, 4.97695649e-08, 6.58232731e-08, 1.23616393e-07,\n", - " 2.54326451e-07, 2.70416881e-07, 1.38021070e-07, 8.80823575e-08,\n", - " 5.45155700e-08, 2.21586304e-07, 3.09675449e-07, 2.78693839e-07,\n", - " 2.33244356e-07, 2.13303117e-07, 3.95575820e-07, 5.10217416e-07,\n", - " 5.55577809e-07, 5.54332627e-07, 4.60837489e-07, 3.45195816e-07,\n", - " 4.08619026e-07, 3.29004646e-07, 1.99000774e-07, 6.32831896e-08,\n", - " 1.10443827e-07, 1.25044715e-07, 5.80890342e-08, 6.50742469e-08,\n", - " 3.18526981e-07, 5.52935197e-07, 6.18173192e-07, 6.35119098e-07,\n", - " 6.52850575e-07, 7.50804686e-07, 8.00443590e-07, 7.44553393e-07,\n", - " 5.48159761e-07, 3.03408876e-07, 3.71190485e-07, 4.09963545e-07,\n", - " 2.14933673e-07, 1.25808499e-07, 2.63823650e-07, 3.78668448e-07,\n", - " 4.21149267e-07, 4.30933377e-07, 3.88958810e-07, 3.39340699e-07,\n", - " 2.99199090e-07, 2.38414859e-07, 9.79969920e-08, 1.71532624e-07,\n", - " 4.15741660e-07, 6.09098279e-07, 7.58500603e-07, 8.81326664e-07,\n", - " 9.27644427e-07, 8.78532515e-07, 7.24006467e-07, 5.27521366e-07,\n", - " 3.13078440e-07, 1.78492138e-07, 1.02943885e-07, 9.00787678e-08,\n", - " 2.23117015e-07, 3.52778792e-07, 3.64945691e-07, 2.71476053e-07,\n", - " 1.50592943e-07, 9.85347571e-08, 1.37514951e-07, 2.62132523e-07,\n", - " 5.61961763e-07, 7.62610677e-07, 7.61311804e-07, 7.51694936e-07,\n", - " 6.75334372e-07, 6.38306937e-07, 6.09471814e-07, 5.06948147e-07,\n", - " 3.77760478e-07, 4.62184582e-07, 5.50134840e-07, 5.93225916e-07,\n", - " 5.70856045e-07, 4.45811062e-07, 2.64324269e-07, 1.74873117e-07,\n", - " 1.41081115e-07, 1.34482520e-07, 9.52025471e-08, 5.85520569e-08,\n", - " 1.73440558e-07, 2.22078318e-07, 2.33007683e-07, 3.03478090e-07,\n", - " 4.05284261e-07, 6.13934440e-07, 7.63735737e-07, 6.12481949e-07,\n", - " 3.23829195e-07, 1.47620966e-07, 1.72441448e-07, 3.74744625e-07,\n", - " 2.70861242e-07, 3.20812078e-08, 1.87066335e-07, 3.01109457e-07,\n", - " 4.91104778e-07, 4.33183644e-07, 2.82325730e-07, 2.97699066e-07,\n", - " 5.17974675e-07, 5.91289304e-07, 3.46911982e-07, 1.78438744e-07,\n", - " 1.02194575e-07, 1.57912315e-07, 2.22870560e-07, 3.24817655e-07,\n", - " 3.50475580e-07, 4.29146299e-07, 3.44077590e-07, 1.72237873e-07,\n", - " 9.22907941e-09, 2.21248674e-07, 3.25739808e-07, 2.14661637e-07,\n", - " 1.64524065e-07, 2.52054707e-07, 4.70487339e-07, 4.74727628e-07,\n", - " 3.43503301e-07, 5.03108132e-07, 5.68300504e-07, 4.01165899e-07,\n", - " 2.44321059e-07, 3.00103881e-07, 3.72187270e-07, 3.47736345e-07,\n", - " 3.10355839e-07, 2.75364159e-07, 4.09862560e-07, 5.73371383e-07,\n", - " 6.27081190e-07, 5.77312744e-07, 6.05007397e-07, 7.27155688e-07,\n", - " 5.92057189e-07, 1.91106106e-07, 2.56967975e-07, 2.92111836e-07,\n", - " 3.90146251e-07, 4.82477848e-07, 5.32305439e-07, 3.44347786e-07,\n", - " 1.72010907e-07, 1.73923000e-07, 2.50814343e-07, 3.89090037e-07,\n", - " 4.75643228e-07, 3.88711305e-07, 1.97222847e-07, 2.46780284e-07,\n", - " 2.64668826e-07, 2.89501174e-07, 4.01518224e-07, 6.74135688e-07,\n", - " 6.18645069e-07, 4.37556495e-07, 2.20923047e-07, 1.14419556e-07,\n", - " 1.26856734e-07, 1.00089621e-07, 1.19525727e-07, 2.57526231e-07,\n", - " 2.26675326e-07, 3.10498070e-07, 3.31654109e-07, 2.14005446e-07,\n", - " 1.86077339e-07, 2.48257635e-07, 3.22971276e-07, 2.40623303e-07,\n", - " 1.11573253e-07, 1.79141024e-07, 2.04903808e-07, 1.84530491e-07,\n", - " 2.06834505e-07, 3.85550780e-07, 4.17616354e-07, 4.10810334e-07,\n", - " 4.15976585e-07, 5.94376739e-07, 7.45402668e-07, 7.06737766e-07,\n", - " 5.06713546e-07, 4.63435309e-07, 5.54252429e-07, 6.89894794e-07,\n", - " 7.03826561e-07, 6.46166485e-07, 6.09534471e-07, 6.27221407e-07,\n", - " 6.25122666e-07, 6.02095574e-07, 5.38525279e-07, 4.77109918e-07,\n", - " 4.68633768e-07, 5.49740086e-07, 6.68247982e-07, 6.83298293e-07,\n", - " 5.75904493e-07, 4.71106274e-07, 2.62474890e-07, 2.08783763e-07,\n", - " 8.82209886e-08, 1.15886977e-08, 5.56766077e-08, 2.55647020e-07,\n", - " 4.29921534e-07, 3.63903429e-07, 2.24994979e-07, 6.40724979e-08,\n", - " 2.18174975e-07, 3.90993800e-07, 3.26305621e-07, 7.97413743e-08,\n", - " 2.02468614e-07, 2.89155193e-07, 3.85857853e-07, 5.37231927e-07,\n", - " 7.73238741e-07, 7.68905833e-07, 6.50909665e-07, 6.70089472e-07,\n", - " 6.39205529e-07, 4.08252469e-07, 2.21792694e-07, 1.14801932e-07,\n", - " 1.13725462e-07, 4.44966872e-07, 8.28901844e-07, 1.01473163e-06,\n", - " 9.24568619e-07, 6.14258722e-07, 3.35031847e-07, 1.85673215e-07,\n", - " 1.52792186e-07, 3.15459204e-07, 3.88451031e-07, 4.23969453e-07,\n", - " 4.50853976e-07, 4.95974133e-07, 4.31684977e-07, 1.04238612e-07,\n", - " 2.50071162e-07, 3.77273337e-07, 4.51408268e-07, 5.05259783e-07,\n", - " 5.63401662e-07, 6.04346571e-07, 5.15800601e-07, 4.71134910e-07,\n", - " 6.03224967e-07, 5.31633718e-07, 3.53417994e-07, 1.39320333e-07,\n", - " 1.22904463e-07, 1.90635450e-07, 3.05044716e-07, 3.71255569e-07,\n", - " 4.28827198e-07, 4.35061635e-07, 3.83926620e-07, 2.93598126e-07,\n", - " 3.03978936e-07, 3.76574453e-07, 4.38974518e-07, 3.67454943e-07,\n", - " 1.85178407e-07, 1.62951258e-07, 2.02209877e-07, 1.03071540e-07,\n", - " 8.78383533e-08, 2.79744145e-07, 3.49905868e-07, 3.96674925e-07,\n", - " 5.90938110e-07, 7.02573590e-07, 6.73909212e-07, 5.14048070e-07,\n", - " 3.30404926e-07, 1.62184815e-07, 2.37903294e-07, 4.85346027e-07,\n", - " 4.03753378e-07, 3.27056394e-07, 2.55584118e-07, 3.05960649e-07,\n", - " 3.83446085e-07, 5.74046413e-07, 6.27709939e-07, 4.78470426e-07,\n", - " 4.65230034e-07, 3.58294942e-07, 1.73612183e-07, 1.92023326e-07,\n", - " 2.54248171e-07, 3.19083436e-07, 1.38770681e-07, 5.41525005e-08,\n", - " 2.77540914e-07, 3.61662365e-07, 3.70860352e-07, 4.06588683e-07,\n", - " 3.85190720e-07, 3.84275516e-07, 3.16298031e-07, 2.21499569e-07,\n", - " 1.53273756e-07, 8.76957469e-08, 1.98060853e-07, 3.91326256e-07,\n", - " 4.25993278e-07, 3.35671756e-07, 5.19576302e-08, 1.70884313e-07,\n", - " 2.15189768e-07, 2.79358661e-07, 3.15516474e-07, 3.76591686e-07,\n", - " 3.18433151e-07, 2.40545801e-07, 2.08688055e-07, 2.82018612e-07,\n", - " 4.53363506e-07, 5.80581909e-07, 5.93196116e-07, 5.40983376e-07,\n", - " 5.58967494e-07, 5.55660148e-07, 6.35585684e-07, 6.20240423e-07,\n", - " 6.81962130e-07, 6.74469772e-07, 6.12472606e-07, 5.11543210e-07,\n", - " 5.75453913e-07, 6.05407513e-07, 5.33758830e-07, 4.72757988e-07,\n", - " 3.75739332e-07, 1.62924315e-07, 2.01131427e-07, 9.05138952e-08,\n", - " 7.45520615e-09, 2.17270471e-07, 2.89617935e-07, 1.30100758e-07,\n", - " 1.30095319e-07, 1.64433901e-07, 1.10164649e-07, 2.98595620e-07,\n", - " 3.83649826e-07, 2.78758448e-07, 2.28737139e-07, 1.84545341e-07,\n", - " 1.44420273e-07, 4.57294424e-07, 6.68904526e-07, 7.24629512e-07,\n", - " 6.92990602e-07, 5.50788691e-07, 3.61729826e-07, 1.54338849e-07,\n", - " 9.36556041e-08, 3.84913625e-07, 6.74676961e-07, 7.49737854e-07,\n", - " 7.91698334e-07, 6.41507399e-07, 6.01816832e-07, 7.41940247e-07,\n", - " 8.15793327e-07, 7.48879176e-07, 5.83365556e-07, 4.20656161e-07,\n", - " 3.18818747e-07, 2.04860203e-07, 2.77391239e-07, 3.67076249e-07,\n", - " 4.10224823e-07, 3.07760784e-07, 3.95908324e-07, 5.47137366e-07,\n", - " 6.51749747e-07, 7.29113815e-07, 7.38477703e-07, 7.71924829e-07,\n", - " 8.09991899e-07, 7.31862177e-07, 4.80444342e-07, 3.75488325e-07,\n", - " 2.30663163e-07, 1.25087616e-07, 1.81723196e-07, 1.51660581e-07,\n", - " 1.45726213e-07, 2.56302335e-07, 3.22508638e-07, 2.97016756e-07,\n", - " 2.46639946e-07, 1.80873620e-07, 1.10603196e-07, 4.11544779e-07,\n", - " 7.00062907e-07, 6.97734300e-07, 5.37358877e-07, 4.43892359e-07,\n", - " 4.13851719e-07, 4.61548999e-07, 4.83614804e-07, 5.09572495e-07,\n", - " 4.97111450e-07, 3.07411792e-07, 1.60220721e-07, 2.50309182e-07,\n", - " 3.48249997e-07, 2.60791915e-07, 1.46551304e-08, 2.78461321e-07,\n", - " 3.72349704e-07, 4.30719884e-07, 4.45666767e-07, 3.27599352e-07,\n", - " 1.23808373e-07, 6.23509798e-08, 1.75828335e-07, 3.04169271e-07,\n", - " 2.93007656e-07, 2.23771779e-07, 2.38133733e-07, 2.32698141e-07,\n", - " 3.81322503e-07, 4.33507591e-07, 4.77924413e-07, 4.98704734e-07,\n", - " 5.11102151e-07, 5.30412445e-07, 5.88101932e-07, 5.25820025e-07,\n", - " 3.64397164e-07, 1.28373792e-07, 1.67656421e-07, 3.26175983e-07,\n", - " 3.98572683e-07, 3.18682353e-07, 1.23289791e-07, 2.31347164e-07,\n", - " 4.30995051e-07, 4.94945496e-07, 5.00033328e-07, 2.90503592e-07,\n", - " 2.36491774e-07, 3.29661022e-07, 4.14656961e-07, 4.73994058e-07,\n", - " 3.92556499e-07, 3.58857059e-07, 3.39263702e-07, 1.55860375e-07,\n", - " 1.45640380e-07, 2.38803777e-07, 3.50502161e-07, 3.89760610e-07,\n", - " 2.96614664e-07, 3.38885974e-07, 4.63940538e-07, 4.33276263e-07,\n", - " 2.50469351e-07, 2.37320277e-07, 3.68405627e-07, 6.17641452e-07,\n", - " 8.84763346e-07, 9.17253173e-07, 7.06064935e-07, 4.99665046e-07,\n", - " 2.86683710e-07, 2.30685990e-07, 1.97848786e-07, 1.78313368e-07,\n", - " 2.21611128e-07, 3.62535608e-07, 5.24055643e-07, 5.77170078e-07,\n", - " 4.67761382e-07, 5.22425933e-07, 4.52543367e-07, 3.79985241e-07,\n", - " 2.77172847e-07, 1.49777161e-07, 1.15214658e-07, 3.59981435e-07,\n", - " 6.03369756e-07, 6.67961744e-07, 5.94612510e-07, 4.16769794e-07,\n", - " 2.58266120e-07, 3.39543432e-07, 4.73534940e-07, 4.96254211e-07,\n", - " 3.71374416e-07, 2.92820765e-07, 4.17394871e-07, 6.16769871e-07,\n", - " 6.53420767e-07, 6.01329267e-07, 5.84599318e-07, 5.32087815e-07,\n", - " 5.11893352e-07, 3.93062658e-07, 1.51709865e-07, 2.12522162e-08,\n", - " 8.89926409e-08, 2.71148514e-07, 5.10614147e-07, 5.86233899e-07,\n", - " 4.56926837e-07, 3.34114450e-07, 3.66266238e-07, 4.64055009e-07,\n", - " 4.71204388e-07, 4.68161087e-07, 4.35620452e-07, 4.07623605e-07,\n", - " 4.27871698e-07, 5.59862233e-07, 6.05468102e-07, 6.36568208e-07,\n", - " 6.54980918e-07, 6.15334462e-07, 3.32778868e-07, 2.44608204e-08,\n", - " 1.28116423e-07, 1.21720857e-07, 1.06496458e-07, 2.26547081e-07,\n", - " 3.03950013e-07, 2.72227746e-07, 2.15457545e-07, 2.44805478e-07,\n", - " 4.37398264e-07, 6.24068867e-07, 6.10211264e-07, 5.84822469e-07,\n", - " 5.59034655e-07, 5.62235625e-07, 5.81709446e-07, 5.34074456e-07,\n", - " 4.31861549e-07, 1.99938765e-07, 1.48787174e-07, 1.20190864e-07,\n", - " 2.57822474e-07, 4.45790132e-07, 4.20567341e-07, 3.44484166e-07,\n", - " 2.73959165e-07, 1.71478123e-07, 7.83323773e-08, 9.37151918e-08,\n", - " 2.49811716e-07, 3.09317789e-07, 3.02401749e-07, 2.48652746e-07,\n", - " 2.39160349e-07, 4.73779328e-07, 5.82964207e-07, 5.28841215e-07,\n", - " 5.67864881e-07, 6.37154438e-07, 6.33173841e-07, 4.17288629e-07,\n", - " 5.18028416e-07, 6.47880325e-07, 7.42836657e-07, 7.70841690e-07,\n", - " 6.62514309e-07, 5.13944815e-07, 3.45391554e-07, 1.26703549e-07,\n", - " 4.91374190e-08, 5.58747034e-08, 1.81795476e-07, 5.04145382e-07,\n", - " 6.36718257e-07, 6.19121328e-07, 5.05161528e-07, 4.23852618e-07,\n", - " 4.07100383e-07, 5.52901048e-07, 5.73362020e-07, 4.64448810e-07,\n", - " 4.09242005e-07, 4.58095006e-07, 4.36634270e-07, 3.77672928e-07,\n", - " 3.26387651e-07, 3.19701485e-07, 3.36957607e-07, 2.76393757e-07,\n", - " 2.33877207e-07, 5.99739826e-08, 3.87451598e-07, 5.06846618e-07,\n", - " 2.73912143e-07, 1.69720831e-07, 4.97385909e-07, 4.49638096e-07,\n", - " 2.75734554e-07, 2.83083828e-07, 3.61067130e-07, 2.82104562e-07,\n", - " 7.75347440e-08, 5.64334566e-08, 1.85022021e-07, 3.03871562e-07,\n", - " 3.10899044e-07, 2.72303530e-07, 2.21233625e-07, 2.48180434e-07,\n", - " 2.78723931e-07, 3.22697810e-07, 5.54059670e-07, 6.19390567e-07,\n", - " 5.51157971e-07, 3.76065087e-07, 4.20955015e-08, 1.22463307e-07,\n", - " 7.62915335e-08, 1.76891360e-07, 2.81819575e-07, 3.15055046e-07,\n", - " 3.26917003e-07, 2.59225916e-07, 1.12111201e-07, 3.54231417e-08,\n", - " 1.30066101e-07, 3.77238140e-07, 6.62036199e-07, 7.23178983e-07,\n", - " 6.28532827e-07, 4.20225381e-07, 1.97549962e-07, 3.35634207e-07,\n", - " 3.66089416e-07, 2.72458372e-07, 1.52055798e-07, 2.29626293e-07,\n", - " 2.16658080e-07, 1.38513811e-07, 2.10525809e-07, 2.35135964e-07,\n", - " 3.75240077e-07, 4.43467112e-07, 1.79198796e-07, 2.34808419e-07,\n", - " 5.07529421e-07, 6.96410096e-07, 6.45342656e-07, 4.42581123e-07,\n", - " 3.07838187e-07, 3.22290837e-07, 2.47777651e-07, 3.71568152e-07,\n", - " 4.23185003e-07, 3.48936635e-07, 2.53383478e-07, 3.81561622e-07,\n", - " 5.49555713e-07, 7.35642765e-07, 8.92304125e-07, 9.49032819e-07,\n", - " 8.15547663e-07, 6.47913144e-07, 5.53582472e-07, 5.82332542e-07,\n", - " 5.28295282e-07, 4.83346357e-07, 5.09975635e-07, 3.61859401e-07,\n", - " 1.87085701e-07, 1.00685767e-07, 6.48184726e-08, 2.51909657e-07,\n", - " 3.41402645e-07, 3.61064978e-07, 3.29101330e-07, 3.09282468e-07,\n", - " 3.56624640e-07, 3.56407153e-07, 4.19803216e-07, 5.20763489e-07,\n", - " 5.84085817e-07, 5.51045302e-07, 6.62566213e-07, 6.34141819e-07,\n", - " 4.17268796e-07, 3.84569151e-07, 4.20606084e-07, 3.47259006e-07,\n", - " 3.13524207e-07, 3.00912440e-07, 2.97730333e-07, 1.80344993e-07,\n", - " 5.71022710e-08, 1.61224854e-07, 1.54991875e-07, 2.70976776e-07,\n", - " 4.12883459e-07, 3.49212288e-07, 1.78077072e-07, 8.46431259e-08,\n", - " 2.16470941e-07, 4.71058132e-07, 5.17018370e-07, 4.12778655e-07,\n", - " 3.59922374e-07, 2.88825818e-07, 1.60507626e-07, 2.56569859e-07,\n", - " 3.94164341e-07, 4.51043831e-07, 4.16377396e-07, 3.41116493e-07,\n", - " 1.87434013e-07, 2.73445796e-07, 3.69698843e-07, 3.89326346e-07,\n", - " 2.05621253e-07, 6.39084693e-08, 2.03270487e-08, 2.19618890e-07,\n", - " 4.09822299e-07, 4.53437598e-07, 6.04374490e-07, 6.71124535e-07,\n", - " 5.35008768e-07, 3.31273048e-07, 1.86286264e-07, 7.87992030e-08,\n", - " 7.33899804e-08, 5.46788003e-08, 7.82461988e-08, 2.89594445e-07,\n", - " 4.71009109e-07, 6.25776587e-07, 7.29467199e-07, 7.03004149e-07,\n", - " 7.15162244e-07, 6.40278175e-07, 4.81499008e-07, 3.26249199e-07,\n", - " 2.51090617e-07, 3.26096355e-07, 4.67166693e-07, 4.49483618e-07,\n", - " 4.44373646e-07, 5.33181373e-07, 5.04411615e-07, 2.90559870e-07,\n", - " 1.76062043e-08, 6.63463654e-08, 6.20297987e-08, 1.36291039e-07,\n", - " 1.64785161e-07, 1.32513331e-07, 1.91439409e-07, 2.02623515e-07,\n", - " 2.60582721e-07, 3.29594684e-07, 3.19847083e-07, 4.86802232e-07,\n", - " 5.06645747e-07, 4.63002082e-07, 4.45252041e-07, 3.29432378e-07,\n", - " 1.33060167e-07, 1.12901016e-07, 5.26525262e-08, 2.23240071e-07,\n", - " 2.15720374e-07, 1.78089833e-07, 9.07086483e-08, 1.85874627e-07,\n", - " 3.43056815e-07, 5.23815412e-07, 5.41483621e-07, 5.34903506e-07,\n", - " 6.87934277e-07, 6.35206008e-07, 5.30810105e-07, 5.86690328e-07,\n", - " 5.96205596e-07, 4.76265283e-07, 2.59530478e-07, 1.74668642e-07,\n", - " 2.20707690e-07, 1.48224947e-07, 7.76568209e-08, 1.49773341e-07,\n", - " 1.78680352e-07, 1.50650345e-07, 1.71730188e-07, 1.91727303e-07,\n", - " 2.55737209e-07, 4.01336506e-07, 4.90735809e-07, 6.14103359e-07,\n", - " 7.46771362e-07, 7.70136971e-07, 7.22502224e-07, 6.80766422e-07,\n", - " 4.75239918e-07, 2.77572849e-07, 2.05658903e-07, 2.15890173e-07,\n", - " 3.81961906e-07, 5.64244747e-07, 6.73058541e-07, 6.74224365e-07,\n", - " 5.94286990e-07, 5.01544846e-07, 3.92881635e-07, 3.41382951e-07,\n", - " 3.33890182e-07, 1.99711452e-07, 2.42957717e-07, 3.43601866e-07,\n", - " 3.29441193e-07, 2.52072739e-07, 2.95682939e-07, 3.75249375e-07,\n", - " 3.42851182e-07, 3.24730227e-07, 2.39156456e-07, 1.41895006e-07,\n", - " 2.08806816e-07, 2.25333412e-07, 2.89249900e-07, 4.32962675e-07,\n", - " 3.95274135e-07, 2.61367467e-07, 2.59601271e-07, 3.31315463e-07,\n", - " 4.64020000e-07, 4.42235952e-07, 2.78579548e-07, 4.32860594e-08,\n", - " 1.19422155e-07, 2.20370440e-07, 2.72269130e-07, 1.95321901e-07,\n", - " 2.49038024e-07, 2.20263688e-07, 1.09444566e-07, 1.19985084e-07,\n", - " 1.64712500e-07, 2.54279504e-07, 5.21125581e-07, 5.99847999e-07,\n", - " 5.50143097e-07, 5.38032710e-07, 5.75328278e-07, 5.84995137e-07,\n", - " 5.91818588e-07, 6.61172483e-07, 5.09732156e-07, 3.38181717e-07,\n", - " 1.90165818e-07, 9.16482454e-08, 2.16879324e-07, 2.71869259e-07,\n", - " 2.34202087e-07, 1.64473707e-07, 1.85627516e-07, 4.21186435e-07,\n", - " 7.20099193e-07, 8.49382786e-07, 8.55383445e-07, 8.06922724e-07,\n", - " 8.86273143e-07, 1.09564047e-06, 1.02477921e-06, 7.71886033e-07,\n", - " 4.82086127e-07, 1.55281914e-07, 2.88683618e-07, 4.12018350e-07,\n", - " 3.66836577e-07, 3.69618906e-07, 3.32524375e-07, 2.48514935e-07,\n", - " 1.59734486e-07, 1.87519651e-07, 1.90979404e-07, 1.35212486e-07,\n", - " 1.37459873e-07, 2.72669989e-07, 3.34520602e-07, 4.73230690e-07,\n", - " 7.20279987e-07, 8.29459769e-07, 8.65655251e-07, 6.95763571e-07,\n", - " 3.59860664e-07, 3.39939569e-07, 4.08631101e-07, 4.24498281e-07,\n", - " 4.20614116e-07, 2.52512024e-07, 3.18811094e-07, 4.74561047e-07,\n", - " 5.65069723e-07, 5.56085131e-07, 4.72746776e-07, 2.86232741e-07,\n", - " 2.83763569e-07, 4.50330590e-07, 4.43099713e-07, 2.94279395e-07,\n", - " 1.94999411e-07, 1.30027981e-07, 7.19276390e-08, 7.09954223e-08]])}], 'sample.x': [{'header': {'systemtime': array([1664380454830796], dtype=uint64), 'createdtimestamp': array([1204630954536], dtype=uint64), 'changedtimestamp': array([1204630954536], dtype=uint64), 'flags': array([1849], dtype=uint32), 'moduleflags': array([0], dtype=uint32), 'chunksizebytes': array([0], dtype=uint64), 'name': '100 17:54:14.8306', 'status': array([0], dtype=uint32), 'groupindex': array([0], dtype=uint32), 'color': array([0], dtype=uint32), 'activerow': array([0], dtype=uint32), 'triggernumber': array([0], dtype=uint64), 'gridrows': array([1], dtype=uint32), 'gridcols': array([1000], dtype=uint32), 'gridmode': array([4], dtype=uint32), 'gridoperation': array([1], dtype=uint32), 'griddirection': array([0], dtype=uint32), 'gridrepetitions': array([1], dtype=uint32), 'gridcoldelta': array([0.00059733]), 'gridcoloffset': array([-0.001]), 'gridrowdelta': array([1.]), 'gridrowoffset': array([0.]), 'bandwidth': array([nan]), 'center': array([0.]), 'nenbw': array([nan])}, 'timestamp': array([[1204630942856, 1204630978696, 1204631014536, 1204631050376,\n", - " 1204631086216, 1204631122056, 1204631157896, 1204631193736,\n", - " 1204631229576, 1204631265416, 1204631301256, 1204631337096,\n", - " 1204631372936, 1204631408776, 1204631444616, 1204631480456,\n", - " 1204631516296, 1204631552136, 1204631587976, 1204631623816,\n", - " 1204631659656, 1204631695496, 1204631731336, 1204631767176,\n", - " 1204631803016, 1204631838856, 1204631874696, 1204631910536,\n", - " 1204631946376, 1204631982216, 1204632018056, 1204632053896,\n", - " 1204632089736, 1204632125576, 1204632161416, 1204632197256,\n", - " 1204632233096, 1204632268936, 1204632304776, 1204632340616,\n", - " 1204632376456, 1204632412296, 1204632448136, 1204632483976,\n", - " 1204632519816, 1204632555656, 1204632591496, 1204632627336,\n", - " 1204632663176, 1204632699016, 1204632734856, 1204632770696,\n", - " 1204632806536, 1204632842376, 1204632878216, 1204632914056,\n", - " 1204632949896, 1204632985736, 1204633021576, 1204633057416,\n", - " 1204633093256, 1204633129096, 1204633164936, 1204633200776,\n", - " 1204633236616, 1204633272456, 1204633308296, 1204633344136,\n", - " 1204633379976, 1204633415816, 1204633451656, 1204633487496,\n", - " 1204633523336, 1204633559176, 1204633595016, 1204633630856,\n", - " 1204633666696, 1204633702536, 1204633738376, 1204633774216,\n", - " 1204633810056, 1204633845896, 1204633881736, 1204633917576,\n", - " 1204633953416, 1204633989256, 1204634025096, 1204634060936,\n", - " 1204634096776, 1204634132616, 1204634168456, 1204634204296,\n", - " 1204634240136, 1204634275976, 1204634311816, 1204634347656,\n", - " 1204634383496, 1204634419336, 1204634455176, 1204634491016,\n", - " 1204634526856, 1204634562696, 1204634598536, 1204634634376,\n", - " 1204634670216, 1204634706056, 1204634741896, 1204634777736,\n", - " 1204634813576, 1204634849416, 1204634885256, 1204634921096,\n", - " 1204634956936, 1204634992776, 1204635028616, 1204635064456,\n", - " 1204635100296, 1204635136136, 1204635171976, 1204635207816,\n", - " 1204635243656, 1204635279496, 1204635315336, 1204635351176,\n", - " 1204635387016, 1204635422856, 1204635458696, 1204635494536,\n", - " 1204635530376, 1204635566216, 1204635602056, 1204635637896,\n", - " 1204635673736, 1204635709576, 1204635745416, 1204635781256,\n", - " 1204635817096, 1204635852936, 1204635888776, 1204635924616,\n", - " 1204635960456, 1204635996296, 1204636032136, 1204636067976,\n", - " 1204636103816, 1204636139656, 1204636175496, 1204636211336,\n", - " 1204636247176, 1204636283016, 1204636318856, 1204636354696,\n", - " 1204636390536, 1204636426376, 1204636462216, 1204636498056,\n", - " 1204636533896, 1204636569736, 1204636605576, 1204636641416,\n", - " 1204636677256, 1204636713096, 1204636748936, 1204636784776,\n", - " 1204636820616, 1204636856456, 1204636892296, 1204636928136,\n", - " 1204636963976, 1204636999816, 1204637035656, 1204637071496,\n", - " 1204637107336, 1204637143176, 1204637179016, 1204637214856,\n", - " 1204637250696, 1204637286536, 1204637322376, 1204637358216,\n", - " 1204637394056, 1204637429896, 1204637465736, 1204637501576,\n", - " 1204637537416, 1204637573256, 1204637609096, 1204637644936,\n", - " 1204637680776, 1204637716616, 1204637752456, 1204637788296,\n", - " 1204637824136, 1204637859976, 1204637895816, 1204637931656,\n", - " 1204637967496, 1204638003336, 1204638039176, 1204638075016,\n", - " 1204638110856, 1204638146696, 1204638182536, 1204638218376,\n", - " 1204638254216, 1204638290056, 1204638325896, 1204638361736,\n", - " 1204638397576, 1204638433416, 1204638469256, 1204638505096,\n", - " 1204638540936, 1204638576776, 1204638612616, 1204638648456,\n", - " 1204638684296, 1204638720136, 1204638755976, 1204638791816,\n", - " 1204638827656, 1204638863496, 1204638899336, 1204638935176,\n", - " 1204638971016, 1204639006856, 1204639042696, 1204639078536,\n", - " 1204639114376, 1204639150216, 1204639186056, 1204639221896,\n", - " 1204639257736, 1204639293576, 1204639329416, 1204639365256,\n", - " 1204639401096, 1204639436936, 1204639472776, 1204639508616,\n", - " 1204639544456, 1204639580296, 1204639616136, 1204639651976,\n", - " 1204639687816, 1204639723656, 1204639759496, 1204639795336,\n", - " 1204639831176, 1204639867016, 1204639902856, 1204639938696,\n", - " 1204639974536, 1204640010376, 1204640046216, 1204640082056,\n", - " 1204640117896, 1204640153736, 1204640189576, 1204640225416,\n", - " 1204640261256, 1204640297096, 1204640332936, 1204640368776,\n", - " 1204640404616, 1204640440456, 1204640476296, 1204640512136,\n", - " 1204640547976, 1204640583816, 1204640619656, 1204640655496,\n", - " 1204640691336, 1204640727176, 1204640763016, 1204640798856,\n", - " 1204640834696, 1204640870536, 1204640906376, 1204640942216,\n", - " 1204640978056, 1204641013896, 1204641049736, 1204641085576,\n", - " 1204641121416, 1204641157256, 1204641193096, 1204641228936,\n", - " 1204641264776, 1204641300616, 1204641336456, 1204641372296,\n", - " 1204641408136, 1204641443976, 1204641479816, 1204641515656,\n", - " 1204641551496, 1204641587336, 1204641623176, 1204641659016,\n", - " 1204641694856, 1204641730696, 1204641766536, 1204641802376,\n", - " 1204641838216, 1204641874056, 1204641909896, 1204641945736,\n", - " 1204641981576, 1204642017416, 1204642053256, 1204642089096,\n", - " 1204642124936, 1204642160776, 1204642196616, 1204642232456,\n", - " 1204642268296, 1204642304136, 1204642339976, 1204642375816,\n", - " 1204642411656, 1204642447496, 1204642483336, 1204642519176,\n", - " 1204642555016, 1204642590856, 1204642626696, 1204642662536,\n", - " 1204642698376, 1204642734216, 1204642770056, 1204642805896,\n", - " 1204642841736, 1204642877576, 1204642913416, 1204642949256,\n", - " 1204642985096, 1204643020936, 1204643056776, 1204643092616,\n", - " 1204643128456, 1204643164296, 1204643200136, 1204643235976,\n", - " 1204643271816, 1204643307656, 1204643343496, 1204643379336,\n", - " 1204643415176, 1204643451016, 1204643486856, 1204643522696,\n", - " 1204643558536, 1204643594376, 1204643630216, 1204643666056,\n", - " 1204643701896, 1204643737736, 1204643773576, 1204643809416,\n", - " 1204643845256, 1204643881096, 1204643916936, 1204643952776,\n", - " 1204643988616, 1204644024456, 1204644060296, 1204644096136,\n", - " 1204644131976, 1204644167816, 1204644203656, 1204644239496,\n", - " 1204644275336, 1204644311176, 1204644347016, 1204644382856,\n", - " 1204644418696, 1204644454536, 1204644490376, 1204644526216,\n", - " 1204644562056, 1204644597896, 1204644633736, 1204644669576,\n", - " 1204644705416, 1204644741256, 1204644777096, 1204644812936,\n", - " 1204644848776, 1204644884616, 1204644920456, 1204644956296,\n", - " 1204644992136, 1204645027976, 1204645063816, 1204645099656,\n", - " 1204645135496, 1204645171336, 1204645207176, 1204645243016,\n", - " 1204645278856, 1204645314696, 1204645350536, 1204645386376,\n", - " 1204645422216, 1204645458056, 1204645493896, 1204645529736,\n", - " 1204645565576, 1204645601416, 1204645637256, 1204645673096,\n", - " 1204645708936, 1204645744776, 1204645780616, 1204645816456,\n", - " 1204645852296, 1204645888136, 1204645923976, 1204645959816,\n", - " 1204645995656, 1204646031496, 1204646067336, 1204646103176,\n", - " 1204646139016, 1204646174856, 1204646210696, 1204646246536,\n", - " 1204646282376, 1204646318216, 1204646354056, 1204646389896,\n", - " 1204646425736, 1204646461576, 1204646497416, 1204646533256,\n", - " 1204646569096, 1204646604936, 1204646640776, 1204646676616,\n", - " 1204646712456, 1204646748296, 1204646784136, 1204646819976,\n", - " 1204646855816, 1204646891656, 1204646927496, 1204646963336,\n", - " 1204646999176, 1204647035016, 1204647070856, 1204647106696,\n", - " 1204647142536, 1204647178376, 1204647214216, 1204647250056,\n", - " 1204647285896, 1204647321736, 1204647357576, 1204647393416,\n", - " 1204647429256, 1204647465096, 1204647500936, 1204647536776,\n", - " 1204647572616, 1204647608456, 1204647644296, 1204647680136,\n", - " 1204647715976, 1204647751816, 1204647787656, 1204647823496,\n", - " 1204647859336, 1204647895176, 1204647931016, 1204647966856,\n", - " 1204648002696, 1204648038536, 1204648074376, 1204648110216,\n", - " 1204648146056, 1204648181896, 1204648217736, 1204648253576,\n", - " 1204648289416, 1204648325256, 1204648361096, 1204648396936,\n", - " 1204648432776, 1204648468616, 1204648504456, 1204648540296,\n", - " 1204648576136, 1204648611976, 1204648647816, 1204648683656,\n", - " 1204648719496, 1204648755336, 1204648791176, 1204648827016,\n", - " 1204648862856, 1204648898696, 1204648934536, 1204648970376,\n", - " 1204649006216, 1204649042056, 1204649077896, 1204649113736,\n", - " 1204649149576, 1204649185416, 1204649221256, 1204649257096,\n", - " 1204649292936, 1204649328776, 1204649364616, 1204649400456,\n", - " 1204649436296, 1204649472136, 1204649507976, 1204649543816,\n", - " 1204649579656, 1204649615496, 1204649651336, 1204649687176,\n", - " 1204649723016, 1204649758856, 1204649794696, 1204649830536,\n", - " 1204649866376, 1204649902216, 1204649938056, 1204649973896,\n", - " 1204650009736, 1204650045576, 1204650081416, 1204650117256,\n", - " 1204650153096, 1204650188936, 1204650224776, 1204650260616,\n", - " 1204650296456, 1204650332296, 1204650368136, 1204650403976,\n", - " 1204650439816, 1204650475656, 1204650511496, 1204650547336,\n", - " 1204650583176, 1204650619016, 1204650654856, 1204650690696,\n", - " 1204650726536, 1204650762376, 1204650798216, 1204650834056,\n", - " 1204650869896, 1204650905736, 1204650941576, 1204650977416,\n", - " 1204651013256, 1204651049096, 1204651084936, 1204651120776,\n", - " 1204651156616, 1204651192456, 1204651228296, 1204651264136,\n", - " 1204651299976, 1204651335816, 1204651371656, 1204651407496,\n", - " 1204651443336, 1204651479176, 1204651515016, 1204651550856,\n", - " 1204651586696, 1204651622536, 1204651658376, 1204651694216,\n", - " 1204651730056, 1204651765896, 1204651801736, 1204651837576,\n", - " 1204651873416, 1204651909256, 1204651945096, 1204651980936,\n", - " 1204652016776, 1204652052616, 1204652088456, 1204652124296,\n", - " 1204652160136, 1204652195976, 1204652231816, 1204652267656,\n", - " 1204652303496, 1204652339336, 1204652375176, 1204652411016,\n", - " 1204652446856, 1204652482696, 1204652518536, 1204652554376,\n", - " 1204652590216, 1204652626056, 1204652661896, 1204652697736,\n", - " 1204652733576, 1204652769416, 1204652805256, 1204652841096,\n", - " 1204652876936, 1204652912776, 1204652948616, 1204652984456,\n", - " 1204653020296, 1204653056136, 1204653091976, 1204653127816,\n", - " 1204653163656, 1204653199496, 1204653235336, 1204653271176,\n", - " 1204653307016, 1204653342856, 1204653378696, 1204653414536,\n", - " 1204653450376, 1204653486216, 1204653522056, 1204653557896,\n", - " 1204653593736, 1204653629576, 1204653665416, 1204653701256,\n", - " 1204653737096, 1204653772936, 1204653808776, 1204653844616,\n", - " 1204653880456, 1204653916296, 1204653952136, 1204653987976,\n", - " 1204654023816, 1204654059656, 1204654095496, 1204654131336,\n", - " 1204654167176, 1204654203016, 1204654238856, 1204654274696,\n", - " 1204654310536, 1204654346376, 1204654382216, 1204654418056,\n", - " 1204654453896, 1204654489736, 1204654525576, 1204654561416,\n", - " 1204654597256, 1204654633096, 1204654668936, 1204654704776,\n", - " 1204654740616, 1204654776456, 1204654812296, 1204654848136,\n", - " 1204654883976, 1204654919816, 1204654955656, 1204654991496,\n", - " 1204655027336, 1204655063176, 1204655099016, 1204655134856,\n", - " 1204655170696, 1204655206536, 1204655242376, 1204655278216,\n", - " 1204655314056, 1204655349896, 1204655385736, 1204655421576,\n", - " 1204655457416, 1204655493256, 1204655529096, 1204655564936,\n", - " 1204655600776, 1204655636616, 1204655672456, 1204655708296,\n", - " 1204655744136, 1204655779976, 1204655815816, 1204655851656,\n", - " 1204655887496, 1204655923336, 1204655959176, 1204655995016,\n", - " 1204656030856, 1204656066696, 1204656102536, 1204656138376,\n", - " 1204656174216, 1204656210056, 1204656245896, 1204656281736,\n", - " 1204656317576, 1204656353416, 1204656389256, 1204656425096,\n", - " 1204656460936, 1204656496776, 1204656532616, 1204656568456,\n", - " 1204656604296, 1204656640136, 1204656675976, 1204656711816,\n", - " 1204656747656, 1204656783496, 1204656819336, 1204656855176,\n", - " 1204656891016, 1204656926856, 1204656962696, 1204656998536,\n", - " 1204657034376, 1204657070216, 1204657106056, 1204657141896,\n", - " 1204657177736, 1204657213576, 1204657249416, 1204657285256,\n", - " 1204657321096, 1204657356936, 1204657392776, 1204657428616,\n", - " 1204657464456, 1204657500296, 1204657536136, 1204657571976,\n", - " 1204657607816, 1204657643656, 1204657679496, 1204657715336,\n", - " 1204657751176, 1204657787016, 1204657822856, 1204657858696,\n", - " 1204657894536, 1204657930376, 1204657966216, 1204658002056,\n", - " 1204658037896, 1204658073736, 1204658109576, 1204658145416,\n", - " 1204658181256, 1204658217096, 1204658252936, 1204658288776,\n", - " 1204658324616, 1204658360456, 1204658396296, 1204658432136,\n", - " 1204658467976, 1204658503816, 1204658539656, 1204658575496,\n", - " 1204658611336, 1204658647176, 1204658683016, 1204658718856,\n", - " 1204658754696, 1204658790536, 1204658826376, 1204658862216,\n", - " 1204658898056, 1204658933896, 1204658969736, 1204659005576,\n", - " 1204659041416, 1204659077256, 1204659113096, 1204659148936,\n", - " 1204659184776, 1204659220616, 1204659256456, 1204659292296,\n", - " 1204659328136, 1204659363976, 1204659399816, 1204659435656,\n", - " 1204659471496, 1204659507336, 1204659543176, 1204659579016,\n", - " 1204659614856, 1204659650696, 1204659686536, 1204659722376,\n", - " 1204659758216, 1204659794056, 1204659829896, 1204659865736,\n", - " 1204659901576, 1204659937416, 1204659973256, 1204660009096,\n", - " 1204660044936, 1204660080776, 1204660116616, 1204660152456,\n", - " 1204660188296, 1204660224136, 1204660259976, 1204660295816,\n", - " 1204660331656, 1204660367496, 1204660403336, 1204660439176,\n", - " 1204660475016, 1204660510856, 1204660546696, 1204660582536,\n", - " 1204660618376, 1204660654216, 1204660690056, 1204660725896,\n", - " 1204660761736, 1204660797576, 1204660833416, 1204660869256,\n", - " 1204660905096, 1204660940936, 1204660976776, 1204661012616,\n", - " 1204661048456, 1204661084296, 1204661120136, 1204661155976,\n", - " 1204661191816, 1204661227656, 1204661263496, 1204661299336,\n", - " 1204661335176, 1204661371016, 1204661406856, 1204661442696,\n", - " 1204661478536, 1204661514376, 1204661550216, 1204661586056,\n", - " 1204661621896, 1204661657736, 1204661693576, 1204661729416,\n", - " 1204661765256, 1204661801096, 1204661836936, 1204661872776,\n", - " 1204661908616, 1204661944456, 1204661980296, 1204662016136,\n", - " 1204662051976, 1204662087816, 1204662123656, 1204662159496,\n", - " 1204662195336, 1204662231176, 1204662267016, 1204662302856,\n", - " 1204662338696, 1204662374536, 1204662410376, 1204662446216,\n", - " 1204662482056, 1204662517896, 1204662553736, 1204662589576,\n", - " 1204662625416, 1204662661256, 1204662697096, 1204662732936,\n", - " 1204662768776, 1204662804616, 1204662840456, 1204662876296,\n", - " 1204662912136, 1204662947976, 1204662983816, 1204663019656,\n", - " 1204663055496, 1204663091336, 1204663127176, 1204663163016,\n", - " 1204663198856, 1204663234696, 1204663270536, 1204663306376,\n", - " 1204663342216, 1204663378056, 1204663413896, 1204663449736,\n", - " 1204663485576, 1204663521416, 1204663557256, 1204663593096,\n", - " 1204663628936, 1204663664776, 1204663700616, 1204663736456,\n", - " 1204663772296, 1204663808136, 1204663843976, 1204663879816,\n", - " 1204663915656, 1204663951496, 1204663987336, 1204664023176,\n", - " 1204664059016, 1204664094856, 1204664130696, 1204664166536,\n", - " 1204664202376, 1204664238216, 1204664274056, 1204664309896,\n", - " 1204664345736, 1204664381576, 1204664417416, 1204664453256,\n", - " 1204664489096, 1204664524936, 1204664560776, 1204664596616,\n", - " 1204664632456, 1204664668296, 1204664704136, 1204664739976,\n", - " 1204664775816, 1204664811656, 1204664847496, 1204664883336,\n", - " 1204664919176, 1204664955016, 1204664990856, 1204665026696,\n", - " 1204665062536, 1204665098376, 1204665134216, 1204665170056,\n", - " 1204665205896, 1204665241736, 1204665277576, 1204665313416,\n", - " 1204665349256, 1204665385096, 1204665420936, 1204665456776,\n", - " 1204665492616, 1204665528456, 1204665564296, 1204665600136,\n", - " 1204665635976, 1204665671816, 1204665707656, 1204665743496,\n", - " 1204665779336, 1204665815176, 1204665851016, 1204665886856,\n", - " 1204665922696, 1204665958536, 1204665994376, 1204666030216,\n", - " 1204666066056, 1204666101896, 1204666137736, 1204666173576,\n", - " 1204666209416, 1204666245256, 1204666281096, 1204666316936,\n", - " 1204666352776, 1204666388616, 1204666424456, 1204666460296,\n", - " 1204666496136, 1204666531976, 1204666567816, 1204666603656,\n", - " 1204666639496, 1204666675336, 1204666711176, 1204666747016]],\n", - " dtype=uint64), 'value': array([[ 3.92985139e-07, 3.83420582e-07, 2.70894730e-07,\n", - " 1.59362046e-07, 5.19425521e-09, -1.48426426e-07,\n", - " -1.43519777e-07, 8.15211657e-08, 2.37241792e-07,\n", - " 1.43174769e-07, 1.06832322e-07, 3.03419964e-07,\n", - " 3.53603991e-07, 2.79436221e-07, 2.91986862e-07,\n", - " 3.61741877e-07, 3.62849251e-07, 4.00763667e-07,\n", - " 4.44543818e-07, 2.68402540e-07, 4.07432428e-09,\n", - " -3.04182928e-07, -5.46997467e-07, -7.22909138e-07,\n", - " -8.42683151e-07, -9.57424350e-07, -8.91693433e-07,\n", - " -5.90276549e-07, -3.09874066e-07, 3.15099414e-08,\n", - " 1.17763757e-07, -2.48585203e-08, -5.14343080e-08,\n", - " -7.95461888e-08, 1.09972075e-08, 2.60788444e-07,\n", - " 5.95013983e-07, 7.90452394e-07, 7.46151442e-07,\n", - " 6.50482553e-07, 5.95991605e-07, 5.00587601e-07,\n", - " 3.03236996e-07, 9.30959778e-08, 2.06233517e-08,\n", - " 3.14812406e-09, 4.27014776e-08, 1.62276378e-07,\n", - " 3.45086417e-07, 2.49326044e-07, 8.88291187e-08,\n", - " 7.91114905e-08, 1.02013570e-07, -1.65233163e-08,\n", - " -1.17815179e-07, -2.93111576e-07, -3.76068382e-07,\n", - " -2.22642030e-07, -8.62448467e-08, 2.06532484e-08,\n", - " 7.47423847e-08, 2.17917751e-07, 2.91384742e-07,\n", - " 2.34781890e-07, 8.57551385e-08, -3.07021322e-08,\n", - " -6.35412815e-08, -4.95621757e-08, -8.56349537e-08,\n", - " -1.45087561e-07, -1.32979989e-07, -2.56436081e-08,\n", - " 3.83718354e-08, -2.08320308e-09, -1.47861378e-07,\n", - " -2.48321514e-07, -2.27038641e-07, -2.11037919e-07,\n", - " -3.84853233e-07, -5.05484683e-07, -5.41471956e-07,\n", - " -5.06235688e-07, -4.06738226e-07, -1.02136146e-07,\n", - " 1.07573163e-07, 9.34738723e-08, -4.02792458e-08,\n", - " -3.98182384e-08, -7.42580579e-08, -8.18560090e-08,\n", - " -5.80349046e-08, 4.76930331e-08, 2.96791264e-07,\n", - " 5.32980691e-07, 5.86162761e-07, 5.87198982e-07,\n", - " 6.17966886e-07, 6.79197152e-07, 5.80585828e-07,\n", - " 2.82879127e-07, 2.60759146e-08, -2.61981323e-07,\n", - " -3.43245975e-07, -3.49784985e-07, -2.03524277e-07,\n", - " -4.41544579e-08, 4.10816736e-08, 1.58254074e-07,\n", - " 1.88760681e-07, 1.04991881e-07, -5.24316624e-08,\n", - " -7.14860345e-08, -7.36427835e-08, -6.57321128e-08,\n", - " 4.97774320e-08, 1.71477989e-07, 4.10129111e-07,\n", - " 6.08990697e-07, 7.57704131e-07, 8.73352994e-07,\n", - " 9.14463967e-07, 8.71196843e-07, 7.13427694e-07,\n", - " 4.95935074e-07, 2.12877165e-07, 8.20102760e-08,\n", - " 8.16299898e-08, -8.94497745e-08, -2.09379848e-07,\n", - " -3.49057897e-07, -3.64097140e-07, -2.65484620e-07,\n", - " -1.38712385e-07, -6.69226000e-08, -6.93950583e-08,\n", - " -2.61780417e-07, -5.49814934e-07, -7.53205273e-07,\n", - " -7.45047656e-07, -7.28842440e-07, -6.66364884e-07,\n", - " -6.38251807e-07, -6.08288124e-07, -5.06938859e-07,\n", - " -3.70191884e-07, -4.39671251e-07, -5.18713381e-07,\n", - " -5.92985192e-07, -5.58427579e-07, -4.05719346e-07,\n", - " -2.36963154e-07, -1.26458320e-07, 8.08335413e-08,\n", - " 1.01863488e-07, -2.76203788e-08, -3.17000845e-08,\n", - " 9.74459498e-08, 1.39901676e-07, 7.68734225e-08,\n", - " -1.09082349e-07, -2.89064159e-07, -4.68825929e-07,\n", - " -5.44368350e-07, -4.44860723e-07, -2.66156100e-07,\n", - " -1.47009919e-07, -7.06746377e-08, -8.82742357e-08,\n", - " -1.26150981e-07, -2.56645358e-08, 1.22603437e-07,\n", - " 2.88491936e-07, 4.83080683e-07, 4.14143642e-07,\n", - " 2.74622850e-07, 2.43333546e-07, 2.92212881e-07,\n", - " 1.99867311e-07, -2.50217564e-08, -1.10268651e-07,\n", - " -3.72949557e-08, 6.92772652e-08, 1.26283125e-07,\n", - " 2.10329367e-07, 2.62502722e-07, 3.08120923e-07,\n", - " 3.12027826e-07, 1.65437058e-07, -6.38055685e-09,\n", - " -1.33220957e-07, -8.91950545e-08, 6.40501236e-08,\n", - " 1.19388943e-07, 1.93055643e-07, 3.50974276e-07,\n", - " 3.97211937e-07, 3.25983014e-07, 2.73461064e-07,\n", - " 1.98727648e-07, 1.55330175e-07, 1.90476753e-07,\n", - " 2.61940664e-07, 2.00896954e-07, 4.53180381e-08,\n", - " -1.97603532e-07, -2.75219588e-07, -2.36965546e-07,\n", - " -1.80616218e-07, -1.54334614e-07, -7.63107663e-08,\n", - " 1.61057788e-07, 2.74578005e-07, 1.63907542e-07,\n", - " -6.21654347e-08, -2.49956267e-07, -2.91821234e-07,\n", - " -3.75682715e-07, -4.41552352e-07, -4.87636344e-07,\n", - " -3.21807041e-07, -1.66438000e-07, -1.28596533e-07,\n", - " -1.44966778e-07, -1.12107299e-07, -2.19878378e-08,\n", - " 1.79218846e-08, -1.00522322e-07, -2.46749545e-07,\n", - " -2.60108593e-07, -2.75065919e-07, -2.58524067e-07,\n", - " -3.81742181e-07, -3.48997505e-07, -2.08807026e-07,\n", - " -1.16515868e-07, -1.05323136e-07, -2.41726897e-08,\n", - " 4.29286926e-08, 5.61681538e-08, 3.76722522e-08,\n", - " 1.38363789e-07, 2.03251619e-07, 2.58051101e-07,\n", - " 1.92023609e-07, 1.52896582e-07, 1.02029714e-07,\n", - " 4.03647504e-08, 5.41549090e-08, -5.61274942e-08,\n", - " -1.70893209e-07, -1.95489236e-07, -1.79434102e-07,\n", - " -1.90418753e-07, -3.48402561e-07, -3.33618635e-07,\n", - " -3.26589917e-07, -4.11926502e-07, -5.46374420e-07,\n", - " -6.52977135e-07, -6.32305351e-07, -4.91076260e-07,\n", - " -4.62341930e-07, -5.53354107e-07, -6.67683329e-07,\n", - " -6.31887993e-07, -4.50556645e-07, -2.71762332e-07,\n", - " -1.42126590e-07, 1.25963230e-07, 3.40132531e-07,\n", - " 4.29167339e-07, 4.55697086e-07, 4.59132817e-07,\n", - " 5.23494464e-07, 6.45093969e-07, 6.82350657e-07,\n", - " 5.68289907e-07, 4.45257751e-07, 2.59265506e-07,\n", - " 2.07892785e-07, 7.75227791e-08, 2.10114111e-09,\n", - " -2.04415797e-08, -1.55623761e-07, -1.85535424e-07,\n", - " -1.49825592e-07, -8.89923548e-08, 4.57419735e-09,\n", - " 5.10922895e-08, 1.40718455e-07, 1.43216026e-07,\n", - " 5.61567930e-08, 1.79643379e-08, 3.86223698e-08,\n", - " 1.53206312e-07, 1.79312124e-07, 7.49385071e-08,\n", - " -2.79522324e-08, -9.90639600e-08, -2.59066394e-07,\n", - " -3.46135792e-07, -1.63205568e-07, 1.90346403e-08,\n", - " -4.05100484e-09, -9.41662802e-08, -1.47081073e-07,\n", - " -6.07148461e-08, -3.67191450e-09, -6.38641661e-08,\n", - " -1.07170155e-07, -1.40608435e-07, -8.53814296e-08,\n", - " 9.04961595e-08, 2.52720517e-07, 2.35757719e-07,\n", - " 2.67364526e-07, 3.95856420e-07, 4.95924909e-07,\n", - " 4.23995806e-07, 1.04117103e-07, -2.16378668e-07,\n", - " -3.11306119e-07, -2.60955268e-07, -7.30400657e-08,\n", - " 2.12508838e-07, 3.22259079e-07, 4.08452504e-07,\n", - " 4.70284889e-07, 5.51629066e-07, 4.34274894e-07,\n", - " 2.41514032e-07, 6.07967631e-08, -1.20032320e-07,\n", - " -1.90575412e-07, -2.92648177e-07, -3.14663520e-07,\n", - " -3.62121565e-07, -3.63577535e-07, -3.71738142e-07,\n", - " -2.93161205e-07, -2.25049314e-07, -1.51070491e-07,\n", - " 7.38030299e-09, 6.07818148e-08, -4.18972560e-08,\n", - " -1.33020649e-07, -1.94261677e-07, -8.04209666e-08,\n", - " -8.10990241e-08, -1.87267041e-07, -2.94979523e-07,\n", - " -3.96578127e-07, -5.46681160e-07, -5.69697445e-07,\n", - " -5.55555103e-07, -4.79262275e-07, -3.06220090e-07,\n", - " -1.15504163e-07, 2.28751723e-07, 4.22506351e-07,\n", - " 2.75850409e-07, 7.17802182e-08, -1.52670563e-07,\n", - " -2.67373495e-07, -3.23360474e-07, -4.74308389e-07,\n", - " -4.85272710e-07, -2.15499705e-07, 2.99624875e-09,\n", - " 9.53585612e-09, -1.37725196e-07, -1.88432415e-07,\n", - " -2.43055507e-07, -2.71423304e-07, -1.12316576e-07,\n", - " -5.20812729e-08, -2.77504893e-07, -3.56383787e-07,\n", - " -3.37075293e-07, -3.63530896e-07, -2.98915127e-07,\n", - " -2.23851651e-07, -1.60337875e-07, -1.63355649e-07,\n", - " -1.03609456e-07, -1.25081875e-08, 1.97007989e-07,\n", - " 3.81623192e-07, 4.15189429e-07, 2.83439989e-07,\n", - " 3.52171340e-08, -5.29291437e-09, 2.70027127e-08,\n", - " 8.30094242e-08, 2.37340451e-07, 3.69867804e-07,\n", - " 3.11326449e-07, 2.07639261e-07, 1.38845724e-07,\n", - " 3.49929087e-08, 2.85627233e-08, 1.99058306e-07,\n", - " 3.25536357e-07, 4.24391040e-07, 5.15305754e-07,\n", - " 5.54799314e-07, 6.02066618e-07, 5.56236150e-07,\n", - " 5.88164047e-07, 5.98419816e-07, 5.44714554e-07,\n", - " 4.76758126e-07, 5.39173497e-07, 5.82523733e-07,\n", - " 5.20635740e-07, 4.53664707e-07, 3.73594130e-07,\n", - " 9.79225034e-08, -1.64556301e-07, -6.45308628e-08,\n", - " -2.53225173e-09, -7.11942426e-08, -6.92868322e-08,\n", - " -1.83482117e-08, -5.87386733e-08, -3.65385688e-08,\n", - " 1.03064140e-07, 2.30992781e-07, 2.62640247e-07,\n", - " 7.88806879e-08, -1.76595708e-07, -1.84531492e-07,\n", - " 1.14630581e-07, 4.46794442e-07, 6.63414078e-07,\n", - " 7.22672357e-07, 6.75053467e-07, 5.45177355e-07,\n", - " 3.61184602e-07, 1.39103434e-07, -8.15002380e-08,\n", - " -3.84913624e-07, -6.68408026e-07, -6.90710377e-07,\n", - " -6.50547728e-07, -5.83720200e-07, -5.99011771e-07,\n", - " -6.59074271e-07, -6.13119433e-07, -5.01846851e-07,\n", - " -3.28521843e-07, -3.56619972e-08, 4.30500733e-08,\n", - " -4.95508149e-09, 5.33895531e-08, 1.68351988e-07,\n", - " 1.90788874e-07, 3.30179317e-08, -2.65245447e-07,\n", - " -4.54763113e-07, -5.42195457e-07, -5.84733100e-07,\n", - " -6.18889499e-07, -6.64385124e-07, -6.42400873e-07,\n", - " -5.23666071e-07, -4.33743928e-07, -3.57675923e-07,\n", - " -2.17862143e-07, -5.70602717e-08, 2.77303987e-08,\n", - " 1.37077035e-07, 1.36061144e-07, 2.01107427e-07,\n", - " 2.33071798e-07, 2.38902255e-07, 1.93699021e-07,\n", - " 1.33213781e-07, -2.10454933e-08, -4.07932301e-07,\n", - " -6.97150727e-07, -6.85435400e-07, -4.98341760e-07,\n", - " -3.69193334e-07, -2.30489918e-07, -1.65074112e-07,\n", - " -1.73244286e-07, -3.12409308e-07, -4.17552466e-07,\n", - " -2.76978711e-07, -1.01703840e-07, 4.00203402e-08,\n", - " 7.96801261e-08, 5.91327120e-08, -5.31025446e-09,\n", - " -3.70498026e-08, -1.22080245e-08, -1.04164937e-07,\n", - " -1.12687893e-07, 2.26682870e-08, 7.39250085e-08,\n", - " 3.86630294e-08, -1.57473769e-07, -2.77513264e-07,\n", - " -2.34415954e-07, -9.34774599e-08, 1.13495702e-07,\n", - " 2.30309940e-07, 2.77524625e-07, 2.54816277e-07,\n", - " 1.46039472e-07, 1.39078919e-07, 1.50235177e-07,\n", - " 6.14425322e-08, -6.96551597e-08, -4.93481152e-08,\n", - " -3.38221533e-08, -1.24280643e-08, -1.38384119e-07,\n", - " -1.30164914e-07, -9.61938754e-08, -1.49727531e-07,\n", - " -1.22355295e-07, -7.24708323e-08, -1.90739246e-07,\n", - " -3.05289704e-07, -4.30052282e-07, -2.88965500e-07,\n", - " -1.99357871e-07, -2.45945323e-07, -2.01812391e-07,\n", - " -1.75720332e-07, -2.87410273e-07, -3.58312126e-07,\n", - " -3.25443080e-07, -9.20071395e-08, 1.06721107e-07,\n", - " 2.36255798e-07, 3.48033635e-07, 3.71790162e-07,\n", - " 2.44360200e-07, -3.30041792e-08, -1.65477718e-07,\n", - " -2.09568795e-07, -1.90201105e-07, -2.05444244e-07,\n", - " -2.42772684e-07, -2.99709183e-07, -4.29494409e-07,\n", - " -4.59779183e-07, -4.38130374e-07, -3.70995508e-07,\n", - " -2.59954326e-07, -2.12623043e-07, -1.96560136e-07,\n", - " -9.51660263e-08, -8.87185008e-08, -1.39274443e-07,\n", - " -9.18026459e-08, -1.22325398e-07, -7.09897490e-08,\n", - " -1.93013190e-09, 8.98390297e-08, 2.15450674e-07,\n", - " 1.84958417e-07, 1.07249680e-07, 1.05097715e-07,\n", - " 1.84560193e-07, 1.00563579e-07, 6.71581861e-08,\n", - " 1.28528368e-07, 7.91252430e-08, -1.03254284e-07,\n", - " -3.00204273e-07, -4.21055763e-07, -4.41529033e-07,\n", - " -3.30959621e-07, -2.49891092e-07, -4.16851089e-07,\n", - " -5.84338464e-07, -5.04995573e-07, -2.83871100e-07,\n", - " -1.08966350e-07, 7.49971047e-08, 2.59871811e-07,\n", - " 2.35015085e-07, 5.78046999e-08, 1.89616923e-08,\n", - " 5.20639328e-08, 2.52515425e-07, 5.02891442e-07,\n", - " 5.86196246e-07, 4.50872952e-07, 3.32533982e-07,\n", - " 3.62297358e-07, 4.60746043e-07, 4.70768618e-07,\n", - " 4.65780650e-07, 3.85436219e-07, 3.07193527e-07,\n", - " 1.69756536e-07, -1.12962943e-07, -3.10589196e-07,\n", - " -4.24860419e-07, -4.91873905e-07, -4.46859617e-07,\n", - " -2.48426153e-07, -1.17500068e-08, 8.72451907e-08,\n", - " 8.76894559e-08, 1.03219005e-07, 2.25426610e-07,\n", - " 2.74669489e-07, 1.74889802e-07, 9.11700314e-08,\n", - " 1.26579700e-07, 2.19670895e-07, 2.72036784e-07,\n", - " 1.76660285e-07, 4.93636615e-08, 7.17258061e-08,\n", - " 4.75489309e-08, -1.28243154e-07, -3.22162214e-07,\n", - " -3.43309954e-07, -1.01288276e-07, 6.92969970e-08,\n", - " 9.49148939e-08, 2.00153721e-07, 3.68585833e-07,\n", - " 3.84339607e-07, 3.28500915e-07, 2.73623702e-07,\n", - " 1.64186180e-07, 7.31961266e-08, 6.60735333e-08,\n", - " 9.36717885e-08, 1.02275465e-07, -2.02699726e-10,\n", - " -1.48580095e-07, -2.13070896e-07, -4.68278819e-07,\n", - " -5.81437287e-07, -5.20804358e-07, -5.67430676e-07,\n", - " -6.15038802e-07, -5.96161419e-07, -3.53384549e-07,\n", - " -2.65704062e-07, -1.59498375e-07, -3.02076405e-09,\n", - " 1.15199217e-07, 2.82614242e-07, 1.88842598e-07,\n", - " 6.59521526e-09, -4.59996832e-08, -4.59883224e-08,\n", - " 4.34303595e-08, 1.69507795e-07, 3.57003247e-07,\n", - " 5.25516080e-07, 6.08550019e-07, 4.93009382e-07,\n", - " 4.03527319e-07, 3.93266169e-07, 3.88992134e-07,\n", - " 3.42486599e-07, 2.64011310e-07, 3.28545761e-07,\n", - " 4.39363913e-07, 4.25984535e-07, 3.74664433e-07,\n", - " 2.42144853e-07, 7.68674431e-08, 3.01484450e-08,\n", - " -9.57824966e-08, -1.44516533e-07, 3.92926542e-08,\n", - " 3.85308859e-07, 5.05405158e-07, 2.73567496e-07,\n", - " -1.47725647e-07, -3.63148218e-07, -2.02561005e-07,\n", - " -8.18243184e-08, -1.13539351e-07, -2.34597128e-07,\n", - " -2.11553339e-07, -5.91261347e-08, 5.44197939e-08,\n", - " -6.64006033e-08, -2.31789229e-07, -3.09711428e-07,\n", - " -2.70477970e-07, -2.18363810e-07, -2.43894409e-07,\n", - " -2.57952442e-07, -1.65912416e-07, 8.97977722e-08,\n", - " 2.25512115e-07, 2.48212092e-07, 1.24256726e-07,\n", - " 4.20180387e-08, 5.78292152e-08, 5.49848418e-08,\n", - " -1.33292709e-07, -2.81195344e-07, -2.61471883e-07,\n", - " -9.86579626e-08, 1.99112120e-09, -6.98746016e-09,\n", - " 2.15441705e-08, 3.71580288e-08, -1.20388091e-07,\n", - " -4.02575408e-07, -5.37950123e-07, -5.66455445e-07,\n", - " -4.17524363e-07, -8.54322540e-08, 8.19755958e-08,\n", - " 1.78326728e-07, 2.05387440e-07, 1.44143422e-07,\n", - " 1.79644575e-07, 1.47876326e-07, 4.88093764e-08,\n", - " -8.83184828e-08, 2.13462543e-10, 2.12627229e-07,\n", - " 2.80647038e-07, 1.25450800e-07, -5.96834095e-08,\n", - " -3.59005729e-07, -6.50030515e-07, -6.45321185e-07,\n", - " -3.91315707e-07, -9.13422365e-08, 4.67758019e-08,\n", - " -1.67632673e-07, -3.60025805e-07, -3.91212264e-07,\n", - " -3.39129198e-07, -2.34033276e-07, -1.98976389e-07,\n", - " 9.53663343e-08, 3.86565119e-07, 6.78102334e-07,\n", - " 7.94773067e-07, 6.75312971e-07, 5.18205137e-07,\n", - " 3.61853690e-07, 3.49845376e-07, 4.18397945e-07,\n", - " 4.49034902e-07, 5.09952448e-07, 3.28503307e-07,\n", - " 7.95724979e-08, -5.88815796e-08, -2.76963165e-09,\n", - " 2.11172455e-08, -8.00992780e-09, -1.54857807e-07,\n", - " -2.87621344e-07, -3.06567490e-07, -3.45380601e-07,\n", - " -3.47566648e-07, -4.19708617e-07, -4.64905274e-07,\n", - " -5.27758333e-07, -5.50948617e-07, -6.16901368e-07,\n", - " -6.01836413e-07, -3.79309784e-07, -1.16091335e-07,\n", - " 8.04855436e-08, 2.60922382e-07, 3.05965968e-07,\n", - " 1.51118326e-07, 1.70321584e-07, 1.11500993e-07,\n", - " 4.55560159e-08, 2.46934905e-08, 1.16256365e-08,\n", - " 7.68345568e-09, 4.35810389e-08, 6.55874127e-08,\n", - " 6.65997154e-08, 7.96059822e-08, 1.25218802e-07,\n", - " 1.69880308e-07, 2.97179323e-07, 3.40381870e-07,\n", - " 3.24701043e-07, 2.83566153e-07, 1.47797399e-07,\n", - " 1.72691197e-07, 2.29566707e-07, 1.78815838e-07,\n", - " 2.06524113e-07, 2.74380089e-07, 1.67206346e-07,\n", - " 2.06466712e-08, -1.03414530e-07, -7.01406823e-08,\n", - " 3.54150503e-08, 5.66315528e-08, 1.05236436e-10,\n", - " -4.27116425e-08, -3.81930530e-08, 1.01061658e-07,\n", - " 2.33339673e-07, 3.38343512e-07, 3.08279376e-07,\n", - " 2.23005574e-07, 1.46063987e-07, 7.48111471e-08,\n", - " 1.67899950e-08, 1.64683063e-08, 6.33337983e-08,\n", - " 2.63583787e-07, 3.62437274e-07, 3.46500532e-07,\n", - " 4.43665452e-07, 5.54326946e-07, 6.36912435e-07,\n", - " 5.88680663e-07, 4.56565287e-07, 3.25703779e-07,\n", - " 1.71597575e-07, -2.70140735e-08, -1.29319435e-07,\n", - " -1.24364354e-07, -1.00961206e-07, -1.60780944e-07,\n", - " -1.77396342e-07, -1.33214379e-07, -3.57684295e-09,\n", - " 6.09462467e-08, 6.19531681e-08, -1.58237332e-08,\n", - " -1.52174278e-09, 8.21759038e-08, 1.54579767e-07,\n", - " 1.52723779e-07, 9.63068850e-08, -2.47652426e-08,\n", - " -2.51300423e-07, -4.81848938e-07, -5.06587274e-07,\n", - " -4.40668008e-07, -3.73317885e-07, -2.15470406e-07,\n", - " 4.91711267e-08, 1.11269593e-07, -4.26937044e-08,\n", - " -1.86128575e-07, -2.14070642e-07, -1.47656884e-07,\n", - " -8.93218165e-08, -9.35886757e-09, 1.35206696e-07,\n", - " 2.87461097e-07, 3.51993156e-07, 2.32537245e-07,\n", - " 1.60774965e-07, 2.04713568e-07, 3.08541869e-07,\n", - " 2.90892642e-07, 2.93433863e-07, 2.42301512e-07,\n", - " 1.02518824e-07, 6.95122534e-08, 1.91951857e-07,\n", - " 1.29419888e-07, -7.00438170e-08, -1.35923620e-07,\n", - " -1.42971471e-07, -1.42289228e-07, -4.13615068e-08,\n", - " 5.64115130e-08, 1.29904813e-07, 2.10795756e-07,\n", - " 1.88795362e-07, 1.14082276e-07, 2.61978931e-08,\n", - " -2.28488632e-08, -1.12846345e-07, -2.38474732e-07,\n", - " -2.81456641e-07, -2.74899096e-07, -9.95267611e-08,\n", - " 1.31155691e-07, 3.42233074e-07, 5.11480170e-07,\n", - " 6.33651899e-07, 6.29492668e-07, 5.71221579e-07,\n", - " 4.80191464e-07, 2.60756754e-07, -8.36031730e-09,\n", - " -1.07722049e-07, -1.67486179e-07, -2.31938713e-07,\n", - " -3.18197312e-07, -3.20214144e-07, -2.18911518e-07,\n", - " -1.07631163e-07, 4.35535340e-09, 9.73634349e-08,\n", - " 9.48682551e-09, -2.62690473e-08, -7.19613923e-08,\n", - " -2.08782511e-07, -2.02599871e-07, -2.28978340e-07,\n", - " -3.80279634e-07, -3.92481081e-07, -2.32316607e-07,\n", - " -2.01331054e-07, -3.21509270e-07, -4.52587230e-07,\n", - " -3.64860104e-07, -1.95073672e-07, -4.32581544e-08,\n", - " 3.76268092e-08, -7.76459536e-08, -1.42308362e-07,\n", - " -4.10481893e-09, 2.16926974e-07, 1.53687649e-07,\n", - " 1.06774921e-07, 6.36459200e-08, 5.98998617e-08,\n", - " -1.60623089e-08, 8.54603569e-08, 1.16995412e-07,\n", - " 1.21679031e-07, 1.92005671e-07, 2.41701784e-07,\n", - " 6.02873231e-08, -2.91312990e-07, -4.71218862e-07,\n", - " -3.52183897e-07, -2.15410015e-07, -1.35076347e-07,\n", - " -8.62358777e-08, -5.95530598e-08, -3.03487530e-08,\n", - " 8.98456070e-09, -3.20104124e-08, -9.66178108e-08,\n", - " -3.88782259e-07, -6.41902196e-07, -6.68480376e-07,\n", - " -5.54219916e-07, -4.27331681e-07, -2.97937504e-07,\n", - " -2.48852480e-07, -1.43612457e-07, 8.00119796e-08,\n", - " 2.20572580e-07, 1.43064749e-07, 3.75084183e-08,\n", - " -1.07341164e-07, -1.40729815e-07, -1.94001575e-07,\n", - " -1.92580884e-07, -9.88289718e-08, -1.16050675e-07,\n", - " -1.86615891e-07, -1.86427542e-07, -4.54729030e-08,\n", - " 7.93171799e-08, 2.37748242e-07, 3.21543352e-07,\n", - " 4.72589328e-07, 7.19963714e-07, 8.07619686e-07,\n", - " 7.82908257e-07, 5.77874794e-07, 1.71552132e-07,\n", - " -2.18546778e-07, -4.07964589e-07, -3.67413283e-07,\n", - " -3.21461435e-07, -2.51965924e-07, -2.42406748e-07,\n", - " -3.32600951e-07, -4.32792615e-07, -4.44281922e-07,\n", - " -3.81532306e-07, -2.55676704e-07, -2.79632344e-07,\n", - " -3.65262514e-07, -2.75049775e-07, -1.84903407e-07,\n", - " -1.84206814e-07, -1.25358121e-07, -7.17850016e-08,\n", - " -6.69752182e-08]])}]}}}, 'triggered': array([0], dtype=int64)}\n", - "Progress [1.] %\n" - ] - } - ], - "source": [ - "my_lockin.daq.set('device', 'dev3442')\n", - "# my_lockin.daq.set('save/directory', 'C:\\\\Users\\\\Surrey\\\\Documents\\\\Zurich Instruments\\\\LabOne\\\\WebServer')\n", - "my_lockin.daq.set('type', 1)\n", - "my_lockin.daq.set('triggernode', '/dev3442/demods/0/sample.AuxIn0')\n", - "my_lockin.daq.set('endless', 0)\n", - "my_lockin.daq.set('grid/cols', 1000)\n", - "# my_lockin.daq.subscribe('/dev3442/demods/0/sample.R.avg')\n", - "my_lockin.daq.subscribe('/dev3442/demods/0/sample.R')\n", - "my_lockin.daq.subscribe('/dev3442/demods/0/sample.X')\n", - "my_lockin.daq.execute()\n", - "my_lockin.daq.set('forcetrigger', 1)\n", - "result = 0\n", - "while not my_lockin.daq.finished():\n", - " time.sleep(1)\n", - " result = my_lockin.daq.read()\n", - " print(result)\n", - " print(f\"Progress {my_lockin.daq.progress()} %\\r\")" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "94f249a8", - "metadata": {}, - "outputs": [ - { - "ename": "RuntimeError", - "evalue": "Timeout during set in dataAcquisitionModule module.", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mRuntimeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_12728\\3516131054.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;32mwhile\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mmy_lockin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfinished\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mtime\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msleep\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmy_lockin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdaq\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Progress {my_lockin.daq.progress()} %\\r\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mRuntimeError\u001b[0m: Timeout during set in dataAcquisitionModule module." - ] - } - ], - "source": [ - "while not my_lockin.daq.finished():\n", - " time.sleep(1)\n", - " result = my_lockin.daq.read()\n", - " print(result)\n", - " print(f\"Progress {my_lockin.daq.progress()} %\\r\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "79514940", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "4b9be78c", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.finish()\n", - "my_lockin.daq.unsubscribe('*')" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "60433d76", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.daq.clear()" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "id": "3a268246", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mz:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py\u001b[0m(270)\u001b[0;36marm_program\u001b[1;34m()\u001b[0m\n", - "\u001b[1;32m 268 \u001b[1;33m \u001b[0mdemod\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_get_demod\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mc\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 269 \u001b[1;33m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m--> 270 \u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mapi_session\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'/{self.serial}/{demod}/enable'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 271 \u001b[1;33m \u001b[1;32mexcept\u001b[0m \u001b[0mRuntimeError\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\u001b[1;32m 272 \u001b[1;33m \u001b[1;32mraise\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[0m\n", - "ipdb> self.api_session.setInt('/dev3442/demods/0/enable', 0)\n", - "ipdb> r\n" - ] - } - ], - "source": [ - "%debug" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7a251206", + "id": "94e01138", "metadata": {}, "outputs": [], "source": [] @@ -6211,7 +1551,7 @@ { "cell_type": "code", "execution_count": null, - "id": "aee44ece", + "id": "eb3982ba", "metadata": {}, "outputs": [], "source": [] @@ -6219,7 +1559,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ab4f5c02", + "id": "0c875430", "metadata": {}, "outputs": [], "source": [] @@ -6227,7 +1567,7 @@ { "cell_type": "code", "execution_count": null, - "id": "c3e129c7", + "id": "4ae8bf57", "metadata": {}, "outputs": [], "source": [] @@ -6235,7 +1575,7 @@ { "cell_type": "code", "execution_count": null, - "id": "cc7cf2f4", + "id": "bef6b06c", "metadata": {}, "outputs": [], "source": [] diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index 191f2fb67..a2fd164c5 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -3,13 +3,14 @@ May lines of code have been adapted from the zihdawg driver. """ -from typing import Dict, Tuple, Iterable, Union, List, Set +from typing import Dict, Tuple, Iterable, Union, List, Set, Any from enum import Enum import warnings import time import traceback import xarray as xr import numpy as np +import numpy.typing as npt from qupulse.utils.types import TimeType from qupulse.hardware.dacs.dac_base import DAC @@ -134,14 +135,11 @@ def __init__(self, device_serial: str = None, self.daq = None self._init_daq_module() - # self.daq.set('type', 1) - # self.daq.set('triggernode', '/dev3442/demods/0/sample.AuxIn0') - # self.daq.set('endless', 0) - - self.assumed_minimal_sample_rate = None + self.force_update_on_arm:bool = True + self.assumed_minimal_sample_rate:Union[float, None] = None # in units of Sa/s self.daq_read_return = {} - self.read_memory={} # self.read_memory[]:List[xr.DataArray] + self.read_memory = {} # self.read_memory[]:List[xr.DataArray] if reset: # Create a base configuration: Disable all available outputs, awgs, demods, scopes,... @@ -169,7 +167,7 @@ def reset_daq_module(self): self.daq.clear() self._init_daq_module() - def register_measurement_channel(self, program_name:str=None, channel_path:Union[str, List[str]]=[], window_name:str=None): + def register_measurement_channel(self, program_name:Union[str, None]=None, channel_path:Union[str, List[str]]=[], window_name:str=None): """ This function saves the channel one wants to record with a certain program Args: @@ -183,7 +181,7 @@ def register_measurement_channel(self, program_name:str=None, channel_path:Union channel_path = [channel_path] self.programs.setdefault(program_name, {}).setdefault("channel_mapping", {}).setdefault(window_name, set()).update(channel_path) - def register_measurement_windows(self, program_name: str, windows: Dict[str, Tuple[np.ndarray, + def register_measurement_windows(self, program_name:str, windows: Dict[str, Tuple[np.ndarray, np.ndarray]]) -> None: """Register measurement windows for a given program. Overwrites previously defined measurement windows for this program. @@ -205,16 +203,28 @@ def register_measurement_windows(self, program_name: str, windows: Dict[str, Tup # for k, v in windows.items(): # self.set_measurement_mask(program_name=program_name, mask_name=k, begins=v[0], lengths=v[1]) - def register_trigger_settings(self, program_name:str, trigger_input:Union[str, None]=None, edge:str='rising', trigger_count:int=1, level:float=0.1, delay:float=-1e-3, post_delay:float=1e-3, count:bool=np.inf, other_settings:Dict[str, Union[str, int, float]]={}): + def register_trigger_settings(self, program_name:str, trigger_input:Union[str, None]=None, trigger_count:int=1, edge:str='rising', level:float=0.1, delay:float=-1e-3, post_delay:float=1e-3, measurement_count:Union[int, float]=1, other_settings:Dict[str, Union[str, int, float, Any]]={}): """ Parameters ---------- program_name + The program name to set these trigger settings for. trigger_input This needs to be the path to input to the lock-in that the lock-in is able to use as a trigger (without the device serial). (see https://docs.zhinst.com/pdf/LabOneProgrammingManual.pdf for more information) - edge trigger_count + The number of trigger events to count for one measurement. This will later set the number of rows in one measurement + edge + The edge to look out for + level + the trigger level to look out for + delay + the delay of the start of the measurement window in relation to the time of the trigger event. Negative values will result in data being recorded before the event occurred. (in seconds) + post_delay + The duration to record for after the last measurement window. (in seconds) + measurement_count + The number of measurement to perform for one arm call. This will result in self.daq.finished() not returning true until all measurements are recorded. This will equal to trigger_count*measurement_count trigger events. The self.daq.progress() field counts the number of trigger events. If the count is set to np.inf the acquisition is not stopped after any number of triggers are received, only by calling self.stop_acquisition() or self.daq.finish(). Data, potentially incomplete and thus filled with nan, can be retrieved also in the continuous mode with the right setting of the measurement function (i.e. wait=False and fail_if_incomplete=False). other_settings + Other settings to set after the standard trigger settings are send to the data server / device. """ if edge not in ["rising", "falling", "both"]: @@ -227,8 +237,8 @@ def register_trigger_settings(self, program_name:str, trigger_input:Union[str, N "level": level, "delay": delay, "post_delay": post_delay, - "endless": count==np.inf, - "count": 0 if count==np.inf else count, + "endless": measurement_count==np.inf, + "measurement_count": 0 if measurement_count==np.inf else measurement_count, "other_settings": other_settings, } @@ -329,7 +339,7 @@ def set_measurement_mask(self, program_name: str, mask_name: str, return (np.min(mask_info[0], axis=-1), np.max(mask_info[2], axis=-1)) - def register_operations(self, program_name: str, operations) -> None: + def register_operations(self, program_name:str, operations) -> None: """Register operations that are to be applied to the measurement results. Args: @@ -339,7 +349,7 @@ def register_operations(self, program_name: str, operations) -> None: self.programs.setdefault(program_name, {}).setdefault("operations", []).append(operations) - def _get_channels_for_window(self, program_name, window_name=None): + def _get_channels_for_window(self, program_name:Union[str, None], window_name:Union[str, List[str], None]=None): """ Returns the channels to be measured for a given window """ if window_name is None: @@ -354,9 +364,18 @@ def _get_channels_for_window(self, program_name, window_name=None): channels.update(self.programs[program_name]["channel_mapping"][wn]) except KeyError: try: - channels.update(self.programs[None]["channel_mapping"][wn]) + channels.update(self.programs[program_name]["channel_mapping"][None]) except KeyError: - pass + try: + channels.update(self.programs[None]["channel_mapping"][wn]) + except KeyError: + try: + channels.update(self.programs[None]["channel_mapping"][None]) + except KeyError: + pass + + if len(channels) == 0: + warnings.warn(f"No channels registered to measure with program {program_name} and window {window_name}.") channels = set([e.lower() for e in channels]) return channels @@ -370,9 +389,11 @@ def _get_demod(self, channel:str): return "/".join(elements[:-1]) - def arm_program(self, program_name: str, force:bool=True) -> None: + def arm_program(self, program_name: str, force:Union[bool, None]=None) -> None: """Prepare the device for measuring the given program and wait for a trigger event.""" + force = force if force is not None else self.force_update_on_arm + # check if program_name specified program is selected and important parameter set to the lock-in if self.currently_set_program is None or self.currently_set_program != program_name or force: @@ -464,7 +485,7 @@ def arm_program(self, program_name: str, force:bool=True) -> None: self.daq.set('endless', 1) else: self.daq.set('endless', 0) - self.daq.set('count', ts["count"]) # defines how many triggers are to be recorded in single mode i.e. endless==0 + self.daq.set('count', ts["measurement_count"]) # defines how many triggers are to be recorded in single mode i.e. endless==0 if "trig" in ts["trigger_input"].lower(): self.daq.set("type", 6) @@ -495,7 +516,7 @@ def arm_program(self, program_name: str, force:bool=True) -> None: # set the buffer size according to the largest measurement window # TODO one might be able to implement this a bit more cleverly measurement_duration = np.max(list(self.programs[program_name]["windows_from_start_max"].values())) - measurement_duration += ts["post_delay"] + measurement_duration += ts["post_delay"]*1e-9 larges_number_of_samples = 1e-9*max_sample_rate*measurement_duration larges_number_of_samples = np.ceil(larges_number_of_samples) self.daq.set('grid/cols', larges_number_of_samples) @@ -527,10 +548,9 @@ def unarm_program(self, program_name:str): self.currently_set_program = None - def force_trigger(self, program_name:str): - """ forces a trigger + def force_trigger(self, *args, **kwargs): + """ forces a trigger event """ - self.daq.set('forcetrigger', 1) def stop_acquisition(self): @@ -618,7 +638,7 @@ def _parse_data(self, recorded_data, program_name:str, fail_on_empty:bool=True): return masked_data - def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout:float=np.inf, return_raw:bool=False, fail_if_incomplete:bool=False, fail_on_empty:bool=False) -> Union[Dict[str, List[xr.DataArray]], Dict[str, Dict[str, List[xr.DataArray]]]]: + def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout:float=np.inf, return_raw:bool=False, fail_if_incomplete:bool=False, fail_on_empty:bool=False, program_name:Union[str, None]=None) -> Union[Dict[str, List[xr.DataArray]], Dict[str, Dict[str, List[xr.DataArray]]]]: """Get the last measurement's results of the specified operations/channels Parameters @@ -638,12 +658,19 @@ def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout: fail_on_empty:bool, optional if one of the channels is empty, which occurred in the development process for large sample rates, an error is raised in the parsing function and this these incomplete measurements will sit in this classes memory, never to be returned. If False, the empty channels are ignored and it will be returned, what every is there. + Note + ---- + - There is currently no mechanism implemented to keep track of the relation between received data and underlying program (i.e. measurement windows, ...). This has to be tracked by the user! + - When the parameter wait=False and fail_if_incomplete=False are given, then incomplete data is parsed and returned. This can lied to receiving the same measurement multiple times. The user has to keep track of that! + """ + program_name = program_name if program_name is not None else self.currently_set_program + # wait until the data acquisition has finished # TODO implement timeout start_waiting = time.time() - while not self.daq.finished() and wait and not (time.time()-start_waiting>timeout) and not self.programs[self.currently_set_program]["trigger_settings"]["count"]==np.inf: + while not self.daq.finished() and wait and not (time.time()-start_waiting>timeout) and not self.programs[program_name]["trigger_settings"]["endless"]: time.sleep(1) print(f"Waiting for device {self.serial} to finish the acquisition...") print(f"Progress: {self.daq.progress()[0]}") @@ -666,12 +693,19 @@ def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout: for signal_name, signal_data in input_data.items(): for final_level_name, final_level_data in signal_data.items(): channel_name = f"/{device_name}/{input_name}/{signal_name}/{final_level_name}".lower() - channel_data = [xr.DataArray( - data=d["value"], - coords={'time': (['row', 'col'], d["timestamp"]/self.clockbase*1e9)}, - dims=['row', 'col'], - name=channel_name, - attrs=d['header']) for i, d in enumerate(final_level_data)] + channel_data = [] + for i, d in enumerate(final_level_data): + converted_timestamps = { + "systemtime_converted": d["systemtime"]/self.clockbase*1e9, + "createdtimestamp_converted": d["createdtimestamp"]/self.clockbase*1e9, + "changedtimestamp_converted": d["changedtimestamp"]/self.clockbase*1e9, + } + channel_data.append(xr.DataArray( + data=d["value"], + coords={'time': (['row', 'col'], d["timestamp"]/self.clockbase*1e9)}, + dims=['row', 'col'], + name=channel_name, + attrs={**d['header'], **converted_timestamps, "device_serial": self.serial, "channel_name": channel_name})) recorded_data[channel_name] = channel_data # check if the shapes of the received measurements are the same. @@ -744,14 +778,15 @@ def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout: for c, i in zip(channels_to_measure, _indexs): that_shot[c] = [self.read_memory[c][i]] # Here the inner list could be removed if one would remove the old functionality from the _parse_data function. + _the_warning_string = f"Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter." try: that_shot_parsed = self._parse_data(that_shot, self.currently_set_program, fail_on_empty=fail_on_empty) except IndexError as e: traceback.print_exc() - warnings.warn(f"Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter.") + warnings.warn(_the_warning_string) except KeyError as e: traceback.print_exc() - warnings.warn(f"Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter.") + warnings.warn(_the_warning_string) except ValueError as e: if "The received data for channel" in str(e): pass From be08e126cedd5e246b9b633143131609ab18af89 Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Fri, 7 Oct 2022 17:40:38 +0200 Subject: [PATCH 16/25] small parameter clean up and one sentence added to some doc-string --- qupulse/hardware/dacs/mfli.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index a2fd164c5..3673acf88 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -167,13 +167,13 @@ def reset_daq_module(self): self.daq.clear() self._init_daq_module() - def register_measurement_channel(self, program_name:Union[str, None]=None, channel_path:Union[str, List[str]]=[], window_name:str=None): + def register_measurement_channel(self, program_name:Union[str, None]=None, window_name:str=None, channel_path:Union[str, List[str]]=[]): """ This function saves the channel one wants to record with a certain program Args: program_name: Name of the program - channel_path: the channel to record in the shape of "demods/0/sample.R.avg". Note that everything but the things behind the last "/" are considered to relate do the demodulator. If this is not given, you might want to check this driver and extend its functionality. window_name: The windows for that channel. + channel_path: the channel to record in the shape of "demods/0/sample.R.avg". Note that everything but the things behind the last "/" are considered to relate do the demodulator. If this is not given, you might want to check this driver and extend its functionality. """ @@ -203,12 +203,12 @@ def register_measurement_windows(self, program_name:str, windows: Dict[str, Tupl # for k, v in windows.items(): # self.set_measurement_mask(program_name=program_name, mask_name=k, begins=v[0], lengths=v[1]) - def register_trigger_settings(self, program_name:str, trigger_input:Union[str, None]=None, trigger_count:int=1, edge:str='rising', level:float=0.1, delay:float=-1e-3, post_delay:float=1e-3, measurement_count:Union[int, float]=1, other_settings:Dict[str, Union[str, int, float, Any]]={}): + def register_trigger_settings(self, program_name:Union[str, None], trigger_input:Union[str, None]=None, trigger_count:int=1, edge:str='rising', level:float=0.1, delay:float=-1e-3, post_delay:float=1e-3, measurement_count:Union[int, float]=1, other_settings:Dict[str, Union[str, int, float, Any]]={}): """ Parameters ---------- program_name - The program name to set these trigger settings for. + The program name to set these trigger settings for. If None is given, then these settings are used as default values. trigger_input This needs to be the path to input to the lock-in that the lock-in is able to use as a trigger (without the device serial). (see https://docs.zhinst.com/pdf/LabOneProgrammingManual.pdf for more information) trigger_count From 6a780d18b2a88d3457023dfa9d1449cf997bcbbc Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Tue, 11 Oct 2022 16:18:06 +0200 Subject: [PATCH 17/25] small (but critical) bug fixes --- qupulse/hardware/dacs/mfli.py | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index 3673acf88..075899491 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -49,6 +49,7 @@ [X] check how that would behave. Does that overwrite or shift things? [X] change in trigger input port [X] implement setting recording channel (could that be already something inside qupulse?) +[ ] see if the bandwidth setting for the trigger input is correctly handled [ ] see why for high sample rates (e.g. 857.1k) things crash or don't behave as expected [ ] Implement yield for not picked up data (read() was not called) => this should be sufficient for operation @@ -516,7 +517,7 @@ def arm_program(self, program_name: str, force:Union[bool, None]=None) -> None: # set the buffer size according to the largest measurement window # TODO one might be able to implement this a bit more cleverly measurement_duration = np.max(list(self.programs[program_name]["windows_from_start_max"].values())) - measurement_duration += ts["post_delay"]*1e-9 + measurement_duration += (ts["post_delay"] + -1*ts["delay"])*1e9 larges_number_of_samples = 1e-9*max_sample_rate*measurement_duration larges_number_of_samples = np.ceil(larges_number_of_samples) self.daq.set('grid/cols', larges_number_of_samples) @@ -527,7 +528,7 @@ def arm_program(self, program_name: str, force:Union[bool, None]=None) -> None: self.currently_set_program = program_name - print(f"Will record {larges_number_of_samples} per row samples for {measurement_duration*1e-9}s!") # TODO this will have to change if proper multi triggers with over multiple rows is going to be used. + print(f"Will record {larges_number_of_samples} samples per row for {measurement_duration*1e-9}s!") # TODO this will have to change if proper multi triggers with over multiple rows is going to be used. print(f"{rows} row(s) will be recorded.") print(f"the following trigger settings will be used: {ts}") print(f"MFLI returns a duration of {self.daq.get('duration')['duration'][0]}s") @@ -622,7 +623,7 @@ def _parse_data(self, recorded_data, program_name:str, fail_on_empty:bool=True): _time_of_first_not_nan_value = applicable_data["time"][:, 0].values - time_of_trigger = applicable_data.attrs["gridcoloffset"][0]*1e9+_time_of_first_not_nan_value + time_of_trigger = -1*applicable_data.attrs["gridcoloffset"][0]*1e9+_time_of_first_not_nan_value # print(f"time_of_trigger={time_of_trigger}") foo = applicable_data.where((applicable_data["time"]>=(time_of_trigger+b)[:, None]) & (applicable_data["time"]<=(time_of_trigger+b+l)[:, None]), drop=False).copy() @@ -696,9 +697,9 @@ def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout: channel_data = [] for i, d in enumerate(final_level_data): converted_timestamps = { - "systemtime_converted": d["systemtime"]/self.clockbase*1e9, - "createdtimestamp_converted": d["createdtimestamp"]/self.clockbase*1e9, - "changedtimestamp_converted": d["changedtimestamp"]/self.clockbase*1e9, + "systemtime_converted": d['header']["systemtime"]/self.clockbase*1e9, + "createdtimestamp_converted": d['header']["createdtimestamp"]/self.clockbase*1e9, + "changedtimestamp_converted": d['header']["changedtimestamp"]/self.clockbase*1e9, } channel_data.append(xr.DataArray( data=d["value"], From 773e858414349cadbc0c637163808d283cdd60bf Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Fri, 21 Oct 2022 15:10:11 +0200 Subject: [PATCH 18/25] small changes (logger and a bug fix) --- qupulse/hardware/dacs/mfli.py | 34 ++++++++++++++++++++-------------- 1 file changed, 20 insertions(+), 14 deletions(-) diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index 075899491..0538a2aec 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -8,6 +8,7 @@ import warnings import time import traceback +import logging import xarray as xr import numpy as np import numpy.typing as npt @@ -32,6 +33,8 @@ +logger = logging.getLogger(__name__) + """ TODO @@ -326,7 +329,7 @@ def set_measurement_mask(self, program_name: str, mask_name: str, # we also only use the max sample value later. The smallest staring point is somewhat ill-defined if np.sum(np.isnan(mask_info)) == len(mask_info.reshape((-1))): pass - print(f"will not use mask {mask_name}") + logging.info(f"will not use mask {mask_name}") else: # TODO need to do something about the different sample rates!!!! # maybe have it not this flexible??? @@ -441,7 +444,7 @@ def arm_program(self, program_name: str, force:Union[bool, None]=None) -> None: for c in self.programs[program_name]["all_channels"]: raw_currently_set_sample_rates.append(self._get_sample_rates(c)) - print(f"sample rates: {[(float(e) if e is not None else None) for e in raw_currently_set_sample_rates]}") + logging.info(f"sample rates: {[(float(e) if e is not None else None) for e in raw_currently_set_sample_rates]}") # CAUTION # The MFLI lock-ins up-sample slower channels to fit the fastest sample rate. @@ -498,7 +501,12 @@ def arm_program(self, program_name: str, force:Union[bool, None]=None) -> None: edge_key = ["rising", "falling", "both"].index(ts["edge"]) self.daq.set("edge", edge_key) - self.daq.set("level", ts["level"]) + if "trigin" in ts["trigger_input"].lower(): + _trigger_id = int(ts["trigger_input"].split("TrigIn")[-1]) + assert _trigger_id in [1, 2] + self.api_session.setDouble(f'/{self.serial}/triggers/in/{_trigger_id}/level', ts["level"]); + else: + self.daq.set("level", ts["level"]) self.daq.set("delay", ts["delay"]) @@ -528,10 +536,10 @@ def arm_program(self, program_name: str, force:Union[bool, None]=None) -> None: self.currently_set_program = program_name - print(f"Will record {larges_number_of_samples} samples per row for {measurement_duration*1e-9}s!") # TODO this will have to change if proper multi triggers with over multiple rows is going to be used. - print(f"{rows} row(s) will be recorded.") - print(f"the following trigger settings will be used: {ts}") - print(f"MFLI returns a duration of {self.daq.get('duration')['duration'][0]}s") + logging.info(f"Will record {larges_number_of_samples} samples per row for {measurement_duration*1e-9}s!") # TODO this will have to change if proper multi triggers with over multiple rows is going to be used. + logging.info(f"{rows} row(s) will be recorded.") + logging.info(f"the following trigger settings will be used: {ts}") + logging.info(f"MFLI returns a duration of {self.daq.get('duration')['duration'][0]}s") # execute daq self.daq.execute() @@ -602,7 +610,7 @@ def _parse_data(self, recorded_data, program_name:str, fail_on_empty:bool=True): _wind = self.programs[program_name]["windows"][window_name] for ci, _cn in enumerate(self._get_channels_for_window(program_name, window_name)): cn = f"/{self.serial}/{_cn}".lower() - # print(cn) + if len(recorded_data[cn]) <= shot_index: # then we do not have data for this shot_index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save. warnings.warn(f"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{shot_index}]") @@ -625,15 +633,12 @@ def _parse_data(self, recorded_data, program_name:str, fail_on_empty:bool=True): time_of_trigger = -1*applicable_data.attrs["gridcoloffset"][0]*1e9+_time_of_first_not_nan_value - # print(f"time_of_trigger={time_of_trigger}") foo = applicable_data.where((applicable_data["time"]>=(time_of_trigger+b)[:, None]) & (applicable_data["time"]<=(time_of_trigger+b+l)[:, None]), drop=False).copy() foo2 = foo.where(~np.isnan(foo), drop=True) rows_with_data = np.sum(~np.isnan(foo), axis=-1)>0 foo2["time"] -= time_of_trigger[rows_with_data, None] extracted_data.append(foo2) - # print(f"extracted_data={extracted_data}") - data_by_channel.update({cn: extracted_data}) masked_data[window_name] = data_by_channel @@ -670,11 +675,12 @@ def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout: # wait until the data acquisition has finished # TODO implement timeout + _endless_flag_helper = (self.programs[program_name]["trigger_settings"]["endless"] if "trigger_settings" in self.programs[program_name] else (self.programs[None]["trigger_settings"]["endless"] if "trigger_settings" in self.programs[None] else False)) start_waiting = time.time() - while not self.daq.finished() and wait and not (time.time()-start_waiting>timeout) and not self.programs[program_name]["trigger_settings"]["endless"]: + while not self.daq.finished() and wait and not (time.time()-start_waiting>timeout) and not _endless_flag_helper: time.sleep(1) - print(f"Waiting for device {self.serial} to finish the acquisition...") - print(f"Progress: {self.daq.progress()[0]}") + logging.info(f"Waiting for device {self.serial} to finish the acquisition...") + logging.info(f"Progress: {self.daq.progress()[0]}") if fail_if_incomplete and not self.daq.finished(): raise ValueError(f"Device {self.serial} did not finish the acquisition in time.") From 6d6d2817a46e8e48c605ea0c5e538485623ecfd0 Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Sun, 23 Oct 2022 13:26:16 +0200 Subject: [PATCH 19/25] added parameter to set wait time --- qupulse/hardware/dacs/mfli.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index 0538a2aec..32fc9f647 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -644,7 +644,7 @@ def _parse_data(self, recorded_data, program_name:str, fail_on_empty:bool=True): return masked_data - def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout:float=np.inf, return_raw:bool=False, fail_if_incomplete:bool=False, fail_on_empty:bool=False, program_name:Union[str, None]=None) -> Union[Dict[str, List[xr.DataArray]], Dict[str, Dict[str, List[xr.DataArray]]]]: + def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout:float=np.inf, wait_time:float=1e-3, return_raw:bool=False, fail_if_incomplete:bool=False, fail_on_empty:bool=False, program_name:Union[str, None]=None) -> Union[Dict[str, List[xr.DataArray]], Dict[str, Dict[str, List[xr.DataArray]]]]: """Get the last measurement's results of the specified operations/channels Parameters @@ -655,6 +655,8 @@ def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout: Should the code wait until the acquisition has finished? Else incomplete data might be returned. (default: True) timeout: float, optional The time to wait until the measurement is stopped in units of seconds. (default: np.inf) + wait_time : float, optional + The time to pause in the until querying the data server for new data. (default = 1e-3 = 1ms) return_raw: bool, optional If True, the function will return the raw data without selecting the measurement windows. This will then be in the shape of data[channel_name][shot_index]: xr.DataArray. If False, the return value will have the structure data[window_name][channel_name][mask_index]: xr.DataArray. @@ -678,7 +680,7 @@ def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout: _endless_flag_helper = (self.programs[program_name]["trigger_settings"]["endless"] if "trigger_settings" in self.programs[program_name] else (self.programs[None]["trigger_settings"]["endless"] if "trigger_settings" in self.programs[None] else False)) start_waiting = time.time() while not self.daq.finished() and wait and not (time.time()-start_waiting>timeout) and not _endless_flag_helper: - time.sleep(1) + time.sleep(wait_time) logging.info(f"Waiting for device {self.serial} to finish the acquisition...") logging.info(f"Progress: {self.daq.progress()[0]}") From 4d808b0c867da76d9d70785a2fce24187dde9db8 Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Mon, 24 Oct 2022 09:49:02 +0200 Subject: [PATCH 20/25] moved logging outside of wait loop --- qupulse/hardware/dacs/mfli.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index 32fc9f647..a2cf8291c 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -679,10 +679,11 @@ def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout: # TODO implement timeout _endless_flag_helper = (self.programs[program_name]["trigger_settings"]["endless"] if "trigger_settings" in self.programs[program_name] else (self.programs[None]["trigger_settings"]["endless"] if "trigger_settings" in self.programs[None] else False)) start_waiting = time.time() - while not self.daq.finished() and wait and not (time.time()-start_waiting>timeout) and not _endless_flag_helper: - time.sleep(wait_time) + if not self.daq.finished() and wait: logging.info(f"Waiting for device {self.serial} to finish the acquisition...") logging.info(f"Progress: {self.daq.progress()[0]}") + while not self.daq.finished() and wait and not (time.time()-start_waiting>timeout) and not _endless_flag_helper: + time.sleep(wait_time) if fail_if_incomplete and not self.daq.finished(): raise ValueError(f"Device {self.serial} did not finish the acquisition in time.") From accf0424b3b3a127dbac9339bedc94fc1d9e8aa5 Mon Sep 17 00:00:00 2001 From: Simon Humpohl Date: Wed, 2 Nov 2022 16:34:56 +0100 Subject: [PATCH 21/25] Refactor everything --- qupulse/hardware/dacs/mfli.py | 1561 ++++++++++++++++----------------- 1 file changed, 765 insertions(+), 796 deletions(-) diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index a2cf8291c..211bede3f 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -3,823 +3,792 @@ May lines of code have been adapted from the zihdawg driver. """ -from typing import Dict, Tuple, Iterable, Union, List, Set, Any -from enum import Enum -import warnings +import dataclasses +import logging import time import traceback -import logging -import xarray as xr +import warnings +from typing import Dict, Tuple, Iterable, Union, List, Set, Any, Sequence, Mapping, Optional, Literal + import numpy as np -import numpy.typing as npt +import xarray as xr -from qupulse.utils.types import TimeType from qupulse.hardware.dacs.dac_base import DAC +from qupulse.utils.types import TimeType try: - # zhinst fires a DeprecationWarning from its own code in some versions... - with warnings.catch_warnings(): - warnings.simplefilter('ignore', DeprecationWarning) - import zhinst.utils + # zhinst fires a DeprecationWarning from its own code in some versions... + with warnings.catch_warnings(): + warnings.simplefilter('ignore', DeprecationWarning) + import zhinst.utils except ImportError: - warnings.warn('Zurich Instruments LabOne python API is distributed via the Python Package Index. Install with pip.') - raise + warnings.warn('Zurich Instruments LabOne python API is distributed via the Python Package Index. Install with pip.') + raise try: - from zhinst import core as zhinst_core + from zhinst import core as zhinst_core except ImportError: - # backward compability - from zhinst import ziPython as zhinst_core - - + # backward compability + from zhinst import ziPython as zhinst_core logger = logging.getLogger(__name__) -""" - - TODO -======== -[X] make TriggerMode class an Enum -[X] setup minimal connection without changing settings other than buffer lengths -[X] extract window things -[X] rethink handling different sample rates! -[X] cut obtained data to fit into requested windows -[X] provide interface for changing trigger settings -[X] print information about how long the measurement is expected to run -[X] implement multiple triggers (using rows) (and check how this actually behaves) - [X] count - [X] endless - [X] check how that would behave. Does that overwrite or shift things? - [X] change in trigger input port -[X] implement setting recording channel (could that be already something inside qupulse?) -[ ] see if the bandwidth setting for the trigger input is correctly handled -[ ] see why for high sample rates (e.g. 857.1k) things crash or don't behave as expected -[ ] Implement yield for not picked up data (read() was not called) -=> this should be sufficient for operation -[ ] implement optional operations (averaging, binning, up/down sampling, ...) -[ ] implement scope interface for higher sample rates (if i understood the documentation correctly) -[ ] implement low level interface (subscribe()) - - -Tests to implement: -[ ] connecting to a MFLI Device by querying - [ ] available nodes of the api_session - [ ] creating and reading a DAQ Module -[ ] registering channels - [ ] Demod 0 and 1 - [ ] AUXIN -[ ] defining measurement windows - [ ] consecutive ones - [ ] overlapping - [ ] some windows with names but no begin and length information -[ ] relating channels to windows - [ ] adding one channel to one window - [ ] adding multiple channels to one windows - [ ] adding one channel to multiple windows -[ ] measuring only one AUXIN (some channel without the rate argument) -[ ] finishing the acquisition before all rows are recorded (data processing (throwing out nans) might not work as intended) -[ ] what happens when the lock-in is not returning what it should? - [ ] missing channels - [ ] channels separated over multiple read() calls +@dataclasses.dataclass +class TriggerSettings: + trigger_input: str + trigger_count: int + edge: Literal['rising', 'falling', 'both'] + level: float + delay: float + post_delay: float + measurement_count: Union[int, float] + def is_endless(self): + return np.isinf(self.measurement_count) or self.measurement_count == 0 -""" +@dataclasses.dataclass +class MFLIProgram: + default_channels: Optional[Set[str]] = dataclasses.field(default=None) + channel_mapping: Optional[Dict[str, Set[str]]] = dataclasses.field(default=None) + windows: Optional[Dict[str, Tuple[np.ndarray, np.ndarray]]] = dataclasses.field(default=None) + trigger_settings: Optional[TriggerSettings] = dataclasses.field(default=None) + other_settings: Dict[str, Any] = dataclasses.field(default_factory=dict) + operations: Any = dataclasses.field(default=None) -class TriggerType(Enum): + def get_minimal_duration(self) -> float: + return max(np.max(begins + lengths) for (begins, lengths) in self.windows.values()) - # https://docs.zhinst.com/pdf/LabOneProgrammingManual.pdf - # | Mode / Trigger Type | Description | Value of type | - # |---------------------|-------------|---------------| - # | Continuous | Continuous recording of data. | 0 | - # | Edge | Edge trigger with noise rejection. | 1 | - # | Pulse | Pulse width trigger with noise rejection. | 3 | - # | Tracking (Edge or Pulse) | Level tracking trigger to compensate for signal drift. | 4 | - # | Digital | Digital trigger with bit masking. | 2 | - # | Hardware | Trigger on one of the instrument’s hardware trigger channels (not available on HF2). | 6 | - # |Pulse Counter | Trigger on the value of an instrument’s pulse counter (requires CNT Option). | 8 | - - CONTINUOUS = 0 - EDGE = 1 - DIGITAL = 2 - PULSE = 3 - TRACKING = 4 - HARDWARE = 6 - PULSE_COUNTER = 8 + def required_channels(self) -> Set[str]: + channels = set() + for window_name in self.windows: + channels |= self.channel_mapping.get(window_name, self.default_channels) + return channels + def merge(self, other: 'MFLIProgram') -> 'MFLIProgram': + raise NotImplementedError() class MFLIDAQ(DAC): - """ This class contains the driver for using the DAQ module of an Zuerich Instruments MFLI with qupulse. - """ - def __init__(self, device_serial: str = None, - device_interface: str = '1GbE', - data_server_addr: str = 'localhost', - data_server_port: int = 8004, - api_level_number: int = 6, - reset: bool = False, - timeout: float = 20) -> None: - """ - :param device_serial: Device serial that uniquely identifies this device to the LabOne data server - :param device_interface: Either '1GbE' for ethernet or 'USB' - :param data_server_addr: Data server address. Must be already running. Default: localhost - :param data_server_port: Data server port. Default: 8004 for HDAWG, MF and UHF devices - :param api_level_number: Version of API to use for the session, higher number, newer. Default: 6 most recent - :param reset: Reset device before initialization - :param timeout: Timeout in seconds for uploading - """ - self.api_session = zhinst_core.ziDAQServer(data_server_addr, data_server_port, api_level_number) - # assert zhinst.utils.api_server_version_check(self.api_session) # Check equal data server and api version. - self.device_interface = device_interface - self.device = self.api_session.connectDevice(device_serial, device_interface) - self.default_timeout = timeout - self.serial = device_serial - - self.daq = None - self._init_daq_module() - - self.force_update_on_arm:bool = True - self.assumed_minimal_sample_rate:Union[float, None] = None # in units of Sa/s - - self.daq_read_return = {} - self.read_memory = {} # self.read_memory[]:List[xr.DataArray] - - if reset: - # Create a base configuration: Disable all available outputs, awgs, demods, scopes,... - zhinst.utils.disable_everything(self.api_session, self.serial) - - self.programs = {} - self.currently_set_program = None - - def _init_daq_module(self): - self.daq = self.api_session.dataAcquisitionModule() - self.daq.set('device', self.serial) - - def reset(self): - """ This function resets the device to a known default configuration. - """ - self.read_memory = {} - - zhinst.utils.disable_everything(self.api_session, self.serial) - self.clear() - - self.reset_daq_module() - - def reset_daq_module(self): - self.daq.finish() - self.daq.clear() - self._init_daq_module() - - def register_measurement_channel(self, program_name:Union[str, None]=None, window_name:str=None, channel_path:Union[str, List[str]]=[]): - """ This function saves the channel one wants to record with a certain program - - Args: - program_name: Name of the program - window_name: The windows for that channel. - channel_path: the channel to record in the shape of "demods/0/sample.R.avg". Note that everything but the things behind the last "/" are considered to relate do the demodulator. If this is not given, you might want to check this driver and extend its functionality. - - """ - - if not isinstance(channel_path, list): - channel_path = [channel_path] - self.programs.setdefault(program_name, {}).setdefault("channel_mapping", {}).setdefault(window_name, set()).update(channel_path) - - def register_measurement_windows(self, program_name:str, windows: Dict[str, Tuple[np.ndarray, - np.ndarray]]) -> None: - """Register measurement windows for a given program. Overwrites previously defined measurement windows for - this program. - - Args: - program_name: Name of the program - windows: Measurement windows by name. - First array are the start points of measurement windows in nanoseconds. - Second array are the corresponding measurement window's lengths in nanoseconds. - """ - - self.programs.setdefault(program_name, {}).setdefault("windows", {}).update(windows) - self.programs.setdefault(program_name, {}).setdefault("windows_from_start_max", {}).update({k:np.max(v[0]+v[1]) for k, v in windows.items()}) - - # the channels we want to measure with: - channels_to_measure: Set[str] = self._get_channels_for_window(program_name, list(windows.keys())) - self.programs.setdefault(program_name, {})["all_channels"] = channels_to_measure - - # for k, v in windows.items(): - # self.set_measurement_mask(program_name=program_name, mask_name=k, begins=v[0], lengths=v[1]) - - def register_trigger_settings(self, program_name:Union[str, None], trigger_input:Union[str, None]=None, trigger_count:int=1, edge:str='rising', level:float=0.1, delay:float=-1e-3, post_delay:float=1e-3, measurement_count:Union[int, float]=1, other_settings:Dict[str, Union[str, int, float, Any]]={}): - """ - Parameters - ---------- - program_name - The program name to set these trigger settings for. If None is given, then these settings are used as default values. - trigger_input - This needs to be the path to input to the lock-in that the lock-in is able to use as a trigger (without the device serial). (see https://docs.zhinst.com/pdf/LabOneProgrammingManual.pdf for more information) - trigger_count - The number of trigger events to count for one measurement. This will later set the number of rows in one measurement - edge - The edge to look out for - level - the trigger level to look out for - delay - the delay of the start of the measurement window in relation to the time of the trigger event. Negative values will result in data being recorded before the event occurred. (in seconds) - post_delay - The duration to record for after the last measurement window. (in seconds) - measurement_count - The number of measurement to perform for one arm call. This will result in self.daq.finished() not returning true until all measurements are recorded. This will equal to trigger_count*measurement_count trigger events. The self.daq.progress() field counts the number of trigger events. If the count is set to np.inf the acquisition is not stopped after any number of triggers are received, only by calling self.stop_acquisition() or self.daq.finish(). Data, potentially incomplete and thus filled with nan, can be retrieved also in the continuous mode with the right setting of the measurement function (i.e. wait=False and fail_if_incomplete=False). - other_settings - Other settings to set after the standard trigger settings are send to the data server / device. - """ - - if edge not in ["rising", "falling", "both"]: - raise ValueError(f"edge={edge} is not in ['rising', 'falling']") - - self.programs.setdefault(program_name, {})["trigger_settings"] = { - "trigger_input": f"/{self.serial}/{trigger_input}", - "edge": edge, - "trigger_count": trigger_count, - "level": level, - "delay": delay, - "post_delay": post_delay, - "endless": measurement_count==np.inf, - "measurement_count": 0 if measurement_count==np.inf else measurement_count, - "other_settings": other_settings, - } - - def _get_sample_rates(self, channel:str): - try: - timetype_sr = TimeType().from_float(value=self.api_session.getDouble(f"/{self.serial}/{self._get_demod(channel)}/rate"), absolute_error=0) - return timetype_sr - except RuntimeError as e: - if "ZIAPINotFoundException" in e.args[0]: - return None - else: - raise - - def set_measurement_mask(self, program_name: str, mask_name: str, - begins: np.ndarray, - lengths: np.ndarray) -> Tuple[np.ndarray, np.ndarray]: - """Set/overwrite a single the measurement mask for a program. Begins and lengths are in nanoseconds. - - Args: - program_name: Name of the program - mask_name: Name of the mask/measurement windows - begins: Staring points in nanoseconds - lengths: Lengths in nanoseconds - - Returns: - Measurement windows in DAC samples (begins, lengths) - """ - - raise NotImplementedError(f"This function has been abandoned as the MFLI returns timestamps.") - - assert begins.shape == lengths.shape - - if program_name not in self.programs: - raise ValueError(f"Program '{program_name}' not known") - - # the channels we want to measure with: - channels_to_measure: List[str] = self._get_channels_for_window(program_name, mask_name) - - if len(channels_to_measure) == 0: - warnings.warn(f"There are no channels defined that should be measured in mask '{mask_name}'.") - - # get the sample rates for the requested channels. If no sample rate is found, None will be used. This code is not very nice. - raw_currently_set_sample_rates: List[Union[TimeType, None]] = [] - - for c in channels_to_measure: - raw_currently_set_sample_rates.append(self._get_sample_rates(c)) - - # CAUTION - # The MFLI lock-ins up-sample slower channels to fit the fastest sample rate. - # This is the cased for the Lab One Data Server 21.08.20515 and the MFLi Firmware 67629. - foo = [x for x in raw_currently_set_sample_rates if x is not None] - if len(foo) == 0 and self.assumed_minimal_sample_rate is None: - raise ValueError(f"No information about the sample rate is given, thus we can not calculate the window sizes.") - if self.assumed_minimal_sample_rate is not None: - foo.append(TimeType().from_float(value=self.assumed_minimal_sample_rate, absolute_error=0)) - max_sample_rate = max(foo) - currently_set_sample_rates = [max_sample_rate]*len(raw_currently_set_sample_rates) - - mask_info = np.full((3, len(begins), len(currently_set_sample_rates)), np.nan) - - for i, _sr in enumerate(currently_set_sample_rates): - if _sr is not None: - sr = _sr*1e-9 # converting the sample rate, which is given in Sa/s, into Sa/ns - # this code was taken from the already implemented alazar driver. - mask_info[0, :, i] = np.rint(begins * float(sr)).astype(dtype=np.uint64) # the begin - mask_info[1, :, i] = np.floor_divide(lengths * float(sr.numerator), float(sr.denominator)).astype(dtype=np.uint64) # the length - mask_info[2, :, i] = (mask_info[0, :, i] + mask_info[1, :, i]).astype(dtype=np.uint64) # the end - - self.programs.setdefault(program_name, {}).setdefault("masks", {})[mask_name] = {"mask": mask_info, "channels": channels_to_measure, "sample_rates": raw_currently_set_sample_rates} - self.programs.setdefault(program_name, {}).setdefault("all_channels", set()).update(channels_to_measure) - self.programs.setdefault(program_name, {}).setdefault("window_hull", [np.nan, np.nan]) - # self.programs.setdefault(program_name, {}).setdefault("largest_sample_rate", -1*np.inf) # This will be used to set the window_hull only based on the fastest channel queried. - - # as the lock-in can measure multiple channels with different sample rates, the return value of this function is not defined correctly. - # this could be fixed by only measuring on one channel, or by returning some "summary" value. As of now, there does not to be a use of the return values. - # but there are also used calculations in the following code. - - if len(channels_to_measure) == 0: - return None - else: - - # update the hull of all measurement windows defined for this program to later set the number of samples to record. - # TODO this whole thing could be improved at some point. - # we also only use the max sample value later. The smallest staring point is somewhat ill-defined - if np.sum(np.isnan(mask_info)) == len(mask_info.reshape((-1))): - pass - logging.info(f"will not use mask {mask_name}") - else: - # TODO need to do something about the different sample rates!!!! - # maybe have it not this flexible??? - - _start = np.nanmin(mask_info[0]) - _end = np.nanmax(mask_info[2]) - if np.isnan(self.programs[program_name]["window_hull"][0]) or self.programs[program_name]["window_hull"][0] > _start: - self.programs[program_name]["window_hull"][0] = _start - if np.isnan(self.programs[program_name]["window_hull"][1]) or self.programs[program_name]["window_hull"][1] < _end: - self.programs[program_name]["window_hull"][1] = _end - - return (np.min(mask_info[0], axis=-1), np.max(mask_info[2], axis=-1)) - - def register_operations(self, program_name:str, operations) -> None: - """Register operations that are to be applied to the measurement results. - - Args: - program_name: Name of the program - operations: DAC specific instructions what to do with the data recorded by the device. - """ - - self.programs.setdefault(program_name, {}).setdefault("operations", []).append(operations) - - def _get_channels_for_window(self, program_name:Union[str, None], window_name:Union[str, List[str], None]=None): - """ Returns the channels to be measured for a given window - """ - if window_name is None: - window_name = list(self.programs[program_name]["windows"].keys()) - if not isinstance(window_name, list): - window_name = [window_name] - - channels: Set[str] = set() - - for wn in window_name: - try: - channels.update(self.programs[program_name]["channel_mapping"][wn]) - except KeyError: - try: - channels.update(self.programs[program_name]["channel_mapping"][None]) - except KeyError: - try: - channels.update(self.programs[None]["channel_mapping"][wn]) - except KeyError: - try: - channels.update(self.programs[None]["channel_mapping"][None]) - except KeyError: - pass - - if len(channels) == 0: - warnings.warn(f"No channels registered to measure with program {program_name} and window {window_name}.") - - channels = set([e.lower() for e in channels]) - return channels - - def _get_demod(self, channel:str): - """ This function gets the demodulator corresponding to a channel - """ - elements = channel.split("/") - elements = [e for e in elements if not e.lower()==self.serial.lower()] - elements = [e for e in elements if len(e) > 0] - - return "/".join(elements[:-1]) - - def arm_program(self, program_name: str, force:Union[bool, None]=None) -> None: - """Prepare the device for measuring the given program and wait for a trigger event.""" - - force = force if force is not None else self.force_update_on_arm - - # check if program_name specified program is selected and important parameter set to the lock-in - if self.currently_set_program is None or self.currently_set_program != program_name or force: - - self.daq.finish() - self.daq.unsubscribe('*') - - # TODO TODO TODO TODO TODO TODO TODO TODO - # # if the program is changed, the not returned data is removed to not have conflicts with the data parsing operations. The cleaner way would be to keep track of the time the program is changed. - # if self.currently_set_program != program_name: - # self.read() - # self.daq.clear() - # self._init_daq_module() - # TODO TODO TODO TODO TODO TODO TODO TODO - - for c in self.programs[program_name]["all_channels"]: - - # activate corresponding demodulators - demod = self._get_demod(c) - try: - self.api_session.setInt(f'/{self.serial}/{demod}/enable', 1) - except RuntimeError as e: - if "ZIAPINotFoundException" in e.args[0] or f"Path /{self.serial}/{demod}/enable not found." in e.args[0]: - # ok, the channel can not be enabled. Then the user should be caring about that. - warnings.warn(f"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.") - pass - else: - raise - - # select the value to measure - self.daq.subscribe(f'/{self.serial}/{c}') - - # # check if sample rates are the same as when register_measurement_windows() was called - # for k, v in self.programs[program_name]['masks'].items(): - # if len(v["channels"]) != len(v["sample_rates"]): - # raise ValueError(f"There is a mismatch between number the channels to be used and the known sample rates.") - # for c, r in zip(v["channels"], v["sample_rates"]): - # if self._get_sample_rates(c) != r: - # raise ValueError(f"The sample rate for channel '{c}' has changed. Please call register_measurement_windows() again.") - - # set the buffer size based on the largest sample rate - # if no sample rate is readable, as for example when only AUXIN channels are used, the first demodulator is activated and the corresponding rate is used - - raw_currently_set_sample_rates: List[Union[TimeType, None]] = [] - for c in self.programs[program_name]["all_channels"]: - raw_currently_set_sample_rates.append(self._get_sample_rates(c)) - - logging.info(f"sample rates: {[(float(e) if e is not None else None) for e in raw_currently_set_sample_rates]}") - - # CAUTION - # The MFLI lock-ins up-sample slower channels to fit the fastest sample rate. - # This is the cased for the Lab One Data Server 21.08.20515 and the MFLi Firmware 67629. - # TODO it needs to be verified, that this code here is actually necessary. One could also query the AUXIN using one of the demods. - foo = [x for x in raw_currently_set_sample_rates if x is not None] - if len(foo) == 0 and self.assumed_minimal_sample_rate is None: - # Ok, we activate the first demodulator - self.api_session.setInt(f'/{self.serial}/demods/0/enable', 1) - foo.append(self._get_sample_rates(f'/{self.serial}/demods/0/sample.R')) - if self.assumed_minimal_sample_rate is not None: - foo.append(TimeType().from_float(value=self.assumed_minimal_sample_rate, absolute_error=0)) - max_sample_rate = max(foo) - currently_set_sample_rates = [max_sample_rate]*len(raw_currently_set_sample_rates) - - - # set daq module settings to standard things - # TODO one might want to extend the driver to support more methods - self.daq.set('grid/mode', 4) # this corresponds to Mode: Exact(on-grid) - # the following two lines set the row repetitions to 1 and off - self.daq.set('grid/repetitions', 1) - self.daq.set('grid/rowrepetition', 0) - - # setting trigger settings - ts = {} - try: - ts.update(self.programs[None]["trigger_settings"]) - except KeyError: - pass - try: - ts.update(self.programs[program_name]["trigger_settings"]) - except KeyError: - pass - - rows = 1 - if len(ts) != 0: - rows = ts["trigger_count"] - # selecting the trigger channel - if ts["trigger_input"] is not None: - - if ts["endless"]: - self.daq.set('endless', 1) - else: - self.daq.set('endless', 0) - self.daq.set('count', ts["measurement_count"]) # defines how many triggers are to be recorded in single mode i.e. endless==0 - - if "trig" in ts["trigger_input"].lower(): - self.daq.set("type", 6) - else: - self.daq.set("type", 1) - - self.daq.set("triggernode", ts["trigger_input"]) - - edge_key = ["rising", "falling", "both"].index(ts["edge"]) - self.daq.set("edge", edge_key) - - if "trigin" in ts["trigger_input"].lower(): - _trigger_id = int(ts["trigger_input"].split("TrigIn")[-1]) - assert _trigger_id in [1, 2] - self.api_session.setDouble(f'/{self.serial}/triggers/in/{_trigger_id}/level', ts["level"]); - else: - self.daq.set("level", ts["level"]) - - - self.daq.set("delay", ts["delay"]) - self.daq.set('bandwidth', 0) - - else: - self.daq.set("type", 0) - - self.daq.set('count', rows) - - for k, v in ts["other_settings"].items(): - self.daq.set(k, v) - - - - # set the buffer size according to the largest measurement window - # TODO one might be able to implement this a bit more cleverly - measurement_duration = np.max(list(self.programs[program_name]["windows_from_start_max"].values())) - measurement_duration += (ts["post_delay"] + -1*ts["delay"])*1e9 - larges_number_of_samples = 1e-9*max_sample_rate*measurement_duration - larges_number_of_samples = np.ceil(larges_number_of_samples) - self.daq.set('grid/cols', larges_number_of_samples) - self.daq.set('grid/rows', rows) # this corresponds to measuring only for one trigger - - # self.daq.set("buffersize", 2*measurement_duration) # that the buffer size is set to be larger than the duration is something that the SM script did. - # # --> in the current version and/or configuration, this path is read-only. - - self.currently_set_program = program_name - - logging.info(f"Will record {larges_number_of_samples} samples per row for {measurement_duration*1e-9}s!") # TODO this will have to change if proper multi triggers with over multiple rows is going to be used. - logging.info(f"{rows} row(s) will be recorded.") - logging.info(f"the following trigger settings will be used: {ts}") - logging.info(f"MFLI returns a duration of {self.daq.get('duration')['duration'][0]}s") - - # execute daq - self.daq.execute() - - # wait until changes have taken place - self.api_session.sync() - - def unarm_program(self, program_name:str): - """ unarms the lock-in. This should be program independent. - """ - - self.daq.finish() - self.daq.unsubscribe('*') - self.api_session.sync() - - self.currently_set_program = None - - def force_trigger(self, *args, **kwargs): - """ forces a trigger event - """ - self.daq.set('forcetrigger', 1) - - def stop_acquisition(self): - self.daq.finish() - - def clear_memory(self): - self.read_memory = {} - - def delete_program(self, program_name: str) -> None: - """Delete program from internal memory.""" - - # this does not have an effect on the current implementation of the lock-in driver. - - if self.currently_set_program == program_name: - self.unarm_program(program_name) - - self.programs.pop(program_name) - - def clear(self) -> None: - """Clears all registered programs.""" - - self.unarm_program(program_name=None) - self.read_memory = {} - - def _parse_data(self, recorded_data, program_name:str, fail_on_empty:bool=True): - """ This function parses the recorded data and extracts the measurement masks and applies optional operations - """ - - # the first dimension of channel_data is expected to be the history of multiple not read data points. This will be handled as multiple entries in a list. This will then not make too much sense, if not every channel as this many entries. If this is the case, they will be stacked, such that for the last elements it fits. - # TODO do this based on the timestamps and not the indices. That might be more sound than just assuming that. - - - # applying measurement windows and optional operations - # TODO implement operations - - # targeted structure: - # results[][] -> [data] - - masked_data = {} - - # the MFLI returns a list of measurements. We only proceed with the last ones from this list. One might want to iterate over that and process all of them. - # This feature might be useful if after some measurements no read() operation is called. Then with the later read, the data is returned. - # TODO this might be more elegantly implemented or handled using yields! - shot_index = 0 # TODO make this more flexible to not lose things - - for window_name in self.programs[program_name]["windows"]: - data_by_channel = {} - _wind = self.programs[program_name]["windows"][window_name] - for ci, _cn in enumerate(self._get_channels_for_window(program_name, window_name)): - cn = f"/{self.serial}/{_cn}".lower() - - if len(recorded_data[cn]) <= shot_index: - # then we do not have data for this shot_index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save. - warnings.warn(f"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{shot_index}]") - continue - applicable_data = recorded_data[cn][-1-shot_index] - applicable_data = applicable_data.where(~np.isnan(applicable_data), drop=True) - - if len(applicable_data)==0 or np.product([*applicable_data.shape])==0: - if fail_on_empty: - raise ValueError(f"The received data for channel {_cn} is empty.") - else: - warnings.warn(f"The received data for channel {_cn} is empty.") - continue - - extracted_data = [] - for b, l in zip(*_wind): - # _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)["time"][:, 0].values - - _time_of_first_not_nan_value = applicable_data["time"][:, 0].values - - time_of_trigger = -1*applicable_data.attrs["gridcoloffset"][0]*1e9+_time_of_first_not_nan_value - - foo = applicable_data.where((applicable_data["time"]>=(time_of_trigger+b)[:, None]) & (applicable_data["time"]<=(time_of_trigger+b+l)[:, None]), drop=False).copy() - foo2 = foo.where(~np.isnan(foo), drop=True) - rows_with_data = np.sum(~np.isnan(foo), axis=-1)>0 - foo2["time"] -= time_of_trigger[rows_with_data, None] - extracted_data.append(foo2) - - data_by_channel.update({cn: extracted_data}) - masked_data[window_name] = data_by_channel - - return masked_data - - def measure_program(self, channels: Iterable[str] = [], wait:bool=True, timeout:float=np.inf, wait_time:float=1e-3, return_raw:bool=False, fail_if_incomplete:bool=False, fail_on_empty:bool=False, program_name:Union[str, None]=None) -> Union[Dict[str, List[xr.DataArray]], Dict[str, Dict[str, List[xr.DataArray]]]]: - """Get the last measurement's results of the specified operations/channels - - Parameters - ---------- - channels: Iterable[str], optional - Has no function here. (default: []) - wait: bool, optional - Should the code wait until the acquisition has finished? Else incomplete data might be returned. (default: True) - timeout: float, optional - The time to wait until the measurement is stopped in units of seconds. (default: np.inf) - wait_time : float, optional - The time to pause in the until querying the data server for new data. (default = 1e-3 = 1ms) - return_raw: bool, optional - If True, the function will return the raw data without selecting the measurement windows. This will then be in the shape of data[channel_name][shot_index]: xr.DataArray. - If False, the return value will have the structure data[window_name][channel_name][mask_index]: xr.DataArray. - Also, if False, the time axis will be shifted, such that the trigger occurred at data[window_name][channel_name][mask_index]["time"]==0 #ns. - fail_if_incomplete: bool, optional - if True and the timeout has been reached and the acquisition has not finished, an error will be raised. - fail_on_empty:bool, optional - if one of the channels is empty, which occurred in the development process for large sample rates, an error is raised in the parsing function and this these incomplete measurements will sit in this classes memory, never to be returned. If False, the empty channels are ignored and it will be returned, what every is there. - - Note - ---- - - There is currently no mechanism implemented to keep track of the relation between received data and underlying program (i.e. measurement windows, ...). This has to be tracked by the user! - - When the parameter wait=False and fail_if_incomplete=False are given, then incomplete data is parsed and returned. This can lied to receiving the same measurement multiple times. The user has to keep track of that! - - """ - - program_name = program_name if program_name is not None else self.currently_set_program - - # wait until the data acquisition has finished - # TODO implement timeout - _endless_flag_helper = (self.programs[program_name]["trigger_settings"]["endless"] if "trigger_settings" in self.programs[program_name] else (self.programs[None]["trigger_settings"]["endless"] if "trigger_settings" in self.programs[None] else False)) - start_waiting = time.time() - if not self.daq.finished() and wait: - logging.info(f"Waiting for device {self.serial} to finish the acquisition...") - logging.info(f"Progress: {self.daq.progress()[0]}") - while not self.daq.finished() and wait and not (time.time()-start_waiting>timeout) and not _endless_flag_helper: - time.sleep(wait_time) - - if fail_if_incomplete and not self.daq.finished(): - raise ValueError(f"Device {self.serial} did not finish the acquisition in time.") - - data = self.daq.read() - self.daq_read_return.update(data) - - self.clockbase = self.api_session.getDouble(f'/{self.serial}/clockbase') - - # go through the returned object and extract the data of interest - - recorded_data = {} - - for device_name, device_data in data.items(): - if device_name == self.serial: - for input_name, input_data in device_data.items(): - for signal_name, signal_data in input_data.items(): - for final_level_name, final_level_data in signal_data.items(): - channel_name = f"/{device_name}/{input_name}/{signal_name}/{final_level_name}".lower() - channel_data = [] - for i, d in enumerate(final_level_data): - converted_timestamps = { - "systemtime_converted": d['header']["systemtime"]/self.clockbase*1e9, - "createdtimestamp_converted": d['header']["createdtimestamp"]/self.clockbase*1e9, - "changedtimestamp_converted": d['header']["changedtimestamp"]/self.clockbase*1e9, - } - channel_data.append(xr.DataArray( - data=d["value"], - coords={'time': (['row', 'col'], d["timestamp"]/self.clockbase*1e9)}, - dims=['row', 'col'], - name=channel_name, - attrs={**d['header'], **converted_timestamps, "device_serial": self.serial, "channel_name": channel_name})) - recorded_data[channel_name] = channel_data - - # check if the shapes of the received measurements are the same. - # this is needed as the assumption, that the lock-in/data server up-samples slower channels to match the one with the highest rate. - - recorded_shapes = {k:set([e.shape for e in v]) for k, v in recorded_data.items()} - if any([len(v)>1 for v in recorded_shapes.values()]) or len(set([e for a in recorded_shapes.values() for e in a]))>1: - warnings.warn(f"For at least one received channel entries with different dimensions are present. This might lead to undesired masking! (The code will not raise an exception.) ({recorded_shapes})") - - if len(recorded_data) == 0: - warnings.warn(f"No data has been recorded!") - - # update measurements in local memory - for k, v in recorded_data.items(): - self.read_memory.setdefault(k, []) - # for all the measurement that we just read of the device: - for m in v: - # get the time stamp of when the measurement was created - crts = m.attrs["createdtimestamp"][0] - - # now look, if that measurement is measurement is already in the memory - for i, e in enumerate(self.read_memory[k]): - if e.attrs["createdtimestamp"][0] == crts: - # then we can overwrite that. - # TODO don't overwrite that. Only replace nan values - self.read_memory[k][i] = m - break - else: - # if we did not find that element in the list, we append it. - self.read_memory[k].append(m) - - # sort the element by their createdtimestamp - order = np.argsort([e.attrs["createdtimestamp"][0] for e in self.read_memory[k]]) - self.read_memory[k] = [self.read_memory[k][o] for o in order] - # CAUTION this only sorts the ones that have been updated. This might not be intended!!! - - - if return_raw: - return recorded_data - - # now we package everything in self.read_memory, such that the elements with one creation time stamp are processed at once. - # If for every self._get_channels_for_window(self.currently_set_program, None) some measurement is present: try parsing the data. If that was successful: remove these elements from the read_memeory and return (or yield) the results. - - # TODO this might lead to leaving some measurements in the memory that will never be used, if they don't get related with measurements from the other channels of the program. - - creation_ts = {k:[e.attrs["createdtimestamp"][0] for e in v] for k, v in self.read_memory.items()} - if len(creation_ts)==0: - # Then we have nothing to process - return None - all_ts = np.unique(np.concatenate(list(creation_ts.values()))) - assert len(all_ts.shape) == 1 - if len(all_ts)==0: - # Then we have nothing to process - return None - - channels_to_measure = self._get_channels_for_window(self.currently_set_program, None) - channels_to_measure = [f"/{self.serial}/{c}" for c in channels_to_measure] - - things_to_remove = {} - - results = [] - - for ts in all_ts: - contained = [k for k, v in creation_ts.items() if ts in v] - if all([(c in contained) for c in channels_to_measure]): - # then we have all measurement for that shot - that_shot = {} - _indexs = [creation_ts[c].index(ts) for c in channels_to_measure] - - for c, i in zip(channels_to_measure, _indexs): - that_shot[c] = [self.read_memory[c][i]] # Here the inner list could be removed if one would remove the old functionality from the _parse_data function. - - _the_warning_string = f"Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter." - try: - that_shot_parsed = self._parse_data(that_shot, self.currently_set_program, fail_on_empty=fail_on_empty) - except IndexError as e: - traceback.print_exc() - warnings.warn(_the_warning_string) - except KeyError as e: - traceback.print_exc() - warnings.warn(_the_warning_string) - except ValueError as e: - if "The received data for channel" in str(e): - pass - else: - raise - else: - # the parsing worked, we can now remove the data from the memory - results.append(that_shot_parsed) - for c, i in zip(channels_to_measure, _indexs): - things_to_remove.setdefault(c, []).append(i) - - else: - pass - # TODO do something here. Maybe raise a warning. - - # then we can remove the element that worked: - for k, v in things_to_remove.items(): - v.sort() - assert (len(v)==0) or (v[0] <= v[-1]) - for i in reversed(v): - self.read_memory[k].pop(i) - - if not return_raw: - if len(results) == 0: - return None - return results \ No newline at end of file + """ This class contains the driver for using the DAQ module of an Zuerich Instruments MFLI with qupulse. + """ + + def __init__(self, + api_session: zhinst_core.ziDAQServer, + device, + reset: bool = False, + timeout: float = 20) -> None: + """ + :param reset: Reset device before initialization + :param timeout: Timeout in seconds for uploading + """ + self.api_session = api_session + self.device = device + self.default_timeout = timeout + self.serial = device.serial + + self.daq = None + self._init_daq_module() + + self.force_update_on_arm: bool = True + self.assumed_minimal_sample_rate: Union[float, None] = None # in units of Sa/s + + self.daq_read_return = {} + self.read_memory: Dict[str, List[xr.DataArray]] = {} # self.read_memory[]:List[xr.DataArray] + + if reset: + # Create a base configuration: Disable all available outputs, awgs, demods, scopes,... + zhinst.utils.disable_everything(self.api_session, self.serial) + + self.default_program = MFLIProgram() + self.programs: Dict[str, MFLIProgram] = {} + + self.currently_set_program: Optional[str] = None + self._armed_program: Optional[MFLIProgram] = None + + @classmethod + def connect_to(cls, device_serial: str = None, + device_interface: str = '1GbE', + data_server_addr: str = 'localhost', + data_server_port: int = 8004, + api_level_number: int = 6, **init_kwargs): + """ + :param device_serial: Device serial that uniquely identifies this device to the LabOne data server + :param device_interface: Either '1GbE' for ethernet or 'USB' + :param data_server_addr: Data server address. Must be already running. Default: localhost + :param data_server_port: Data server port. Default: 8004 for HDAWG, MF and UHF devices + :param api_level_number: Version of API to use for the session, higher number, newer. Default: 6 most recent + """ + api_session = zhinst_core.ziDAQServer(data_server_addr, data_server_port, api_level_number) + device = api_session.connectDevice(device_serial, device_interface) + cls(api_session, device, **init_kwargs) + + def _init_daq_module(self): + self.daq = self.api_session.dataAcquisitionModule() + self.daq.set('device', self.serial) + + def reset(self): + """ This function resets the device to a known default configuration. + """ + self.read_memory.clear() + + zhinst.utils.disable_everything(self.api_session, self.serial) + self.clear() + self.programs.clear() + + self.reset_daq_module() + + def reset_daq_module(self): + self.daq.finish() + self.daq.clear() + self._init_daq_module() + + def register_measurement_channel(self, program_name: Union[str, None] = None, window_name: str = None, + channel_path: Union[str, Sequence[str]] = ()): + """ This function saves the channel one wants to record with a certain program + + Args: + program_name: Name of the program + window_name: The windows for that channel. + channel_path: the channel to record in the shape of "demods/0/sample.R.avg". Note that everything but the + things behind the last "/" are considered to relate do the demodulator. If this is not given, you might want + to check this driver and extend its functionality. + """ + + if isinstance(channel_path, str): + channel_path = [channel_path] + + if program_name is None: + program = self.default_program + else: + program = self.programs.setdefault(program_name, MFLIProgram()) + + if window_name is None: + program.default_channels = set(channel_path) + else: + program.channel_mapping[window_name] = set(channel_path) + + def register_measurement_windows(self, program_name: str, windows: Dict[str, Tuple[np.ndarray, + np.ndarray]]) -> None: + """Register measurement windows for a given program. Overwrites previously defined measurement windows for + this program. + + Args: + program_name: Name of the program + windows: Measurement windows by name. + First array are the start points of measurement windows in nanoseconds. + Second array are the corresponding measurement window's lengths in nanoseconds. + """ + self.programs.setdefault(program_name, MFLIProgram()).windows = windows + + # self.programs.setdefault(program_name, {}).setdefault("windows", {}).update(windows) + # self.programs.setdefault(program_name, {}).setdefault("windows_from_start_max", {}).update( + # {k: np.max(v[0] + v[1]) for k, v in windows.items()}) + + # the channels we want to measure with: + # channels_to_measure: Set[str] = self._get_channels_for_window(program_name, list(windows.keys())) + # self.programs.setdefault(program_name, {})["all_channels"] = channels_to_measure + + # for k, v in windows.items(): + # self.set_measurement_mask(program_name=program_name, mask_name=k, begins=v[0], lengths=v[1]) + + def register_trigger_settings(self, program_name: Union[str, None], trigger_input: Union[str, None] = None, + trigger_count: int = 1, + edge: Literal['rising', 'falling', 'both'] = 'rising', + level: float = 0.1, + delay: float = -1e-3, post_delay: float = 1e-3, + measurement_count: Union[int, float] = 1, + other_settings: Dict[str, Union[str, int, float, Any]] = None): + """ + Parameters + ---------- + program_name + The program name to set these trigger settings for. If None is given, then these settings are used as default values. + trigger_input + This needs to be the path to input to the lock-in that the lock-in is able to use as a trigger (without the device serial). (see https://docs.zhinst.com/pdf/LabOneProgrammingManual.pdf for more information) + trigger_count + The number of trigger events to count for one measurement. This will later set the number of rows in one measurement + edge + The edge to look out for + level + the trigger level to look out for + delay + the delay of the start of the measurement window in relation to the time of the trigger event. Negative values will result in data being recorded before the event occurred. (in seconds) + post_delay + The duration to record for after the last measurement window. (in seconds) + measurement_count + The number of measurement to perform for one arm call. This will result in self.daq.finished() not returning true until all measurements are recorded. This will equal to trigger_count*measurement_count trigger events. The self.daq.progress() field counts the number of trigger events. If the count is set to np.inf the acquisition is not stopped after any number of triggers are received, only by calling self.stop_acquisition() or self.daq.finish(). Data, potentially incomplete and thus filled with nan, can be retrieved also in the continuous mode with the right setting of the measurement function (i.e. wait=False and fail_if_incomplete=False). + other_settings + Other settings to set after the standard trigger settings are send to the data server / device. + """ + + if edge not in ["rising", "falling", "both"]: + raise ValueError(f"edge={edge} is not in ['rising', 'falling']") + + if program_name is None: + program = self.default_program + else: + program = self.programs.setdefault(program_name, MFLIProgram()) + + program.trigger_settings = TriggerSettings( + trigger_input=trigger_input, + edge=edge, + trigger_count=trigger_count, + level=level, + delay=delay, + post_delay=post_delay, + measurement_count=measurement_count + ) + program.other_settings = other_settings or {} + # return + # self.programs.setdefault(program_name, {})["trigger_settings"] = { + # "trigger_input": f"/{self.serial}/{trigger_input}", + # "edge": edge, + # "trigger_count": trigger_count, + # "level": level, + # "delay": delay, + # "post_delay": post_delay, + # "endless": measurement_count == np.inf, + # "measurement_count": 0 if measurement_count == np.inf else measurement_count, + # "other_settings": other_settings, + # } + + def _get_sample_rates(self, channel: str): + try: + timetype_sr = TimeType().from_float( + value=self.api_session.getDouble(f"/{self.serial}/{self._get_demod(channel)}/rate"), absolute_error=0) + return timetype_sr + except RuntimeError as e: + if "ZIAPINotFoundException" in e.args[0]: + return None + else: + raise + + def set_measurement_mask(self, program_name: str, mask_name: str, + begins: np.ndarray, + lengths: np.ndarray) -> Tuple[np.ndarray, np.ndarray]: + """Set/overwrite a single the measurement mask for a program. Begins and lengths are in nanoseconds. + + Args: + program_name: Name of the program + mask_name: Name of the mask/measurement windows + begins: Staring points in nanoseconds + lengths: Lengths in nanoseconds + + Returns: + Measurement windows in DAC samples (begins, lengths) + """ + raise NotImplementedError(f"This function has been abandoned as the MFLI returns timestamps.") + + def register_operations(self, program_name: str, operations) -> None: + """Register operations that are to be applied to the measurement results. + + Args: + program_name: Name of the program + operations: DAC specific instructions what to do with the data recorded by the device. + """ + + self.programs.setdefault(program_name, MFLIProgram()).operations = operations + + def _get_channels_for_window(self, program_name: Union[str, None], window_name: Union[str, List[str], None] = None): + """ Returns the channels to be measured for a given window + """ + raise NotImplementedError("removed") + + # if window_name is None: + # window_name = list(self.programs[program_name]["windows"].keys()) + # if not isinstance(window_name, list): + # window_name = [window_name] + # + # channels: Set[str] = set() + # + # for wn in window_name: + # try: + # channels.update(self.programs[program_name]["channel_mapping"][wn]) + # except KeyError: + # try: + # channels.update(self.programs[program_name]["channel_mapping"][None]) + # except KeyError: + # try: + # channels.update(self.programs[None]["channel_mapping"][wn]) + # except KeyError: + # try: + # channels.update(self.programs[None]["channel_mapping"][None]) + # except KeyError: + # pass + # + # if len(channels) == 0: + # warnings.warn(f"No channels registered to measure with program {program_name} and window {window_name}.") + # + # channels = set([e.lower() for e in channels]) + # return channels + + def _get_demod(self, channel: str): + """ This function gets the demodulator corresponding to a channel + """ + elements = channel.split("/") + elements = [e for e in elements if not e.lower() == self.serial.lower()] + elements = [e for e in elements if len(e) > 0] + + return "/".join(elements[:-1]) + + def arm_program(self, program_name: str, force: Union[bool, None] = None) -> None: + """Prepare the device for measuring the given program and wait for a trigger event.""" + + force = force if force is not None else self.force_update_on_arm + + # check if program_name specified program is selected and important parameter set to the lock-in + if self.currently_set_program is None or self.currently_set_program != program_name or force: + + self.daq.finish() + self.daq.unsubscribe('*') + + # TODO TODO TODO TODO TODO TODO TODO TODO + # # if the program is changed, the not returned data is removed to not have conflicts with the data parsing operations. The cleaner way would be to keep track of the time the program is changed. + # if self.currently_set_program != program_name: + # self.read() + # self.daq.clear() + # self._init_daq_module() + # TODO TODO TODO TODO TODO TODO TODO TODO + + program = self.default_program.merge(self.programs[program_name]) + + for c in program.required_channels(): + + # activate corresponding de-modulators + demod = self._get_demod(c) + try: + self.api_session.setInt(f'/{self.serial}/{demod}/enable', 1) + except RuntimeError as e: + if "ZIAPINotFoundException" in e.args[0] or f"Path /{self.serial}/{demod}/enable not found." in \ + e.args[0]: + # ok, the channel can not be enabled. Then the user should be caring about that. + warnings.warn( + f"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.") + pass + else: + raise + + # select the value to measure + self.daq.subscribe(f'/{self.serial}/{c}') + + # # check if sample rates are the same as when register_measurement_windows() was called + # for k, v in self.programs[program_name]['masks'].items(): + # if len(v["channels"]) != len(v["sample_rates"]): + # raise ValueError(f"There is a mismatch between number the channels to be used and the known sample rates.") + # for c, r in zip(v["channels"], v["sample_rates"]): + # if self._get_sample_rates(c) != r: + # raise ValueError(f"The sample rate for channel '{c}' has changed. Please call register_measurement_windows() again.") + + # set the buffer size based on the largest sample rate + # if no sample rate is readable, as for example when only AUXIN channels are used, the first demodulator is activated and the corresponding rate is used + + raw_currently_set_sample_rates: List[Union[TimeType, None]] = [] + for c in program.required_channels(): + raw_currently_set_sample_rates.append(self._get_sample_rates(c)) + + logging.info( + f"sample rates: {[(float(e) if e is not None else None) for e in raw_currently_set_sample_rates]}") + + # CAUTION + # The MFLI lock-ins up-sample slower channels to fit the fastest sample rate. + # This is the cased for the Lab One Data Server 21.08.20515 and the MFLi Firmware 67629. + # TODO it needs to be verified, that this code here is actually necessary. One could also query the AUXIN using one of the demods. + foo = [x for x in raw_currently_set_sample_rates if x is not None] + if len(foo) == 0 and self.assumed_minimal_sample_rate is None: + # Ok, we activate the first demodulator + self.api_session.setInt(f'/{self.serial}/demods/0/enable', 1) + foo.append(self._get_sample_rates(f'/{self.serial}/demods/0/sample.R')) + if self.assumed_minimal_sample_rate is not None: + foo.append(TimeType().from_float(value=self.assumed_minimal_sample_rate, absolute_error=0)) + max_sample_rate = max(foo) + currently_set_sample_rates = [max_sample_rate] * len(raw_currently_set_sample_rates) + + # set daq module settings to standard things + # TODO one might want to extend the driver to support more methods + self.daq.set('grid/mode', 4) # this corresponds to Mode: Exact(on-grid) + # the following two lines set the row repetitions to 1 and off + self.daq.set('grid/repetitions', 1) + self.daq.set('grid/rowrepetition', 0) + + # setting trigger settings + ts = program.trigger_settings + + rows = 1 + if ts is not None: + rows = ts.trigger_count + # selecting the trigger channel + if ts.trigger_input is not None: + + if ts.is_endless(): + self.daq.set('endless', 1) + else: + self.daq.set('endless', 0) + # defines how many triggers are to be recorded in single mode i.e. endless==0 + self.daq.set('count', ts.measurement_count) + + if "trig" in ts.trigger_input.lower(): + self.daq.set("type", 6) + else: + self.daq.set("type", 1) + + self.daq.set("triggernode", ts.trigger_input) + + edge_key = ["rising", "falling", "both"].index(ts.edge) + self.daq.set("edge", edge_key) + + if "trigin" in ts.trigger_input.lower(): + _trigger_id = int(ts.trigger_input.split("TrigIn")[-1]) + assert _trigger_id in [1, 2] + self.api_session.setDouble(f'/{self.serial}/triggers/in/{_trigger_id}/level', ts.level); + else: + self.daq.set("level", ts.level) + + self.daq.set("delay", ts.delay) + self.daq.set('bandwidth', 0) + + else: + self.daq.set("type", 0) + + self.daq.set('count', rows) + + if program.other_settings: + for k, v in program.other_settings.items(): + self.daq.set(k, v) + + # set the buffer size according to the largest measurement window + # TODO one might be able to implement this a bit more cleverly + measurement_duration = np.max(list(self.programs[program_name]["windows_from_start_max"].values())) + measurement_duration += (ts.post_delay + -1 * ts.delay) * 1e9 + larges_number_of_samples = max_sample_rate / 10 ** 9 * measurement_duration + larges_number_of_samples = np.ceil(larges_number_of_samples) + self.daq.set('grid/cols', larges_number_of_samples) + self.daq.set('grid/rows', rows) # this corresponds to measuring only for one trigger + + # self.daq.set("buffersize", 2*measurement_duration) # that the buffer size is set to be larger than the duration is something that the SM script did. + # # --> in the current version and/or configuration, this path is read-only. + + self.currently_set_program = program_name + + logging.info( + f"Will record {larges_number_of_samples} samples per row for {measurement_duration * 1e-9}s!") # TODO this will have to change if proper multi triggers with over multiple rows is going to be used. + logging.info(f"{rows} row(s) will be recorded.") + logging.info(f"the following trigger settings will be used: {ts}") + logging.info(f"MFLI returns a duration of {self.daq.get('duration')['duration'][0]}s") + + self._armed_program = program + + # execute daq + self.daq.execute() + + # wait until changes have taken place + self.api_session.sync() + + def unarm_program(self): + """ unarms the lock-in. This should be program independent. + """ + + self.daq.finish() + self.daq.unsubscribe('*') + self.api_session.sync() + + self.currently_set_program = None + + def force_trigger(self, *args, **kwargs): + """ forces a trigger event + """ + self.daq.set('forcetrigger', 1) + + def stop_acquisition(self): + self.daq.finish() + + def clear_memory(self): + self.read_memory.clear() + + def delete_program(self, program_name: str) -> None: + """Delete program from internal memory.""" + + # this does not have an effect on the current implementation of the lock-in driver. + + if self.currently_set_program == program_name: + self.unarm_program() + + self.programs.pop(program_name) + + def clear(self) -> None: + """Clears all registered programs.""" + self.unarm_program() + self.read_memory.clear() + + def _parse_data(self, + recorded_data: Mapping[str, List[xr.DataArray]], + program_name: str, + fail_on_empty: bool = True) -> Mapping[str, Mapping[str, List[xr.DataArray]]]: + """ This function parses the recorded data and extracts the measurement masks and applies optional operations + """ + + # the first dimension of channel_data is expected to be the history of multiple not read data points. This will + # be handled as multiple entries in a list. This will then not make too much sense, if not every channel as this + # many entries. If this is the case, they will be stacked, such that for the last elements it fits. + # TODO do this based on the timestamps and not the indices. That might be more sound than just assuming that. + + # applying measurement windows and optional operations + # TODO implement operations + + # targeted structure: + # results[][] -> [data] + + masked_data = {} + + # the MFLI returns a list of measurements. We only proceed with the last ones from this list. One might want to + # iterate over that and process all of them.This feature might be useful if after some measurements no read() + # operation is called. Then with the later read, the data is returned. + # TODO this might be more elegantly implemented or handled using yields! + shot_index = 0 # TODO make this more flexible to not lose things + + for window_name, (begins, lengths) in self.programs[program_name].windows.items(): + data_by_channel = {} + # _wind = self.programs[program_name]["windows"][window_name] + for ci, _cn in enumerate(self._get_channels_for_window(program_name, window_name)): + cn = f"/{self.serial}/{_cn}".lower() + + if len(recorded_data[cn]) <= shot_index: + # then we do not have data for this shot_index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save. + warnings.warn( + f"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{shot_index}]") + continue + applicable_data = recorded_data[cn][-1 - shot_index] + applicable_data = applicable_data.where(~np.isnan(applicable_data), drop=True) + + if len(applicable_data) == 0 or np.product([*applicable_data.shape]) == 0: + if fail_on_empty: + raise ValueError(f"The received data for channel {_cn} is empty.") + else: + warnings.warn(f"The received data for channel {_cn} is empty.") + continue + + extracted_data = [] + for b, l in zip(begins, lengths): + # _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)["time"][:, 0].values + + _time_of_first_not_nan_value = applicable_data["time"][:, 0].values + + time_of_trigger = -1 * applicable_data.attrs["gridcoloffset"][ + 0] * 1e9 + _time_of_first_not_nan_value + + foo = applicable_data.where((applicable_data["time"] >= (time_of_trigger + b)[:, None]) & ( + applicable_data["time"] <= (time_of_trigger + b + l)[:, None]), drop=False).copy() + foo2 = foo.where(~np.isnan(foo), drop=True) + rows_with_data = np.sum(~np.isnan(foo), axis=-1) > 0 + foo2["time"] -= time_of_trigger[rows_with_data, None] + extracted_data.append(foo2) + + data_by_channel.update({cn: extracted_data}) + masked_data[window_name] = data_by_channel + + return masked_data + + def get_mfli_data(self, + wait: bool = True, + timeout: float = np.inf, + wait_time: float = 1e-3, + return_raw: bool = False, + fail_if_incomplete: bool = False, + fail_on_empty: bool = False): + """Get the last measurement's results of the specified channels + + Parameters + ---------- + wait: bool, optional + Should the code wait until the acquisition has finished? Else incomplete data might be returned. (default: True) + timeout: float, optional + The time to wait until the measurement is stopped in units of seconds. (default: np.inf) + wait_time : float, optional + The time to pause in the until querying the data server for new data. (default = 1e-3 = 1ms) + return_raw: bool, optional + If True, the function will return the raw data without selecting the measurement windows. This will then be in the shape of data[channel_name][shot_index]: xr.DataArray. + If False, the return value will have the structure data[window_name][channel_name][mask_index]: xr.DataArray. + Also, if False, the time axis will be shifted, such that the trigger occurred at data[window_name][channel_name][mask_index]["time"]==0 #ns. + fail_if_incomplete: bool, optional + if True and the timeout has been reached and the acquisition has not finished, an error will be raised. + fail_on_empty:bool, optional + if one of the channels is empty, which occurred in the development process for large sample rates, an error is raised in the parsing function and this these incomplete measurements will sit in this classes memory, never to be returned. If False, the empty channels are ignored and it will be returned, what every is there. + + Note + ---- + - There is currently no mechanism implemented to keep track of the relation between received data and underlying program (i.e. measurement windows, ...). This has to be tracked by the user! + - When the parameter wait=False and fail_if_incomplete=False are given, then incomplete data is parsed and returned. This can lied to receiving the same measurement multiple times. The user has to keep track of that! + + """ + + program = self._armed_program + + # wait until the data acquisition has finished + # TODO implement timeout + _endless_flag_helper = program.trigger_settings.is_endless() + + start_waiting = time.time() + if not self.daq.finished() and wait: + logging.info(f"Waiting for device {self.serial} to finish the acquisition...") + logging.info(f"Progress: {self.daq.progress()[0]}") + while not self.daq.finished() and wait and not ( + time.time() - start_waiting > timeout) and not _endless_flag_helper: + time.sleep(wait_time) + + if fail_if_incomplete and not self.daq.finished(): + raise ValueError(f"Device {self.serial} did not finish the acquisition in time.") + + data = self.daq.read() + self.daq_read_return.update(data) + + clockbase = self.api_session.getDouble(f'/{self.serial}/clockbase') + + # go through the returned object and extract the data of interest + + recorded_data = {} + + for device_name, device_data in data.items(): + if device_name == self.serial: + for input_name, input_data in device_data.items(): + for signal_name, signal_data in input_data.items(): + for final_level_name, final_level_data in signal_data.items(): + channel_name = f"/{device_name}/{input_name}/{signal_name}/{final_level_name}".lower() + channel_data = [] + for i, d in enumerate(final_level_data): + converted_timestamps = { + "systemtime_converted": d['header']["systemtime"] / clockbase * 1e9, + "createdtimestamp_converted": d['header'][ + "createdtimestamp"] / clockbase * 1e9, + "changedtimestamp_converted": d['header'][ + "changedtimestamp"] / clockbase * 1e9, + } + channel_data.append(xr.DataArray( + data=d["value"], + coords={'time': (['row', 'col'], d["timestamp"] / clockbase * 1e9)}, + dims=['row', 'col'], + name=channel_name, + attrs={**d['header'], **converted_timestamps, "device_serial": self.serial, + "channel_name": channel_name})) + recorded_data[channel_name] = channel_data + + # check if the shapes of the received measurements are the same. + # this is needed as the assumption, that the lock-in/data server up-samples slower channels to match the one with the highest rate. + + recorded_shapes = {k: set([e.shape for e in v]) for k, v in recorded_data.items()} + if any([len(v) > 1 for v in recorded_shapes.values()]) or len( + set([e for a in recorded_shapes.values() for e in a])) > 1: + warnings.warn( + f"For at least one received channel entries with different dimensions are present. This might lead to undesired masking! (The code will not raise an exception.) ({recorded_shapes})") + + if len(recorded_data) == 0: + warnings.warn(f"No data has been recorded!") + + # update measurements in local memory + for k, v in recorded_data.items(): + self.read_memory.setdefault(k, []) + # for all the measurement that we just read of the device: + for m in v: + # get the time stamp of when the measurement was created + crts = m.attrs["createdtimestamp"][0] + + # now look, if that measurement is already in the memory + for i, e in enumerate(self.read_memory[k]): + if e.attrs["createdtimestamp"][0] == crts: + # then we can overwrite that. + # TODO don't overwrite that. Only replace nan values + self.read_memory[k][i] = m + break + else: + # if we did not find that element in the list, we append it. + self.read_memory[k].append(m) + + # sort the element by their createdtimestamp + order = np.argsort([e.attrs["createdtimestamp"][0] for e in self.read_memory[k]]) + self.read_memory[k] = [self.read_memory[k][o] for o in order] + # CAUTION this only sorts the ones that have been updated. This might not be intended!!! + + if return_raw: + return recorded_data + + # now we package everything in self.read_memory, such that the elements with one creation time stamp are processed at once. + # If for every self._get_channels_for_window(self.currently_set_program, None) some measurement is present: try parsing the data. If that was successful: remove these elements from the read_memeory and return (or yield) the results. + + # TODO this might lead to leaving some measurements in the memory that will never be used, if they don't get related with measurements from the other channels of the program. + + creation_ts = {k: [e.attrs["createdtimestamp"][0] for e in v] for k, v in self.read_memory.items()} + if len(creation_ts) == 0: + # Then we have nothing to process + return None + all_ts = np.unique(np.concatenate(list(creation_ts.values()))) + assert len(all_ts.shape) == 1 + if len(all_ts) == 0: + # Then we have nothing to process + return None + + channels_to_measure = self._get_channels_for_window(self.currently_set_program, None) + channels_to_measure = [f"/{self.serial}/{c}" for c in channels_to_measure] + + things_to_remove = {} + + results = [] + + for ts in all_ts: + contained = [k for k, v in creation_ts.items() if ts in v] + if all([(c in contained) for c in channels_to_measure]): + # then we have all measurement for that shot + that_shot = {} + _indexs = [creation_ts[c].index(ts) for c in channels_to_measure] + + for c, i in zip(channels_to_measure, _indexs): + that_shot[c] = [self.read_memory[c][i]] + # Here the inner list could be removed if one would remove the old functionality from the _parse_data function. + + _the_warning_string = f"Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter." + try: + that_shot_parsed = self._parse_data(that_shot, self.currently_set_program, + fail_on_empty=fail_on_empty) + except IndexError as e: + traceback.print_exc() + warnings.warn(_the_warning_string) + except KeyError as e: + traceback.print_exc() + warnings.warn(_the_warning_string) + except ValueError as e: + if "The received data for channel" in str(e): + pass + else: + raise + else: + # the parsing worked, we can now remove the data from the memory + results.append(that_shot_parsed) + for c, i in zip(channels_to_measure, _indexs): + things_to_remove.setdefault(c, []).append(i) + + else: + pass + # TODO do something here. Maybe raise a warning. + + # then we can remove the element that worked: + for k, v in things_to_remove.items(): + v.sort() + assert (len(v) == 0) or (v[0] <= v[-1]) + for i in reversed(v): + self.read_memory[k].pop(i) + + if not return_raw: + if len(results) == 0: + return None + return results + + def measure_program(self, + channels: Iterable[str] = None, + wait: bool = True, + timeout: float = np.inf, + wait_time: float = 1e-3, + return_raw: bool = False, + fail_if_incomplete: bool = False, + fail_on_empty: bool = False) -> Union[Dict[str, List[xr.DataArray]], + Dict[str, Dict[str, List[xr.DataArray]]], + None]: + return self.get_mfli_data(wait, timeout, wait_time, return_raw, fail_if_incomplete, fail_on_empty) From 4ecf9bc2e110856e1373a8907512cd931802bf5a Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Wed, 23 Aug 2023 20:28:32 +0200 Subject: [PATCH 22/25] Fix everything --- .../zurich_instruments_lockin_mfli_daq.ipynb | 660 ++++++------------ qupulse/hardware/dacs/mfli.py | 102 ++- 2 files changed, 297 insertions(+), 465 deletions(-) diff --git a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb index 02988cc55..be6775a48 100644 --- a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb +++ b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb @@ -18,19 +18,10 @@ }, { "cell_type": "code", - "execution_count": 131, + "execution_count": 1, "id": "37894582", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "# this function let's jupyter/ipython reload changes made in the source code automatically.\n", "%load_ext autoreload\n", @@ -69,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "76ba4dc7", "metadata": {}, "outputs": [], @@ -79,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 146, + "execution_count": 6, "id": "65986db0", "metadata": {}, "outputs": [], @@ -88,23 +79,35 @@ ] }, { - "cell_type": "markdown", - "id": "cdcb0f9d", + "cell_type": "code", + "execution_count": 7, + "id": "18800300", "metadata": {}, + "outputs": [], "source": [ - "Now we instantiate the MFLIDAQ instance. This object contains all functions necessary to work with qupulse. At this point, it only get information about how to talk to the device, there are not functional settings passed (other then resetting the device if ```reset=True``` is given.)." + "import zhinst.ziPython as zi" ] }, { "cell_type": "code", "execution_count": 8, "id": "42af2895", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [], "source": [ - "my_lockin = MFLIDAQ(device_serial=\"dev3442\", device_interface=\"PCIe\", data_server_addr=\"192.168.53.202\")" + "my_lockin = MFLIDAQ.connect_to(device_serial=\"dev4797\")" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "1ee1dbe4", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "id": "4e5e5266", @@ -123,6 +126,36 @@ "my_lockin.api_session.setDebugLevel(0)" ] }, + { + "cell_type": "markdown", + "id": "c9fb333b", + "metadata": {}, + "source": [ + "And the sample rate and aux outputs are configured" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9bcd679c", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.api_session.setDouble(f'/{my_lockin.serial}/demods/0/rate', 10000)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e1bad934", + "metadata": {}, + "outputs": [], + "source": [ + "for i in range(4):\n", + " my_lockin.api_session.setInt(f'/{my_lockin.serial}/auxouts/{i}/outputselect', -1)\n", + " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/{i}/offset\", 0)" + ] + }, { "cell_type": "markdown", "id": "41396548", @@ -141,7 +174,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "id": "016ae5ee", "metadata": {}, "outputs": [], @@ -160,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "id": "264cb7fa", "metadata": {}, "outputs": [], @@ -184,7 +217,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "id": "bb0ef71a", "metadata": {}, "outputs": [], @@ -198,35 +231,28 @@ "id": "e684b4f8", "metadata": {}, "source": [ - "Here are the currently saved information for the default program ```None```" + "Here are the currently saved information for the default program ```my_lockin.default_program```" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "460a60f0", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'channel_mapping': {'R': {'demods/0/sample.R'},\n", - " 'X': {'demods/0/sample.X'},\n", - " 'Y': {'demods/0/sample.Y'},\n", - " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", - " 'many': {'auxins/0/sample.AuxIn0.avg',\n", - " 'demods/0/sample.R',\n", - " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y'}}}" + "MFLIProgram(default_channels=None, channel_mapping={'R': {'demods/0/sample.R'}, 'X': {'demods/0/sample.X'}, 'Y': {'demods/0/sample.Y'}, 'A': {'auxins/0/sample.AuxIn0.avg'}, 'many': {'demods/0/sample.Y', 'demods/0/sample.R', 'demods/0/sample.X', 'auxins/0/sample.AuxIn0.avg'}}, windows=None, trigger_settings=None, other_settings={}, operations=None)" ] }, - "execution_count": 13, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "my_lockin.programs[None]" + "my_lockin.default_program" ] }, { @@ -243,7 +269,7 @@ }, { "cell_type": "code", - "execution_count": 132, + "execution_count": 16, "id": "bc46a01c", "metadata": {}, "outputs": [], @@ -256,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "id": "f45534ef", "metadata": { "scrolled": true @@ -265,24 +291,10 @@ { "data": { "text/plain": [ - "{None: {'channel_mapping': {'R': {'demods/0/sample.R'},\n", - " 'X': {'demods/0/sample.X'},\n", - " 'Y': {'demods/0/sample.Y'},\n", - " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", - " 'many': {'auxins/0/sample.AuxIn0.avg',\n", - " 'demods/0/sample.R',\n", - " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y'}}},\n", - " 'test': {'windows': {'A': (array([0, 3]), array([ 1, 10])),\n", - " 'many': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))},\n", - " 'windows_from_start_max': {'A': 13, 'many': 0.0101},\n", - " 'all_channels': {'auxins/0/sample.auxin0.avg',\n", - " 'demods/0/sample.r',\n", - " 'demods/0/sample.x',\n", - " 'demods/0/sample.y'}}}" + "{'test': MFLIProgram(default_channels=None, channel_mapping=None, windows={'A': (array([0, 3]), array([ 1, 10])), 'many': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))}, trigger_settings=None, other_settings={}, operations=None)}" ] }, - "execution_count": 15, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -301,7 +313,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "id": "eb3c0a0e", "metadata": {}, "outputs": [], @@ -311,24 +323,17 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "id": "60fe5854", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{None: {'channel_mapping': {'R': {'demods/0/sample.R'},\n", - " 'X': {'demods/0/sample.X'},\n", - " 'Y': {'demods/0/sample.Y'},\n", - " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", - " 'many': {'auxins/0/sample.AuxIn0.avg',\n", - " 'demods/0/sample.R',\n", - " 'demods/0/sample.X',\n", - " 'demods/0/sample.Y'}}}}" + "{}" ] }, - "execution_count": 17, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -339,11 +344,24 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "4955fbc2", + "execution_count": 20, + "id": "ecdc3bc7", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "MFLIProgram(default_channels=None, channel_mapping={'R': {'demods/0/sample.R'}, 'X': {'demods/0/sample.X'}, 'Y': {'demods/0/sample.Y'}, 'A': {'auxins/0/sample.AuxIn0.avg'}, 'many': {'demods/0/sample.Y', 'demods/0/sample.R', 'demods/0/sample.X', 'auxins/0/sample.AuxIn0.avg'}}, windows=None, trigger_settings=None, other_settings={}, operations=None)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.default_program" + ] }, { "cell_type": "markdown", @@ -365,7 +383,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 21, "id": "37b55006", "metadata": {}, "outputs": [], @@ -375,7 +393,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 22, "id": "be93574e", "metadata": {}, "outputs": [], @@ -392,7 +410,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 23, "id": "1d42e3fc", "metadata": {}, "outputs": [], @@ -410,7 +428,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 24, "id": "d2632242", "metadata": {}, "outputs": [], @@ -430,7 +448,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 25, "id": "ea1cdd4c", "metadata": {}, "outputs": [ @@ -438,8 +456,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "z:\\git\\qupulse\\qupulse\\pulses\\arithmetic_pulse_template.py:72: ImplicitAtomicityInArithmeticPT: ArithmeticAtomicPulseTemplate treats all operands as if they are atomic. You can silence this warning by passing `silent_atomic=True` or by ignoring this category.\n", - " category=ImplicitAtomicityInArithmeticPT)\n" + "\\\\Janeway\\User AG Bluhm\\Surrey\\git\\qupulse\\qupulse\\pulses\\arithmetic_pulse_template.py:73: ImplicitAtomicityInArithmeticPT: ArithmeticAtomicPulseTemplate treats all operands as if they are atomic. You can silence this warning by passing `silent_atomic=True` or by ignoring this category.\n", + " warnings.warn(\"ArithmeticAtomicPulseTemplate treats all operands as if they are atomic. \"\n" ] } ], @@ -449,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 26, "id": "eb2ea77b", "metadata": {}, "outputs": [ @@ -457,7 +475,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'T', 'R', 'A'}\n", + "{'A', 'R', 'T'}\n", "[]\n", "set()\n" ] @@ -471,7 +489,7 @@ }, { "cell_type": "code", - "execution_count": 142, + "execution_count": 27, "id": "eeeee0ec", "metadata": {}, "outputs": [ @@ -479,8 +497,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\Surrey\\Miniconda3\\envs\\py37\\lib\\site-packages\\ipykernel_launcher.py:1: DeprecationWarning: This is only a hack until https://github.com/qutech/qupulse/issues/578 is resolved. Do not call this method directly\n", - " \"\"\"Entry point for launching an IPython kernel.\n" + "C:\\Users\\Surrey\\AppData\\Local\\Temp\\ipykernel_12824\\4247546520.py:1: DeprecationWarning: This is only a hack until https://github.com/qutech/qupulse/issues/578 is resolved. Do not call this method directly\n", + " combined_pulse.get_measurement_windows(parameters={\"dt\": 1e8}, measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"T\"})\n" ] }, { @@ -493,7 +511,7 @@ " ('T', 1000000000.0, 300000000.0)]" ] }, - "execution_count": 142, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -504,13 +522,13 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 28, "id": "d325087c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -528,7 +546,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 29, "id": "70da8095", "metadata": {}, "outputs": [], @@ -549,7 +567,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 30, "id": "20626e0f", "metadata": {}, "outputs": [], @@ -562,13 +580,13 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 31, "id": "62aab374", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -586,7 +604,7 @@ }, { "cell_type": "code", - "execution_count": 138, + "execution_count": 32, "id": "d5c5f40f", "metadata": {}, "outputs": [ @@ -596,7 +614,7 @@ "{'A', 'R', 'T'}" ] }, - "execution_count": 138, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -607,7 +625,7 @@ }, { "cell_type": "code", - "execution_count": 136, + "execution_count": 33, "id": "c547473f", "metadata": {}, "outputs": [ @@ -617,7 +635,7 @@ "[]" ] }, - "execution_count": 136, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -655,7 +673,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 34, "id": "031fd70e", "metadata": {}, "outputs": [], @@ -665,7 +683,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 35, "id": "f0143c3d", "metadata": {}, "outputs": [], @@ -675,7 +693,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 36, "id": "843fb93c", "metadata": {}, "outputs": [], @@ -693,7 +711,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 37, "id": "7df89611", "metadata": {}, "outputs": [], @@ -711,7 +729,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 38, "id": "21afd2d6", "metadata": {}, "outputs": [], @@ -729,18 +747,46 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 39, + "id": "05b61c6b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'R': {'demods/0/sample.R'},\n", + " 'X': {'demods/0/sample.X'},\n", + " 'Y': {'demods/0/sample.Y'},\n", + " 'A': {'auxins/0/sample.AuxIn0.avg'},\n", + " 'many': {'auxins/0/sample.AuxIn0.avg',\n", + " 'demods/0/sample.R',\n", + " 'demods/0/sample.X',\n", + " 'demods/0/sample.Y'}}" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_lockin.default_program.channel_mapping" + ] + }, + { + "cell_type": "code", + "execution_count": 40, "id": "2e4e2b0b", "metadata": {}, "outputs": [], "source": [ - "for n in my_lockin.programs[None][\"channel_mapping\"].keys():\n", + "for n in my_lockin.default_program.channel_mapping.keys():\n", " setup.set_measurement(f\"{n}\", MeasurementMask(my_lockin, n))" ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 41, "id": "632a30f6", "metadata": {}, "outputs": [], @@ -759,7 +805,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 42, "id": "6abf0e7f", "metadata": {}, "outputs": [], @@ -769,7 +815,7 @@ }, { "cell_type": "code", - "execution_count": 139, + "execution_count": 43, "id": "b3d52873", "metadata": {}, "outputs": [], @@ -779,7 +825,7 @@ }, { "cell_type": "code", - "execution_count": 112, + "execution_count": 44, "id": "e35f0e2f", "metadata": {}, "outputs": [], @@ -797,7 +843,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 45, "id": "7f811d07", "metadata": {}, "outputs": [], @@ -805,15 +851,16 @@ "def plot_windows(data):\n", " for j, w in enumerate(data.keys()):\n", " for i, c in enumerate(data[w].keys()):\n", - " for e in data[w][c]:\n", - " plt.plot(e[\"time\"].values.T, e.values.T, color=f\"C{j}\")\n", + " for k, e in enumerate(data[w][c]):\n", + " plt.plot(e[\"time\"].values.T, e.values.T, color=f\"C{j}\", label=(w if (i==0 and k==0) else None))\n", " plt.scatter(e[\"time\"].values.T, e.values.T, color=f\"C{j}\", marker=\"x\", alpha=.1)\n", + " plt.legend()\n", " plt.show()" ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 46, "id": "176c260b", "metadata": {}, "outputs": [], @@ -837,7 +884,7 @@ }, { "cell_type": "code", - "execution_count": 143, + "execution_count": 47, "id": "d0c8669f", "metadata": {}, "outputs": [], @@ -872,7 +919,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 48, "id": "f069c321", "metadata": { "scrolled": true @@ -885,7 +932,7 @@ }, { "cell_type": "code", - "execution_count": 140, + "execution_count": 49, "id": "b037496c", "metadata": {}, "outputs": [], @@ -903,7 +950,7 @@ }, { "cell_type": "code", - "execution_count": 141, + "execution_count": 50, "id": "d38e253f", "metadata": { "scrolled": false @@ -912,35 +959,24 @@ { "data": { "text/plain": [ - "{'windows': {'X': (array([1.0e+07, 3.0e+07, 5.0e+07, 7.0e+07, 9.0e+07, 1.1e+08, 1.3e+08,\n", - " 1.5e+08, 1.7e+08, 1.9e+08]),\n", - " array([3000000., 3000000., 3000000., 3000000., 3000000., 3000000.,\n", - " 3000000., 3000000., 3000000., 3000000.])),\n", - " 'R': (array([6.500e+06, 1.400e+07, 2.650e+07, 3.400e+07, 4.650e+07, 5.400e+07,\n", - " 6.650e+07, 7.400e+07, 8.650e+07, 9.400e+07, 1.065e+08, 1.140e+08,\n", - " 1.265e+08, 1.340e+08, 1.465e+08, 1.540e+08, 1.665e+08, 1.740e+08,\n", - " 1.865e+08, 1.940e+08]),\n", - " array([1400000., 1000000., 1400000., 1000000., 1400000., 1000000.,\n", - " 1400000., 1000000., 1400000., 1000000., 1400000., 1000000.,\n", - " 1400000., 1000000., 1400000., 1000000., 1400000., 1000000.,\n", - " 1400000., 1000000.])),\n", - " 'A': (array([3.00e+06, 1.20e+07, 2.30e+07, 3.20e+07, 4.30e+07, 5.20e+07,\n", - " 6.30e+07, 7.20e+07, 8.30e+07, 9.20e+07, 1.03e+08, 1.12e+08,\n", - " 1.23e+08, 1.32e+08, 1.43e+08, 1.52e+08, 1.63e+08, 1.72e+08,\n", - " 1.83e+08, 1.92e+08]),\n", - " array([1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", - " 1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", - " 1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", - " 1500000., 3000000.]))},\n", - " 'windows_from_start_max': {'X': 193000000.0,\n", - " 'R': 195000000.0,\n", - " 'A': 195000000.0},\n", - " 'all_channels': {'auxins/0/sample.auxin0.avg',\n", - " 'demods/0/sample.r',\n", - " 'demods/0/sample.x'}}" + "MFLIProgram(default_channels=None, channel_mapping=None, windows={'X': (array([1.0e+07, 3.0e+07, 5.0e+07, 7.0e+07, 9.0e+07, 1.1e+08, 1.3e+08,\n", + " 1.5e+08, 1.7e+08, 1.9e+08]), array([3000000., 3000000., 3000000., 3000000., 3000000., 3000000.,\n", + " 3000000., 3000000., 3000000., 3000000.])), 'R': (array([6.500e+06, 1.400e+07, 2.650e+07, 3.400e+07, 4.650e+07, 5.400e+07,\n", + " 6.650e+07, 7.400e+07, 8.650e+07, 9.400e+07, 1.065e+08, 1.140e+08,\n", + " 1.265e+08, 1.340e+08, 1.465e+08, 1.540e+08, 1.665e+08, 1.740e+08,\n", + " 1.865e+08, 1.940e+08]), array([1400000., 1000000., 1400000., 1000000., 1400000., 1000000.,\n", + " 1400000., 1000000., 1400000., 1000000., 1400000., 1000000.,\n", + " 1400000., 1000000., 1400000., 1000000., 1400000., 1000000.,\n", + " 1400000., 1000000.])), 'A': (array([3.00e+06, 1.20e+07, 2.30e+07, 3.20e+07, 4.30e+07, 5.20e+07,\n", + " 6.30e+07, 7.20e+07, 8.30e+07, 9.20e+07, 1.03e+08, 1.12e+08,\n", + " 1.23e+08, 1.32e+08, 1.43e+08, 1.52e+08, 1.63e+08, 1.72e+08,\n", + " 1.83e+08, 1.92e+08]), array([1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", + " 1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", + " 1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", + " 1500000., 3000000.]))}, trigger_settings=None, other_settings={}, operations=None)" ] }, - "execution_count": 141, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" } @@ -959,7 +995,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 51, "id": "060a1a4c", "metadata": {}, "outputs": [], @@ -977,7 +1013,7 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 52, "id": "cf3ce29e", "metadata": {}, "outputs": [ @@ -985,19 +1021,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:399: UserWarning: The channel auxins/0/sample.auxin0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", - " warnings.warn(f\"The channel {c} does not have an interface for enabling it. If needed, this can be done using the web interface.\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "sample rates: [107142.859375, 107142.859375, None]\n", - "Will record 1608 per row samples for 0.015000000001000002s!\n", - "3 row(s) will be recorded.\n", - "the following trigger settings will be used: {'trigger_input': '/dev3442/demods/0/sample.TrigIn1', 'edge': 'rising', 'trigger_count': 3, 'level': 0.5, 'delay': -0.001, 'post_delay': 0.001, 'endless': False, 'count': 3, 'other_settings': {'holdoff/time': 1e-08}}\n", - "MFLI returns a total record time of 0.003752s\n" + "\\\\Janeway\\User AG Bluhm\\Surrey\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:413: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + " warnings.warn(\n" ] } ], @@ -1015,7 +1040,7 @@ }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 53, "id": "1505ae0a", "metadata": {}, "outputs": [], @@ -1027,7 +1052,7 @@ }, { "cell_type": "code", - "execution_count": 98, + "execution_count": 54, "id": "8504fda1", "metadata": {}, "outputs": [], @@ -1049,7 +1074,7 @@ }, { "cell_type": "code", - "execution_count": 85, + "execution_count": 55, "id": "8ab20ee5", "metadata": {}, "outputs": [], @@ -1067,73 +1092,48 @@ }, { "cell_type": "code", - "execution_count": 99, - "id": "8d97dfac", - "metadata": { - "scrolled": true - }, + "execution_count": 56, + "id": "48582b63", + "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:740: UserWarning: Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter.\n", - " pass\n", - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:740: UserWarning: Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter.\n", - " pass\n" - ] - }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEFCAYAAAAbsWtZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAf4klEQVR4nO3da5Ad5X3n8e//dJ/r3EfDSIMEkmIEWE4WDAN2xbuprNd2wOUUpBKnIFQgCRUq2Ti7+yJVIevy7outrSJvsl6XLylCOcG7iVkS24H12qEMsZM4NoSREWAEQiOQYKSRZqSR5nru/d8Xp3U8EnM5zYzmIv0+VafO6T7P0/08c/tNP0+fbnN3REREkkitdwNERGTzUXiIiEhiCg8REUlM4SEiIokpPEREJLFwvRuwVvr6+nzXrl3r3QwRkU1l3759p9z9igvXXzbhsWvXLoaGhta7GSIim4qZHV1ovYatREQkMYWHiIgkpvAQEZHEFB4iIpKYwkNERBJblbOtzOw24H8CAfCIuz90wfsWv/9xYA74DXf/0VJ1zawX+D/ALuAI8KvufiZ+74+A+4E68B/c/anV6IessRcfh8P/+JPlyhycPgTlqZ+sqxXBUhBkG8tRDaIqBBmwYPXKpEIo9ED3VZAuNMpkO2DPRxqPTepvX3ibp388SgS0Zxq/7q8cn2JsZo50kCKwxv+PpVoNM8gGjTK1KKIWRZddmb6OHHv6O5itNNYV0iE/u6ePO99/1ep9Uw49Da8/DeWZxs+8RzB3GqZHGz+Tq/HzbCnId0Hv7p/8PAcZuObDsPcXV6UbKw4PMwuALwAfBUaA583sSXc/MK/Y7cCe+PEB4EvAB5ap+yDwjLs/ZGYPxst/aGZ7gbuA9wFXAk+b2bXuXl9pX2SNVebgzGGYGm0sz01AdXL92nM2DaeHIdcNqQz0vQeqpfVrzyooluu8dbbE2OQcQSrFbLXK2eK5d+vxY77qBcuXV5nRySrDY9O0ZQKCVIrtPQXef3UPq6pagjNHYeIwVOegPA2V2QXauEKTIUy8CfmeRqD0XA2V4vL1WrQaw1a3AsPu/oa7V4DHgDsuKHMH8BVveBboNrOBZereATwav34UuHPe+sfcvezubwLD8XZks7nlN+CnfxnKZ2H6GFSnlqtxkVWhPAmzJxvB8f57YO8n1rlNK3P3B3fxkeu3UqobJ2fmB4cspAbMVGBirs4VHTl+6f07uPuDu1Z3J3s/ATfdA8UJmDkOlbOsenAAUGtse3oEunfADXfDjb+6altfjfDYDrw9b3kkXtdKmaXqbnX3UYD4uT/B/gAwswfMbMjMhsbHx1vukKyhm++F0hmIKsBGuLdMBPUSbL9p0wfHObv62zlbrFGL1rslm4MDlQgGuvOrHxzn7P0E1GZhLQZMoipsfd+qBgesTnjYAusu/CuwWJlW6r6b/TVWuj/s7oPuPnjFFe/4dL1sBPv+NwzcDNleNsQFD1I5aNsGx34EB7653q1ZFRPTZa65Ik8hs94t2RxSQEfGGJ8q8tVnj1ycnRz4Juz4WSgMABfxG2NZKGyFkwdg/+OruunVCI8RYP5s0g7geItllqp7Mh7aIn4eS7A/2Qye/wv48V835jpyXZBuW+cGpSGdb0xCnjoML/zlpg+Qrz57hK+/MMJMsUJPLk13fr1btLGFQFsG2jIpRidLfOOFkdUPkAPfhB/9JUy+DUEImQKQXt19ABA2fp7TBTj7Nrz41VUNkNX4V+95YI+Z7QaO0ZjM/rULyjwJfMrMHqMxYT7p7qNmNr5E3SeB+4CH4ucn5q3/KzP7ExoT5nuAf1mFfshayxSg5z2NB2zMs63SuYv7NbjI8tmAq7tz7OjO6WyrFsosdLZVPhus7jclnYOenVDYsvZnW2VW778HW417mJvZx4HP0jjd9svu/t/N7HcA3P1P41N1Pw/cRuNU3d9096HF6sbrtwCPA1cDbwGfdPeJ+L1PA79FY37rP7n7t5dr4+DgoOvCiCIiyZjZPncffMf61QiPzUDhISKS3GLhoU+Yi4hIYgoPERFJTOEhIiKJKTxERCQxhYeIiCSm8BARkcQUHiIikpjCQ0REElN4iIhIYgoPERFJTOEhIiKJKTxERCQxhYeIiCSm8BARkcQUHiIikpjCQ0REElN4iIhIYgoPERFJTOEhIiKJKTxERCQxhYeIiCSm8BARkcQUHiIikpjCQ0REElN4iIhIYgoPERFJTOEhIiKJKTxERCQxhYeIiCSm8BARkcQUHiIikpjCQ0REElN4iIhIYgoPERFJbEXhYWa9ZvYdMzsUP/csUu42MztoZsNm9mAr9c3sj+LyB83sF+at/168bn/86F9JH0REJLmVHnk8CDzj7nuAZ+Ll85hZAHwBuB3YC9xtZnuXqh+/fxfwPuA24Ivxds65x91vjB9jK+yDiIgktNLwuAN4NH79KHDnAmVuBYbd/Q13rwCPxfWWqn8H8Ji7l939TWA43o6IiGwAKw2Pre4+ChA/LzSEtB14e97ySLxuqfpL1QH483jI6jNmZos1zsweMLMhMxsaHx9P0i8REVlCuFwBM3sa2LbAW59ucR8L/XH3FdS5x92PmVkH8DXg14GvLLQRd38YeBhgcHBwuX2KiEiLlg0Pd//IYu+Z2UkzG3D3UTMbABaafxgBrpq3vAM4Hr9erP6iddz9WPw8bWZ/RWM4a8HwEBGRi2Olw1ZPAvfFr+8DnligzPPAHjPbbWYZGhPhTy5T/0ngLjPLmtluYA/wL2YWmlkfgJmlgU8AP15hH0REJKFljzyW8RDwuJndD7wFfBLAzK4EHnH3j7t7zcw+BTwFBMCX3f2Vpeq7+ytm9jhwAKgBv+fudTNrA56KgyMAngb+bIV9EBGRhMz98pgKGBwc9KGhofVuhojIpmJm+9x98ML1+oS5iIgkpvAQEZHEFB4iIpKYwkNERBJTeIiISGIKDxERSUzhISIiiSk8REQkMYWHiIgkpvAQEZHEFB4iIpKYwkNERBJTeIiISGIKDxERSUzhISIiiSk8REQkMYWHiIgkpvAQEZHEFB4iIpKYwkNERBJTeIiISGIKDxERSUzhISIiiSk8REQkMYWHiIgkpvAQEZHEFB4iIpKYwkNERBJTeIiISGIKDxERSUzhISIiiSk8REQkMYWHiIgktqLwMLNeM/uOmR2Kn3sWKXebmR00s2Eze3C5+ma2xcy+a2YzZvb5C7Z1s5m9HG/rc2ZmK+mDiIgkt9IjjweBZ9x9D/BMvHweMwuALwC3A3uBu81s7zL1S8BngD9YYJ9fAh4A9sSP21bYBxERSWil4XEH8Gj8+lHgzgXK3AoMu/sb7l4BHovrLVrf3Wfd/fs0QqTJzAaATnf/obs78JVF9ikiIhfRSsNjq7uPAsTP/QuU2Q68PW95JF7Xav0LtzWyyLbewcweMLMhMxsaHx9fZtMiItKqcLkCZvY0sG2Btz7d4j4WmpPwFuuuaFvu/jDwMMDg4OC73aeIiFxg2fBw948s9p6ZnTSzAXcfjYeUxhYoNgJcNW95B3A8ft1K/Qu3tWORbYmIyBpZ6bDVk8B98ev7gCcWKPM8sMfMdptZBrgrrtdq/aZ4aGvazD4Yn2V173J1RERk9a00PB4CPmpmh4CPxsuY2ZVm9i0Ad68BnwKeAl4FHnf3V5aqH2/jCPAnwG+Y2ci8M7R+F3gEGAYOA99eYR9ERCQha5y0dOkbHBz0oaGh9W6GiMimYmb73H3wwvX6hLmIiCSm8BARkcQUHiIikpjCQ0REElN4iIhIYgoPERFJTOEhIiKJKTxERCQxhYeIiCSm8BARkcQUHiIikpjCQ0REElN4iIhIYgoPERFJTOEhIiKJKTxERCQxhYeIiCSm8BARkcQUHiIikpjCQ0REElN4iIhIYgoPERFJTOEhIiKJKTxERCQxhYeIiCSm8BARkcQUHiIikpjCQ0REElN4iIhIYgoPERFJTOEhIiKJKTxERCQxhYeIiCSm8BARkcRWFB5m1mtm3zGzQ/FzzyLlbjOzg2Y2bGYPLlffzLaY2XfNbMbMPn/Btr4Xb2t//OhfSR9ERCS5lR55PAg84+57gGfi5fOYWQB8Abgd2AvcbWZ7l6lfAj4D/MEi+73H3W+MH2Mr7IOIiCS00vC4A3g0fv0ocOcCZW4Fht39DXevAI/F9Rat7+6z7v59GiEiIiIbzErDY6u7jwLEzwsNIW0H3p63PBKva7X+Qv48HrL6jJnZYoXM7AEzGzKzofHx8RY3LSIiywmXK2BmTwPbFnjr0y3uY6E/7t5i3YXc4+7HzKwD+Brw68BXFiro7g8DDwMMDg6uZJ8iIjLPsuHh7h9Z7D0zO2lmA+4+amYDwELzDyPAVfOWdwDH49et1L+wPcfi52kz+ysaw2ILhoeIiFwcKx22ehK4L359H/DEAmWeB/aY2W4zywB3xfVard9kZqGZ9cWv08AngB+vqAciIpLYskcey3gIeNzM7gfeAj4JYGZXAo+4+8fdvWZmnwKeAgLgy+7+ylL1420cATqBjJndCXwMOAo8FQdHADwN/NkK+yAiIgmZ++UxFTA4OOhDQ0Pr3QwRkU3FzPa5++CF6/UJcxERSUzhISIiiSk8REQkMYWHiIgkpvAQEZHEFB4iIpKYwkNERBJb6YcEL1lHJo9wcOIgxWqRbe3beF/f+zg5e5LhM8OUaiV2dOzgvX3vpS3dtt5NFRFZcwqPRdSiGifnTnJ08ijPn3ieb7z+DUr1EpOlScJUyBWFK7h2/Fp6co37X5VqJbZ3bOembTcpUETkkqfwWMQ1PdcA8M03vsnJ2ZNUoyrmRle2i3yQZ2xujFdOvUJ7uh2A0EK2tm/l0MQhevO9QCNQevO93Lj1RvoLuuGhiFw6FB5LuKbnGnpyPYzMjDBdnQZgqjZFYAGBBZgboYV05jrpCDsYPjPMwYmD5MIcRuO9be3bOHzmMAPtA5RqJcyM7mw31225jl1du9a3gyIi75LCYwnDZ4b50JUfojvTzfjcOCfmTlCqlSjVS9SiGsWoSNnLzM7NcpKThKkQwwgIyKfzdKY7KU+VOTx5GIC0pUmn0vS39XPg9AF2d+1uBko2yHJt77Xs7du7TKtERNafLoy4iOEzw/zg+A84OnmU9kw71XqV1yZe49j0Meaqc5gZnZlOIoso18tU6hWqUZVirUhE1NxOOpVuBkouzNGT7SEX5KhEFar1KrkwRyaVoTffy0DbAH35Prpz3WSDLAC9uV6u77tew14isi4WuzCijjwWEaZCtha20pnuZLY6y8m5k7Rn2rmy7UomyhPUo3pzeKpWr0EEGcvQW+gllUo1AiWqUK6XKdVLVLxCsVLkTOUMoYWkLIW5kbY0WwpbSFmKYzPHKNVKZMMsHWEH2TBLX6GPH538EQPtA81AyYd5DXuJyLrSkUcLDpw6wOsTrzeXy/UyR6aOMDozymRpklpUY6o6RS2qkQ/zBBYwVZ1ipjQD1vhjn0vnqNQrVKIKxXqx+fqcC+dROrId9GR6qHmNcr1MOkjTEXaQz+T5qa6f4urOqymEBUBHJyJy8ejIYwX29u19x1zE/M+BQCNQRudGOTF9gtOl0wQEZFIZ6l5v/pGvR3VqtRohIYV0gfZsYzisWC9SrpepRlVKUakxj1KcZaw4RpgKwRtnc01lpuiv9zMajDJbmQWD9kw71/deTz2qr/nXRUQuXwqPd2lX1653DBuNzY3x2unXmChOUK6XcXeKtSJHpo4wNjdGylON+Q6vkE1lCS2kHtWJ6hGBB2SCDFvzW0lZitnabHMupRyVqXiFudIc46VxDs8cpj3dzrU91zK4bZBbB25loH1gfb4QInJZUnisov5C/zuGjmarsxw4dYBj08eagQJwdOooRyaPEBUj2traqEZVqlGVTJAh8oiQkGpUJWc5evO9hEFIuV5uzqVMViYp18vs6d2j4BCRNafwuMja0m3cMnALtwzcct76A6cO8PL4y7g7uTAHwJHpI7x++nWmylMUUgVq2Rpz9bnG2VoWEHlEpVahkCqws30nOzt2cmjiED3ZHgWIiKwphcc6WWgeZWxujP0n9zNRnGgGyonZExw8c5DJ0iTVepUtuS2EqZDubDeRR7w28RqAhq5EZE0pPDaQ/kI/H9v9sfPWzZ9HAejOddOT62GiNMFkaRKAnmwPQSpY8/aKyOVL4bHBLTSPIiKy3nQ/DxERSUzhISIiiSk8REQkMYWHiIgkpvAQEZHEFB4iIpKYwkNERBJTeIiISGIKDxERSUzhISIiiSk8REQksRWFh5n1mtl3zOxQ/NyzSLnbzOygmQ2b2YPL1Tezj5rZPjN7OX7+8Lw6N8frh83sc2ZmK+mDiIgkt9IjjweBZ9x9D/BMvHweMwuALwC3A3uBu81s7zL1TwG/6O4/A9wH/K95m/wS8ACwJ37ctsI+iIhIQisNjzuAR+PXjwJ3LlDmVmDY3d9w9wrwWFxv0fru/oK7H4/XvwLkzCxrZgNAp7v/0Bu35PvKIvsUEZGLaKXhsdXdRwHi54WuHb4deHve8ki8rtX6vwy84O7luN7IItsSEZE1suz9PMzsaWDbAm99usV9LDQn4S1VNHsf8MfAuTskJdqWmT1AY4iLq6++upVdiohIC5YND3f/yGLvmdlJMxtw99F4SGlsgWIjwFXzlncA54akFq1vZjuAbwD3uvvhedvasci2Fmr7w8DDAIODgy0FloiILG+lw1ZP0pjQJn5+YoEyzwN7zGy3mWWAu+J6i9Y3s27g/wF/5O7/fG5D8dDWtJl9MD7L6t5F9ikiIhfRSsPjIeCjZnYI+Gi8jJldaWbfAnD3GvAp4CngVeBxd39lqfpx+WuAz5jZ/vhxbj7kd4FHgGHgMPDtFfZBREQSssZJS5e+wcFBHxoaWu9miIhsKma2z90HL1yvT5iLiEhiCg8REUlM4SEiIokpPEREJDGFh4iIJKbwEBGRxBQeIiKSmMJDREQSU3iIiEhiy14YUURkvY3NjfHa6deYKE401xVrRSIi2sK25rp8mOe6Ldexq2vXOrTy8qLwEJENrx7VmShN8MLJF5iqTmEYJ2ZPMFOZIQxC2oJGgHRlu3h14lV2de4CoFQrkU/nuaH/BgXKKlN4iMiGN9A+wAcGPsDfv/X3fHfku6QsRdrSAAQEFDIFOsNOpqvTvDX9FmEQkkvliDyiK9vFG2ffYHfXbqARKGbGz1zxM+zt27vUbmUJCg8R2RQG2ge445o7MDMOnTnEmfIZ5qpzlCkzV5rjFKdIp9IYRooU+SBPZ7aTmtf43tvf4x9G/oFsKkvd6/Tl+zg6eZSXxl4CwMzIBll2dOzgvX3vpS3dtnRjROEhIpvD6Mwo05VperI9bC1sJZvKUsvVcHfKUZlyvUw1qlKqlah4hVJU4kz1DKGFpCxFihQBAd35bsJiyHPF5/j+se8TpkLCVEhvrpdtbdt4aewlCulCM1B6c71c33c9/YWF7pJ9+VJ4iMiGNzozynOjz3Hw9EHqUZ3eXC/uTqlaouY1Io+oRBXCKKQv20c+nadcL1OpV6h4hXK9TKleAmB2dpZRGyWwgJSnCC2kM9sJDqeLpxk6MURoIYV0gUK6QHeum2ePP8vOrp1kg2yzTdf2XntZD3spPERkwwtSAb25Xq7rva657sTsCd6cfJOJ0gT5ap5CWGCuNkc2yJILckRElKolUlGKrrCLjraOZqCU6iWq3jhKKXuZ2eIsJ4onCFMh5kZAQHu2nS3RFs6Wz3Lg1AFSIyl6sj0AtGXaeHn8ZV4ef7kZKKVaiT29e7h5283r8jVaawoPEdnw+gv97xg2uvD03XK9zJnyGUZnRhmbGyMsNybNzwVKISwAMFuexdwoBAW2dWzD3alEFeZqc1SjKsV6kYpXKJaKjJfGz5tHmSxPsiW3hXK9zMj0CM+NPkdPtoe618kFOQ6cPsChiUPkwhzQCJTtHdu5adtNl9w8isJDRDalhQJltjrLgVMHODZ9DGgESrFW5OTsSUamR/A5J9OWoRgVSVuadCpNOSpTr9Uhgqxl6c33kg7SFOvF5jxKuV6mFJUoRSXOzpwltLAZKKdLp+nOddMetPPi+IvsH9tPe7qdutfJprLs6NrBoYlD9OZ7m2d6DbQNbPp5FN2GVkQueQdOHeD1idcp18u4O7kwx5tTb3J08ihjM2PUvEbNa7g5AQG1qMZcbY5StTFPkk/nac+0M1ubpVxvTM7XohrFerG5jxQpgtRP5lHasm10hp2YGRERKWtM2OeCHNs7t7OzYycD7QPNQOnOdp/3AcdzR1ajM6PNNp8tn+X49HEmShNgkA/yAFSjKtWoSibIEFrjmKAr28VVnVeteJ5msdvQKjxE5LJ0ZPIIBycOcrZ0tvnHeXR2lOEzw5yYOUHNawDM1GaaRymlqMR0aZq61wlTIV25Lir1CuWoMZdS9Spz1Tmcxt9VwxoT86QILKCQLtCT6SFIBc2J/kwqQz7Is6WwhbZ0G+VaGQxyqRzFepGJ0gSzlVlqXqPqVar1KvWojuONsLIUtaiGR04qlSJlqeZRT3eum85sJ1tyWxhoH+BD2z/EDf03JPo6LRYeGrYSkcvSrq5d7/jU+djcGPtP7meiONGctzhbPstrE68xNjdGppKhu6Obs5VG4KQtTRAElGoliCCfytPf0U/k0U/O9ooqjXmUqEKxXOR0+XTz9GHzxunAfbk+6lGd6fo0pWqJyCPSQZpckKMaVZmuTFOulwFIpVKNoxmPfvKg8ezuRETN/hydPQrAb//0b7+r4FiKwkNEJNZf6Odjuz/2jvX7Tuw7byK8XC/z+sTrHJ87zkxphkJYaAZKPsg3Th2uV6jX64QWcmX+SsIgbIbJuVOHy16mXCszNTNFyhrXqXX35pHLgqLGEU2YagRQkArIWIZ0kG4e4QQWNIawUiHb27ezs2vnqgYHKDxERJZ187ab33EK7rl5lHPK9TJHpo4wOjPKZGmStKWZDqdxd9rCNupep1wrU61VCQjoy/aRS+eo1quU6qXG51QsJB2kCVMhOM0jiXMT9BGNo4uUpcAa75/j7phZc7ke1SmEBUILOTZ9jBfHXtSRh4jIetvbt/cdk8/n5lGK1WJzcv5M+QxHJ49yunSakJB8mKdOvTnZXalVqNaqjfmRIGhes6saVSnXynjk5DN5ujJdpCzFTG2GSq2y6JxHkAqIPCIf5OnKdtGR6WB0ZpR/PvbPAKsWIAoPEZFVstg8yrnPo5wLlGKtyJGpIxyfOQ4O7en25nBWtV5tBkN3tptUKj57K91GX6GPbJBtTqonPdsqnUqvWl8VHiIiF9FSn0d54+wbzTO9SrUSI9MjnJg9AQZbso0zpLpz3Rvy8yEKDxGRNdaWbuOWgVu4ZeCW9W7Ku6bb0IqISGIKDxERSUzhISIiiSk8REQkMYWHiIgkdtlcGNHMxoGj692OJfQBp9a7EatEfdl4LpV+gPqy1na6+xUXrrxswmOjM7Ohha5cuRmpLxvPpdIPUF82Cg1biYhIYgoPERFJTOGxcTy83g1YRerLxnOp9APUlw1Bcx4iIpKYjjxERCQxhYeIiCSm8FhjZnabmR00s2Eze3CJcreYWd3MfmUt25dEK30xs583s/1m9oqZ/cNat7EVy/XDzLrM7P+a2YtxP35zPdrZCjP7spmNmdmPF3nfzOxzcV9fMrOb1rqNrWihH/fE7X/JzH5gZqt7j9VVtFxf5pXb8L/z53F3PdboAQTAYeCngAzwIrB3kXJ/D3wL+JX1bve77QvQDRwAro6X+9e73e+yH/8Z+OP49RXABJBZ77Yv0p+fA24CfrzI+x8Hvg0Y8EHgufVu87vsx88CPfHr2zdqP1rpS1xmw//OX/jQkcfauhUYdvc33L0CPAbcsUC53we+BoytZeMSaqUvvwZ83d3fAnD3jdifVvrhQIc1bhDdTiM8amvbzNa4+z/SaN9i7gC+4g3PAt1mNrA2rWvdcv1w9x+4+5l48Vlgx5o07F1o4XsCm+N3/jwKj7W1HXh73vJIvK7JzLYDvwT86Rq2691Yti/AtUCPmX3PzPaZ2b1r1rrWtdKPzwPvBY4DLwP/0d2jtWneqmulv5vN/TSOpjalTfQ7fx7dSXBt2QLrLjxX+rPAH7p7vfGP7obVSl9C4Gbg3wF54Idm9qy7v36xG5dAK/34BWA/8GHgPcB3zOyf3H3qIrftYmilv5uGmf1bGuHxr9e7LSvwWTbH7/x5FB5rawS4at7yDhr/zc43CDwW/xD1AR83s5q7/+2atLB1rfRlBDjl7rPArJn9I3ADsJHCo5V+/CbwkDcGp4fN7E3geuBf1qaJq6qV/m4KZvavgEeA29399Hq3ZwU2y+/8eTRstbaeB/aY2W4zywB3AU/OL+Duu919l7vvAv4G+Pcb9Ido2b4ATwD/xsxCMysAHwBeXeN2LqeVfrxF4+gJM9sKXAe8saatXD1PAvfGZ119EJh099H1blRSZnY18HXg1zfYkWxim+h3/jw68lhD7l4zs08BT9E4u+LL7v6Kmf1O/P6mGfNspS/u/qqZ/R3wEhABj7j7kqcrrrUWvyf/DfgLM3uZxrDPH7r7hryMtpl9Ffh5oM/MRoD/CqSh2Zdv0TjjahiYo3FUteG00I//AmwBvhj/x17zDXp12hb6sinp8iQiIpKYhq1ERCQxhYeIiCSm8BARkcQUHiIikpjCQ0TkEtTqBRnjsv8jvoDpfjN73czOLltHZ1uJiFx6zOzngBka1zL76QT1fh94v7v/1lLldOQhInIJWuiCjGb2HjP7u/hac/9kZtcvUPVu4KvLbV8fEhQRuXw8DPyOux8ysw8AX6RxzTYAzGwnsJvG5eGXpPAQEbkMmFk7jfug/PW8CzBmLyh2F/A37l5fbnsKDxGRy0MKOOvuNy5R5i7g91rdmIiIXOLiWwi8aWafhOYtiZu37zWz64Ae4IetbE/hISJyCYovyPhD4DozGzGz+4F7gPvN7EXgFc6/a+bdwGPe4im4OlVXREQS05GHiIgkpvAQEZHEFB4iIpKYwkNERBJTeIiISGIKDxERSUzhISIiif1/q5UbCdTdCDoAAAAASUVORK5CYII=\n", "text/plain": [ - "
" + "MFLIProgram(default_channels=None, channel_mapping={'R': {'demods/0/sample.R'}, 'X': {'demods/0/sample.X'}, 'Y': {'demods/0/sample.Y'}, 'A': {'auxins/0/sample.AuxIn0.avg'}, 'many': {'demods/0/sample.Y', 'demods/0/sample.R', 'demods/0/sample.X', 'auxins/0/sample.AuxIn0.avg'}}, windows=None, trigger_settings=None, other_settings={}, operations=None)" ] }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "data = my_lockin.measure_program(return_raw=False)#(wait=False, fail_if_incomplete=False)\n", - "if data is not None:\n", - " for d in data:\n", - " plot_windows(d)\n", - "else:\n", - " print(\"RETURNED NONE\")" - ] - }, - { - "cell_type": "markdown", - "id": "1ec2e091", - "metadata": {}, - "source": [ - "and here a different measurement, left in this notebook." + "my_lockin.default_program" ] }, { "cell_type": "code", - "execution_count": 111, - "id": "066a4fe1", - "metadata": {}, + "execution_count": 57, + "id": "8d97dfac", + "metadata": { + "scrolled": true + }, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:684: UserWarning: No data has been recorded!\n", - " warnings.warn(f\"No data has been recorded!\")\n", - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:596: UserWarning: The received data for channel auxins/0/sample.auxin0.avg is empty.\n", - " warnings.warn(f\"The received data for channel {_cn} is empty.\")\n", - "z:\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:596: UserWarning: The received data for channel auxins/0/sample.auxin0.avg is empty.\n", - " warnings.warn(f\"The received data for channel {_cn} is empty.\")\n" - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1145,7 +1145,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1157,7 +1157,7 @@ } ], "source": [ - "data = my_lockin.measure_program(return_raw=False)#(wait=False, fail_if_incomplete=False)\n", + "data = my_lockin.measure_program(wait=False, return_raw=False)#(wait=False, fail_if_incomplete=False)\n", "if data is not None:\n", " for d in data:\n", " plot_windows(d)\n", @@ -1167,226 +1167,19 @@ }, { "cell_type": "code", - "execution_count": 108, + "execution_count": 58, "id": "e7af816c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'/dev3442/auxins/0/sample.auxin0.avg': [\n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664887609699785]\n", - " createdtimestamp: [1166080844523]\n", - " changedtimestamp: [1167529609323]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 004 14:46:49.6996\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1608]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan],\n", - " [nan, nan, nan, ..., nan, nan, nan]])\n", - " Coordinates:\n", - " time (row, col) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664887657586630]\n", - " createdtimestamp: [1168331979003]\n", - " changedtimestamp: [1180144016443]\n", - " flags: [313]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 005 14:47:37.5862\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1608]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.r': [\n", - " array([[1.38888485e-07, 1.43719805e-07, 1.48582047e-07, ...,\n", - " 4.34784579e-07, 4.33234794e-07, 4.31670555e-07],\n", - " [4.04857345e-07, 4.03119455e-07, 4.01376717e-07, ...,\n", - " 4.97918708e-07, 5.00165983e-07, 5.02359520e-07],\n", - " [4.41924624e-07, 4.39022641e-07, 4.36096277e-07, ...,\n", - " 7.97933342e-07, 7.96385363e-07, 7.94804775e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.943e+13 1.943e+13 ... 1.946e+13 1.946e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664887609699917]\n", - " createdtimestamp: [1166080844523]\n", - " changedtimestamp: [1167529609323]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 004 14:46:49.6996\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1608]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[3.63043354e-07, 3.63724650e-07, 3.64442278e-07, ...,\n", - " 1.84079775e-07, 1.83911762e-07, 1.83743967e-07],\n", - " [3.83388020e-07, 3.82172869e-07, 3.80939033e-07, ...,\n", - " 4.64023112e-07, 4.63896600e-07, 4.63726540e-07],\n", - " [6.12628005e-07, 6.12437061e-07, 6.12181524e-07, ...,\n", - " 5.86469886e-07, 5.87969943e-07, 5.89465841e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.947e+13 1.947e+13 ... 1.967e+13 1.967e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664887657586707]\n", - " createdtimestamp: [1168331979003]\n", - " changedtimestamp: [1180144016443]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 005 14:47:37.5862\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1608]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]],\n", - " '/dev3442/demods/0/sample.x': [\n", - " array([[-1.32408364e-07, -1.37151777e-07, -1.41934653e-07, ...,\n", - " -3.26519959e-08, -3.30352718e-08, -3.34245270e-08],\n", - " [ 4.01130200e-07, 3.99142667e-07, 3.97138989e-07, ...,\n", - " -4.93793274e-07, -4.95846580e-07, -4.97835310e-07],\n", - " [ 2.59233217e-07, 2.56886923e-07, 2.54549598e-07, ...,\n", - " -7.81379937e-07, -7.80011266e-07, -7.78618677e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.943e+13 1.943e+13 ... 1.946e+13 1.946e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664887609699837]\n", - " createdtimestamp: [1166080844523]\n", - " changedtimestamp: [1167529609323]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 004 14:46:49.6996\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [1608]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan],\n", - " \n", - " array([[ 1.51871723e-07, 1.49524831e-07, 1.47228763e-07, ...,\n", - " 9.08997651e-08, 9.05643240e-08, 9.01774605e-08],\n", - " [-2.19322299e-07, -2.20265839e-07, -2.21161545e-07, ...,\n", - " -3.30884282e-07, -3.29631609e-07, -3.28349638e-07],\n", - " [-5.72672766e-07, -5.73008805e-07, -5.73258741e-07, ...,\n", - " 5.86422265e-07, 5.87938626e-07, 5.89447214e-07]])\n", - " Coordinates:\n", - " time (row, col) float64 1.947e+13 1.947e+13 ... 1.967e+13 1.967e+13\n", - " Dimensions without coordinates: row, col\n", - " Attributes:\n", - " systemtime: [1664887657586670]\n", - " createdtimestamp: [1168331979003]\n", - " changedtimestamp: [1180144016443]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 005 14:47:37.5862\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [1608]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [9.33333333e-06]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]]}" + "{'/dev4797/auxins/0/sample.auxin0.avg': [],\n", + " '/dev4797/demods/0/sample.r': [],\n", + " '/dev4797/demods/0/sample.x': []}" ] }, - "execution_count": 108, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" } @@ -1413,7 +1206,7 @@ }, { "cell_type": "code", - "execution_count": 116, + "execution_count": 59, "id": "1ac65d7f", "metadata": {}, "outputs": [], @@ -1424,7 +1217,7 @@ }, { "cell_type": "code", - "execution_count": 117, + "execution_count": 60, "id": "fe7ace96", "metadata": { "scrolled": true @@ -1437,7 +1230,7 @@ }, { "cell_type": "code", - "execution_count": 118, + "execution_count": 61, "id": "be1c9ade", "metadata": {}, "outputs": [], @@ -1447,36 +1240,23 @@ " edge=\"rising\",\n", " trigger_count=3,\n", " level=.5,\n", - " count=3,\n", " other_settings={\"holdoff/time\": 1e-3}\n", " )" ] }, { "cell_type": "code", - "execution_count": 119, + "execution_count": 62, "id": "58dee40c", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "sample rates: [107142.859375]\n", - "Will record 1608 per row samples for 0.015000000001000002s!\n", - "3 row(s) will be recorded.\n", - "the following trigger settings will be used: {'trigger_input': '/dev3442/demods/0/sample.TrigIn1', 'edge': 'rising', 'trigger_count': 3, 'level': 0.5, 'delay': -0.001, 'post_delay': 0.001, 'endless': False, 'count': 3, 'other_settings': {'holdoff/time': 0.001}}\n", - "MFLI returns a duration of 0.01s\n" - ] - } - ], + "outputs": [], "source": [ "setup.run_program(\"test2\")" ] }, { "cell_type": "code", - "execution_count": 129, + "execution_count": 63, "id": "dc4dc54f", "metadata": {}, "outputs": [], @@ -1490,13 +1270,13 @@ }, { "cell_type": "code", - "execution_count": 130, + "execution_count": 64, "id": "d206d097", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1508,7 +1288,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1520,7 +1300,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1597,7 +1377,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.11" + "version": "3.10.4" } }, "nbformat": 4, diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index 211bede3f..1240a68bf 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -67,7 +67,53 @@ def required_channels(self) -> Set[str]: return channels def merge(self, other: 'MFLIProgram') -> 'MFLIProgram': - raise NotImplementedError() + + new_program = MFLIProgram() + + new_program.default_channels = self.default_channels + + if new_program.default_channels is None: + new_program.default_channels = other.default_channels + elif isinstance(new_program.default_channels, set): + new_program.default_channels = new_program.default_channels.union(other.default_channels) + + new_program.channel_mapping = {**self.channel_mapping} + if other.channel_mapping is not None: + for k, v in other.channel_mapping.items(): + new_program.channel_mapping[k].update(v) + + if self.windows is not None or other.windows is not None: + new_program.windows = {} + + def add_to_windows(name, begins, lengths): + if name not in new_program.windows: + new_program.windows[name] = [[], []] + for b, l in zip(begins, lengths): + if b not in new_program.windows[name][0]: + new_program.windows[name][0].append(b) + new_program.windows[name][1].append(l) + + if self.windows is not None: + for wn, v in self.windows.items(): + add_to_windows(wn, v[0], v[1]) + if other.windows is not None: + for wn, v in other.windows.items(): + add_to_windows(wn, v[0], v[1]) + + for k, v in new_program.windows.items(): + new_program.windows[k][0] = np.array(new_program.windows[k][0]) + new_program.windows[k][1] = np.array(new_program.windows[k][1]) + + if other.trigger_settings is not None: + new_program.trigger_settings = other.trigger_settings + + new_program.other_settings.update(self.other_settings) + new_program.other_settings.update(other.other_settings) + + if other.operations is not None: + new_program.operations = other.operations + + return new_program class MFLIDAQ(DAC): @@ -76,7 +122,7 @@ class MFLIDAQ(DAC): def __init__(self, api_session: zhinst_core.ziDAQServer, - device, + device_props: Dict, reset: bool = False, timeout: float = 20) -> None: """ @@ -84,9 +130,9 @@ def __init__(self, :param timeout: Timeout in seconds for uploading """ self.api_session = api_session - self.device = device + self.device_props = device_props self.default_timeout = timeout - self.serial = device.serial + self.serial = device_props["deviceid"] self.daq = None self._init_daq_module() @@ -108,11 +154,7 @@ def __init__(self, self._armed_program: Optional[MFLIProgram] = None @classmethod - def connect_to(cls, device_serial: str = None, - device_interface: str = '1GbE', - data_server_addr: str = 'localhost', - data_server_port: int = 8004, - api_level_number: int = 6, **init_kwargs): + def connect_to(cls, device_serial: str = None, **init_kwargs): """ :param device_serial: Device serial that uniquely identifies this device to the LabOne data server :param device_interface: Either '1GbE' for ethernet or 'USB' @@ -120,9 +162,11 @@ def connect_to(cls, device_serial: str = None, :param data_server_port: Data server port. Default: 8004 for HDAWG, MF and UHF devices :param api_level_number: Version of API to use for the session, higher number, newer. Default: 6 most recent """ - api_session = zhinst_core.ziDAQServer(data_server_addr, data_server_port, api_level_number) - device = api_session.connectDevice(device_serial, device_interface) - cls(api_session, device, **init_kwargs) + discovery = zhinst_core.ziDiscovery() + device_id = discovery.find(device_serial) + device_props = discovery.get(device_id) + api_session = zhinst_core.ziDAQServer(device_props['serveraddress'], device_props['serverport'], device_props['apilevel']) + return cls(api_session, device_props, **init_kwargs) def _init_daq_module(self): self.daq = self.api_session.dataAcquisitionModule() @@ -167,6 +211,8 @@ def register_measurement_channel(self, program_name: Union[str, None] = None, wi if window_name is None: program.default_channels = set(channel_path) else: + if program.channel_mapping is None: + program.channel_mapping = dict() program.channel_mapping[window_name] = set(channel_path) def register_measurement_windows(self, program_name: str, windows: Dict[str, Tuple[np.ndarray, @@ -433,7 +479,7 @@ def arm_program(self, program_name: str, force: Union[bool, None] = None) -> Non else: self.daq.set("type", 1) - self.daq.set("triggernode", ts.trigger_input) + self.daq.set("triggernode", f"/{self.serial}/{ts.trigger_input}") edge_key = ["rising", "falling", "both"].index(ts.edge) self.daq.set("edge", edge_key) @@ -441,7 +487,7 @@ def arm_program(self, program_name: str, force: Union[bool, None] = None) -> Non if "trigin" in ts.trigger_input.lower(): _trigger_id = int(ts.trigger_input.split("TrigIn")[-1]) assert _trigger_id in [1, 2] - self.api_session.setDouble(f'/{self.serial}/triggers/in/{_trigger_id}/level', ts.level); + self.api_session.setDouble(f'/{self.serial}/triggers/in/{_trigger_id-1}/level', ts.level); else: self.daq.set("level", ts.level) @@ -459,7 +505,7 @@ def arm_program(self, program_name: str, force: Union[bool, None] = None) -> Non # set the buffer size according to the largest measurement window # TODO one might be able to implement this a bit more cleverly - measurement_duration = np.max(list(self.programs[program_name]["windows_from_start_max"].values())) + measurement_duration = self.programs[program_name].get_minimal_duration() measurement_duration += (ts.post_delay + -1 * ts.delay) * 1e9 larges_number_of_samples = max_sample_rate / 10 ** 9 * measurement_duration larges_number_of_samples = np.ceil(larges_number_of_samples) @@ -523,7 +569,7 @@ def clear(self) -> None: def _parse_data(self, recorded_data: Mapping[str, List[xr.DataArray]], - program_name: str, + program: MFLIProgram, fail_on_empty: bool = True) -> Mapping[str, Mapping[str, List[xr.DataArray]]]: """ This function parses the recorded data and extracts the measurement masks and applies optional operations """ @@ -547,10 +593,10 @@ def _parse_data(self, # TODO this might be more elegantly implemented or handled using yields! shot_index = 0 # TODO make this more flexible to not lose things - for window_name, (begins, lengths) in self.programs[program_name].windows.items(): + for window_name, (begins, lengths) in program.windows.items(): data_by_channel = {} - # _wind = self.programs[program_name]["windows"][window_name] - for ci, _cn in enumerate(self._get_channels_for_window(program_name, window_name)): + # _wind = program["windows"][window_name] + for ci, _cn in enumerate(program.channel_mapping[window_name]): cn = f"/{self.serial}/{_cn}".lower() if len(recorded_data[cn]) <= shot_index: @@ -642,6 +688,9 @@ def get_mfli_data(self, data = self.daq.read() self.daq_read_return.update(data) + if data is None or len(data) == 0: + warnings.warn(f"Reading form the data acquisition module did not work.") + clockbase = self.api_session.getDouble(f'/{self.serial}/clockbase') # go through the returned object and extract the data of interest @@ -649,7 +698,7 @@ def get_mfli_data(self, recorded_data = {} for device_name, device_data in data.items(): - if device_name == self.serial: + if device_name == self.serial.lower(): for input_name, input_data in device_data.items(): for signal_name, signal_data in input_data.items(): for final_level_name, final_level_data in signal_data.items(): @@ -726,8 +775,11 @@ def get_mfli_data(self, # Then we have nothing to process return None - channels_to_measure = self._get_channels_for_window(self.currently_set_program, None) - channels_to_measure = [f"/{self.serial}/{c}" for c in channels_to_measure] + channels_to_measure = [] + for k, v in program.windows.items(): + channels_to_measure.extend(program.channel_mapping[k]) + channels_to_measure = list(np.unique(channels_to_measure)) + channels_to_measure = [f"/{self.serial}/{c}".lower() for c in channels_to_measure] things_to_remove = {} @@ -735,7 +787,7 @@ def get_mfli_data(self, for ts in all_ts: contained = [k for k, v in creation_ts.items() if ts in v] - if all([(c in contained) for c in channels_to_measure]): + if all([(c.lower() in contained) for c in channels_to_measure]): # then we have all measurement for that shot that_shot = {} _indexs = [creation_ts[c].index(ts) for c in channels_to_measure] @@ -746,8 +798,7 @@ def get_mfli_data(self, _the_warning_string = f"Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter." try: - that_shot_parsed = self._parse_data(that_shot, self.currently_set_program, - fail_on_empty=fail_on_empty) + that_shot_parsed = self._parse_data(that_shot, program, fail_on_empty=fail_on_empty) except IndexError as e: traceback.print_exc() warnings.warn(_the_warning_string) @@ -778,6 +829,7 @@ def get_mfli_data(self, if not return_raw: if len(results) == 0: + raise ValueError() return None return results From d2d14dd4f648b7b57c5c368107b35a5120175402 Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Thu, 24 Aug 2023 10:12:09 +0200 Subject: [PATCH 23/25] added missing updates within the MFLIProgram merge method --- qupulse/hardware/dacs/mfli.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index 1240a68bf..68743aa3b 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -71,7 +71,6 @@ def merge(self, other: 'MFLIProgram') -> 'MFLIProgram': new_program = MFLIProgram() new_program.default_channels = self.default_channels - if new_program.default_channels is None: new_program.default_channels = other.default_channels elif isinstance(new_program.default_channels, set): @@ -104,12 +103,16 @@ def add_to_windows(name, begins, lengths): new_program.windows[k][0] = np.array(new_program.windows[k][0]) new_program.windows[k][1] = np.array(new_program.windows[k][1]) + if self.trigger_settings is not None: + new_program.trigger_settings = self.trigger_settings if other.trigger_settings is not None: new_program.trigger_settings = other.trigger_settings new_program.other_settings.update(self.other_settings) new_program.other_settings.update(other.other_settings) + if self.operations is not None: + new_program.operations = self.operations if other.operations is not None: new_program.operations = other.operations From 0d749c2c1c3e5782408936c8de6eab88d28d1dec Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Thu, 24 Aug 2023 10:32:14 +0200 Subject: [PATCH 24/25] used interface to add post processing callbacks to average for each window or crop the measurements to these windows --- .../zurich_instruments_lockin_mfli_daq.ipynb | 516 +++++++++++++++--- qupulse/hardware/dacs/mfli.py | 201 ++++--- 2 files changed, 564 insertions(+), 153 deletions(-) diff --git a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb index be6775a48..ca2d5ddc2 100644 --- a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb +++ b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb @@ -75,13 +75,13 @@ "metadata": {}, "outputs": [], "source": [ - "from qupulse.hardware.dacs.mfli import MFLIDAQ" + "from qupulse.hardware.dacs.mfli import MFLIDAQ, postprocessing_crop_windows, postprocessing_average_within_windows" ] }, { "cell_type": "code", "execution_count": 7, - "id": "18800300", + "id": "5a7826ef", "metadata": {}, "outputs": [], "source": [ @@ -103,7 +103,7 @@ { "cell_type": "code", "execution_count": null, - "id": "1ee1dbe4", + "id": "a9fe5e61", "metadata": {}, "outputs": [], "source": [] @@ -128,7 +128,7 @@ }, { "cell_type": "markdown", - "id": "c9fb333b", + "id": "6724c4a8", "metadata": {}, "source": [ "And the sample rate and aux outputs are configured" @@ -137,7 +137,7 @@ { "cell_type": "code", "execution_count": 10, - "id": "9bcd679c", + "id": "faaf68cc", "metadata": {}, "outputs": [], "source": [ @@ -147,7 +147,7 @@ { "cell_type": "code", "execution_count": 11, - "id": "e1bad934", + "id": "3b311267", "metadata": {}, "outputs": [], "source": [ @@ -345,7 +345,7 @@ { "cell_type": "code", "execution_count": 20, - "id": "ecdc3bc7", + "id": "3b91d286", "metadata": {}, "outputs": [ { @@ -475,7 +475,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'A', 'R', 'T'}\n", + "{'T', 'R', 'A'}\n", "[]\n", "set()\n" ] @@ -497,7 +497,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\Surrey\\AppData\\Local\\Temp\\ipykernel_12824\\4247546520.py:1: DeprecationWarning: This is only a hack until https://github.com/qutech/qupulse/issues/578 is resolved. Do not call this method directly\n", + "C:\\Users\\Surrey\\AppData\\Local\\Temp\\ipykernel_13892\\4247546520.py:1: DeprecationWarning: This is only a hack until https://github.com/qutech/qupulse/issues/578 is resolved. Do not call this method directly\n", " combined_pulse.get_measurement_windows(parameters={\"dt\": 1e8}, measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"T\"})\n" ] }, @@ -528,7 +528,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -586,7 +586,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -748,7 +748,7 @@ { "cell_type": "code", "execution_count": 39, - "id": "05b61c6b", + "id": "1fd061c4", "metadata": {}, "outputs": [ { @@ -933,6 +933,17 @@ { "cell_type": "code", "execution_count": 49, + "id": "b10655d1", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.register_operations(\"test\", postprocessing_crop_windows)\n", + "# my_lockin.register_operations(\"test\", postprocessing_average_within_windows)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, "id": "b037496c", "metadata": {}, "outputs": [], @@ -950,7 +961,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 51, "id": "d38e253f", "metadata": { "scrolled": false @@ -976,7 +987,7 @@ " 1500000., 3000000.]))}, trigger_settings=None, other_settings={}, operations=None)" ] }, - "execution_count": 50, + "execution_count": 51, "metadata": {}, "output_type": "execute_result" } @@ -995,7 +1006,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 52, "id": "060a1a4c", "metadata": {}, "outputs": [], @@ -1013,7 +1024,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 53, "id": "cf3ce29e", "metadata": {}, "outputs": [ @@ -1021,7 +1032,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "\\\\Janeway\\User AG Bluhm\\Surrey\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:413: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + "\\\\Janeway\\User AG Bluhm\\Surrey\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:551: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", " warnings.warn(\n" ] } @@ -1040,7 +1051,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 54, "id": "1505ae0a", "metadata": {}, "outputs": [], @@ -1052,7 +1063,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 55, "id": "8504fda1", "metadata": {}, "outputs": [], @@ -1074,7 +1085,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 56, "id": "8ab20ee5", "metadata": {}, "outputs": [], @@ -1092,28 +1103,7 @@ }, { "cell_type": "code", - "execution_count": 56, - "id": "48582b63", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "MFLIProgram(default_channels=None, channel_mapping={'R': {'demods/0/sample.R'}, 'X': {'demods/0/sample.X'}, 'Y': {'demods/0/sample.Y'}, 'A': {'auxins/0/sample.AuxIn0.avg'}, 'many': {'demods/0/sample.Y', 'demods/0/sample.R', 'demods/0/sample.X', 'auxins/0/sample.AuxIn0.avg'}}, windows=None, trigger_settings=None, other_settings={}, operations=None)" - ] - }, - "execution_count": 56, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.default_program" - ] - }, - { - "cell_type": "code", - "execution_count": 57, + "execution_count": 58, "id": "8d97dfac", "metadata": { "scrolled": true @@ -1121,7 +1111,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1133,7 +1123,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1145,7 +1135,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZYAAAEFCAYAAADACsF7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA3uElEQVR4nO3de3hd1Xng/+977rpfLVuWbEvGNkgm4WINEEqAEgiGJwFSkjwmmYRk3HpKQjPl16Q4k0mbyXQ6pM1vQklIO4bQkKQxUNIG8xsIAUNIIBgwYMB3C/kmW7Yl63Z0Off398feko/MkXTsc2xJ9vt5nvOcfVlr7bXss/Wetdfe64iqYowxxuSLZ6orYIwx5sxigcUYY0xeWWAxxhiTVxZYjDHG5JUFFmOMMXnlm+oKTLXq6mptaGiY6moYY8yM8sYbb3Sp6qxM+876wNLQ0MDGjRunuhrGGDOjiMje8fbZpTBjjDF5ZYHFGGNMXllgMcYYk1dn/RhLJvF4nPb2diKRyFRXZUKhUIj6+nr8fv9UV8UYY0ZZYMmgvb2dkpISGhoaEJGprk5GqsrRo0dpb2+nsbFxqqtjjDGj7FJYBpFIhKqqqmkbVABEhKqqqmnfqzLGTDPRMET6xm6L9Dnb88QCyzimc1AZMRPqaIzJg0zBoO+A80qXTYDQFMSGjpUX6XPWNZW36lpgMTPXiX7zOg3f1GaigWiC/kh8zLb+SJyBaCKntCYHx39WNQXhQ8cCSaQPYoMQG3C2Rfqc9/BhJ+3I5zrSB/0dY8sKlUEyBr/6r7DrOSeoBAqd7XligWUa2r9/P42NjXR3dwPQ09NDY2Mje/eO+zzSmef4EysahiPbx35D69wFe14Ze7J1tTonUqay0r+pjZyIA0dguHds2t79Y0/G9JP0DAxCKVWGY8nRgNEfiTMcS5Jyf6tpJJgMRBP0DccYjiU50DvEQDTBgd4husLR0bTjOdXBK72O6e1I3w5wuD/Cgd6hMXkP9A5xuH+aXVLu73A+yyOfweiA8/l//m/gnceh6z3wF0CgGNrfhGf+G3RsAtTJd/Bt5/MdG4JUwtnWudMpq+8A7H8NNv0MjrYeO2YeP9s2eD8NzZs3jzvuuIPVq1ezZs0aVq9ezapVq1iwYMFUV+30ifQ738bA+SY13Aud28EXcrZpytnffxB69wEpqHRvYggUOcEhEYFkHDw+56QpmeOcUOu/BUv/CM65BioanP29+0E8zje+xLBzMgaKIVTqlOPxO98QgyUwq+T0/3ucAgPRBClVSkPOXYVtnQMMRhPUlhVQXRIc3T4SeBKpFNF4isNDEcKRBC+/18XypbUUBb14ROiPxPGIUBx8/5+VkTIASkP+0eBVEPC+L204EmfQDQTFAR8DsQRH+iMUBX0Zyz6+jj6Ph/7hGP3DCcoK/fg8ntHjJFIpegbjwBB15YUc6B2iZzBORdGxOysP90dIpFLUlReObjvQO4TP42F2aegk/qVPQDTsfLb9BdC3Hx79PMy7BOqWwbv/CtufhF3PwKVfcj6//hA8czf0H4DdL0LTTc7n+NDbcMFnYP5lznpiGLp3Q6TX+SzveAq8ATjnIxDtd8+P2XlrhgWWaequu+5i2bJl3Hvvvbz00kt8//vfn+oqnX7RAdj1E5j/ByA437Q2/QxK6+HARrjsyzDYCa/9H0Bh3ofgD74C4SMwdBR8ARjuA1/Q6fo//kUIdzjLr/4TlDdAKgXxIaec8CGYewFEwk75W5+AgUNQPAeuvweKq6C4xglCHh+U1k7xP1Bu0v/Yt3UO8pkHXqW6OMhDX2gZDSrgBIJEMsUTmzpYUFnIy61d7Dg8wKu7u3lxRyf3/NEH6egdprTAT0qVlCoekdGgNRJEeodivL57gKa5pRQHfSRSKTzie1+AKwr6ONwf4YfrtvBOex//6xNLCfh81KT9UU8PYiO9kYKAl9fa+ljz2zZmlwV56t1DPPInl3Fubclo2WUFAQYiCZ56pwO/10Pz3FJ8HqGsoGi07N6hGH3DTq/H5/HQNxyjZzBOfWVBxuPnVX+H80e+sgFe+h7s+Z0TMBZf7wSUUDkM9zif+XcegZ7dkEpCw1Ww50V45ftO4EjFYfdvIVgGV33dORee/hrMOheu+Sa0/QaKZztfzgJFQH5/SdgCyyT++5Nb2HqwP69lNs8t5a8/vnTCNH6/n7//+79n+fLl/PrXvyYQCOS1DtNesBgOHYVffxNmnw+X3gFv/RQ6t8GRrU6aF/7H2Dz7X4GXgYoF0LMXjmxxLgV43RMt5V5KWXAl7P0d/OpuKKuDwaNO4BrugQ99BYa7nQAG4C+E8EF49Ydw64POtqGjUFh1Ov4VTqmRP/bbOiJ8+edvEkuk2Nc9xI5DYWpKQ2OCwxObDvK3T23nA3WlvHvAOR+Kg15aOwe541/e5J/+48UUBr0Mx5IMRZMkNYVXPLyzv4dEEsoL/fxmRyf3rt/F+XNLuePqc6ivKKQk5CcciRONp3jvSJjSUIBZpUF6BuP88q0DpBT++eW9/D8fXcJwLEnPUJT+oQSFAR+FQS8pVQajCfZ0DdIZjnL3L95lOJ5EcP5UPvr6Pu5y8470WvqHY/ztU9sB+PZNTVy0oIqDvUOoOoHE7/Xg8wgPvbSbH720hy9evoA/WFSNR5weTH8kPmkP6qT5C2DgMPzbHU5QAaclu37lLEb6gRQMHnFecCyQjEjFoWiW82Up0gO/vhv8Rc72w5th2//nfMaHu+HtR6D5Zpiz1OnZ5EleShKR5SKyQ0RaRWR1hv0iIve5+98RkYsnyysilSLyrIjsct8r0vZ93U2/Q0SuT9u+TETedffdJzP8tqmnn36a2tpaNm/ePNVVOf1CZe5lL4XD78K6LzlBpcD9gy4enGiA88e/crGzvP8V55vc/lecLr4mnEtZqQT4CpzX3t865SaGnWvMkV4nqAC8cp8bVMS57BV3r8fv3wC/v88JKt4AFJSfrn+JUyaRShFPKv/72Z0U+L381cebEODFnZ28297L5vZejvRH2HKwj+8+swOvwOYD/XgAj8BANEnQKxwOR/jbp7bT2e+MtezuCvPvbx7gT3+2kc899Drf+OW7vNzayQ9/00pRwMvmg/388q0DtPcO0Xo4TM9gjF2H+3lnfy/3v7CL944M8I8vto5+h3568yE27evhMw9s4IsPbaRnKEY4GmdP1yDv7O9hc3sfr7Yd5WuPv0PI72FWcQAFSkM+fr31MNsO9nOwd4jO/ijhSJz//uQ2FCfw/N0zO2nvHuTeZ3fxwxda2XW4n96hGD6vh1++dRCAX246SDSRpK1zgDW/fY89XYOn7maF8nlOUGhb7643QEmdsxwqh7K5Tm95hK/A+Wzv+71zHowYOgrFtc5nVfXYZWWALf/mvFc0wtyLnIATye+X55zDrYh4gfuB64B24HURWaeqW9OS3QAsdl+XAv8IXDpJ3tXAelW9xw04q4G7RaQZWAEsBeYCz4nIElVNuuWuAjYATwHLgadzad9kPYtTZdOmTTz77LNs2LCBK664ghUrVlBbO7MvvZyQSB8UlkPDlbDnt+5GgeGjzqLH51zSClXAh78KDX8AD3/s2AkkPqg6x/n2F+l10ieGnTL8BRCPcKz7rxAsdfZF024YSESdy3AHNkIyCm/9DM65Fmo/mNdbM6dKXXkhA5F+IrEEw7EEz205zLlzinm59SiXNlQyuyxIfyTOPU9tJxJPcctFc/nFmwdRwOf2ZiKJFD6P8Nqebh5/o51rzpvFj3+/h5dau/F5oCjg5UBvhO/+ehdBn4fBWJKKQj8v7OgknkyhwLIF5cSTykMv7WEwluS9zkHebnf+H86pLuK9rkG+9vi7o/9bz2w5zG2XzOdfXm3j9+910z0YA8ArUFdezOaD/dSWhejocwbk3znQx/lzS3lrXw+vtvWwOe0KRDia5M61m0iknNJfaj3Kn1zZSCSe4Khbbs9QnN/u7OKZLYfpHY7zlx9dwvXn11KU797KiOIaJyiEyuDyO6GkFtZ+2rlE5i+A+R9yPq+JqPPlaeCw815QBWX1sP9V57M+fBTqW+DQVhBxzgMU4oPOcZo/4XyWgyVOIAJnOQ9EJ7mbY9ICRD4EfEtVr3fXvw6gqv8rLc3/AX6jqmvd9R3A1UDDeHlH0qhqh4jUuvnPPb58EXkG+BawB3hBVc9zt9/m5v/PE9W/paVFj582f9u2bTQ1NZ3sP0nOVJXLL7+cb3/721x33XV8//vfZ8OGDfzLv/zL+9JOdV1Pmb4DzphHsATWf9sZtAQonQeVCyHWD9XnwZwPOr0HX4EzuN651enNhCoh1gfqhX2/g7kXQ2Glc7KmEjDU49wRFihy8sz5IFQshN//A/TugVlL4eLPwexmOPAWvPA3zjfJq/4S5l3qbJ/hRsY+bntgA22dzh8bv0eIp5RvfbyZ7sEYj7y+nyPhKAuri+joG2Y47gTUkE+oLAoSjiaIxhKkEJIpxe8VYsnx/6YIzljI7NIge7qGRoOFRyDk9xBNKMmU4hUoCfn4wWcu5scv7+a57Z0ABLweEqkUVUUBOgdiNFQVsLd7GL9H8HmFoViKwoCXlZcv4JdvH2R/T4T5lQV0hmMMx5Oj9SgKeLl0YSXPu+WObBuKJ/GKU9OE2574ce351k1NXNc8Z8zgft6M3NnYt9/psceHnc9qQSl4As55MXgECiug+lwnIIQ7IRVzLgGXzIZtT8LBt2DprVA6B8Tr5OnZC63rnc87ONs/8tfwwU8750RB+QkFFhF5Q1VbMu3LR8itA/anrbfj9EomS1M3Sd7ZqtoB4AaXmrSyNmQoK+4uH7/9fURkFU7Phvnz50/QtKnxwAMPMH/+fK677joAvvSlL/HjH/+YF198kauuumqKa3caBUucb2hXf925Q6uw0nkvqIBYBKoanMHIwU44+p7Ti5h3qfPNLhGD4lng8UD1QufuMNxehscPpSFnUN7rhfJ6iMeck/SCz0Iq6hyjosEJWFWN8IffcO468xc4PaXe/c5lixnMI0LvUIzvffpC9nUP8b1nd9LW5QSYn7yyl7auQXzOX1l2dw3idZdrSoLcumwuA8MJfvrqfm66oJZ1bzu3eI8EFRE4d3YJC6oKCPl8PL25g3hSKQ76CLuXkRQoL3DGWJprS9h6aICk23NIKkQSKf7y8XdYvnQO0IkH5/IdQDSRZOUVC3j63UOoQiKlFAZ8DJNiKJbk19uO8GfXnMNfrdvGvu7hkYumo646dxZXL6keDSxeDwzFkiiQ0JHawR9f0cA/vrh7NN+ljZUsqCgcvT07/SaHvOjvcHobdcucz1fbi85l2sJq57NeOhe6tjtjJv4CZ6zPG3C+MHl8Tq9k3mWwZLlbVhQCJc5lr8pFUNPkBJ2I29MJuMExz5/lfASWTOMYx39lGS9NNnmzPV7WZanqGmANOD2WSY532q1atYpVq1aNrnu9Xt54440prNEUCJU6A/jRAWeM5KLPwkCX89VWU1BQ6QSeRNS5uwWcy18V851veeFDziWF2CCMDOUOHoWiane50+mBRAeccsIHnWBRsxSKq51LZYkht/xaqGl2gho4J7rnFF0GOY36hmPEk0p1SYDqkgC3Xz6Pb63bjgjs63bGlhJJxedxvr0nksrc8hB3XbuYwoCXgWiC0rc7+L/vHkKAmtIg88pD1JSGWFpbSk1ZEBA6w1GW1CwikkzxTy+2AbC7a4iPnDeL+vICfvbafra5QeWC+jKG4gk6eqM0Vheyp2uIh36/B3C/FrhnaziS5DfbOznYF6Wi0E95oZ/dXUN8tLkGn8fDU5sP8dDL+/jC5Qv4143tHB0c+1zMkppikim45rxZVBcHWLepg/JiP8sWVPDMlkMkUjCrOEB1cZDCgJehWJKA18N/vnIhFcUBBqIJiqKJ/AeWUJnTix75Q193sfM59fqdIFBzrnNeBEucz7amnOVo2L1d3uNcJiuqdoJONOzs9wWdG1nCHueW5KJq6NzhfOHq2pn3ByTzcXa0A+nhrh44mGWawAR5D4tIbdqlsCOTlNXuLk9UDzNTjHTJR/7wl8xxLoFpygkcgaJjgUc8zq2/6SdGyWznRCqtdfZrCuqXOZcaxOOUB1Dvdmr7a53yy+cdO3bvfudYwZJjJ97IA2uBU3AZ5DTzeTyjz2/0DMa5bOEsLpjXwab9faMPPNaVhxiIJqgtC7H90AAfmFtGZVGAWSVBEknl0sZKnt12hD+6aC4XL6igdyhKYcCPT8ArXnxemF9VSH15ISLCkpoSfrphD6/t6eVD51RRWRhk495utnQMUFsa5JPL6qgsDNAfSTAcTxDwenjsjQMUBbwsnl1Ce/cQR8IRNh8M817XEAL8yZUN1JUV0DUQp8DvZXZZkKriAD/bsI/eoRgKVBb6uXJJFc9v7yKlcM6sYlIof/LhhXhEuLSxioFoDJ/Hy8LqIh58aQ83fGAOkXiSpjklvLGvlysWVVFZ7LQ9EjtFY2zH38IeLHn/Zdea8zLnHXkWZeQ8KJ937PMeLIGuXc7t9GV1zrmx6Brn0loi6qxD3oJLPgLL68BiEWkEDuAMrH/muDTrgDtF5BGcS119bsDonCDvOuB24B73/Ym07T8Xkf+NM3i/GHhNVZMiEhaRy4BXgc8DZ+HDH2eYkZ5L+gc+/WQZ70QIlWXeN7Lt+GvJpbXvP6nL5x17YG0k38h7Hm/NnCojD/sd7o9QUeSnJOTnrmuXcPs/v45H4FPL6vjwklmICPFEkue3d7J86Rwaq4upLgniEeGTy+r5QF0pH6grp6I4QGHAS1c4hojznExJyEdVsZN2MJrgvNpSvvSHi3ntn1/n3QP9fLqlnnjKGV/55seaqSwOEPJ5qRMYiibxeoT/ck0BHo8wFE9wSWMFs4pDtHUN8He/2sGyBeUsqCyiqbaMoN/5P+kKx7jmvBpU4bGN+4kllS9dvZBFs0pYWleOzyMsqC6iMOBlMJqgOOgn4BNiiUICPmF2aYjvfuqD9A45g/d/sKiKPUeHWPnhRkqCfjwizCp12jStZBofST8Hqt07J6PhY1+URvaPnFN5knNgUdWEiNwJPAN4gYdUdYuI/Km7/59w7tC6EWgFhoAvTpTXLfoe4DERWQnsAz7l5tkiIo8BW4EE8GX3jjCAO4AfAwU4d4PldEeYmQYmO1nO9OOfBiMBZiCaYNHsYj69rJ7ikI8PL66moihAUcDHUCzJbZcUUBLyj/ZmUqosnl3CopoSRCDo91BXXsicsvjoMzDpDzEWBX14RCgMerm2qYan3z3EktnF7Dw8wG2XzAOBZFJZVFcyeoy2zgFC/hBFQS9H+iN4PR7KC/0015bx/376AiLugHw8mWLhrGL6I3F8Hg9Kitsvb2BZQwVv7evluubZFAZ89A7FKQr6SGmKgoCXOWUFpFSZXRaibzjGUDRJNJFiQVGQ4pCPtiMD1FcUck3TbGrLCkikUpSE/Pl/fuV0Og2f6ZzvCpvppuNdYSdiJtXVTG/9kTid/VEGY3GKAn4GY3FUheqSAMOxJEVBH0VBH4PRBEPRJIpSUxp63xQtE407jKRr7xlixZoNzkOJXuHfv3w5sbgyHE8wr7LQuRXafSI/PUiN/PE/OhilqijI7LIQh/siRBMpKor8lBUExjzx3xWOjj4lXxjwjj69PxhN4BF5X33Tp3NJnzGgvDBAQcCbVRvPFqf6rjBjzBlgMJpAURqqi0f/MB/pjzAcS44GEHCmeOnoGx5dTn+f7PLQyB/zZQsq+cRFdTy2sZ1bLppL0OulrjxI2O1xABl7BcXudC+FQe/o7b6lIf/oXF4jeUaCQnVJkIWziunoG2YoemyuspH2HV/f9LnARuo6u7T0fW0wE7PAYowBoCTkpyjoyxgsjv8jX1tW8L782XyLTy/nv32sGa9H+PyHGkaPm00ZmSaCPP6ZkuN7I7VlBe8LJJMdK1Ngs55Kdmb+COQZyKbNN1OhOC2ojCg9xeMJf37tEiqLnHnwjp8qPxdT0RZzjAWWaSh92nzg7Jw235zR0sdkZpeGRscv8hlczNSx8D1N2bT55kx2/KWqbMdozMxggWUSNm2+Mfln4xdnNrsUNo2d1dPmG2NmLOuxTMKmzTfGmBNjPZZpSFW54447uPfee5k/fz5f+9rX+OpXvzrV1TLGmKxYYJmGMk2bv337dl588cUprpkxxkzOLoVNQzZtvjFmJrMeizHGmLyywGKMMSavLLAYY4zJKwssxhhj8soCizHGmLyywGKMMSavLLBMQzZtvjFmJrPAMg3ZtPnGmJksp8AiIpUi8qyI7HLfK8ZJt1xEdohIq4iszia/iHzdTb9DRK53txWKyP8Vke0iskVE7klL/wUR6RSRTe7rj3Np21S766672LBhw+i0+X/xF38x1VUyxpis5Prk/Wpgvare4waM1cDd6QlExAvcD1wHtAOvi8g6Vd06Xn4RaQZWAEuBucBzIrLELfK7qvqCiASA9SJyg6o+7e57VFXvzLFNY9i0+cYYc2JyvRR2M/Cwu/wwcEuGNJcArarapqox4BE330T5bwYeUdWoqu4GWoFLVHVIVV8AcMt6E6jPsQ3Tlk2bb4yZiXLtscxW1Q4AVe0QkZoMaeqA/Wnr7cClk+SvAzYcl6cuvVARKQc+DvxD2uZbReRKYCdwl6qmH/ek2LT5xhhzYibtsYjIcyKyOcPr5snyjhSRYZvmkkdEfMBa4D5VbXM3Pwk0qOoHgec41hN6f+Eiq0Rko4hs7OzsnKQqp59Nm2+MmckmDSyqeq2qnp/h9QRwWERqAdz3IxmKaAfmpa3XAwfd5fHyT5QHYA2wS1XvTavnUVWNuqsPAMsmaNMaVW1R1ZZZs2ZN2P6pYNPmG2NmslzHWNYBt7vLtwNPZEjzOrBYRBrdAfcVbr6J8q8DVohIUEQagcXAawAi8jdAGfDn6QcZCVCum4BtJ9+sqbVq1SoeffTR0fWRafOvuuqqKayVMcZkJ9cxlnuAx0RkJbAP+BSAiMwFHlTVG1U1ISJ3As8AXuAhVd0yUX5V3SIijwFbgQTwZVVNikg98A1gO/CmiAD8QFUfBL4iIje56buBL+TYNmOMMSdBVCcb7jiztbS06MaNG8ds27ZtG01NTVNUoxMzk+pqjDlziMgbqtqSaZ89eW+MMSavLLAYY4zJKwssxhhj8soCizHGmLyywDJNeb1eLrzwQs4//3w+/vGP09vbO9VVMsaYrFhgmaYKCgrYtGkTmzdvprKykvvvv3+qq2SMMVmxwDIDfOhDH+LAgQNTXQ1jjMlKrg9InvmeXg2H3s1vmXM+ADfcM3k6IJlMsn79elauXJnfOhhjzCliPZZpanh4mAsvvJCqqiq6u7tH5w0zxpjpznosk8myZ5FvI2MsfX19fOxjH+P+++/nK1/5ypTUxRhjToT1WKa5srIy7rvvPr773e8Sj8enujrGGDMpCywzwEUXXcQFF1zAI488MtVVMcaYSdmlsGlqYGBgzPqTTz45RTUxxpgTYz0WY4wxeWWBxRhjTF5ZYDHGGJNXFliMMcbklQUWY4wxeWWBxRhjTF5ZYJmmbNp8Y8xMlVNgEZFKEXlWRHa57xXjpFsuIjtEpFVEVmeTX0S+7qbfISLXp23/jbttk/uqcbcHReRRN8+rItKQS9ummk2bb4yZqXLtsawG1qvqYmC9uz6GiHiB+4EbgGbgNhFpnii/u38FsBRYDvzQLWfEZ1X1Qvd1xN22EuhR1UXA94Dv5Ni2acOmzTfGzCS5Pnl/M3C1u/ww8Bvg7uPSXAK0qmobgIg84ubbOkH+m4FHVDUK7BaRVrecVyapy7fc5ceBH4iIqKqeVMtG2LT5xhhzQnLtscxW1Q4A970mQ5o6YH/aeru7baL8E+UB+Gf3Mtg3RUSOz6OqCaAPqMpUaRFZJSIbRWRjZ2dndi09zWzafGPMTDVpj0VEngPmZNj1jSyPIRm2TdaLmCjPZ1X1gIiUAL8APgf85ESOo6prgDUALS0tE9fFps03xpgTMmmPRVWvVdXzM7yeAA6LSC2A+34kQxHtwLy09XrgoLs8Xv5x86jqAfc9DPwc5xLZmDwi4gPKgO7J2jfd2bT5xpiZJtdLYeuA293l24EnMqR5HVgsIo0iEsAZlF83Sf51wAr3Tq9GYDHwmoj4RKQaQET8wMeAzRnK+iTwfM7jK9OETZtvjJlJch28vwd4TERWAvuATwGIyFzgQVW9UVUTInIn8AzgBR5S1S0T5VfVLSLyGM4AfwL4sqomRaQIeMYNKl7gOeABt6wfAT91B/q7cQLYjGXT5htjZqqcAouqHgU+kmH7QeDGtPWngKeyze/u+5/A/zxu2yCwbJz0EdzAZIwxZurYk/fGGGPyygKLMcaYvLLAYowxJq8ssBhjjMkrCyzGGGPyygLLNGXT5htjZioLLNOUTZtvjJmpLLDMADZtvjFmJsn1yfszn02bb4wxJ8R6LNOUTZtvjJmprMcyGZs23xhjToj1WKY5mzbfGDPTWGCZAWzafGPMTGKXwqYpmzbfGDNTWY/FGGNMXllgMcYYk1cWWIwxxuSVBRZjjDF5ZYHFGGNMXllgMcYYk1c5BRYRqRSRZ0Vkl/teMU665SKyQ0RaRWR1NvlF5Otu+h0icr27rURENqW9ukTkXnffF0SkM23fH+fStung3//93xERtm/fPtVVMcaYrOXaY1kNrFfVxcB6d30MEfEC9wM3AM3AbSLSPFF+d/8KYCmwHPihiHhVNayqF468gL3Av6Ud7tG0/Q/m2LYpt3btWq644gp7MNIYM6PkGlhuBh52lx8GbsmQ5hKgVVXbVDUGPOLmmyj/zcAjqhpV1d1Aq1vOKBFZDNQAv8uxDdPSwMAAL7/8Mj/60Y8ssBhjZpRcn7yfraodAKraISI1GdLUAfvT1tuBSyfJXwdsOC5P3XHl3obTQ9G0bbeKyJXATuAuVd1PBiKyClgFMH/+/Akb+J3XvsP27vxeijqv8jzuvuTuCdP88pe/ZPny5SxZsoTKykrefPNNLr744rzWwxhjToVJeywi8pyIbM7wunmyvCNFZNimGbadaJ4VwNq09SeBBlX9IPAcx3pC7y9IdY2qtqhqy6xZsyapytRYu3YtK1asAGDFihWsXbt2khzGGDM9TNpjUdVrx9snIodFpNbtbdQCRzIkawfmpa3XAwfd5fHyT5QHEbkA8KnqG2n1PJqW/gHgO5O1LRuT9SxOhaNHj/L888+zefNmRIRkMomI8Hd/93eIZIq5xhgzfeQ6xrIOuN1dvh14IkOa14HFItIoIgGcnsa6SfKvA1aISFBEGoHFwGtpZd7G2N4KbmAacROw7aRaNA08/vjjfP7zn2fv3r3s2bOH/fv309jYyEsvvTTVVTPGmEnlGljuAa4TkV3Ade46IjJXRJ4CUNUEcCfwDM4f+8dUdctE+d39jwFbgV8BX1bVZNpxP81xgQX4iohsEZG3ga8AX8ixbVNm7dq1fOITnxiz7dZbb+XnP//5FNXIGGOyJ2PHvs8+LS0tunHjxjHbtm3bRlNT0xTV6MTMpLoaY84cIvKGqrZk2mdP3htjjMkrCyzGGGPyygLLOGbCJcKZUEdjzNnHAksGoVCIo0ePTus/3KrK0aNHCYVCU10VY4wZw37zPoP6+nra29vp7Oyc6qpMKBQKUV9fP9XVMMaYMSywZOD3+2lsbJzqahhjzIxkl8KMMcbklQUWY4wxeWWBxRhjTF5ZYDHGGJNXFliMMcbklQUWY4wxeWWBxRhjTF5ZYDHGGJNXFliMMcbklQUWY4wxeWWBxRhjTF5ZYDHGGJNXFliMMcbkVU6BRUQqReRZEdnlvleMk265iOwQkVYRWT1ZfhGpEpEXRGRARH5wXFnLRORdt6z7RETc7UERedTd/qqINOTSNmOMMScn1x7LamC9qi4G1rvrY4iIF7gfuAFoBm4TkeZJ8keAbwJfzXDMfwRWAYvd13J3+0qgR1UXAd8DvpNj24wxxpyEXAPLzcDD7vLDwC0Z0lwCtKpqm6rGgEfcfOPmV9VBVX0JJ8CMEpFaoFRVX1Hn5x1/knbM9LIeBz4y0psxxhhz+uQaWGarageA+16TIU0dsD9tvd3dlm3+48tqH6es0eOoagLoA6qybokxxpi8mPQXJEXkOWBOhl3fyPIYmXoNJ/tj8hOVlfVxRGQVzuU05s+ff5JVMcYYk8mkgUVVrx1vn4gcFpFaVe1wL1MdyZCsHZiXtl4PHHSXs8l/fFnpP/KeXtbIcdpFxAeUAd3jtGkNsAagpaXlZIOcMcaYDHK9FLYOuN1dvh14IkOa14HFItIoIgFghZsv2/yj3MtlYRG5zB0/+XxanvSyPgk8747DGGOMOY0m7bFM4h7gMRFZCewDPgUgInOBB1X1RlVNiMidwDOAF3hIVbdMlN8tYw9QCgRE5Bbgo6q6FbgD+DFQADztvgB+BPxURFpxeiorcmybMcaYkyBn+5f6lpYW3bhx41RXwxhjZhQReUNVWzLtsyfvjTHG5JUFFmOMMXllgcUYY0xeWWAxxpizyGB8kHAsPGZbOBZmMD6Yt2PkeleYMcaYaWwwPkhKU3jEQ0pTAHQOdTIUH6LQX8hQfAgRocBXkLdjWmAxxpgzwPEBxCMe+qP9eMTDYHwQRRGEeCrO3vBetnRuYWn1UhaVL2JW4SxKAiV5q4sFFmOMmYHG64mMBJCB+ABe8dId6ea9vvfY2rWVnb072du/l0QqAcDK81dyYc2FeQ0qYIHFGGOmvfQgEo6FKfIXMRAbIJqMkkgliCajhHwhwrEwmzs3s71nO219bezu281AfACAgCfAOeXncP2C62mqamJB6QKaKpsAZ4zFeizGGHMGm6g3MhQfYn9iP8XBYt7reY+3O99mV88u9oX30TncCYAg1JfUc0XdFcwrmUdzVTOzC2dTFCiie7gbVaWqsIpCfyEAw4lhgLwFFwssxhgzRbIdF0lqkgMDB9jcuZmdvTtp7Wnl4OBBkpoEoCpUxaLyRdzQeAMNpQ00VTXhEQ/JVJJoMoqqOvO/K1QEKxCPUOAtYDgxTIGvgAJfAR7J303CFliMMeY0yWZcxOfxEY6Gae1rZWvXVnb17mJ3324iSed3Dwt9hSwsW8iyOcuYVzKPpVVLqS2uHe2JhPwhCn2FpDRFjBhBghQFitCUE1xqCp2fvUoPZkX+ory20wKLMcacAtmOiwwnhtnStYXt3c64yJ7+PXRHnF/88IqXhtIGrqy/kqaqJuaXzGdh+UJ6I70Mxgbxer34xDemJzISQIr9xagqpcHS9/WK8h1IjmeBxRhj8iCbcZGyUBl7+vawqXMTu7qdcZGOwQ7U/U3COYVzuKjmIuaVzKOpqom5RXMpDZaO6Y0Mx4cJeUOECkOEvCEiyQiD8UEayhqAU9sTyZYFFmOMOQHZjoukNMWR4SNs7tzMjp4dtPa0sn9gP/FUHIDSQCmLyhdx1byraChtoLm6mYAnMGZcxOvxvq83MpwcpipURXGgeLQOQ/GhKQ0kx7PAYowxE8h2XCSSiNDW18bmrs3s6tlFW1/bsVt9vQEaShv46IKPOuMi1UuZVzKPnkjPaE+kyFd00uMi+X4OJVcWWIwxxjUyj1aRv2j0j/hAbIDuSDchXwhBUJR4Ks62rm1s69lGW68zLnJ46DDg3Oo7v2Q+LXNaaKp0nhdZXLGY/mj/6LiIX/wIMq3GRfLJAosx5qw1Xm/kqBwl6A06A+2aoGOgg/d632NHzw7a+tpoD7ePudW3qaqJj8z/CE1VTcwrmUdFqGLMuEg0EZ324yL5ZIHFGHPGy3ZcRFEiyQhvHHqD1r5W9vTtYV943+gDhAW+As4pO4dbFt1CY1kjzVXNFPmLxoyLBLyBGTkukk8WWIwxZ5xsx0WSqSRtfW1s6drCzp6dtPW10RPtAZxbfeeXzueKuitGL2mN3Op7Jo6L5JMFFmPMjDdZIFGUpCbZcXTH6Dxae/r2cGDgwLFbfYvm0FzVTFNVEzUFNTRVNZFIJRiMDVLoLyTkD+HBc8aOi+RTToFFRCqBR4EGYA/waVXtyZBuOfAPgBd4UFXvmSi/iFQBjwP/Afixqt7ppi8E/hU4B0gCT6rqanffF4C/Bw64h/2Bqj6YS/uMMTNDSlMMJ4ZJppJ4PV4SyQSHhw6PmZBxX3gfsWQMgBJ/CU1VTVw29zKaq5qZVzKPmsIauoe7nUASKKTY7162IkXIG6LQW3janlyf6XLtsawG1qvqPSKy2l2/Oz2BiHiB+4HrgHbgdRFZp6pbJ8gfAb4JnO++0n1XVV8QkQCwXkRuUNWn3X2PjgQhY8zZY+Sy0ltH3uKhzQ+xs2fn6K8kBjwBGsoauL7hehpLG2mubqY8UE5KU6PjIiF/aHRcJORzBth9Hh9Bb5CmyiaG4kMUB4otkGQp18ByM3C1u/ww8BuOCyzAJUCrqrYBiMgjbr6t4+VX1UHgJRFZlF6Qqg4BL7jLMRF5E6jPsQ3GmDPASHDpGu5i2exlnFd5HgtKF7CkYgn90f73j4uksh8XOZPHQ06FXAPLbFXtAFDVDhGpyZCmDtiftt4OXHoC+TMSkXLg4ziX2EbcKiJXAjuBu1R1/zh5VwGrAObPn5/tIY0x01g4Fua8yvO475r7xtzq6xOfjYucZpMGFhF5DpiTYdc3sjyGZNimWebNXKCID1gL3DfSEwKeBNaqalRE/hSnB3RNpvyqugZYA9DS0pJTXYwxUy8cC4+OsRT7i9GUjgkkNi5yek0aWFT12vH2ichhEal1exu1wJEMydqBeWnr9cBBdzmb/JmsAXap6r1p9Tyatv8B4DtZlmWMmeE84hn9TZGUpqgprCEcC1sgmSK5/rLLOuB2d/l24IkMaV4HFotIozvgvsLNl23+MUTkb4Ay4M+P216btnoTsC27JhhjZrqRcZD08ZD0dQsqp1euYyz3AI+JyEpgH/ApABGZi3Nb8Y2qmhCRO4FncG43fkhVt0yU3y1jD1AKBETkFuCjQD/OJbjtwJsiAsduK/6KiNwEJIBu4As5ts0YY8xJENWze4ihpaVFN27cONXVMMaYGUVE3lDVlkz78vcjx8YYYwwWWIwxxuSZBRZjjDF5ZYHFGGNMXllgMcYYk1cWWIwxxuSVBRZjjDF5ZYHFGGNMXllgMcYYk1cWWIwxxuSVBRZjjDF5ZYHFGGNMXllgMcYYk1cWWIwxxuSVBRZjjDF5ZYHFGGNMXllgMcYYk1cWWIwxxuSVBRZjjDF5ZYHFGGNMXuUUWESkUkSeFZFd7nvFOOmWi8gOEWkVkdWT5ReRKhF5QUQGROQHx5X1G7esTe6rxt0eFJFH3WO8KiINubTNGGPMycm1x7IaWK+qi4H17voYIuIF7gduAJqB20SkeZL8EeCbwFfHOe5nVfVC93XE3bYS6FHVRcD3gO/k2DZjjDEnIdfAcjPwsLv8MHBLhjSXAK2q2qaqMeARN9+4+VV1UFVfwgkwJ1OXx4GPiIicQH5jjDF5kGtgma2qHQDue02GNHXA/rT1dndbtvkz+Wf3Mtg304LH6HFUNQH0AVWZMovIKhHZKCIbOzs7szykMcaYbPgmSyAizwFzMuz6RpbHyNRr0CzzZvJZVT0gIiXAL4DPAT85keOo6hpgDUBLS0sudTHGGHOcSQOLql473j4ROSwitaraISK1wJEMydqBeWnr9cBBdzmb/MfX54D7HhaRn+NcavtJ2nHaRcQHlAHdk5VnjDEmv3K9FLYOuN1dvh14IkOa14HFItIoIgFghZsv2/yjRMQnItXush/4GLA5Q1mfBJ5XVeuNGGPMaTZpj2US9wCPichKYB/wKQARmQs8qKo3qmpCRO4EngG8wEOqumWi/G4Ze4BSICAitwAfBfYCz7hBxQs8BzzgZvkR8FMRacXpqazIsW3GGGNOgpztX+pbWlp048aNU10NY4yZUUTkDVVtybTPnrw3xhiTVxZYjDHG5JUFlhluMD5IOBYesy0cCzMYH5yiGhljzna5Dt6b02gwPkhKU3jEM/reMdCBz+NjIDZAabCU/mg/0WSUqoKMz4YaY8wpZ4FlGjs+kAB0DnWiKIIwEB/AK1729e9jb3gvO3t2cuviW6krrqMkUDLFtTfGnK0ssEwDmXoi/dF+POJhMD44GkgUZSgxxObOzezo2UFbbxu7+3fTG+0FwOfxcXX91bTMyXijhjHGnBYWWKZANj0Rn8eHIOwL72NL1xZ29uykra+NQ4OHUHemmtqiWlpmtzC7cDbNVc0sKF1AbXEt4VjYeizGmCljgeUUm2hcJJFKjL5HEhEODR5iW/c22vra2NO/h739e4mn4gCUBcs4p+wcrpl/DQtKF7C0aik+j49wNExc45QFyphdNJtkKslwYhjAgosxZkpYYMmzbHsjHQMd7A3vZevRrbzX9x77+vcxEB8AIOgNsqRiCcsblnNe1XksKFlAfUk9PZEeVJWQP0SRr4iUpvB5fYQkNBpUvB4vyVQSj9gNf8aYqWGBJUeTBRJFiSVjbO3ayvae7bT1tbG7bzedw850/YJQV1zHZXMvY2HpQpqrm6kpcH49IJqMjgYSQagIViAeQVMKAsX+Yor8RZQGS9/XKyryF03Zv4kx5uxmgeUETRZIEprgwMABNnduHh0XaR9oH01bFapiafVS/rDwD2mqamJO4RxCvtD7eiKxVIwgQYoCRaOBpKbQCTgWQIwx05kFlhOU0hTDieHRy02HBw/zTtc7bD26lV09u9jdv5toMgpAka+IheULubT2UhpKG1havZQCX8HouIhf/JQES0imkmMCSLG/GFW1nogxZkaywHKCRgbEf7HrFzy0+SF6Ij0AeMVLY1kjV9dfzXlV59FQ2kBDWQO9kd5xx0XKgmUkUglKC0pJppKUFpZaADHGzHgWWE5CSaCEylAly2qWUV9ST3NVM3OL5lISLKF7uHs0kHjw2LiIMeasY4HlJIRjYS6rvYzzq88fDSQejweU9wUSGxcxxpxtLLCcoHAsPDrGUuwvRlNqgcQYY9JYYDlBHvFQ4CsYDRw1hTWEY2ELJMYY47LAcoIyBQ17wt0YY46xx7ONMcbkVU6BRUQqReRZEdnlvleMk265iOwQkVYRWT1ZfhGpEpEXRGRARH6Qlr5ERDalvbpE5F533xdEpDNt3x/n0jZjjDEnJ9cey2pgvaouBta762OIiBe4H7gBaAZuE5HmSfJHgG8CX00vS1XDqnrhyAvYC/xbWpJH0/Y/mGPbjDHGnIRcA8vNwMPu8sPALRnSXAK0qmqbqsaAR9x84+ZX1UFVfQknwGQkIouBGuB3uTXBGGNMPuUaWGarageA+16TIU0dsD9tvd3dlm3+8dyG00PRtG23isg7IvK4iMw7gbKMMcbkyaR3hYnIc8CcDLu+keUxJMM2zbDtRK0APpe2/iSwVlWjIvKnOD2gazJWSGQVsMpdHRCRHXmoz6lSDXRNdSXyxNoyPVlbpqfp3pYF4+2YNLCo6rXj7RORwyJSq6odIlILHMmQrB1I7z3UAwfd5WzyZzruBYBPVd9Iq+fRtCQPAN8ZL7+qrgHWZHOsqSYiG1X1jPitYWvL9GRtmZ5mcltyvRS2DrjdXb4deCJDmteBxSLSKCIBnJ7GuhPIn8ltwNr0DW5gGnETsC3LsowxxuRRrg9I3gM8JiIrgX3ApwBEZC7woKreqKoJEbkTeAbwAg+p6paJ8rtl7AFKgYCI3AJ8VFW3urs/Ddx4XF2+IiI3AQmgG/hCjm0zxhhzEmTs2LeZbkRklXvpbsaztkxP1pbpaSa3xQKLMcaYvLIpXYwxxuSVBRZjjDF5ZYFlmhhvPrUM6f6DiCRF5JOns34nIpu2iMjV7pxuW0TkxdNdx2xM1g4RKRORJ0XkbbcdX5yKemZDRB4SkSMisnmc/SIi97ltfUdELj7ddcxWFm35rNuGd0Tk9+7jCdPSZG1JSzftz/sxVNVeU/zCuVvuPWAhEADeBprHSfc88BTwyamu98m2BSgHtgLz3fWaqa73SbbjvwLfcZdn4dyNGJjquo/TniuBi4HN4+y/EXga54Hmy4BXp7rOObTlcqDCXb5hJrfFTTPtz/vjX9ZjmR4mmk8t3Z8BvyDLB0mnSDZt+Qzwb6q6D0BVp2N7smmHAiUiIkAxTmBJnN5qZkdVf4tTv/HcDPxEHRuA8uOeDZs2JmuLqv5eVXvc1Q04D2VPS1n8v8DMOO/HsMAyPUw0nxoAIlIHfAL4p9NYr5MxaVuAJUCFiPxGRN4Qkc+fttplL5t2/ABowplJ4l3gv6hq6vRUL++yae9MtBKnJzYjzaDzfgz7BcnpIZv51O4F7lbVpPMFedrKpi0+YBnwEaAAeEVENqjqzlNduROQTTuuBzbhzEl3DvCsiPxOVftPcd1OhVM1p9+UEZE/xAksV0x1XXJwLzPjvB/DAsv0MNF8aiNagEfcD1c1cKOIJFT1l6elhtnLpi3tQJeqDgKDIvJb4AJgOgWWbNrxReAedS6Et4rIbuA84LXTU8W8yqa9M4aIfBB4ELhBx84jONPMlPN+DLsUNj1MNJ8aAKraqKoNqtoAPA58aZp+uCZtC86ccB8WEZ+IFAKXMv3mdsumHftwel2IyGzgXKDttNYyf9YBn3fvDrsM6FP3Jy1mGhGZj/MDgJ+bZr3gEzaDzvsxrMcyDeg486m50/+jqjPm+mo2bVHVbSLyK+AdIIUzr9yEt1uebln+n/wP4Mci8i7OpaS7VXVaTnMuImuBq4FqEWkH/hrww2hbnsK5M6wVGMLpjU1LWbTlr4Aq4IfuN/2ETtNZgrNoy4xkU7oYY4zJK7sUZowxJq8ssBhjjMkrCyzGGGPyygKLMcaYvLLAYowxZ5FsJ750037PnSx2k4jsFJHerI5hd4UZY8zZQ0SuBAZw5oY7/wTy/Rlwkar+p8nSWo/FGGPOIpkmvhSRc0TkV+7cfb8TkfMyZL0NWJvNMewBSWOMMWuAP1XVXSJyKfBDnDnwABCRBUAjzvT9k7LAYowxZzERKcb5DZt/TZvoMnhcshXA46qazKZMCyzGGHN28wC9qnrhBGlWAF8+kQKNMcacpdyfedgtIp+C0Z+pHv05ZxE5F6gAXsm2TAssxhhzFnEnvnwFOFdE2kVkJfBZYKWIvA1sYeyvpd4GPKIncAux3W5sjDEmr6zHYowxJq8ssBhjjMkrCyzGGGPyygKLMcaYvLLAYowxJq8ssBhjjMkrCyzGGGPy6v8H28orq7XzQbMAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1165,29 +1155,6 @@ " print(\"RETURNED NONE\")" ] }, - { - "cell_type": "code", - "execution_count": 58, - "id": "e7af816c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'/dev4797/auxins/0/sample.auxin0.avg': [],\n", - " '/dev4797/demods/0/sample.r': [],\n", - " '/dev4797/demods/0/sample.x': []}" - ] - }, - "execution_count": 58, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_lockin.read_memory" - ] - }, { "cell_type": "code", "execution_count": null, @@ -1206,7 +1173,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 60, "id": "1ac65d7f", "metadata": {}, "outputs": [], @@ -1217,7 +1184,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 61, "id": "fe7ace96", "metadata": { "scrolled": true @@ -1230,7 +1197,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 62, "id": "be1c9ade", "metadata": {}, "outputs": [], @@ -1246,7 +1213,17 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 67, + "id": "d0eac924", + "metadata": {}, + "outputs": [], + "source": [ + "my_lockin.register_operations(\"test2\", postprocessing_crop_windows)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, "id": "58dee40c", "metadata": {}, "outputs": [], @@ -1256,7 +1233,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 69, "id": "dc4dc54f", "metadata": {}, "outputs": [], @@ -1270,13 +1247,37 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 70, "id": "d206d097", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -1288,7 +1289,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAEQCAYAAACZYT5EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABPTklEQVR4nO29eZBl51nm+Xxnv0ve3GpVlUolydZiy0iyZbAxS7fBYUNjGBigTbPMMJ5wM0MD3TEDTMdEDMF0TA8TQbMNBsZDMw7cPZgwOBgwqzHYGLDBMsiSLMmybEm1V2VmZebdz/rNH995v/Odu2RmqfIumfn+IhSqzLx576lz6z7nPc+7CSklGIZhmPnFmvUBMAzDMDvDQs0wDDPnsFAzDMPMOSzUDMMwcw4LNcMwzJzDQs0wDDPnTEyohRC/IYS4IYR4ep+eLxVCPJH/9/v78ZwMwzAHATGpOmohxNcBaAP4TSnlQ/vwfG0pZf32j4xhGOZgMbGIWkr5VwBumt8TQtwrhPgTIcRnhRCfFEI8MKnXZxiGOSxM26N+H4AfkVK+AcD/COBXbuF3AyHE40KITwsh/ouJHB3DMMwc4kzrhYQQdQBfDeBDQgj6tp//7DsA/K8jfu2ylPLt+Z/PSSmvCCHuAfAXQoinpJRfmvRxMwzDzJqpCTVU9L4lpXxk8AdSyg8D+PBOvyylvJL//8tCiI8DeBQACzXDMIeeqVkfUsomgBeFEN8FAELx8F5+VwixLISg6PsYgLcAeGZiB8swDDNHTLI877cAfArA/UKIS0KIdwP4XgDvFkJ8DsDnAXzbHp/uQQCP57/3lwB+RkrJQs0wzJFgYuV5DMMwzP7AnYkMwzBzzkSSiceOHZPnz5+fxFMzDMMcSj772c+uSymPj/rZRIT6/PnzePzxxyfx1AzDMIcSIcTL437G1gfDMMycw0LNMAwz57BQMwzDzDks1AzDMHMOCzXDMMycc+CEuh0maPbj0vea/RjtMJnRETEMw0yWAyfUmZToRakW62Y/Ri9KkXGHJcMwh5QDJ9SNwEXgWvjQ4xdx4WYHvShFxbPRCNxZHxrDMMxEOHBCDQAXb/bw7z7yLD79JbVAhkWaYZjDzMEU6s0uAKAXpwAw5FkzDMMcJg6cUDf7MdZaIQAgcC1UPLvkWTMMwxw2prnhZV+whEA3UpF0P8607WEV670YhmEOFQdOqOu+g35ueYSJ+j971AzDHGYOnPUBAFtdZXOEcTbjI2EYhpk8B1KoN7sRACBMWKgZhjn8HEihpoiaLBCGYZjDzAEVao6oGYY5OhxIod4kjzrhiJphmMPPgRRqjqgZhjlKHDihTtIMzb6alMdVHwzDHAUOnFBv94oOxD5bHwzDHAEOnFCTPw1wRM0wzNHgwAn1dk/500JwMpFhmKPBgRPqzY6KqI/XfU4mMgxzJDh4Qp1XfJxaDLjhhWGYI8GBE2pKJp5sBBxRMwxzJDhwQr3ZjWBbAsfqHgs1wzAlDuvy6wMo1DGWKi58x0bI1gfDMAaHdfn1gRPq7W6MpaoL37XQ54iaYRiDRuAikxI//qHP4QvXmodm+fWBE+rNboSlqofAsRElGeQBv1IyDLO/XNjo4k8/fx1PX2kCOByLRQ6gUMdYziNqgOd9MAxT5ibNAjpEy68PnFBv5xG179gAWKgZhilo9mO08llAFc8+NMuvD9zORB1RO3lEHadA5eDf2jAMc/uYS67DQ7T8+kAJdT9O0YtT5VG7HFEzDFOm7jsgSaaGuCPlUQshbCHEPwohPjLJA9oJanZZMiNqnvfBMEeOneqlKXg7TEHcrXjUPwbg2UkdyF6g9vHlqqeFus8T9BjmyLFTvTRF0pPUhmk31uxJqIUQZwH8MwC/PpGj2CM0kGmp4sJn64NhjiyNwEXFs/GXz93Ar33iS6V66SKiHn+3fbtCO+3Gmr1G1L8A4CcAjFVFIcR7hBCPCyEeX1tb249jG4JGnC4ZETV3JzLM0aQRuPiL527g1z/5Zf01UARvO0XUJLTbvQj9OL1loaULxVY3ws9/9Hm0+8lEG2t2FWohxLcAuCGl/OxOj5NSvk9K+ZiU8rHjx4/v2wGa0NKA5ZrLyUSGOeI0+zF8x9IaQNEtBW87RdQktB/+h8v4yv/tz7HWCm9ZaBuBi8df2sQvfuyLePZqc6JJy71E1G8B8K1CiJcAfBDAW4UQ/2liR7QDozxqTiYyzNGDIuCa7yCMs1K99F6TiY3AxZfXOmj2Ezx75daF1nytOM0mWqu9q1BLKf+tlPKslPI8gHcB+Asp5fdN7Ih2YLurrqCBaxtCzRE1wxw1LCFQ8WwsVlxEaYaa56Di2bCEMJKJOwdxzX6Mmx0V/D19ZfuWhJYuFObxTLKx5kDVUW92IyxXPQDQycRpLA9ohwkyKUtX3GY/hiUE6v6BOoUMcyigz11hgaZDHvVOQRwJ7Vae93rmalML714ia7pQ2Jaq2nZtS18oJsEtqYyU8uMAPj6RI9kBEsrNfHIeoG41gOlE1JR4ANSbSG9yxbMn/toMw4ynkgt1L0pR9ZSckR26UxBHQruV572evtxE4Fp7Flq6UES5/kRpNnOPeuaQUG60QyxVlVBmmcrOTmMTOSUe1lshPv6FG1hrlhMPh2EwOcMcRIJ8OJs58piqPXYK4uq+g0bgYr0dwnMs3OxE2OrGt3yHTEKdpJOd4nkghJqEcrMbo+KqpMFilW5zppNMbAQu/tOnX8Z//f98Bv/ho19ANxfmwzKYnGEOIsEIC5Q0Ybe77SyT2GhHeMu9qwCAf7iwecuvH6VFMnGSHAihBpRQdsIEtfyKt1L1YInpdSY2+zG2ezEsAfzxU9fw7b/yt/jrF9Z0LWZnIKLmKJthJk9gWB+Ejqh3yV9t92IkmcRX33sMNc/GP17YuuXXN62PSXJghLrZjxGnGTxbHXIrTBC49lQi6iJqBo7Vffzcdz+MrW6E9//NS2j1Y9jCQsfodOIom2Gmg5lMJPYaUa+3QwDAiYaPh+9cKgn1XjsX2fowIOFLM4lGxdU1k55tTSWZSIkHAPBdC2+8exmpBJ671kI/zhB4Fk40Ajx7pYnf/swFtPrxoVj/wzDzTpCX6faiQgcob7VbRdhaLtTH6z4ePbeEZ43KD7Nz8WYnGht8sfVhQEKZZBKeY2nP2netqSQTKfEQpRlsIfAPF7YQJRn6cYqKa8Ox1Gn8+BfW8JO/+xQgD8doRYaZdyiAMkW5v+eIWpXm1XwH959aQJJJPH1lW/88kxJ//uwNfNW//3Nc3eqNDL6ihIVaQ0IZpxmkVBF2I3C19TEtPzhOMniOhQ/+/UUAQJJJ1AMHSZahEyYIkxQCgG2JA79RgmEOAjqZaFofe/So11sqol6uuXj1iQUAwD9e2Cx1PV682UWcSmz34pHBV8gedRkpJeJUwragO4B8x0IrTKbmB0dphkwCf/uljfyY1BW9HymhzqSyRqq+cyjW/zDMvBM4w8lEPZRpDx61YwmcXarizHIFZ5Yq+NSXNko9Es18Bn6cypGf52l51AemrS7OT8RCHln/4P/1GSSZnMo6eGq4idMM290Yri3gWAJJlulqFMJ3imM56Ot/GGbeCbxRddRKtNNMIkkzOPboeHStFWK17sGyBBqBi3MrVVxvhvrnvShFN78A2JYY2bl4JD3qnTKtdCJcW+BmJ8IzV5tI0gxRMtmOIKBILLT6CTY6Id7x0Cn4ro00b7o5vVjB6cUKwiTVM0gagcvt5QwzYXTVRy7OUkqESaY7FneKqtfbIY7VfQBKZxYrrt4i1QnV2NJOLs7jWsTjo2h97DSMm24tXNvSbZ+2sBBNeGoVUDTc3GiGyCTwnW84C9eyMOi2hEkG352rU8owh5rKQB012R6L+cLrnXzq9XaEY3Vf68xq3UOzF5cEeSuf2JnkLeKDwZeOqJMjVJ5HgvjSegf/5a/+La5sFplWOiFpJnXi0HMEoiSbih/cCFz04hSOJfDAqQZcR+iImgiTDL7D8z8YZlq4tgXbEkOVHlqo9xBRU1XZyUaAVpig4tparLcNj3oU2qPOjlBEDShB/Lsv38RnX97EF2+0ta1RWB8W8oFVsIRAksmJTq0imv0YaSb169hCQA6E1GFcNOQwDDMdAsfSddTU7NKoqMh3XC21lKp9/NiCp6vKlvOxFFvdWEfPdPc+zoM+suV5zX6MF9baAIBuVHjWdCIWAgduLoZCCD3ecJJ+sGnB2FYx3jAbsj5Stj4YZspUPFtH1DRf2oyoR5XvNnsJojTD8dyjBtSKP6CwO8w/j/Ogw/z70VGyPkgQX1rvAICu6qD2cUBF1PRnIaYzPY9ujUioG4EL37Ex+NYo62OuTinDHHp8xx5aFkDldRudcGT5LnUlHjOEmmbdk9inmUSzrwR+1hH1XJUlkCB+KY+oM8PWoCuWa1vF1U1OZ3EARetZBjiOsj6CEZFzmGRYqnBHIsNMk8C1tA5Ql/Dz15SGtHqjl86ujxLqmnoM7WalGmpgfJ10lEfyR8qjrvsOoiTTrZ3tsLA16ER4jtAlMRLTXcWV5hG1Og516hLjShpxRM0wU6fi2cYMaiWcX7jeAjB+oL8W6gVPf295wPrYMoR6nPURHUXrAwCev9bSf+5Gha80yvqQUDWTg0m9SSGlhGOXhXpwDi6tCGMYZjoEhvUxaIWG8ejyXWofH2V9UERtetWztj7mTqify4XaEiglAOiK5ViGUOf6POlicyKTxa0VRc6dsDxjgKs+GGa6BK6NXi7UNw1xBVQwN6p8d70dwbaEFmdARea+Y42MqOMxd+5HVqifv97CctXFiYWg1JpNJ8JzhLY7KEEwDfuDaqbdPKKmemnzYsINLwwzfQK3sD4GBVPkea/B8t31doiVmqetTGKl5ulk4nbXEOrd6qiP2jzq5661cP+pBdT8on0TGLQ+1Ekh8ZxGQpFen+YGUDKxZVypzRZyhmGmQ+BaYzsQw2R0R6HZPm6yVPVGWx9jkoXaoz5KEXWWSTx/vYUHTjVQ852REbXpUU9zwS1F7RRR04yBzsDULu5MZJjpUjGsj2GPerSAr7UjHKt7Q99frrpjrI/hiDnLpA4aj5T1cXmrh26UqojaGxTqojyPTkqyg/Wx11U6e0VbLzqiJqFWzyel5KoPhpkByvoYvSxgnC263gpLzS7EctXDJgl1N8ZC4MASo4XYjKKPlPVBicT7Ti7kEfWw9eEZddR0ckbtTdxpwNMrgbwoqvagYTDd/BjpmNijZpjpEriWjqgHbdDBiLodJtjuRcr6WCgm51EAt1R1tfWx3YuxVHVLwaGJKdRHIqKm6Pf5vPbx/lML8ByBVmia+eQRC30bQkI9ahM5DXhab4X4vX+8fNtzq4tkZi7UeedTd2BqF1d9MMx0qeTJRBpxSqhhTWVtaPVjvLzeRZhkOFb30OzHWGuGOte0UvOw1Y2QZRJb3QhLFQ+ekRczMStBjoRHTdHvU5e3cXa5gkxK+I5diqijEdYH/X/cJvJG4OKjz1zHv/7tJ3Btu39bc6ujASGuUkSdWx/kjXEdNcNMF19vIs9KEbUtxFBEXfMd3OyqGmrXtrDWDCEhUcuTjUtVD5kEWv0EWxRROxxRAyii3+evtXB+tYZelGIhcErrdWJDKLVQZyTUo09Ssx/rW6JLm93bGoWqrY08WVjxByPqNP/5XJxShjky6L2JcToQUQ/fbTcCVz8mzTL04hQnGoEO4miC3mY3wnZXLRNwLDFaqPPnqXr20fGoK66Ni5td3HuiBkDdgvTiVJfg6aoPRxhtm7TEcvgkkidNXG+FtzW3OorL1kfNU1fgHkXUCQn53JxShjkS6G0ucVYqQKDpmoM8fbkJALi82R/6WdGdGBURtTlfyID0p+Y7E7c+5mYoUy9O8Wf/5uu0F+TkheidKEEjcJFkpvVB4j0+mUgDnuy80P1GM7ytudVU3UH101U3F+q4fNHg8jyGmS70mezHaamvwRLDd9vNfowv5rmwlbqHwFX2B6Ci7aU8or7ZiQqP2hntUdNz132n9LqTYC7Cv2IVjo/7Ti6g4tm6sURXVeQnxbHEUDvnqIiahoFTJH7xZve25lZ3cwuFbrNqfnG7BRgRNVd9MMxM6MUp2qEZtImhKpBOmOB6PudjwXdwohFAQupIfKWmIuqLN7vIJPKIWpSGrxEURdd8e2zn4n4xFxE1Rb/kE5lXNiqbidMMri0gxLBfNC6ZCBRJyJdvdm7rGMmLJmtjSKjz//tc9cEwU4U+kxudUAsu3TcPRtQLgavHl1LXIgB9p03LA17a6AJQCwjGludpj9pBmklkmYRlTWbT1FwI9agol4rROyWhVm/IoB+006wPOsEX8hP/SiG/m/ww8qip/IcjaoaZDct5FPzc1RY28zkdKzUPUZoNRdR139F7EElozWqwRuDAtgRezJeXLFU9OLalAz6TyLA+AFXc4FuTsT7nVlWquRCSNxynshDqPXYfqd9TP2v2k1Lv/q1CQk3WR+BRSdCA9cEeNcNMFfpM/vJfvIBrTZUgPLUYQMrR2kBbW0b9TAiBpYprCLULzx62W4FyMhEYP7hpP5hboaarVMfo/COhHrwN2Wkok/nYl28jqh5c8UPVH+HAwHKu+mCY6aK7hKNUl+Ou1j09r96kH6daYMdVaizXPFzaVFqxtJP1kVJErV5/3CjU/WBXVRFCBEKIvxdCfE4I8XkhxE9P7GgMyAMm6yNJM3j5QKQ4laDiDd+2doyozc0LF27ug1Dn/yg8Hd2Xk50cUTPMdKHtT0mW6YXTdd9BlsmhIO7adlGSN3hnTixXXf08i9RCPrjJGmWPGhg/YW8/2Ev4FwJ4q5TyYQCPAHiHEOJNEzuiHLqdKFkfThFRU8TtOMPdRyZxmuF43tM/TqivN/u4vFX+2eWtLq43izeVrtTVwYg6KQ+GYo+aYaYLCSVpqWMJ1DwH2Qjr48p2T/95XBHCkrFMQCcTd7I+ck2YqfUhFe38Szf/b+K7r7RQ5xF1lGa6ttrcg+ZaYseIOsnUwtljdX9sQjHJMmx2Yi3Wl7e62OzEpYWV1OFE1segDUMXC571wTDTZbU2PK60HjjI5M4R9TjdoO7EqmfDd2y49ujOxDAd8KgnaH3sqepDCGED+CyAVwF4r5Ty70Y85j0A3gMA586du+0Do1kaVBcZJ2WPeiHII2rb2tGjjhKVhLxrtTq2RO/MUhVAF3/9/DquNfv4hgdPYrnm5t9X0NWXjktfNLjqg2FmSjAwXyfNJDzbQpoNe9SXNouIerz1oYR/qZIHg7uU5xXJxNlaH5BSplLKRwCcBfCVQoiHRjzmfVLKx6SUjx0/fvz2D8wSqHo2ukZ5HtkNcSJ1RO3sElHHaQbXsXBupbpjid6ZpSp+4WNfxC9+7IuQUpZEGiiEuJq/KUIICAzPG+GImmGmy2ACX0KNKM2kElNz+fVLG0WwNjaiziP0xVyw3THT8wqhngPrw0RKuQXg4wDeMYmDGaTmOyPL88yI2rZ2TibGeRLy3EoVV5v9sb7U5a0uwjhFJoGNTjTkWYcD1gegiuRjHVGncCyhOyoZhpkOQgh4TrnR5MrWaIvj8p4iahUEUkTtOTsPZaKeiplG1EKI40KIpfzPFQDfCOC5iR2RQc2zC+sj70wElEdNdcyqn189ZtQGF2qUuWu1CinLtz4EedKUjFhr9UueNb0mUI6YhQU9g4S3uzDM7DCrrQLXwsXN4rO73g61LlCdtakbg1Aykbqjx1kfcZrBEkXwNmvr4zSAvxRCPAngMwA+KqX8yMSOyKDmOyXrw4yozW7GfpyN3eAS5ZH4uRVlZYyyPxzLwnLNRZr/7tWtPpZrLhyrOD2DG14ANe+22DKT8SxqhpkRZgC1XPFw0ajw2urGWhfW22rOx8lGMDKiboeJ/oyTUGdSjp6el9uxpBOTtD52TSZKKZ8E8OjEjmAHar5jzPowrQ+pM71JluHSZnfsBpc4ySBEMWyFSvSa/RiWEKj7Dk42AgDFVvMnL23jR7/xvtLzhCOE2rKErgwJ44z9aYaZEa7xuTy9FOCqUVprCdUm3o9T3UB3ejEYKb6ZlAjy51qsqA0wAmLkctsoUZ95sl1mHVHPjJpnGx61sj7STCLN1AYYz7bQjTJcb4ZIjJI9kzgv66t6NgLXwssb3bHRN9kYz+a7GwefBwB8u4iaHSFA702YpFzxwTAzwjWGIZ3IAy/9szyAum7YHscX/JFTNxuBi9NLlfz3hA4ARzWzhEkGz7HHdkzvJ3OhLOM2hvuuXVoea3pFriPgO5bO6MapHLkUIE4zVD0HVd/BmaUKvnijNTb6znKhvrzVG3qukdaHJbRdErJHzTAzw0ziV73y53AjH9RECcaFwEXg2mNbyM+v1vDT3/pafPPrTgNQXY5SFnfcBOWlivn4xfONypfdDnOhLOM2hlc9uzTm1NxAnmWyJJpOfvUbFFiyTBqBi1OLAW4YQ8IHMd+IZ640B55nWKidPMIHSKjZo2aYWeAYEfWCX/5sN3sxmv0Y15qqkGClphbWjqv6aPZjvOOhU9ouzeSwEAOFR03XCBr2NO6O/XaYC6GmnYlv+7lP4N995Bkd8S5VPD0HOskF1+z+MSPYwLWRZFlp/RZA9dcCzX6MhcDVwj8o6FkmS+2WQ0Kd3/rYxj8Ix7L0m8FVHwwzOxzbtD78oZ9bQuBq3pV4YsGH744u6yWRrXg2TjYCVDwbpLeDEXiUpPBsSzfI/OnT1/A97/v02Dv222FulKURuOhGxSodtY1FedRSyrxxRejbjKrnwHdtLZQ3OxEcyyrVOQNKqKVUY0qXqy46UYKKZw9F3z2ju7ERuPj8gFAnxiAowrEFpES+pp49aoaZFbbx4aQKLyJKM2RS4upWX/vTwM4r/MwlJjTfZ7BFPEpURE0e9bVmXxcr7KdIA3Mk1M1+jMCx9UyNZj9GLfeGupEaTehYhUe9EDiouLaufW714tFVH6mySCqejWN1H81ejAXfGdqf2DUi8TtXKnjmalmo00wOnSyq8giTTCUWuOqDYWaC+Vk+Vi9H1P04RS9KdW11I3BhCbHjCj+ThfzrwfI7sj5IqNthokv6XukS7XHMhbKYtxsAdMRrGQtuSXAjwyum1k0A+PJ6Z+RVLMqTiY3ARSNQ4ws7UTq0P7EbFcb/8bqPL15vlRppoiQbWrPjmEIds0fNMLNCGEpW9x2Yn1SKkq9s9ZBJNbCp6tlI8vVZu+Hao8vvqDyPZg31ohSnF4ORd+y3y1wINZ3IqmejH6faszaXB1B5nk7q2arQnK6kn3355tCJIcuE5lg3Kur5aGeaiRlRL1XV1vMvXm/ri0iayaEN5lQ/GSYpWx8MM0OEIc0Vzy59Fmk34lZXfe6Xq66OksdVfph4zujyO7I+KDfVjRKs1nytX4N6cTvMhbLQ7UbFs7VX3AhcnXVt92MkGSUT8wxsluUesfr6iYtbQ1exNJOQsoh8KeIedaUzhfpY7mF96ssbOtLPpCwlEgHD+ogzLs9jmBnRDpNShYXv2KXPYj9WukA9GcvGvOmd5gQR4zoPw3yiJ7Wcd6MUq3X158E79ttlrpRFedSFYNJftNlTJ9g1yvN8R0XgVMf8/PV23ntfiCmdWPKQGvmQFXo+E9P6WAxc+I6FF9fUpK1G4CLNZClhAQCeU+xNjLg8j2FmQibLFoY5bgJQk/S6YaIrwk4tFg0x40r0TMZaH6kKzujnmSw6oPebuRJqM6IGijmv23kEbFofC4GDuu+CGoYyqaJq8ypGJXV0InVEPcL66BjF6Vu9GAtBMbmv2Y+Rjoio6ard54iaYWZGI3BL+aNMylL1V5yq/BJp+Z0rVZ3f2ov1Qe3pw+V5yvoQQmhtGExk7hdzpSwV1y7VQdOKGxJW1yhS92wLgWvpiLrm2/jL59ZKzxcPdBPSaNRR1gfNAACAVj/Wq3woMZBmErY9INSuWfWRlpphGIaZHmYM5Ts2ap5KKFpCBXGmh71a87BUUZHvTmv8CLI4k8GqD6PSixpuyPrYb+ZKWQK3KM8Dioi62S+EWreQ2xYCo476gVMNfOL5G/oWqNmPsWUIPGBaH8NCbYp3nErUAzW5j7xzKcvdT0ARUffyqhS2PhhmNpj+sWsLOLaAlUe6YZzpRjca0OSNiZIJc6wF6cdWLyq1hVN5HlA0wh0R68MaaX208tZMb0ioLd019KoTNay3Izx1eVtXalB5HZ3oIqIe9qjNNyBOM9Q8RycYVVmfLI09BYoVQK1QvaFc9cEw04fKZwEVTFV9B55tQQjVCNMKYz2QaSG3Scypl6Mwx1pQ12NnIGkZJ4VQU/rqyFgfZjKRrI92LqyuIxDlV07PEQiMCPbB0w0IAB958oqu1KAIlzxq17ZQ9eyREXXLSDD2ohRV3y4lGKUsnoeg12/11DGzR80w08cSQgsozfUJXBtCqFHEYZxhI59DvVhxS3fP4yJqupN+ab2DX/vEl/TrmL0aZkRN1opZUbKfzJWyVFyVTKSSO8dWNYqU1DNnfZD1QSxVPNx7vK47ChuBW6q5JhqBO9qjNkS5mw+E6uQRtZRqDsjgmi1KWNDzsfXBMNOn7js6UUjBFDW9CKEmXNII47rvoBeluuhgp6qPRuDi01/ewJ99/joAlO6os0yqJjxDE1xbTCxPNVdCHeResFnbWDeWB5gt5GR9EKrl3Na3Ms1+rGuuTYFtVJxdy/O6cYqqV2yXoQl5QxF1/voUjXNEzTCzITbKdgFlS0oogQvjTAvyqUVlTazUxs/7IJr9uNRfMSoSJ2GWkBMdITFXykJWgml/VH1bV2SYSyZd2yqtvuqEiW5MoUqNrV6UP7YQ2HERdbtfvGYvSvKlBcUsbABwBzzqar7UkjxqrvpgmNmQDAinDuLy3YhPXNwEALz5nmMACmHfadRpL0pLlR7dqEgwFv0cuVDLyX7+50pZyEooJRQ9R0e7quGFPGqrFMFaQqDmObpdtJL38gMD1kdltFD34iR/PVtZH/ktEgAdmQ++EdX8QkE12BxRM8xsIF0ggfadYjxpJ0zw1GVliX7H68+ogM6YIz8KGmuRGI00AkI31A0uEkmz4WKD/WT/ehz3gUoufGYtdd0vqi/M8jzPtkrdR7YlELi2PvGNwNURsLlPrRE4eOHGKOtDvcZiRY1brXlqA0SUZEO3OQSNP6TIm5fbMsxsoIiaNCRwi1nxYZLhwkYXAqp8TgihS3XHCTV52KYlaltiyNv2bAvtMEEy0Gdh7mTdD+YqBKTkYC9OdR1j1RDqOM109OraolTXTO2cpudEop6kmY6iKaIeXJVDF4dGxUU3SlDJbY1elI4V6oDuACKOqBlmllAdNd2VB/kI5CyT+PJaB63cGhV5REzLsXdrITcb4cwWcjOijtOsNAb50G54Iegk9+NM1zH6TjFGMM0konyruG2JUkt3nEi1tcGoiySBta1iTVcjcNHMe//NE9lLioi6H2eo5LdQnSjR3Uv+QLKAEhe9uOxXMQwzXaguupYHWBT0SUhtpdKsaKD47O42lMmMqM2mGjN4IxulH6f43//o2cO94QUoblvMUaeeY+mIuu47EELAtVV/vdkomGRqKJKZiKQr4HLVQ8Wz8ekvbeDSZheZBCTKWxj6hvUBFE0y3SgpPOgBa4OSlPSaXJ7HMNOnHSY66UfBHt1ZUyzWCBws+MUqPt2ZuKtQl/WE7vRN6+PlfKtLP8nw4X+4nL/e/m54mWuPuhG4qHmF+C5VvVJ/vTXS+ihOvFkh0ghc/PyfP4+b+UbiwbsSal0noaZovRul+oo8GDHTm02/y1UfDDN9oiTV+04D10azH+sGFCqtXQgcXRUG3IpQlzuW6U5/s6t0JM4yXN1SS3OlLLqT6e59v5grZaGMLQkjreMi8Y2SYoEAAFgYtD5UMpEaZoo6aoGNTogv3ejoK+SV7Z7+3XaYoJ+UI2p6Azthim7uUwUDLeJ0wYgS7kxkmFlh3smSkB7LhyMVPRAWGkGxZsu2VI5rpzpqoPCobUsgSouKsg986mX1AAlsUPAHiXq+5u9QbnghzGQiGfKmr5RkEp0o0baEOR46Tosxo+Qf0f/DJMOzV5uI0kyL7nor1Ccyk1JfDEioKRrvRoku3Ru0NgYHu/CsD4aZPvTZrbgW3vrACQDQw/ylBP75G+9EnGb6e4TnWHuOqC1RBH41z8GfPaO6FV1jFZeUqhLs0G54IYpkYqrrGM0hJwuBgySVRVmecSKUR12MHQXMbiULL66rJQA0FjUylgwERs0leVhU0teJUm3FDAqxqyNqmb8Oe9QMM21Ma/RN96wCgLY4MgA/9g2vRjcvTDAxd7COg0pvLVEMcqIBT4DKU220CzuVNOxQb3gxPWpaz2X+ZVdqPiRgDEIxsrC59QGoaBkohNq2BL5wrVV6rSSV+rnNuu3/9+8vlI7F3AxRcUdH1PQGsvXBMNNno6M+7xXPxsmGWi7bNz7TS1XVG+G7VsmO8B1r7PQ8omuMR43zMl/KcwFqyciNVqiqP6Qc0oj9Yq6UJXCL8jyCRpMC+YaXpPCozYSgaX1s91SdNJXTJKnEs1dbpXI+c4KeOZCJRqrSLU83StGNyaMeEGo9UJyFmmFmBX3OKfBqBC4ahmXa7icIkwxLFa9kR+wWUUsp9WdfCIEoUQuuU0N4XlzvoNmPUXFpfMVk6jPmSllsS02f6pX2JhYnnDoTyXIw6xrjNNNCagmBP3nqGtZa6hal5tv4wrUWHr1zST/enEm9lkfgJlQb3Y0SfeGgTkSiiKiRz7/dP0+KYZi9QbtMa4ZInlmq6D9Tsm+17pXu0H3H3jGZ2I8zHQwKKI2p+06piOHJi9to9mJU84FylQnlqeZKqIHhmdTmiXXyzKs34EUDyDesFKUxP/G7T+LxlzZhWwLNXoJ2mODr7jsOQEXmZkTdH/FmZVLCtQU6UaqPZ/C2hi4Yacb7EhlmVtDnk/YgAuW73/V8FvWgZ+zZOycTzTttoLBSze8/cXEL6+1ICTWGNWK/mDt1CVyr5BmT9WELASFEKaKm2xbHEiXr46X1NgDghRttOBbwyRfULsXX37UEQF1JW/3yUgCCnuPl9a4edUoR/riIOs244oNhZgUFbDVDiM2lIpTsM21UQH1+d+pM7Brt4xDFHbxZW73Vi/HiemeoI3K/mTt1oeUBhBbq/EjNYd3m+h0l1OokreVvTD9Rty6fu7AN2xK4a6WGpYqromwjqWBeGL721Srqfurylh51SgmH6ogrMqCib674YJjZQJ3DDUOIzcCpiKjLDSiDDXJDzzsuog6H78DpIhFMSAfmTqiDAaGmE0BdiGbDCwm1RULtUqdg8ftRKvF7T1zGncsVLFZdHFvwYYnyEHDzDVmuuhAAvnCtrQvX2/m86cGImo5DCfXcnUqGORKQjblgdAKagrmeB271ERH1TtYHRc62JQBpCnWhF3csBgDUvlcAkGL/BjGZ7KouQog7hRB/KYR4VgjxeSHEj03kSHIqXtmjdm0LtiV0S2iUGNZHUtQ4xqnUbw5FwLoqI5M4lZ/QpaoLKVHa8mL28weuDd/NE5pSVZDQz2sDGV2aN5JNeGg4wzDj2e6TUI+OqDfGeNS+Y+/sUeeR83LVRWYKta6tBh47vwKgyFeZEz33k72oSwLgf5BSPgjgTQB+WAjxmokcDYaTiYD6y1NBRZRmuhmFPGqR1zjSm3Mjr+I4seCXnuNGs4+Vqockk2Otj+WqiwXfgSWAdqSSkFSOU/WHb2uo5I+FmmFmA+WbqKsYKJfKUtXHoEc9OBZ5EIqoV2oeJKReTtA1Bjs9fOei/jMANCqTWW67a9GflPIqgKv5n1tCiGcBnAHwzCQOqJIPVSkdpC10wi9OsyGPmkpn6M3Z6uZX2IoDv618qG6UQEBgpeYhSrOxddQVz8FCoKZsZVKJOP0DGOU/2ZaK5lmoGWY2UDex2SIuhFBVHWk2vupjlzpqiqhXaz5e2ujqfolOlMISKiJ/+2tPQUrgaj47yJ1hRK0RQpwH8CiAvxvxs/cIIR4XQjy+trb2ig8oyH1hE3PFTZzIIY9aSirPo1kh6o0LHBurNQ8V18ZWN8Hxho/VuprAt92L9fAm8/Wq+WhVx7aQZhLdONFX1lFiTMfm2izUDDML2n0S6oFkYX6HvdGOIMRwjmm3zkRqdlmpe/nW8aK3wrEEXFuNXH7nw3foQHJwAfZ+sWd1EULUAfwugH8tpWwO/lxK+T4p5WNSyseOHz/+ig9IWR/lk2eLckRNohimmfKIIUcmEy2hNrZ812NnceFmF3GS4fSiKoTPZOFNd6MUdH6FUG+gbQmkmUQYZ4XnPUqo81+c1JWUYZidoeTe8sDQJboDXm+Hepa9yW4RNVkcqzUPmZS6PK8Tpvn0PUu3rdu62GFGyUQAEEK4UCL9n6WUH57IkeQEbrkzEQAsS40QBHKP2rA+bEvoqx29MSTASV6N8dj5FSSZxDNXm6WrKlks3SiByE90zXdQ8x3YQo1A7EWp9qhHrYOn5IHDETXDzAT6vA960DSWOEwyLIwYkLR7w0sx7CmT0JueOmEC21LLtWlsKkXSM4uohboM/UcAz0opf24iR2FQcYetD0sI5HOPlEftqIWS7TCBLQTSTF3JenECIYxZIVJVcbzmdAMA8NJGpzSNjyo/ulEKO68qWal6WKy4kFKiH6uNDrRqZ5QY00XD5oiaYWYCBXaDHrTZfDJYmgcoa2TnhpcEVc/W3YZmZyIt0yYoMK/5+7vZhdhLGPgWAN8P4K1CiCfy/755IkeDouFFmu2CohhPGqfKo6YB4ZYlkGZqW3g/zuDb5ZPv2hbuPlZD4Fp4ca2LM8vFDACKqDthCpGfiYpno+LZoDsYCdViPk6GtVDznA+GmQkU2NV2EuqREbWNNJN6ucAgnShF1XN0ZB5n1JmokommFZrkP5vUjfVeqj7+GhirU/tOoHeeFUOWBNSmhiTf9uvZajh3JqXykvMax4pnw3dtxLlQJ5kSddsSeOBUA89c3S69eVT50erHoImpNc9B1bNLb14/zjBOhz0n3zbDETXDzASa1TOY0K+46j5ZAqiPWItFOa0oyfQcaaIdJtjuRaj5ttaMKFF32J1QVZCZQp3mt/z7uSzAZO6MVXPB7SAUAbtOMebU05P01Joc30gQJIaf/Zo7GnjmShM1z9I2RbOvxqF2okRfiiqejarn6GYaQF00Rk3GI+sFgE5GNvuxLhdiGGbyhHGGUXGS71o6wBrnUQMYWUudSYlWP0Hg2EVEne9M7EYpIMo5K4qoJxWwza1QlxKKeXBL9dF0gjpRoq+KmQQ2uxECV0XDthCIM6mbY15zuoFmP0E7TLGcl/Fc3uyhF6WlKhPypCJzNXwy+h9CJqX2rYUQen1YJieT+WUYZpgwzUbmiALX1gHWSOtjhwW3jcBFlGSIswz/9sNPAVBz7RuBq6tMStZHrhdHJ6L2ypvIAa3TWqhdW21q6MdZqYqj1Y9hW+rxji2Q5AOc2mGCu1arAIBnrjRxPO9YvJiveTevqFXPHqq3jNNMR85mxNwIXOPNVhUilXxnGsMw0yFKslKvBeE7xeTokcnEEeOSTcKkyH0BSlfSfG8rUBZquosf53ffLnMn1EXTSiGeFKFu9wqhtoSqczYHsbi2VWpAoQFOmZS4c7kKATU/tuqq25nPXdoGoArmKQiu5h41UJTexWkGyxodMVfzOwB6q1mkGWa6xGmm+xlMAtfWQd5g2VyzH+ufjRPqVj8eirbDJM0XCsiBiLq8p3W/mTuhNhfcElSat9VTPfuuLVD3HaSZRM1z9FUzcGz9hnlOsQ2mEbhYqXs4t1LFx569ASEEbCHw/PUWtroRurn4ivz3qvnwpUbeOp5JAHk7uRkxm3NAKIF5eauLdpiwV80wUyJJ5cj65cAYzOQ7Nq5s9dCPUx1wDXY4mzT7ahjb4M8ubapW8UwCvuFRx0dOqPWC2+IvTBlVqns2vSXfsbT/FKeZnrLn5yMMKZnYCFy88+E78Pz1Fj778iZ6cYpMAk9e2tZXVBJ5iqjN+bZ0NTAj5u1eseTSEgJb3QibnRiXN7vsVTPMlEizbOQIh8CxdZnvUtXFez7wOP7lBz6rA66lfIDSqGSiJQR6UTo0k5oGQGUDETXltGbamThNRlV9UEZVV30YG148x8JinhyM0qKMruLauuaafvf733wXfue/ezNed3YRmVR/+b95YR2AqiAh20SvfDemcdH12hwYtVjxtKiHSYpPfGEN//6PntXlPmyDMMzkSSVGLu4IXBtkGR9f8HHhZhefeH4NFza6A/ml4Si47jvoRumQ8JL9mmaFUDf7sW43PzoRdT6Au1cS6nJEbbaQe46lp9slqdRec+Da2vqgW52KZ+MNd63gW77iNABguebhb17YAKCE2tURtZO/TnE7ZVtCLxIgsa77jp5RbQmBp6808Q8XNnFswWeRZpgpkWWjF3eY38syqfXjtx+/iGY/1j8fNe8jTjP9/fN5IQIAbHXVXXSSqUIF0ha6Kz8yQh2MKM+j0hfatGJ6S55tYaWmRJHqHAFlX6iGF5V4pAi32Y+xmreRL1ddrOUjENUyW0v/LgBsdovoWQiBRuCi4tmlEpwtGpcqgAs3uzi3UoUlxNCoVoZh9h8p1RSgYMTOUrO5jfSk5tn4wyev4kazr0V11AQ9c5kILcUGiug7SVXpHgWAVO2x0+yQ22HuhHrQ+sgyiVSqiJbGGXoD1sdKTQlvO0z0CaOrpZd72BThqvnSKgo2u5EkCu+bvn8pL98DoC2VRuBqT7zZj3V3o29buHizi1efWECSv4Es1gwzWUhQRy2VNcWbPr8/8NXn0YtT/PHT1+Dnv7PVi4YS/1QeLATwta8+pr9PgVkmi9rsRuDqC0FyVMrzdESdn6g4tz18xxqqX4xz62O1ppIC15t9bZNQI8pgNrji2XowU5LJ0np3xxJo54NYAJSaXkaVsVtCoJW/we0wxUYnwn2n6liseEORN8Mw+w81n1QH1uS1wwSmZFLjy+vPLeHRO5fwW393QRcLqCUhZYElrVmteXgwH+oGFL0cQFFY0OzHerJefFQi6kHrg8x837H0xgVzHrXnWDiWN7Bcb/YRJTJ/jCg9lmgErp5J3ezFeOiO4k1wbQutfrznovW67+iImryrrzizpCP4Ud1QDMPsHxTh1gaa1AaFdyNfcHtmuYIf+Oq7cGW7j098oVhwMphT6uZac2oxwB2LxSC3tVZf//ncSlXnrSiyPzIetW2pYSe9gStU4Nr6ZLi2BSmlKs+zLb0bca0d6QSAqyPq4b/iyUYAS6hC99eeWdTfD1x7aALXTiRphpv5Pjbys+87tXBLf1+GYV45m/nnbzCibgRuSXw380Dq7tU63nr/SQDAtaYS3VGTLykfdmapAsvY2drsFxbJYsXVeat+PmYiOirleYDyqcngpyuUEmqyPoSOtD3HwokFtWF8vRWWtrsAo4f9N/sxnHxo+Dc8eALf9vAdAFQSsRG4aFRcOJbAfSfr+nfECPPj4mZPl/+0whh139Hr4xmGmTybeS/DqABrObdEHz67iK1ujFo+whhCVYlQcLXdG84lXd1WIn5uRVV8UJdy2xTqvCy4Ebjox2rrS3JUImqgvDyAZsBWByJqipxVeZ56kzbakVF/TZtXhltHe1GKwLEQpxKnFwN85xvO5s+rHtsIXLzx/Aq+/dEzO853feFGW/+5H2d41Yn6yCl7DMNMhu2uEs7B7S5A0Sj3nq+7Bzc7EVbrvp4RdKoRaH+7MyLx/9JGBwBwzzEVrFHAt9mN9AAoWqYbpxniVOaLro+SUHv2kPVR8Wwtwq6xQsezLXh5sfu1Zr8oUM/1ctD6oFI9qrM+0QiwWlcn3MnrIpv9GL/wrkfwHa8/q39fYviWxhTqNJOlCJxhmMlDOaJBoW72Y30XXPFsbHUjLFXV5LuKZ+P0UoC1lirNlVIOJf4v563ir84/01QhcrMTwssDOurfIF1yLHG0rI/ANYQ6v0JVvWLpbUmoHVuL6eWtopyu2Apc/itSoq/q2UilLPlYdd9BJ0x0beTJRqBLfEYlGF+40S61md93kv1phpkmZFs0BoTaEgIL+Z12P86w2Y1xfMHHQu5dn2oEuNbs55GyGEr8k/Vx97EagKK3Yrun9iU6ltAJTLr7ty3rqFkflh5sRBZH1Xd0T75XEmpL35bc7BS3L9TjTxtYBlkIXC3m1L/fqDhYyJMDJODkfY26Tn5prY3TS0VG+C6jg4lhmMlB+tDKLYtGxS0NQqv7Do7l/RX9OMV6O8TpxUAL8qnFCq43+/BsgU7+XObzXs+FeiFwcXW7V1qUa1vq9Wj5bU/f6R8x6yNwbfQjNd+Zbk98W+jEnesIRGku2o41csQhLaQdVfUBwKihjPWbVPWcUnMMUNxSyYFyHyklvnSjjbOGUJ/mRCLDTAXamUrVHK4thgahUalvO0yw1Y1Li61PNXw1C8ix0M9nyTf7MTIpcaPZx3onhIBa89UN01K/BSCw4Dv6tXra+rAmNpRpLgt9K66N7V6MimfjP//dBQDQPjSgxDc0POpRYkzjR8cKde4vXdnqo53XTA4uDACg510PWh83WiFaYYKzxrLcwRIhhmEmAwVT2z2qwhBDg9AoCia/mRaGACqiBlQ5MKTysX/ho8/jr55fx2rdQ6ufwLUt9KIUxxvl2T1SSixVi/I/XeTgiJFzQ/aDuVSWIE8cNgIXT19Ww/3NTTuOJbT14RvWh0myS0S9nGdsr2/3dfa3NqK7iW6VzAl+lhA6kXiiUUTR3fyqbIlhz4thmP2lEbhGya411LRCE/UubSmhLkXU+d2vqn1W+1b/8KmrkFK1jbu2paPoRuCWFpRkUmIlL/0DgH5UWLJHzKNWicMLNzva1Nczoy0BIUTJo3ZH+NB0wkaJOABd6XG92Uc7tz5q/nB3E1kfSSqx3Yuw3gqx3Yu0UJ8yhPpGq89zqBlmSjT7Mb7mVWoOh+9YQyV2NO+Hhv2bQl3YlAJhnOHizS6uN0N892N34te+7w34qntWsFQtWsRNezVKZalum6wPz5mc9TEXQt02zHxACXUnTEotnlTxQYXnZh21uS+tYqyAB4brqAk9H6QV6qTA4Ep5SwgcywVdQo1ZjdMMYZzh2atNLPgOVupm91PMc6gZZgpQPwRNwlysuEOD0Ky8y5mGqx03hPpY3YdtCUhIdKMET+V37q8904CERD/KUPMdVDwba82w9Npxona10mt1jYh6UtbHXAg1JQaubveUdWCpTO0zV5u6uJyGpNA6drOO2tzQQJaD2RwzCupm3GiH+rGDdkUmJR48VcwCWWv1sVT14LsWXrjRxrnVKu45VsdX3b2sXjNMWKQZZgpQPwTVP6/W/ZGD0ALHwkbeZn5sobArbEvgxIKPLFNB38t5g8uDpxo40QiQZJnuVK76dqlOW0IFk/RaFFH7+fq/ifx9J/Kst0gjcBG4Fn7iQ0/i//zYFxEnEv0kw1OXtnWybq2d9+UPCrVjqa3jlkDgWqjmYttPdrY+aJDTRifSPteCPzwvIPCK39/uJUiyDGeWqri81cOdy1UkqcT//M9eA6DwqBmGmSxUndU3RHLUIDSq/Kh59lCy/2QjQJJJpJnEi+sdHKt7OH+shkbgat8aAE4vVkrROKDqrOm1aCCb79p6dv5+MxdCDagxhJ0owf/9yRfxe/94GQDw+StNXZt8bVvdftBVzLQ+GoGrl9gu5lc+6mgc5V8DqmYaUENdKKIe1d30+nMr+Pr7inm0jmXh8lYXrX6iOyipVjvJJM+hZpgpEuqiguGKLQDwcyv02II/9LNTjUBtckkyPHu1hQeMu+dumOqgD1AFDiZPXNyClDKfSa8CvcA95BE18avf9wa89188qjuKJIB7j6sWTpoDS9Uf1JFEEbNrC7z53lV82yNnAGBoit4gVdfRz9PTQj3sUVsW8C1foYY2CaGunt0wRTtMcLIRYLlWZISTVPIcaoaZImR7jlrFBagFt0A5kUicWgwQJRm6UYrnr7fw4Omis7gTJaXRqcHAheBGK8THnruBXpSiFyuh9m1b647ZfLMfzIVQmzsNv/a+43jXG+/UP6M1W4OPp5I6eoOcfOUWWRW0bHKcUNMWl1Y/0bdPFW+46sOxiuW5tK4rkerNOL7g48xSFQuBqxcb8Bxqhpk8VIAQ5uv4LEuMFEeyPgatC0AJdZJJvLjeRphkePB0Qz9vN0y1VdLsxxiMvWwLutghzXIdEmrkBenZflZ/zYVQU2KgEyZYa4a6GN0SwFa3fOIzqXrr6RR4eVkOVYMs+HkRelxkYkdBpXjtMDFaQEcPcKI3WUCoWyhJU/aKVTx139nXKyjDMOOhAoRmL9aleaPEMdDWhzf0HFSiR0tZHjjVQCYlumGCTpToyo5elOqtUsSpRoALeTVJP051cjGMiz2K+1lYMBehH0WgnTCBRLEeK5PA37ywDiAffRqnupWb7AXPsZDJYj1XsQ24vOllELqV6YSJ/p3Bx9Jx0ZW1G6kmnAuZeoOouxFQM0G6LNQMMxXMrkAnbx8fJY7+DtbHSaMHwrUFXnWiDs+x0I9TZLK4GFQ8WzfIEXet1nB1u4eKZ6OVT+TzHEvr0n5Xf81FRE2cXqzgRCPQ0XHNs/HctRaAYuARtXLTMBbPVstrPUfVMA7WMdrWaKG2LAHHEujFaWl86iiotZyqQ2i04uKAUFMrOsMwk6cRuFiqunrC3Shx1BH1CKE2Z/Pce7yugz0KyheMO+bKwPLcB08t4OWNLuqegyRfCfjjb78f/9+/egsA7HtBwVxE1CaNwMWj55bw42+/H89c2cYfPnUNAkqon7vWUgtpPRvdMIUliiW2nm0hTrLS6nfPtnYc5O85FrpRqqfn7eZnk0VSjFY0hDq3bhiGmQ7Nfowf+vp7S18PRdTkUY+o+jAj6tcYC2xfXFc11av59L1mP9bVI4C6u7/nRB1hkuFqs49enCJwbR3Rk10C7F9kPVcRNVCsyXrHa0/hLXl7qGMLHVHHaaYmV0GWfCPXtpBkUtsY6ns7V1/Q1ZaufuOib4qoabkuPZ6SjICKqKkph2GYyWIWIJxsBHrJ7OC4UrPqw0w2tsMEUZohyDXkgdMLaPZjXN3u4eq2ajl/1cm6fl5zKFuj4uDuVRXFv7zeQT8ummMA6D2K+1n9NVcR9eDJdx2B5aoqaj+zpIQ6k2rBZJzIUqKQZsFGplCPKdkhKq4DIEYnj87HQW92LxfiUcPK676Di5vd4V9mGGbfoUS/KY70faDwl2m6RMW1tLaYP68FDvrtCHet1nQUTHfYx+vF1DyzImypqhpjAODFjQ6iJCvlq8zj2S92FWohxG8A+BYAN6SUD+3rqw8wePLPrdTw9teewt+8sI6TjeLW5cX1NrpRUrIqaFmt2U4+zsogzLGmO139LEug6hU7G5u9BJYoT9ur+bZeMc/sD3Ec49KlS+j3+7M+lLEEQYCzZ8/CdXl0wDQZVQJriiP9mTaMVz2npC2WEEiyDI3AwUY7wrmVKpIsw2LFK4Q6t0sagYsVI5m4XFUbYnzHwkvrHfTjtKRPk2AvEfX7AfwygN+c6JFg+OQ3+zF+9BtejR/+p69SV0ehIupLN3uQKGokAeVHdyNVwUGPG1eaR1B3IjDe9iCqnq1L/pr9GI2Kq+eOqJ877FHvM5cuXcLCwgLOnz8/l0uDpZTY2NjApUuXcPfdd8/6cJgBGoGLB04v4OGzi0MVIdQjcd+JBWy0I3i2Gu6WSYm1VoiFwCnpi/nn5aoHy1J27IvrXXSjwcUC+8+uHrWU8q8A3JzoUYyAbJB64ODOlSpOLQX4+vuOAwDWOyGkLHvQri2QZBJRkunoeDePmmqugd2FmrwqQFkfg7c29dyjHtwEw7xy+v0+VldX51KkATX2YHV1da4j/qNMsx/jmx46jff9wGP6a6IRuEiyDKt1H62+8rNVhO1irR2Wko/tMCm1hi9VVcLw7HIVL2100ItTVCa8NGTfkolCiPcIIR4XQjy+tra2+y/swqANAgD/5m2vBgCstyJ0omQomUjWB4nubtaHOdtj14jadUrleYsDnlTNd1QzTsz2x34yryJNzPvxHVV2SzaqJjkLp5cCSKhyX8dSjTNrrbBUzpdJCTP+Clz1XOdWqriw0VWbzWcdUe8VKeX7pJSPSSkfO378+G0/n7m7kE76+WN1VD0bW70I/Tgtiatrq4Eoavnk3oS6Hjg6iejsIaLumhF1pXwFrfvlyhCGYWbHqGSjWYlBHvU9eVKw1VeTMS0hsN4qR9RUr01UPVWKd/+pBUSpmhVS8SZbQDd35XmjME/6yUaAzW6MNJMDexQF4lRZH4VQ7yK+biG2u4l6zTeSif3hudM1o7uSOTzYto1HHnkEDz30EN75zndia2tr1ofE7IHBJdVAMeoBKDxqqt642YlKHvXgbJClqqf1pBGofYnn8xI9YPL7Ug+EUJsn/fiCj7VmiCwrtrkAeR11HlE7e4yoq55dbDbf5bEV1zGqPoatD3qjeN7H4aJSqeCJJ57A008/jZWVFbz3ve+d9SEx+wAFf68+sQAh1Fz6imcjSjK0wmSoQabZj3VCcSFw0OzHuiMSKCcbJ8FeyvN+C8A/AXBMCHEJwE9JKf/jRI9qB042Ajx5aQtLVQ+LXiGWrmMhSiXCJNXdirsKtV+OyHd8rGeX6qgH6ybrHFFPlJ/+g8/jmSvNfX3O19zRwE+987V7fvyb3/xmPPnkk/t6DMxsMCvMTiz4uLTZQyNwcZHWdhlCTdZr4NhoQYl4L7c7aAbRpD3qXYVaSvk9Ez2CW+TEgo8bzRBVzyk3vFhC7zPUEfUuDS9V1xTq3aPvbqTmgoRJNiKZmHvU3J14KEnTFB/72Mfw7ne/e9aHwuwzZ5YquJwvwF1rqwUlplBT9E1NL3csVbTfTaMtzJ6MSTBXnYl74WTDRy9OcbMT6kQAUCQTozTTAu7tECW3w6SUsfddlfG1hBhZTE/JRMoaN4LBZCJF1JxMnAS3EvnuJ71eD4888gheeuklvOENb8Db3va2mRwHMznOLlfxxMUtAMBaKxdqw6OmzzaNnFisuLCEQCYlzq/W8Ny1FgLX3lE/bpcD4VGb0FLa682wXJ7nWEhSiTDOdCS9U5ScSVmqGnGE2HHYd81T5Xk0OW/Q+qiy9XEoIY/65ZdfRhRF7FEfQs4sV3B1u4c0k1qoT4wY4kQ+9FLV0y3odywpPZKQ+74swOTgCbXRqlme9aHGnIZJaqznGv/XGyy58R17qG7bpJInHtdaapHlkEfNycRDzeLiIn7pl34JP/uzP4s45p2Yh4kzSxXEqcSNVh9rrRBCACu1omXcHPBkW0Kv6MqkxGm95GS472M/OXhCvVCMJixF1Hl03DG2MezmO9MYQwBYqAyX85iQB3W9qbrQhsvzuI76sPPoo4/i4Ycfxgc/+MFZHwqzj5xZVmJ7ebOHtXaI1ZqnCxKAYoCTYwssVVy0wkQNdPIdvPHuZbz+3BLuzreXT4oD6VETg9YHALT7id6juFslh0Rxm+La1sh5tgQJ9dVtJdSDyUTHtvTeRObw0G63S1//wR/8wYyOhJkUZ5dyod7qDXUlAkVQ5jsWFgKnNIXv9GIFv/p9bwAweh72fnHghLruO7okZrCFHEA+xHv3iJqMf4LaQoHRIwqpl/9aPqt2sDORjo09aoY5WFBEfWlTCfWoJQONwMV/+7X36M1SAErrvyaxLMDkwAm1EAInGj5e3uiWPGqzwoP2pO0k1JZQs66Jmm/vOOy7NhBRj3ozqj5veWGYg0bVc7BS87RQm9VkRLMf41Un6vrrTpigZjTiDc7D3m8OnEcNACdzn9qMqE1PibKzrjP+pNV9p+R3u7ZVajEdpGJ41L5jjexEqnm8N5FhDiJnliq4vNXDens4oh414GmUIO+kH7fLgRTq47lP7Y+wPgDoLqHd5lGbnYm7Ppasj2Z/qOKDYOuDYQ4mZ5YqeO5qE2GSDQn1bgOepsGBFOpREbWZOKTod7eqD8+29jxpj5KJa61wqNmFqPnFKFSGYQ4OZ5YruNEa7koEdh/wNA0OnFC3w0Qn8igKbvbjUqF5dY9CLYTQbeS7D2Wi2snhig+i7jtcR80wB5AzeeUHgKHJefPAgRPqTErdqOI5lvaPzNsQa2DMqbl9eBAdfe/gZwPl/YqD1gcVxFc9u7SpnEX74MNjTo8GZ5cNoR5R9TFrDpxQNwIXd+RXv16UapPfjHLNMack5GNbw/1ydD6OmnGbMxhRU0G861jo5KI9yXZSZnrwmNOjwZk5F+oDV54HAG84t4zzq1Xcc1yV0TQCtyS0x+s+XFvAsUSp1nEUlT1aH75jQQhAyuHSPF0Qb6uGl26YoDrC12JeOTzmlJkU7TDRwZdrCyxW3IkOWHolzMdR3CKuY+G3/+Wb9dfNflwaaXrHcgUf+qE36/K7vbSG79XP7kTpyGaXRuCi6ttwbQthkuHUIov0YYLHnB5e1LYXNcNj0WgRr0x4dOmtcOCE2qxpNDuCwqSoX06zYlgK/c7Y1vD8irlbuzmguhM7UToymdjsx/j+N92FH3jz+V1fk7l1eMwpMynoc3pqMYDnWLvehc+CA+dRj6tp9I39iVLKsduHB6GqD2+XJQNAEX0PvoF0saj6zp5ekzk48JjTo0EjcPF9b7oL//yNd+qv54kDJ9TjahrNKHchXz5JP9upOH2v1of52MGIeh4K4pnJwmNODzfNfoxvft1pfNNDp/XX88SBE+pxmEK7asySBXYuTqfuxFsR6lH7EmddEM9MHh5zejgZ1SI+b3fEh0ZJHGNby15sDIJaw/fiUdNj5+22iJkcPOb08DPqjpi+Py8cGqE2xdn0q3djL3NB2mGCLPe9Acxl+Q7DMK+MUZ/heQvGDo3KmNaFv4eImsRXe9TO+OW2uqElj7qFwNyV7zAMc3g5REJ9a9YHiS+1m0dJNlZ86epKUbdtTXY/GsMwjMkhEupbi6hJZMnbJmtjnPg2Ahdnlis4u1yBbQkWaYZhpsahE2rbEqUlAjvRCFzce7yO43UfJxb8HcW32Y/xvV91F777sTv11yzWDMNMg0Mj1LYlYIndhyuZNPsx7j+1gI/86Nfor0eJL5Xv1ANnKvvRGIZhTA6NUAMqqvbdvQn1uFZ0YFh8D0L5DjMZbNvG6173OiRJgrvvvhsf+MAHsLS0NOvDYo4Yh6bhBciFeo811LfSTcgNLUcXHnPKzAOHSmlcW+y5hvog1E4yBTzmlDnKHLqI+la6Ehlmr9CY02/91m+d9aEwR5BDFlHv3fpgDhY85pQ5yhwKVaOdhcr6KBbe8s5C5nbhMafMPHAohJq6DG1LlBbe8s5CZr/gMafMLDkUQk0VG7YlILD7nkSGeSXwmFNmVuzJoxZCvAPALwKwAfy6lPJnJnpUr4BG4OK/evN5vS2cRZrZD3jMKTMP7CrUQggbwHsBvA3AJQCfEUL8vpTymUkf3K3Q7Mf4xtecLH3NYs0wzGFgL9bHVwJ4QUr5ZSllBOCDAL5tsod1axyEDQ0MwzCvlL0I9RkAF42vL+XfKyGEeI8Q4nEhxONra2v7dXx7gncWHl7knCeE5/34mMPBXoR6lNoN/euUUr5PSvmYlPKx48eP3/6R3QLc4n04CYIAGxsbcyuGUkpsbGwgCIJZHwpzyNmLkl0CcKfx9VkAVyZzOAxTcPbsWVy6dAnTvkO7FYIgwNmzZ2d9GMwhZy9C/RkArxZC3A3gMoB3AfgXEz0qhgHgui7uvvvuWR8Gw8ycXYVaSpkIIf4VgD+FKs/7DSnl5yd+ZAzDMAyAPdZRSyn/CMAfTfhYGIZhmBEcis5EhmGYw4yYREZdCLEG4OV9f+KDyTEA67M+iDmHz9HO8PnZmcNyfu6SUo4smZuIUDMFQojHpZSPzfo45hk+RzvD52dnjsL5YeuDYRhmzmGhZhiGmXNYqCfP+2Z9AAcAPkc7w+dnZw79+WGPmmEYZs7hiJphGGbOYaFmGIaZc1io9wkhxDuEEF8QQrwghPifRvx8UQjxB0KIzwkhPi+E+MFZHOesEEL8hhDihhDi6TE/F0KIX8rP35NCiNdP+xhnyR7Oz/fm5+VJIcTfCiEenvYxzpLdzo/xuDcKIVIhxHdO69imAQv1PmBswfkmAK8B8D1CiNcMPOyHATwjpXwYwD8B8B+EEN5UD3S2vB/AO3b4+TcBeHX+33sA/OoUjmmeeD92Pj8vAvh6KeVXAPh3OAIJtAHej53PD30O/w+ouUSHChbq/WEvW3AkgAUhhABQB3ATQDLdw5wdUsq/gvo7j+PbAPymVHwawJIQ4vR0jm727HZ+pJR/K6XczL/8NNS44SPDHv79AMCPAPhdADcmf0TThYV6f9jLFpxfBvAg1CzvpwD8mJQym87hHQj2tEmIAQC8G8Afz/og5gkhxBkA3w7g12Z9LJOAV6DsD3vZgvN2AE8AeCuAewF8VAjxSSllc8LHdlDY0yaho44Q4p9CCfXXzPpY5oxfAPCTUspUHMIVfCzU+8NetuD8IICfkapw/QUhxIsAHgDw99M5xLmHNwntghDiKwD8OoBvklJuzPp45ozHAHwwF+ljAL5ZCJFIKX9vpke1T7D1sT/oLTh5gvBdAH5/4DEXAHwDAAghTgK4H8CXp3qU883vA/iBvPrjTQC2pZRXZ31Q84IQ4hyADwP4finl87M+nnlDSnm3lPK8lPI8gN8B8N8fFpEGOKLeF8ZtwRFC/FD+81+DytS/XwjxFNRt/k9KKQ/DaMY9IYT4Lahql2NCiEsAfgqAC+jz80cAvhnACwC6UHcgR4Y9nJ//BcAqgF/Jo8bksE+MM9nD+TnUcAs5wzDMnMPWB8MwzJzDQs0wDDPnsFAzDMPMOSzUDMMwcw4LNcMwzG2y16FR+WN/XgjxRP7f80KIrV1/h6s+GIZhbg8hxNcBaEPNq3noFn7vRwA8KqX8b3Z6HEfUDMMwt8mooVFCiHuFEH8ihPisEOKTQogHRvzq9wD4rd2enxteGIZhJsP7APyQlPKLQoivAvArULN+AABCiLsA3A3gL3Z7IhZqhmGYfUYIUQfw1QA+ZAyJ8gce9i4AvyOlTHd7PhZqhmGY/ccCsCWlfGSHx7wLaqHInp6MYRiG2Ufy8cUvCiG+C9Cr5vT6NCHE/QCWAXxqL8/HQs0wDHOb5EOjPgXgfiHEJSHEuwF8L4B3CyE+B+DzKG99+h4AH5R7LLvj8jyGYZg5hyNqhmGYOYeFmmEYZs5hoWYYhplzWKgZhmHmHBZqhmGYOYeFmmEYZs5hoWYYhplz/n+qfnAv7tzE7gAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1300,7 +1301,19 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -1322,16 +1335,353 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 66, "id": "94e01138", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[1;32mc:\\users\\surrey\\appdata\\local\\temp\\ipykernel_13892\\952329596.py\u001b[0m(2)\u001b[0;36mplot_windows\u001b[1;34m()\u001b[0m\n", + "\n", + "ipdb> data\n", + "'/dev4797/demods/0/sample.r'\n", + "ipdb> u\n", + "> \u001b[1;32mc:\\users\\surrey\\appdata\\local\\temp\\ipykernel_13892\\204029398.py\u001b[0m(4)\u001b[0;36m\u001b[1;34m()\u001b[0m\n", + "\n", + "ipdb> data\n", + "{'/dev4797/demods/0/sample.r': [\n", + "array([[2.29439020e-06, 2.52993391e-06, 2.75723595e-06, 2.98964174e-06,\n", + " 3.23372421e-06, 3.47543592e-06, 3.69586935e-06, 3.86975728e-06,\n", + " 3.99453325e-06, 4.10223783e-06, 4.21237993e-06, 4.30662357e-06,\n", + " 4.36115085e-06, 4.36670876e-06, 4.33322519e-06, 4.27960630e-06,\n", + " 4.22439338e-06, 4.17741629e-06, 4.13593279e-06, 4.08753749e-06,\n", + " 4.02874103e-06, 3.95674119e-06, 3.87274721e-06, 3.79136368e-06,\n", + " 3.72070539e-06, 3.65714470e-06, 3.58999562e-06, 3.51539276e-06,\n", + " 3.43128253e-06, 3.35685548e-06, 3.30350007e-06, 3.26843706e-06,\n", + " 3.23733412e-06, 3.19184358e-06, 3.12635385e-06, 3.04183879e-06,\n", + " 2.95828005e-06, 2.89284067e-06, 2.84518915e-06, 2.79303547e-06,\n", + " 2.72350220e-06, 2.63936473e-06, 2.55017957e-06, 2.47914483e-06,\n", + " 2.43590789e-06, 2.41025881e-06, 2.38641620e-06, 2.36224347e-06,\n", + " 2.33238955e-06, 2.30657503e-06, 2.29964887e-06, 2.31467439e-06,\n", + " 2.33662861e-06, 2.35641173e-06, 2.37137087e-06, 2.38875241e-06,\n", + " 2.42555734e-06, 2.49442274e-06, 2.58710829e-06, 2.68124350e-06,\n", + " 2.75955172e-06, 2.82052129e-06, 2.87733610e-06, 2.94696905e-06,\n", + " 3.03768035e-06, 3.13974719e-06, 3.23803296e-06, 3.32327326e-06,\n", + " 3.40098870e-06, 3.48106394e-06, 3.57135224e-06, 3.67332004e-06,\n", + " 3.78727824e-06, 3.91105568e-06, 4.02480781e-06, 4.12381018e-06,\n", + " 4.21972722e-06, 4.31759716e-06, 4.41018414e-06, 4.48567219e-06,\n", + "...\n", + " 2.49041063e-06, 2.77321990e-06, 3.04061728e-06, 3.26562599e-06,\n", + " 3.44617836e-06, 3.58972559e-06, 3.69229437e-06, 3.75108819e-06,\n", + " 3.76720779e-06, 3.73676126e-06, 3.65942105e-06, 3.54173062e-06,\n", + " 3.41260856e-06, 3.28993658e-06, 3.17870027e-06, 3.06211020e-06,\n", + " 2.92779449e-06, 2.76865066e-06, 2.58377712e-06, 2.39732687e-06,\n", + " 2.21843778e-06, 2.04805936e-06, 1.87623089e-06, 1.69492947e-06,\n", + " 1.51086329e-06, 1.34456821e-06, 1.20792319e-06, 1.09852803e-06,\n", + " 1.00639479e-06, 9.19625063e-07, 8.44927226e-07, 8.15115365e-07,\n", + " 8.58987718e-07, 9.56215893e-07, 1.06088387e-06, 1.15851062e-06,\n", + " 1.26361235e-06, 1.39030224e-06, 1.54894590e-06, 1.72907054e-06,\n", + " 1.90543392e-06, 2.06391881e-06, 2.19265471e-06, 2.30466124e-06,\n", + " 2.43189865e-06, 2.58057748e-06, 2.73695739e-06, 2.88338072e-06,\n", + " 3.01131268e-06, 3.11764855e-06, 3.21544555e-06, 3.32338756e-06,\n", + " 3.44148308e-06, 3.56020619e-06, 3.66604179e-06, 3.73940926e-06,\n", + " 3.77729370e-06, 3.79550785e-06, 3.81162227e-06, 3.83121596e-06,\n", + " 3.83801799e-06, 3.81025605e-06, 3.74768403e-06, 3.65945180e-06,\n", + " 3.56566226e-06, 3.47721041e-06, 3.39734862e-06, 3.31565888e-06,\n", + " 3.20964794e-06, 3.07155526e-06, 2.91646888e-06, 2.76448281e-06,\n", + " 2.61645019e-06, 2.46580987e-06, 2.30503591e-06, 2.12691576e-06,\n", + " 1.93655526e-06, 1.75273664e-06, 1.59066020e-06, 1.44488484e-06]])\n", + "Coordinates:\n", + " time (row, col) float64 7.02e+11 7.02e+11 7.02e+11 ... 7.1e+11 7.1e+11\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1692865553]\n", + " createdtimestamp: [42118520536]\n", + " changedtimestamp: [42601097176]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 000 10:25:53.4101\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [0]\n", + " gridrows: [3]\n", + " gridcols: [228]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [7.46666667e-05]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]\n", + " systemtime_converted: [2.82144259e+10]\n", + " createdtimestamp_converted: [7.01975342e+11]\n", + " changedtimestamp_converted: [7.10018286e+11]\n", + " device_serial: DEV4797\n", + " channel_name: /dev4797/demods/0/sample.r, \n", + "array([[2.12723580e-06, 2.23760496e-06, 2.34409608e-06, 2.45480986e-06,\n", + " 2.58202348e-06, 2.72373432e-06, 2.86547936e-06, 2.98613365e-06,\n", + " 3.07858441e-06, 3.15821730e-06, 3.23723439e-06, 3.31806729e-06,\n", + " 3.39932789e-06, 3.46726144e-06, 3.51720831e-06, 3.55372838e-06,\n", + " 3.58906441e-06, 3.62552331e-06, 3.64921291e-06, 3.64333921e-06,\n", + " 3.60605962e-06, 3.54393165e-06, 3.46699686e-06, 3.38404802e-06,\n", + " 3.28601593e-06, 3.16905198e-06, 3.03066450e-06, 2.87579468e-06,\n", + " 2.72516862e-06, 2.59823510e-06, 2.49870358e-06, 2.40657131e-06,\n", + " 2.30013378e-06, 2.18125044e-06, 2.06650061e-06, 1.97663842e-06,\n", + " 1.92529736e-06, 1.89963432e-06, 1.89520970e-06, 1.91491517e-06,\n", + " 1.97301594e-06, 2.07674031e-06, 2.22201373e-06, 2.38616190e-06,\n", + " 2.53732547e-06, 2.65875511e-06, 2.75416234e-06, 2.84033838e-06,\n", + " 2.92825281e-06, 3.01419835e-06, 3.08829442e-06, 3.13888585e-06,\n", + " 3.16163393e-06, 3.16126428e-06, 3.13547824e-06, 3.10393859e-06,\n", + " 3.05537995e-06, 2.97224076e-06, 2.85407977e-06, 2.70814828e-06,\n", + " 2.55225994e-06, 2.40195230e-06, 2.26487340e-06, 2.13223182e-06,\n", + " 1.98766554e-06, 1.83429333e-06, 1.68131171e-06, 1.53953459e-06,\n", + " 1.40899339e-06, 1.27077339e-06, 1.10317071e-06, 9.23855788e-07,\n", + " 7.71482125e-07, 6.71456432e-07, 6.36486775e-07, 6.55454995e-07,\n", + " 7.09842874e-07, 7.94481532e-07, 9.18602846e-07, 1.07654530e-06,\n", + "...\n", + " 3.94304602e-06, 3.92870392e-06, 3.90450220e-06, 3.87259374e-06,\n", + " 3.82262580e-06, 3.74567750e-06, 3.64802577e-06, 3.54361136e-06,\n", + " 3.44860437e-06, 3.37175451e-06, 3.31278739e-06, 3.25490795e-06,\n", + " 3.19235866e-06, 3.12515312e-06, 3.04788860e-06, 2.97411551e-06,\n", + " 2.91372563e-06, 2.86059908e-06, 2.79919563e-06, 2.71266144e-06,\n", + " 2.60229858e-06, 2.49230289e-06, 2.40453032e-06, 2.35249273e-06,\n", + " 2.32529326e-06, 2.29418343e-06, 2.24682171e-06, 2.17982707e-06,\n", + " 2.09702633e-06, 2.00666827e-06, 1.91139311e-06, 1.80598320e-06,\n", + " 1.67930926e-06, 1.52765746e-06, 1.36086519e-06, 1.19204382e-06,\n", + " 1.02652401e-06, 8.64534336e-07, 6.98939543e-07, 5.23912313e-07,\n", + " 3.55569145e-07, 2.99238890e-07, 4.31552196e-07, 6.25134298e-07,\n", + " 8.18765462e-07, 1.00547451e-06, 1.19518006e-06, 1.39348493e-06,\n", + " 1.61278473e-06, 1.85055243e-06, 2.08680283e-06, 2.30467341e-06,\n", + " 2.51322364e-06, 2.71778978e-06, 2.92172724e-06, 3.12142407e-06,\n", + " 3.30191267e-06, 3.44331645e-06, 3.53988173e-06, 3.60607388e-06,\n", + " 3.65136013e-06, 3.68227528e-06, 3.69619206e-06, 3.68109756e-06,\n", + " 3.63249346e-06, 3.56305266e-06, 3.49473954e-06, 3.43892607e-06,\n", + " 3.39039549e-06, 3.34318950e-06, 3.29465898e-06, 3.25042605e-06,\n", + " 3.22296643e-06, 3.22503742e-06, 3.26336285e-06, 3.33671955e-06,\n", + " 3.43454020e-06, 3.54592527e-06, 3.65842302e-06, 3.76783180e-06]])\n", + "Coordinates:\n", + " time (row, col) float64 7.14e+11 7.14e+11 ... 7.221e+11 7.221e+11\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1692865565]\n", + " createdtimestamp: [42842295896]\n", + " changedtimestamp: [43323317976]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 001 10:26:05.5124\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [1]\n", + " gridrows: [3]\n", + " gridcols: [228]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [7.46666667e-05]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]\n", + " systemtime_converted: [2.82144261e+10]\n", + " createdtimestamp_converted: [7.14038265e+11]\n", + " changedtimestamp_converted: [7.220553e+11]\n", + " device_serial: DEV4797\n", + " channel_name: /dev4797/demods/0/sample.r, \n", + "array([[2.79262726e-06, 2.79339751e-06, 2.82217203e-06, 2.88056241e-06,\n", + " 2.95310839e-06, 3.01499023e-06, 3.06179701e-06, 3.09597215e-06,\n", + " 3.12131343e-06, 3.13378712e-06, 3.12411928e-06, 3.07715484e-06,\n", + " 2.98358734e-06, 2.85706070e-06, 2.71564218e-06, 2.57667845e-06,\n", + " 2.46745593e-06, 2.39234392e-06, 2.34263476e-06, 2.30327467e-06,\n", + " 2.27420455e-06, 2.26380410e-06, 2.28060478e-06, 2.32386238e-06,\n", + " 2.38739313e-06, 2.45775869e-06, 2.51761694e-06, 2.56769643e-06,\n", + " 2.61412652e-06, 2.67399000e-06, 2.75499425e-06, 2.86163773e-06,\n", + " 2.97733546e-06, 3.07722970e-06, 3.16598875e-06, 3.25576346e-06,\n", + " 3.35898646e-06, 3.47217865e-06, 3.59113766e-06, 3.71320443e-06,\n", + " 3.81895359e-06, 3.90954786e-06, 3.98830342e-06, 4.06249413e-06,\n", + " 4.14424551e-06, 4.22680061e-06, 4.30422724e-06, 4.36571725e-06,\n", + " 4.40926062e-06, 4.44258258e-06, 4.48156961e-06, 4.52630871e-06,\n", + " 4.56888815e-06, 4.59477942e-06, 4.59834265e-06, 4.58300461e-06,\n", + " 4.54452397e-06, 4.48350220e-06, 4.41033290e-06, 4.32362421e-06,\n", + " 4.22282891e-06, 4.11940521e-06, 4.01891875e-06, 3.92727138e-06,\n", + " 3.84787777e-06, 3.77289640e-06, 3.68947346e-06, 3.58688210e-06,\n", + " 3.46944214e-06, 3.34788523e-06, 3.21801208e-06, 3.07146738e-06,\n", + " 2.91309509e-06, 2.73817889e-06, 2.54764266e-06, 2.34712637e-06,\n", + " 2.15276381e-06, 1.98188004e-06, 1.82792359e-06, 1.66951343e-06,\n", + "...\n", + " 2.18201987e-06, 2.21679803e-06, 2.24835478e-06, 2.26302432e-06,\n", + " 2.25136247e-06, 2.21603749e-06, 2.15799395e-06, 2.07788505e-06,\n", + " 1.97901834e-06, 1.85691843e-06, 1.69909991e-06, 1.51266192e-06,\n", + " 1.31823588e-06, 1.13678757e-06, 9.78015190e-07, 8.33718609e-07,\n", + " 6.90393314e-07, 5.34693456e-07, 3.70656540e-07, 2.21539753e-07,\n", + " 1.22670757e-07, 1.27768775e-07, 1.93610322e-07, 2.82684197e-07,\n", + " 3.92947022e-07, 5.18975722e-07, 6.44946036e-07, 7.54553378e-07,\n", + " 8.49543740e-07, 9.34776770e-07, 1.02796742e-06, 1.13058844e-06,\n", + " 1.23852123e-06, 1.33367012e-06, 1.40267240e-06, 1.43066637e-06,\n", + " 1.43042025e-06, 1.41879443e-06, 1.40802429e-06, 1.39637804e-06,\n", + " 1.37179232e-06, 1.32372484e-06, 1.24864587e-06, 1.15479332e-06,\n", + " 1.05958924e-06, 9.68016586e-07, 8.85974042e-07, 8.23572727e-07,\n", + " 7.78173531e-07, 7.46997584e-07, 7.28239475e-07, 7.24959819e-07,\n", + " 7.44458592e-07, 7.97958600e-07, 8.80279119e-07, 9.81560872e-07,\n", + " 1.09481635e-06, 1.21047572e-06, 1.33014059e-06, 1.45888109e-06,\n", + " 1.59521543e-06, 1.74241577e-06, 1.88925184e-06, 2.00906439e-06,\n", + " 2.09886371e-06, 2.16600461e-06, 2.22529855e-06, 2.28458072e-06,\n", + " 2.35115533e-06, 2.41597634e-06, 2.46188217e-06, 2.47378364e-06,\n", + " 2.45832351e-06, 2.41744537e-06, 2.35310032e-06, 2.27776603e-06,\n", + " 2.19571905e-06, 2.09161968e-06, 1.94733021e-06, 1.77332086e-06]])\n", + "Coordinates:\n", + " time (row, col) float64 7.261e+11 7.261e+11 ... 7.341e+11 7.341e+11\n", + "Dimensions without coordinates: row, col\n", + "Attributes:\n", + " systemtime: [1692865577]\n", + " createdtimestamp: [43565202136]\n", + " changedtimestamp: [44047133656]\n", + " flags: [1849]\n", + " moduleflags: [0]\n", + " chunksizebytes: [0]\n", + " name: 002 10:26:17.4266\n", + " status: [0]\n", + " groupindex: [0]\n", + " color: [0]\n", + " activerow: [2]\n", + " triggernumber: [2]\n", + " gridrows: [3]\n", + " gridcols: [228]\n", + " gridmode: [4]\n", + " gridoperation: [1]\n", + " griddirection: [0]\n", + " gridrepetitions: [1]\n", + " gridcoldelta: [7.46666667e-05]\n", + " gridcoloffset: [-0.001]\n", + " gridrowdelta: [1.]\n", + " gridrowoffset: [0.]\n", + " bandwidth: [nan]\n", + " center: [0.]\n", + " nenbw: [nan]\n", + " systemtime_converted: [2.82144263e+10]\n", + " createdtimestamp_converted: [7.26086702e+11]\n", + " changedtimestamp_converted: [7.34118894e+11]\n", + " device_serial: DEV4797\n", + " channel_name: /dev4797/demods/0/sample.r]}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ipdb> r\n" + ] + } + ], + "source": [ + "%debug" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "eb3982ba", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\\\\Janeway\\User AG Bluhm\\Surrey\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:551: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "my_lockin.register_operations(\"test\", postprocessing_average_within_windows)\n", + "setup.run_program(\"test\")" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "97961792", + "metadata": {}, "outputs": [], - "source": [] + "source": [ + "for _ in range(3*3):\n", + " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 1)\n", + " time.sleep(1)\n", + " my_lockin.api_session.setDouble(f\"/{my_lockin.serial}/auxouts/0/offset\", 0)\n", + " time.sleep(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "0c875430", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\\\\Janeway\\User AG Bluhm\\Surrey\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:236: UserWarning: The received data for channel auxins/0/sample.AuxIn0.avg is empty.\n", + " warnings.warn(f\"The received data for channel {_cn} is empty.\")\n" + ] + } + ], + "source": [ + "data = my_lockin.measure_program(wait=False, return_raw=False)#(wait=False, fail_if_incomplete=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "b66d0af1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'X': {'/dev4797/demods/0/sample.x': [-1.6976033251434238e-07]},\n", + " 'R': {'/dev4797/demods/0/sample.r': [2.7888774838955474e-06,\n", + " 2.803098860263337e-06]},\n", + " 'A': {'/dev4797/auxins/0/sample.auxin0.avg': [-0.0011679467272793786,\n", + " -0.0011265247281813495]}},\n", + " {'X': {'/dev4797/demods/0/sample.x': [6.544044351717994e-07]},\n", + " 'R': {'/dev4797/demods/0/sample.r': [1.2454712756408315e-06,\n", + " 2.5542675760151297e-06]},\n", + " 'A': {}},\n", + " {'X': {'/dev4797/demods/0/sample.x': [-8.034974107565979e-07]},\n", + " 'R': {'/dev4797/demods/0/sample.r': [1.921719080586302e-06,\n", + " 8.421336791063582e-07]},\n", + " 'A': {'/dev4797/auxins/0/sample.auxin0.avg': [-0.0006591849960386753,\n", + " -0.0006591849960386753]}}]" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] }, { "cell_type": "code", "execution_count": null, - "id": "eb3982ba", + "id": "bef6b06c", "metadata": {}, "outputs": [], "source": [] @@ -1339,7 +1689,7 @@ { "cell_type": "code", "execution_count": null, - "id": "0c875430", + "id": "b53d2f80", "metadata": {}, "outputs": [], "source": [] @@ -1347,7 +1697,7 @@ { "cell_type": "code", "execution_count": null, - "id": "4ae8bf57", + "id": "77491fc3", "metadata": {}, "outputs": [], "source": [] @@ -1355,7 +1705,7 @@ { "cell_type": "code", "execution_count": null, - "id": "bef6b06c", + "id": "5f8a9a09", "metadata": {}, "outputs": [], "source": [] diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index 68743aa3b..392c21588 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -33,7 +33,6 @@ logger = logging.getLogger(__name__) - @dataclasses.dataclass class TriggerSettings: trigger_input: str @@ -119,6 +118,130 @@ def add_to_windows(name, begins, lengths): return new_program +def postprocessing_crop_windows( + serial:str, + recorded_data: Mapping[str, List[xr.DataArray]], + program: MFLIProgram, + fail_on_empty: bool = True) -> Mapping[str, Mapping[str, List[xr.DataArray]]]: + """ This function parses the recorded data and extracts the measurement masks + """ + + # the first dimension of channel_data is expected to be the history of multiple not read data points. This will + # be handled as multiple entries in a list. This will then not make too much sense, if not every channel as this + # many entries. If this is the case, they will be stacked, such that for the last elements it fits. + # TODO do this based on the timestamps and not the indices. That might be more sound than just assuming that. + + # applying measurement windows and optional operations + # TODO implement operations + + # targeted structure: + # results[][] -> [data] + + masked_data = {} + + # the MFLI returns a list of measurements. We only proceed with the last ones from this list. One might want to + # iterate over that and process all of them.This feature might be useful if after some measurements no read() + # operation is called. Then with the later read, the data is returned. + # TODO this might be more elegantly implemented or handled using yields! + shot_index = 0 # TODO make this more flexible to not lose things + + for window_name, (begins, lengths) in program.windows.items(): + data_by_channel = {} + # _wind = program["windows"][window_name] + for ci, _cn in enumerate(program.channel_mapping[window_name]): + cn = f"/{serial}/{_cn}".lower() + + if len(recorded_data[cn]) <= shot_index: + # then we do not have data for this shot_index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save. + warnings.warn( + f"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{shot_index}]") + continue + applicable_data = recorded_data[cn][-1 - shot_index] + applicable_data = applicable_data.where(~np.isnan(applicable_data), drop=True) + + if len(applicable_data) == 0 or np.product([*applicable_data.shape]) == 0: + if fail_on_empty: + raise ValueError(f"The received data for channel {_cn} is empty.") + else: + warnings.warn(f"The received data for channel {_cn} is empty.") + continue + + extracted_data = [] + for b, l in zip(begins, lengths): + # _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)["time"][:, 0].values + + _time_of_first_not_nan_value = applicable_data["time"][:, 0].values + + time_of_trigger = -1 * applicable_data.attrs["gridcoloffset"][ + 0] * 1e9 + _time_of_first_not_nan_value + + foo = applicable_data.where((applicable_data["time"] >= (time_of_trigger + b)[:, None]) & ( + applicable_data["time"] <= (time_of_trigger + b + l)[:, None]), drop=False).copy() + foo2 = foo.where(~np.isnan(foo), drop=True) + rows_with_data = np.sum(~np.isnan(foo), axis=-1) > 0 + foo2["time"] -= time_of_trigger[rows_with_data, None] + extracted_data.append(foo2) + + data_by_channel.update({cn: extracted_data}) + masked_data[window_name] = data_by_channel + + return masked_data + + +def postprocessing_average_within_windows( + serial:str, + recorded_data: Mapping[str, List[xr.DataArray]], + program: MFLIProgram, + fail_on_empty: bool = True) -> Mapping[str, Mapping[str, List[float]]]: + """ This function returns one float per window that averages each channel individually for that window. + """ + + # targeted structure: + # results[][] -> [data] + + masked_data = {} + + shot_index = 0 # TODO make this more flexible to not lose things + + for window_name, (begins, lengths) in program.windows.items(): + data_by_channel = {} + # _wind = program["windows"][window_name] + for ci, _cn in enumerate(program.channel_mapping[window_name]): + cn = f"/{serial}/{_cn}".lower() + + if len(recorded_data[cn]) <= shot_index: + # then we do not have data for this shot_index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save. + warnings.warn( + f"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{shot_index}]") + continue + applicable_data = recorded_data[cn][-1 - shot_index] + applicable_data = applicable_data.where(~np.isnan(applicable_data), drop=True) + + if len(applicable_data) == 0 or np.product([*applicable_data.shape]) == 0: + if fail_on_empty: + raise ValueError(f"The received data for channel {_cn} is empty.") + else: + warnings.warn(f"The received data for channel {_cn} is empty.") + continue + + extracted_data = [] + for b, l in zip(begins, lengths): + # _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)["time"][:, 0].values + + _time_of_first_not_nan_value = applicable_data["time"][:, 0].values + + time_of_trigger = -1 * applicable_data.attrs["gridcoloffset"][ + 0] * 1e9 + _time_of_first_not_nan_value + + foo = np.nanmean(applicable_data.where((applicable_data["time"] >= (time_of_trigger + b)[:, None]) & ( + applicable_data["time"] <= (time_of_trigger + b + l)[:, None]), drop=False)) + extracted_data.append(foo) + + data_by_channel.update({cn: extracted_data}) + masked_data[window_name] = data_by_channel + + return masked_data + class MFLIDAQ(DAC): """ This class contains the driver for using the DAQ module of an Zuerich Instruments MFLI with qupulse. """ @@ -570,74 +693,6 @@ def clear(self) -> None: self.unarm_program() self.read_memory.clear() - def _parse_data(self, - recorded_data: Mapping[str, List[xr.DataArray]], - program: MFLIProgram, - fail_on_empty: bool = True) -> Mapping[str, Mapping[str, List[xr.DataArray]]]: - """ This function parses the recorded data and extracts the measurement masks and applies optional operations - """ - - # the first dimension of channel_data is expected to be the history of multiple not read data points. This will - # be handled as multiple entries in a list. This will then not make too much sense, if not every channel as this - # many entries. If this is the case, they will be stacked, such that for the last elements it fits. - # TODO do this based on the timestamps and not the indices. That might be more sound than just assuming that. - - # applying measurement windows and optional operations - # TODO implement operations - - # targeted structure: - # results[][] -> [data] - - masked_data = {} - - # the MFLI returns a list of measurements. We only proceed with the last ones from this list. One might want to - # iterate over that and process all of them.This feature might be useful if after some measurements no read() - # operation is called. Then with the later read, the data is returned. - # TODO this might be more elegantly implemented or handled using yields! - shot_index = 0 # TODO make this more flexible to not lose things - - for window_name, (begins, lengths) in program.windows.items(): - data_by_channel = {} - # _wind = program["windows"][window_name] - for ci, _cn in enumerate(program.channel_mapping[window_name]): - cn = f"/{self.serial}/{_cn}".lower() - - if len(recorded_data[cn]) <= shot_index: - # then we do not have data for this shot_index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save. - warnings.warn( - f"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{shot_index}]") - continue - applicable_data = recorded_data[cn][-1 - shot_index] - applicable_data = applicable_data.where(~np.isnan(applicable_data), drop=True) - - if len(applicable_data) == 0 or np.product([*applicable_data.shape]) == 0: - if fail_on_empty: - raise ValueError(f"The received data for channel {_cn} is empty.") - else: - warnings.warn(f"The received data for channel {_cn} is empty.") - continue - - extracted_data = [] - for b, l in zip(begins, lengths): - # _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)["time"][:, 0].values - - _time_of_first_not_nan_value = applicable_data["time"][:, 0].values - - time_of_trigger = -1 * applicable_data.attrs["gridcoloffset"][ - 0] * 1e9 + _time_of_first_not_nan_value - - foo = applicable_data.where((applicable_data["time"] >= (time_of_trigger + b)[:, None]) & ( - applicable_data["time"] <= (time_of_trigger + b + l)[:, None]), drop=False).copy() - foo2 = foo.where(~np.isnan(foo), drop=True) - rows_with_data = np.sum(~np.isnan(foo), axis=-1) > 0 - foo2["time"] -= time_of_trigger[rows_with_data, None] - extracted_data.append(foo2) - - data_by_channel.update({cn: extracted_data}) - masked_data[window_name] = data_by_channel - - return masked_data - def get_mfli_data(self, wait: bool = True, timeout: float = np.inf, @@ -673,6 +728,12 @@ def get_mfli_data(self, program = self._armed_program + if callable(program.operations): + program.operations = [program.operations] + + if program.operations is None or len(program.operations) == 0: + return_raw = True + # wait until the data acquisition has finished # TODO implement timeout _endless_flag_helper = program.trigger_settings.is_endless() @@ -801,7 +862,7 @@ def get_mfli_data(self, _the_warning_string = f"Parsing some data did not work. This might fix itself later, when the missing data is retrieved from the device. If not, clearing the memory (i.e. self.clear_memory()), resetting the daq_module (i.e. self.reset_daq_module()), or setting the field to the selected program (i.e., self.currently_set_program=None) to None and then rearming the original program might work. For debugging purposes, one might want to call the measure function with the return_raw=True parameter." try: - that_shot_parsed = self._parse_data(that_shot, program, fail_on_empty=fail_on_empty) + that_shot_parsed = program.operations[0](serial=self.serial, recorded_data=that_shot, program=program, fail_on_empty=fail_on_empty) except IndexError as e: traceback.print_exc() warnings.warn(_the_warning_string) From a4926137406de2751ad4fba128aabd1bd66aa1a6 Mon Sep 17 00:00:00 2001 From: Paul Surrey Date: Thu, 24 Aug 2023 10:51:43 +0200 Subject: [PATCH 25/25] added default operation --- .../zurich_instruments_lockin_mfli_daq.ipynb | 451 ++++-------------- qupulse/hardware/dacs/mfli.py | 224 +++------ 2 files changed, 165 insertions(+), 510 deletions(-) diff --git a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb index ca2d5ddc2..5f0f20387 100644 --- a/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb +++ b/qupulse/examples/zurich_instruments_lockin_mfli_daq.ipynb @@ -13,7 +13,10 @@ "id": "d11c4c6c", "metadata": {}, "source": [ - "This notebook was used to develop the qupulse MFLI driver and is now intended as a documentation with examples." + "This notebook was used to develop the qupulse MFLI driver and is now intended as a documentation with examples.\n", + "\n", + "\n", + "To run this notebook, a MFLI is needed. **Further, the aux output with the printed label ```Aux Output 1``` has to be connected to the trigger input with the printed label ``` Trigger In 1```.**\n" ] }, { @@ -81,7 +84,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "5a7826ef", + "id": "744c6f73", "metadata": {}, "outputs": [], "source": [ @@ -103,7 +106,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a9fe5e61", + "id": "4515c7a8", "metadata": {}, "outputs": [], "source": [] @@ -128,7 +131,7 @@ }, { "cell_type": "markdown", - "id": "6724c4a8", + "id": "bd5cfd82", "metadata": {}, "source": [ "And the sample rate and aux outputs are configured" @@ -137,7 +140,7 @@ { "cell_type": "code", "execution_count": 10, - "id": "faaf68cc", + "id": "6d1eed5b", "metadata": {}, "outputs": [], "source": [ @@ -147,7 +150,7 @@ { "cell_type": "code", "execution_count": 11, - "id": "3b311267", + "id": "1be6716c", "metadata": {}, "outputs": [], "source": [ @@ -243,7 +246,7 @@ { "data": { "text/plain": [ - "MFLIProgram(default_channels=None, channel_mapping={'R': {'demods/0/sample.R'}, 'X': {'demods/0/sample.X'}, 'Y': {'demods/0/sample.Y'}, 'A': {'auxins/0/sample.AuxIn0.avg'}, 'many': {'demods/0/sample.Y', 'demods/0/sample.R', 'demods/0/sample.X', 'auxins/0/sample.AuxIn0.avg'}}, windows=None, trigger_settings=None, other_settings={}, operations=None)" + "MFLIProgram(default_channels=None, channel_mapping={'R': {'demods/0/sample.R'}, 'X': {'demods/0/sample.X'}, 'Y': {'demods/0/sample.Y'}, 'A': {'auxins/0/sample.AuxIn0.avg'}, 'many': {'demods/0/sample.X', 'auxins/0/sample.AuxIn0.avg', 'demods/0/sample.Y', 'demods/0/sample.R'}}, windows=None, trigger_settings=None, other_settings={}, operations=)" ] }, "execution_count": 15, @@ -291,7 +294,7 @@ { "data": { "text/plain": [ - "{'test': MFLIProgram(default_channels=None, channel_mapping=None, windows={'A': (array([0, 3]), array([ 1, 10])), 'many': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))}, trigger_settings=None, other_settings={}, operations=None)}" + "{'test': MFLIProgram(default_channels=None, channel_mapping=None, windows={'A': (array([0, 3]), array([ 1, 10])), 'many': (array([0. , 0.002, 0.004]), array([0.001 , 0.004 , 0.0061]))}, trigger_settings=None, other_settings={}, operations=)}" ] }, "execution_count": 17, @@ -345,13 +348,13 @@ { "cell_type": "code", "execution_count": 20, - "id": "3b91d286", + "id": "1eb601a8", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "MFLIProgram(default_channels=None, channel_mapping={'R': {'demods/0/sample.R'}, 'X': {'demods/0/sample.X'}, 'Y': {'demods/0/sample.Y'}, 'A': {'auxins/0/sample.AuxIn0.avg'}, 'many': {'demods/0/sample.Y', 'demods/0/sample.R', 'demods/0/sample.X', 'auxins/0/sample.AuxIn0.avg'}}, windows=None, trigger_settings=None, other_settings={}, operations=None)" + "MFLIProgram(default_channels=None, channel_mapping={'R': {'demods/0/sample.R'}, 'X': {'demods/0/sample.X'}, 'Y': {'demods/0/sample.Y'}, 'A': {'auxins/0/sample.AuxIn0.avg'}, 'many': {'demods/0/sample.X', 'auxins/0/sample.AuxIn0.avg', 'demods/0/sample.Y', 'demods/0/sample.R'}}, windows=None, trigger_settings=None, other_settings={}, operations=)" ] }, "execution_count": 20, @@ -475,7 +478,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'T', 'R', 'A'}\n", + "{'R', 'A', 'T'}\n", "[]\n", "set()\n" ] @@ -497,7 +500,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\Surrey\\AppData\\Local\\Temp\\ipykernel_13892\\4247546520.py:1: DeprecationWarning: This is only a hack until https://github.com/qutech/qupulse/issues/578 is resolved. Do not call this method directly\n", + "C:\\Users\\Surrey\\AppData\\Local\\Temp\\ipykernel_18272\\4247546520.py:1: DeprecationWarning: This is only a hack until https://github.com/qutech/qupulse/issues/578 is resolved. Do not call this method directly\n", " combined_pulse.get_measurement_windows(parameters={\"dt\": 1e8}, measurement_mapping={\"A\":\"A\", \"R\":\"R\", \"T\":\"T\"})\n" ] }, @@ -528,7 +531,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -586,7 +589,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -748,7 +751,7 @@ { "cell_type": "code", "execution_count": 39, - "id": "1fd061c4", + "id": "b54bec7a", "metadata": {}, "outputs": [ { @@ -930,14 +933,28 @@ "setup.register_program('test', test_program, run_callback=lambda *a, **b: None, update=True)" ] }, + { + "cell_type": "markdown", + "id": "82a4d52f", + "metadata": {}, + "source": [ + "Without registering an operation, the raw recorded data is returned when calling the ```my_lockin.measure_program``` function. One can register operations that are then used to post process the data. As of writing this, the function ```postprocessing_crop_windows``` and ```postprocessing_average_within_windows``` are implemented. The first crops the raw data to the specified measurement windows, the second one averages the whole windows down to floats. ```postprocessing_crop_windows``` is the default." + ] + }, { "cell_type": "code", "execution_count": 49, - "id": "b10655d1", + "id": "3f21a648", "metadata": {}, "outputs": [], "source": [ + "# returning raw data:\n", + "my_lockin.register_operations(\"test\", None)\n", + "\n", + "# back to the default\n", "my_lockin.register_operations(\"test\", postprocessing_crop_windows)\n", + "\n", + "# or to average (the plotting implemented within this notebook does not work with this operation)\n", "# my_lockin.register_operations(\"test\", postprocessing_average_within_windows)" ] }, @@ -984,7 +1001,7 @@ " 1.83e+08, 1.92e+08]), array([1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", " 1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", " 1500000., 3000000., 1500000., 3000000., 1500000., 3000000.,\n", - " 1500000., 3000000.]))}, trigger_settings=None, other_settings={}, operations=None)" + " 1500000., 3000000.]))}, trigger_settings=None, other_settings={}, operations=)" ] }, "execution_count": 51, @@ -1032,7 +1049,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "\\\\Janeway\\User AG Bluhm\\Surrey\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:551: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + "\\\\Janeway\\User AG Bluhm\\Surrey\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:473: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", " warnings.warn(\n" ] } @@ -1103,15 +1120,23 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 57, "id": "8d97dfac", "metadata": { "scrolled": true }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\\\\Janeway\\User AG Bluhm\\Surrey\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:96: UserWarning: The received data for channel auxins/0/sample.AuxIn0.avg is empty.\n", + " warnings.warn(f\"The received data for channel {_cn} is empty.\")\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1123,7 +1148,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1135,7 +1160,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1173,7 +1198,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 58, "id": "1ac65d7f", "metadata": {}, "outputs": [], @@ -1184,7 +1209,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 59, "id": "fe7ace96", "metadata": { "scrolled": true @@ -1197,7 +1222,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 60, "id": "be1c9ade", "metadata": {}, "outputs": [], @@ -1213,17 +1238,7 @@ }, { "cell_type": "code", - "execution_count": 67, - "id": "d0eac924", - "metadata": {}, - "outputs": [], - "source": [ - "my_lockin.register_operations(\"test2\", postprocessing_crop_windows)" - ] - }, - { - "cell_type": "code", - "execution_count": 68, + "execution_count": 61, "id": "58dee40c", "metadata": {}, "outputs": [], @@ -1233,7 +1248,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 62, "id": "dc4dc54f", "metadata": {}, "outputs": [], @@ -1247,25 +1262,13 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 63, "id": "d206d097", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1277,7 +1280,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1289,31 +1292,7 @@ }, { "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAEQCAYAAACZYT5EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAy7klEQVR4nO3dd3ib1d3/8feRLUvykPeItzOcSRInJglhJuxZCmUWuii0hbb06XpG9/zxtJTu0oe2lFlo2XtTVkgI2TvOcOx4JHa85CVb4/z+sG9FTkziJBq3pe/ruriKreHD7fqjc3/PUlprhBBCmJcl2g0QQghxZBLUQghhchLUQghhchLUQghhchLUQghhchLUQghhcmELaqXUvUqpFqXUphC9X6lS6lWl1Fal1BalVHko3lcIIcwunD3q+4ALQvh+DwC/1FpPBxYALSF8byGEMK2wBbXW+h2gPfh7SqlJSqmXlVKrlVLvKqWmjeW9lFIzgESt9WvD792jte4LfauFEMJ8Il2jvgf4itZ6PvBN4E9jfF0l0KmUelIptVYp9UulVELYWimEECaSGKkfpJRKBRYDjymljG/bhh+7AvjxKC9r1Fqfz1A7TweqgHrgn8BngL+Ft9VCCBF9EQtqhnrvnVrruYc+oLV+EnjyCK9tANZqrXcDKKWeBhYhQS2EiAMRK31orV1ArVLqKgA1ZM4YX/4hkKmUyh3+eimwJQzNFEII0wnn9LxHgOXAVKVUg1LqJuCTwE1KqfXAZuBjY3kvrbWPoZr2G0qpjYAC/hKelgshhLko2eZUCCHMTVYmCiGEyYVlMDEnJ0eXl5eH462FECImrV69+oDWOne0x8IS1OXl5axatSocby2EEDFJKVX3UY9J6UMIIUxOgloIIUxOgloIIUxOgloIIUxOgloIIUxOgjoEega8uNyeEd9zuT30DHij1CIhRCyJ5KZMMadnwIt/eGVn/6Av8P3eAS8WpXAkyU6sQogTJ0F9Avxa0z/ow5ZoYZ/Lzfs7D1B7oJdbzphIntOO026NdhOFEDFAgvoYGb1op92K027l7e2tfO+ZTXT2DZU+7FYLN58+UUJaCBEyEtTHyOhF+/2aB5fXcddrNVTkpHDDwlKmTXAyrzSTBIvC5fZIWAshQkKC+hg57Vb8fs23H9/Aq1v2c870PG4+o4KUJCsOawKp9qFLatSsJayFECdKgnoMgssdAI+s3MurW/Zz/cJSrju5hJw0Gym2gwHtSErAkZSA5eCRY0IIcdwkqMfAKHcAbG508ctXtnH65ByuqS4iOSmRFFviiJ6zRSlSbXJphRChIWkyBkYI723v49aHV1OY7uB7l06nMt+Jy+0ZUeaQUocQItQkqMcoNSmRHz67mf5BH3d+Yg6V+U7gYIhLmUMIES6yMvEIglcc3v32Lj7c08GXzppERW7KiJWITrtVSh1CiLCRdDkCoza9rr6D37xew2mTc7jm5BJ8QTVrKXUIIcJNgvoInHYrAx4fP3x2C6m2RL578XSShwcOXW6PlDuEEBEhQX0U9y7bw+4Dvdx19RwyU5ICPWjpSQshIkVq1IcIrkuv39vJ/729iwtm5jO3JAPgsF3yhBAi3KRHfQijLj3o9fP1f60jMzmJL505mZw0GyArDoUQkTemoFZK7QG6AR/g1VpXh7NR0WQE8K9fq2FXay8/u3wWFXkphy1oEUKISDmWHvUSrfWBsLXERFpcbh5YXseFswo4Z0b+iJCWnrQQItKkRn0IrTXff2YzDmsCXz17CiB1aSFEdI01qDXwqlJqtVLqltGeoJS6RSm1Sim1qrW1NXQtjIDgAcRn1zfx/q42bjqtnJKsZBxJCfQP+iSshRBRM9bSx6la6yalVB7wmlJqm9b6neAnaK3vAe4BqK6u1iFuZ1gZA4gDHh+/fGU7FTkpXF1dMmLHPKlLCyGiZUw9aq110/D/tgBPAQvC2ahIc9qtOJISuHfZHho6+vnmeZWkOawj5kzLEnEhRLQcNaiVUilKqTTj34HzgE3hblikJSVYeOSDehZPyqa6PEsGDYUQpjGWbmI+8JQauvVPBP6htX45rK2Kgn+srKez38MNi8oA5CgtIYRpHDWotda7gTkRaEvUdPYN8sD7e5g+IY0LZxXQPeCVhS1CCNOI2+l5wTM9lu1qY09bH586pZzeQV+gZi0DiELEp+B8MLjcHnoGvFFpT9yOkAUfr/Xwijry0mycMSUHvx6asCI9aSHij3E+KhzcLqJ3wEuP24vTMdSBAwK7Z0ZqkkHcBrURxOv3dvL+rja+vGTyiJkeQoj4Y3Tg9rb38f6uNpbvbqOps595pRlcVV3C4kk5geP3jNCOhLgNahgK65c27iPRorhsbqGEtBBxyOhFG2eePri8jjtf2Y4GCjPs5KTaeGZdE0+tbWJ+WSbfOLeSWcXpgbyIRO86roO6s2+Q17fuZ9HEbNIdVpnpIUQcMnrRPr/md2/s4O/L9rB4UjY3n15Bbpqd3DQbB3oGeGpNIw9/UM/ND6zi2xdM5ePzigECvetwBnbcDia63B5W1rbT0j3AlfOLZKm4EHHKabdit1r4zlMb+fuyPVw5r4hvnl9JbpodhzUBR1ICGclWLq8q4v9unEdZdgo/eHYLn79/FWvqOvBrTfdwOcSob4d64DFug9qiFG9tbyUp0cI50/NlpocQceyFDft4ceM+blxUxmdPrWBCuoPS7GRynTZaXQP0D/rITLEyryyLhz6/gM8sLmdjQxc33b+KX7y0na1N3Xj9/sAxfcGhHQpxW/pwWBN4bet+lkzNJU2O1xIirgTXpbc2u/jRc5uZX5bJVdVFOKwJpAyfjQpDsz4AJqQ7AHBpzQ2LSrlk9gT++l4tz6xv5Kl1jZxcnsllcwpZOj2PNHtoJybEXVAbv6AtTS5auwe4ZHZhxKfaCCGiy6hL9w14ufXhNaTYEvnvC6dRnpMKjDzJyQhoINBbznPayXPa+eZ5lVxTXcLbNS28tGkfv39zJ2dPzw95py/uksn4BT25pgGHNYGTKzIjPtVGCBFdRpD+8JnN7DnQyy8/MZvKgrSjnuRkUSqQFcGBXZzp4Ip5xXT1D5JgUSGfmBB3Qe20W/H5Na9t2c+pk7NRDF14KXsIEV82NXTx5NpGrl9QyumVuWM6ycm46+4Z8AZyw+X24HRYSbYlMDE3dcRiulDlStwFNcCeA7109Hk4szIXkNq0EPHCKH0mWhTfenwDxZkOrl9YQu/wkvGxZkFwmdToZTvt9hHPCeXEhLgM6le37EcBCyuyAdkpT4h4YfR273xlO42d/fzxk1Xkptnx+v3H3QsebWwr1HkSd9PzXG4P7+04wMwiJ5UFaTJ/Wog44rRbqdnfzeOrG7h8biHVZVk4khIoykg29fTcuAvqbreXzU1dLJ2aByDzp4WII4NePz95fgt5Thu3nzN0ePV4OMkp7oJ6XX0nfg1nDNenwdy/ICHEiQnesvSed3ZRs7+HryydjLEeZTzcTcddOr1T00qaPZG5JRnRbooQIgKMuvSeA7387o2dnFmZyykTc8hJswGMi0NC4iqotda8s6OV0ybnkJgQdzcTQsQlp92K1pofP7cFa6Liy0smk+u0HXXOtJnERVoZtz47Wnpo7nJzRmVuVE9rEEJE1uq6DlbVdfClMydRmp182Jxps5c+4yKojVufVzfvA2BeaUbIN00RQpiT1+fnZy9spSTLwcerioDxUZcOFhdBbczseG/nAcqzk8lITpLViELEsOABxAdX1LGrtZcvnjmJ9OG//fE2Jdfc/f0QclgTWL+3i4tnTwDMPXAghDgxgU2XBr386a1dzCpycva0vMCOeWD+unSwuOhRA6zY3Ua/x8e80gxg/N36CCHGzriLvn9ZHa3dA9x+9hSSg7YuHQ916WDjp6UnwOX2sHxXGwDnzSwgKdEyLqbkCCGOX1KChUc/rOeUSdnMLs4Y13/rcRHUFqVYt7eTyvxUclJtI74vhIhNDyzfQ0efh0+fUgaM7z194qL0YUu0sG5vJ4smZge+N95ufYQQY9feO8Dfl+1hdnE6588sGJcDiMHiIqg3NnbRN+gbEdRCiNhjzPZ4fWsLzV1uvrxkMt0D3sBWpOP1LjouupQrdg/VpxdUZEW5JUKIcPJrTd+Al7+9W8vkvFQWVGQFTnAar2UPiOEedfA8yhW726nMTyUp0SKrEYWIYU67lU1NLrbv7+bak0sY8PrHfUhDDAe1MY+yrXeAVXvamVeaKasRhYgDL2/aR3JSAufOyAdiY2ZXzAa1MY9ybX0nfYM+Zhenx8QnqxDio/UP+nhxYzNLp+Vhtw4dQjteBxCDxWxQw1BYr6nrAKCqNFNCWogY98z6RvoGfVxeVUS+0z7uZ3sYYjqoXW4Pa+s7Kc9OJisladz/soQQR/bChmYKnPaYO8FpzEGtlEpQSq1VSj0fzgaFisvtodvtYUNDJ6dOzomZT1YhxEjGxIHW7gHe39XGFfOK6Bn0BiYOxMKaiWPpUd8ObA1XQ0LNohT1bX30DvpYODE7Zj5ZhRAjGRMH/rVqLz6/5ryZ+TE3cWBMQa2UKgYuBv4a3uaETqotkU2NLgAWDs+fjoVPViHESEYn7Ln1TUwrSGNCuiPmJg6MtUf9G+DbgP+jnqCUukUptUoptaq1tTUUbTthH9S2U56dTL7THu2mCCHCqLPXw7Z93Zw3M3am5AU7alArpS4BWrTWq4/0PK31PVrraq11dW5u7pGeGhF+v+bDPe0srJBl40LEumfWNwKwZHgQMdbGosbSoz4VuEwptQd4FFiqlHoorK0KgW37uunq98iycSFinMvt4bUt+5lWkEZVaWZMThw4alBrrf9ba12stS4HrgXe1FrfEPaWHSdjBHhl7dD+HgsnZslBtkLEsLaeQTY2dHHRSQdPb4q1iQMxN7JmjAC/t/MARRkOnA5rYFMWIUTsWbbzABq4YFZB4HtxV6MOprV+S2t9SbgaEwpOuxW71cLqug7mlKTHxM5ZQoiRgjdde2XzPibmpJDvtMXsnXNMrkxs7R6go89DVUkmEHufrkLEO+POeW97H8t3tbFkWh5ujz+m5k4Hi8mgfrtmaHpglRxkK0RMMurQr2/dj9evOW149XGsdspiLqiHBhLbyU21Mb8sNkeAhRBDYb1s5wHy0mxMn5AWsyENMTiYqIC19Z0snJiFUirwy4ulEWAhxFCn7IeXzaSxox+l1Lg+vPZoYi6oO/s8tHQPBJaNg9SohYg1LreH/kEfToeV4szkwNcQm3/vMRfUH9S2A7BAViQKEbOMw2qNUI71O+eYC+qVtW1kJFuZkpca7aYIIcJktM3VYrEnbYi5wcSVte2cXJ6FxRKbn6xCiPgTE0FtTH7f73Kzp62PhRWybFwIETtiIqiNye/G/OmZhc6Y2zhcCBG/YqJGbdSmPtjdRnJSAqXZyTE9+V0IEV9iokcNQ2G9bm8nJxWlk2ixSEgLIWJGzAR1Q0cfu1t7mVOSAciycSFE7IiJoHa5Payu60ADZ1bmyrJxIURMiYkatUUptjS7sCiYU5IRmGMZq5PfhRDxJSaCOtWWyOZGF9MKnIGQlhq1ECJWxETpw+vzs7a+g+ryzGg3RQghQi4mgnr7/m56B33ML5OgFkJEVvBpM4ZQL7iLidLHmroOAOaVSlALISLLWHC33+Um3WHFbk0I+TmtMdGjXl3XQV6ajeJMR7SbIoSIM8ZpM79+rYZz7nqbjt7BkC+4G7dBHXy7sbq+g/llmXQPeGV/DyFExHX2enhl034uPmkCdmvoV0WP26A2bjd2tfawt72fWUXpsr+HECIqfvNGDQkWxQ2LyoDQL7gbt0Ft3G6sHD4oYFpBmuzvIYSIiOA7+m37XDyzrolL50ygLDslLAvuxvVgotNuZVNjF0kJFqYWxPbhlkII8zDu6AH+vmwPCvj04nL8WofltJlxHdQut4ctTS4qC1KxJlhi+nBLIcRBPQPeEaEIQ3lgUWrU019Czfi5dW29PLmmgUvnFFKek3LY0WChMm5LHy63h263h637XFSXZcn+HkLEEaNHa/y9G4fbRnKMymm38tCKevwaPnVKWVg7ieM2qC1K0dzlxu3xM6ckPVCzlv09hIh9xt/7+r2d3PPOrsC85UjeUdce6OHptY1cOKuAwgxHWDuJ47b0kWpLZHdLLwBzijMA2d9DiHjitFt5ZGU9r2zaT3l2CufNLIjYz3a5Pfx92R48Pj9fP7cycEdvtCvUxm2PGmBdQydOeyLl2SnRbooQIsJcbg/fOG8qeU4b3316E3vb+0Y8Fo41FcZsj+5+D4+vbuDi2YXkpNmwKBXWO/pxHdTr93YypyRDThwXIs4YNencNBt3XT2H9t5B/vvJjXT1D4a1Xm3Uxh9cUUffoI9PLy4L/Cyn3Rq2gcxxG9Ruj49t+7qZXZwe7aYIISLM6ME67VZOmZTD186Zwns7D3D/+3vCWq922q14/X4e/qCeMytzKcmMzPms4zaoNzd14fPrQH1aCBE/Um2JI8LxtiWTqSrJ4MHl9Qx4fWENzn992EC328tNp1UAkRkbG7dBvX5vFwBzh89IFELEr+6BoeBs7RnghQ3NYZuB0dk3yN/eq+WsqblMLUgDInM+61GDWillV0qtVEqtV0ptVkr9KOytOgKjmL++oZMJ6XbynPawDRwIIczPqEmfXpnD3JIMHlxRR3e/J2QBGrxc/A//3knvgJfPnVpOii0xYus3xtKjHgCWaq3nAHOBC5RSi8LaqiMwivlr6zuZXZwelYnuQgjzMOrV6Y4kPn96BU2dbt7c3hKYgXGiHTkjc/a09fLwB/UsnZ7H1AJnYAAxEus3jhrUekjP8JfW4X+ilopOu5VBr5/69j4m5aZGZaK7EMI8guvVp0/JYUpeKn99txaHNSEkHTkjjP/yzm4GPD5uOX3iiMwJ52wPw5hq1EqpBKXUOqAFeE1r/cEoz7lFKbVKKbWqtbU1xM0cqa5taL7k9AlOQBa6CCGGpDuS+MKZE6lr6+Px1XtD1pHr6vPwr1V7uXDWhBF7ekTKmIJaa+3TWs8FioEFSqlZozznHq11tda6Ojc3N8TNHGlV3dDWppEs5gshxofL5xaR77TxxOpGIDQduZ+/uBWLUnzhzIlA5DPnmGZ9aK07gbeAC8LRmLFwuT1sauyiMMNOZX6abMYkhBihz+Pj41VFrNzTTl1b73FlQ/AA4rKdB3hp0z6uXVDCxNzUqGTOWGZ95CqlMob/3QGcA2wLc7s+kkUpavb3jNjfQzZjEkLAwRkgV1eXYE1QPLu+6bhC1RhA7Oof5M5Xt5OVksSnTymP6ABisLH0qCcA/1ZKbQA+ZKhG/Xx4m/XR/FpT397HrKKDKxIjUcwXQpifMQMkz2nn7On5PLuuKfD9Y5n9YYTxCxuaWVvfyS1nTCQnzRbRAcRgY5n1sUFrXaW1nq21nqW1/nEkGvZRtjS5AJhZ6IxmM0YIvk0yyNxuISLPmAHi15rL5xbicnt5e3troId8LLM/Ei2K37y+gyl5qVw6Z0JUJy2Mu5WJmxqHViTOLDTPHh9m2MRcCHHQ0B4g2UzKTeFvy2rpG/COafZHcKfrV6/W0NI9wG1LJjHg8Ud1HGzcBfXmJhcFTju5abZoNyXAuE16t6aVbz++nv1dbpnbLUSUpTuSuHJeMdv3dbO5yTWmv0ej0/X+rlbuf38PF84q4JRJOdislqhOWhh3Qb2psYtZReYpexicditPr2vi5c37JKSFMAGX28OFJxWQYkvgsdUNYwpZp92K3WrhV6/UYLNa+MrSyTiSEijKSI7qpIVxFdR9g152tfaYquxhaOrs552aVs6dnh84aFcIER1G+TE71cZV80t4Y+t+Gtr7xvR3+U7NAVbXd/LFMyaRnRq9AcRg4yqotza78GtGzPgwA5fbw4sbmxnw+rl+YZnM7RYiyoL3q75yfjEen+bFTfuOuv9Ht9vDj5/bwtSCNK6cXxx4brSNi6A2CvybGodmfMwqcppqVoVFKV7ZvI/y7GTmlWbI3G4hoix4/4+y7GQWVGTxrw/3Yk+0HDbYHzyAeMdL2zjQM8C3zq/E6bCaptM1LoL64I55HeSkJpE8fPHMMqvC1e9hVV0Hl1cVoYbDWeZ2C2EOTruVTy4spaV7gMdWNxy2/4eRLx/UtvHIynouryrkpKKMqC1uGc24CGrjYm1ucjElLw23x2+KATvjk/jpdY1oDVdUFZuqpy+EGHLJ7EImpNt5ZGU9ejiADU67FVuihR8/t4V0h5XblkyO+O54R2OKoB7LghFbooXdB3qpLEgFzLFjnl9r+ga8PLG6geqyTDJSrKbq6QshhvQOerlhURkbGrpYXddxWN68uHEfm5tcfPXsKaTZrabIl2CmCOqxLBhZW9+Jz6+Zmm+eHfOcdit72vrY1drL2dPzZG9sIUzo4P4fxeSm2bh/eR0Hugdo7BzaLvlAzwB3vLSV2cXpnDElJ/AaMzFFUDvtVhITFL94eRsvb2o+LPBcbg8bGjoBWDwpxzQFfoAXNjRjS7Rw7ox8wBw9fSHEQcYMkNw0O59ZXM7K2nZq9ncHVht+/5lN9A76uP3sKeQ67abKF4MpghogKcHCW9tb+d4zm+nsGxwReBal2NXaS6otkdKsZNMU+N0eH0+va+SsqbmkBX2oCCHMI3gGyJXzi8hwWHloRT05aTbe2LqfFzfu42NzCzm5IgvncNnDDPkSzDRBrYHvXTydzr5BfvjcFjr7BoGDwbdjfzczJjixWMwzq+KZdY10u71cOa+YfJN+EgshDipwOvjU4jLe23mAD3e384c3d5KbmsRXl045bIAx2vkSzBRBbdSQZhWn87VzKlm+q42/vLubxs4++gd9eHx+tjZ3M8NEO+YBPLOuiQnpds6ZfrDsYbZPYiHESDefPpEMh5XvP7uZXa29fOXsKTiSEkzdwTJFUBs1pKKMZG5YVMrSaXnc/dYu1tR14EhKoK1nkH6PzxRbmxozVBo7+1m+u42rq0voGfQGZqiY7ZNYCHGQ8fd7/cISGjv7Kc5wsHRa7mETGszGFEEdXENKdyTxnYumk++0c8dL27Eoxeamoa1NzbB03PiF/uODOrSG82fly5Q8IcaJrv5BOno9NHW5AejzeNnvGsCvNV6/n/5BX5RbODpTBHUwl9tDqj2R/7pgGs1d/XznqY1saXKRlGghz2mL+mISp91KUqKFp9Y2Mr8sk+wUm0zJE2KcSHck0e/x8sKGZqpKMmjv9fDS8B4giRYLjqSEaDdxVKYKaqNW7UhKYMn0PK5bUMoz65p4c1sLk3NT8fq0KXqu6+o7aep0c0VVESBT8oQYL1Jtidz3fh0JFsV/XjCNUydn8+DyOpo6+03d4TJVUAfveOW0W/n6eZVMK0hjR0sPEzLsprmQ9y6rJTsliTOn5gIyJU+I8WJ1XQcvbGjmhoVlVOSm8PnTJpJgUfz0+a2kJpl3bMlUQR1cq+4Z8GJNsPCN8yqBoZWJvQMHB+2itafGlqYu3ttxgE9UF1OcmSxT8oQwOWMAUWvNj57bTE5qEtcuKMGvNSVZDj6zuIy1ezu5++1dgdeYbc8eUwV1ML/WtLoGaB4u+nf0DvIf/1yH1+eP+JmEwXuRPLa6AYtSfGJ+MT0DXpmSJ4TJGRMAHlvdwIaGLm45YyIKRe+AlzynnesXlnJyeSa/fX0H6xs6TXnmqWmDGkCj2dXSgwJuXFTGit3t/OrV7RHfU8P4Rbd0u3lqbSNLp+cFTjoGmZInhJk57Va01tz1ag1T8lK5ZHYhybYE8px2nHYrxZkp3HHlbGyJFr79+AZc/R7TlFkNpg1qi1LkOe3sPtBLWXYyty6ZxHkz8nlwRT2Pr24YcRHDfZti9JqfX99MZ5+Hy+cWmu4XKYT4aH99t5Z9LjffOn8qCRbFhHTHiL/fSbmpfPeS6Wzf182vX6uJaL6MhWmD2uihbm12MaPQSe+Aj/84dwrzSjO467UanlzbAIy+0144pNkS+eeHe5mYk8L8skwJaSFMLLhcubGhi3uX1XLJ7AlMzhvaJnm0bZXPmprHx6uKeGJNI//4oC7wfTOUQUwb1C63h7q2Xg70DDK7OAONJikhgT9cP4+K7GS+8+SmUXfaC5c3t7WwfX831y4oQSklg4dCmJhRrmzvHeBbj68nIzmJm0+bSE6a7bAJAMHTgv/3ytlMn5DGz17Yyrs7WkyzdbFpg9qiFLtbe4GhFYl5Tju5ThtOh5WHb15Eii2B/3lyI/u63CO2Qw3HLYrL7eG+9/eQmWzlU6eUy0wPIUzOKFf+7b1atu3r5stLJlORlzLq7njB04KTEi3cc2M1KPj5i9vw+vxRD2kwcVCn2hLZ2dJDgkUxvzQzcIFTbYk4khK444rZDHj93P7oWho6+sJyi2LcPjW09/HejgPcuKiMQZ8/8IuVmR5CmNfu1l7+/PZulkzN5aKTCj5yd7zgacEA6clWvnFuJVubu/nLu7Ujet7RqlWbNqgBNjR0UZmfNmJZpxHICyZm8dvrqmjo6OfWh9fQ1NEX8lsU4/bpwRV1JCYoPlZVFPgwkJkeQpiP0blyuT18+R9ryE218dWzJ9M3xjtgI1/On1XAZXMKuf/9Pbxb0xrYyTNatWrTBrXWmo2NXcw+ZCOm4NuUc6bn852Lp7OhoYvfv7kr5CO1TrsVj8/P02ubOHdGfqA3b4ZbISHE4YxzTL/+z3U0d7r54WUzKMxIxma1jKlcGbyT5/9cPI3SrGS+/8xmWlwDUf3bN21QN3T00947yEnFI4M6+DbF5fZw0UkT+MT8Yl7Y2Mw97+wKfD9Un37PrGui3+PjugWlgOzrIYSZOe1WHlvdwOtbW/j04jKqSjMDwTuWcmVwvhQ4Hfzk8ll09Xv4w5s7SYviHbRpg3pj49DWprOLR9/aNHik9o4rTqK6LJNfvrKd5zc0hWyktn/Qx1/f3c3iSdlUmuhQXSHEQcFT8Z7f0MSvXq3hjCk5XL9wZOfqWMuVLreHqQVpfHpxGW9sa+HRD/eOeCyS9WrTBvWGhi6sCYqpBWmjPh5cAklMsHDPp6rJTknip89vDSztPlF/f7+Wjj4PXzhzohy1JYRJGWNJ/97ewtf/uZ7ZwydFGY7n7zW4I3jbksnMLHTy0xe2ULO/Oypzq00V1CMmqTd2Mq3AyYDXP+on16EjtYkJip9efhIt3W5+8fK2Eb+cY/n0M9ow6PVz//t7mF+WSVVppuzrIYSJBGeF027l3R2t3PrQGnLTbPz3hdPIT7cxOS/tuDtXwR3BrBQbv/jEbHx+zX8+sYHeAW/E69VHDWqlVIlS6t9Kqa1Kqc1KqdvD1Rjjk7Grf5ANDV1MK0gb0ydX8EyQm0+fyCub9/PEqobA6O+xfPoFTnBZWcd+1wCfP71ixOtltocQ0Re8oOVnL2zhm49toDQrmZ9cPoO8NDtFGcnA8Z9jemhHcGZhOv9xTiVr6zt5ZGV9xMeqxtKj9gLf0FpPBxYBtymlZoSjMcZFrdnfQ7fbG5iaZxllJWBwLzn40++b509lVqGTu16vYVuz65jr1U67lUSL4q/v1jKtII2qkgyZ6SGEyRhZ8T9PbeIv79Zy2ZxCfn3NHGYWZpBqTxyRF6HoXLncHj42t5BTJ2Vz91u7WFnbNuKxcNerjxrUWutmrfWa4X/vBrYCReFqkNNuZdPwQOL0wrTALnXG7UvPgPewOY1+rQOfmNYEC7+7ropBr5+7XqtBD895PhZPrGmgoaN/aDtEpSSkhTAhp93KNdUl/NcF07jljIkUZyWHZSzJuCtPtiXy8ytOIs1u5ZuPbaCl2x2xevUx1aiVUuVAFfDBKI/dopRapZRa1draetwNcrk9rN/bSYotgbxUOy63J/DpuXpPOx/sbqOj14PXP7S0c7QLlZNm44tnTmTF7naeWtt41JVFwfWulm43v319BwsrsphbkhF4nRDCXFxuDzMKnZw3Mx+H9eCiuFCPJQXfsZdlp/Dzj8+ivr2Pnz6/NWJ7gYz5fkAplQo8AXxNa+069HGt9T3APQDV1dXH9fHS3NVP34CPjY1dzCvNxGKBLY0u1uwdOj5nc9PQj63ITuH0yhxuXFSG02EdcaGM4L6qupgVu9v57Rs7qC7PojDD/pGHVxo9doCfv7CVAa+fW8+aRE6aDSDwmPSshTCH4FkZ+U574GsgsN1EqBxaNrlg1gSuri7mX6saWFiRxScXlQXaZFEqLGNYY+pRK6WsDIX0w1rrJ0PdiOAebWf/ILtae5lbks7rW/bzpYdX84uXt9M36ONLZ03kq2dPJjs1iYdW1PGFB1fT1jNwWEg7khIozkzhpx+fhTXBwvef2USP+6NHao1P4FV72nl6XRNXziumquzg/iIy00MIcwnu5ULoe9FH4nJ7uOnUCqYWpPGzF7eyqbEr7CUQpY/yxkopBdwPtGutvzaWN62urtarVq0acyOCA/bNrfv52j/XU56dzJ62PirzU7n1rMlMyk2hLGdo96vGzj5e3NDMna/WkJNq497PVDMhwzHqbcjDK+r4ztObOHtaHn/5VDUWy9AvsrmrH4AJ6Q4A9rvcXP7HZQx6/Tz2xVOYmJs65vYLIeJDcFY1d/bzibuXk+e08fvrqijOSj6hnrxSarXWunq0x8bSoz4VuBFYqpRaN/zPRcfdmlEMLVpRPLG6gR89twWArn4PXz+3kvs/t4DZxekkD58Q7HJ7SLRYuGj2BH573Vw6+gb51L0r2d3Sc1hIu9wezpmRz02nVfDGthb+56mNgcHIvgEfvcM9+fr2Xq7+83I6+zz86GMzSbElSl1aCHGY4J781AInP7xsJrtae7n7rV1hLY0etZiitX4PCPv9RLI1kd+8voN+j48J6Xbu/fTJ+LTGrzUTc1NH3Fqk2BJx2ofmSiZeZ+GWB1bxf+/s5u4b5gfeL/iT77sXT6erf5BHP9yL2+PjquoSynOSSbNbWVPXzo+f30pTVz93XT2HS2YXHlbvEkIIGFmvdrk9nDYlh+sWlPDIyr0snFjHDWGqV5tm5YbH7+dXV83mCw+u5szKXDJShqblJVosgZkfwIj/eJfbw0lF6Vy3oJSHP6jnxY3NXHTSBAB6h2d3GK/7xZVz6HZ7eXpdEy9u3MfS6Xnsbe9jc5OLRIviB5fO4NI5RSNeI3VpIcRogjuC3zp/KlubXfzk+S1Mm5BGZX5a4LFQMcUScuM/esDnx6fh1Mk5WJQi7ZABguCJ68EX6j/OraQsO5kfPLOZxs6+wKdZStCnWc+glx9/bBb/+PxCLp49gbe2tdA36ONzp5bz9G2nct7MgpBPkhdCxKZDl5j/+pq5pNoSuf2RdbT3DIZ8yp4pkqh/0IfX76d2+Oit06fk0DvopX8Q8p32UV9z6Kjv/7viJG746wfc8eI2vnvJjFGn7DmSElg8OYeynGSuqS4GBbmpQ0d8Ge0AKXcIIY7s0E5cRU4qP7/iJLY1u7BbLSHPEFP0qB1JCSRaLLy/q42p+WlYLOoj5zwbDl2Lv3hSDldVl/DCxmZ2t/aMeCw41I3ByKzUJMqyU8h12gIBLdPwhBDHw+X2MLckg2sXlIbl8GtTBLVxqOS6vZ3MLHQe12ofl9vD504dOnj2T2/tGnGhgkPdCO3KfCcT0h0j5l9KuUMIcawOXXwTju2QTRHUMBSmP7h0BpfNLQSOrfxgXKgJGQ4+f9pE3t1xgOW72kZdOn5oT9z4WRLQQojjEYnFN6YJ6n6Pj7Om5jF9ghM4tv01gi/U9QtLyU218fs3d6AI7bFcQghxqEh0/kzRjQy+dQjeaAnG1rMOviD5Tju3LpnEj57bwgsbmlkyLU+2KRUiTng8HhoaGnC73dFuykey2+0UFxdjtY49k0wR1KPdOhjfPx43LirjgeV1/PGtnZw+JQenffSZI0KI2NLQ0EBaWhrl5eUoE04M0FrT1tZGQ0MDFRUVY36dKUofob516PP4+PKSyext7x+xzakQIra53W6ys7NNGdIASimys7OPucdviqAOJaNscsqkLE4uz+Rv79XS6hoIHMsVyZODhRCRZ9aQNhxP+2IuqI0ySqrdym1LJtPR5+EfK+vpHfDKoKIQYlyKuaA2yihOu5V5ZZlcMLOAh1bU0eIakEFFIURYJSQkMHfuXGbNmsWll15KZ2dnSN435oI6mNNu5UtnTQLg92/ukJAWQoSVw+Fg3bp1bNq0iaysLP74xz+G5H1NMesjXFxuDwXpdq45uYQHltfx7+0tLJmaF3gsXMfmCCGi70fPbWZL02GnBp6QGYVOfnDpzDE995RTTmHDhg0h+bkx26MOnpt925LJ5KbZ+NkLW+noG5RFMEKIsPL5fLzxxhtcdtllIXm/mO1OBs/NdtqtfOv8qXz78Q08tLyOq08ukXq1EDFurD3fUOrv72fu3Lns2bOH+fPnc+6554bkfWO2R33o3Oyr5hczpzide5fV0uP2SkgLIULOqFHX1dUxODgYshp1zAb1oboHvHz9vEo6+zzcu6xWFsEIIcImPT2d3/3ud9x55514PCeeNXER1EZNuqo0k8urivjnh3vZvq971N31hBAiFKqqqpgzZw6PPvroCb9XXAR1cL36K0snk5Ro4Tev12AZ3uBbBhaFEKHQ09Mz4uvnnnuOG2+88YTfNy6COrhePTE3lVvOmMiynW28uW3/cR1SIIQQkRQXQX2oL501iaIMB79+bQdev19CWghhanEZ1ANeP7efPYXaA708tUZ21xNCmFvcBbVRkz5tSjYLK7K4553d7Ot0y+56QgjTirugDt5d7/azp9A74ONvy2pldz0hhGnFXVAH7643qzidK+YV8diqvexq7ZFBRSGEKcVdUAdz2q3cfMZEUu2J3PVqDWmyQZMQ4gTINqdh4HJ7SHdY+ezictbUd/LEmoYRj0m9WghxLGSb0xAL3l3v04vLeW59M794eTunT8nFkZQQeEwIMT7JNqcxIHi1YlaKje9eMp2W7gH++O+dsghGCHFCZJvTEDn0wICl0/I5Z3oej67cy6VzCjm5PCtKLRNChIJscxqDXG4PXzunEmui4n9f2kZX/2C0mySEGGeits2pUupepVSLUmpTSH6iCRn16tLsZL5+7lRW1XXwxOpG2V1PCHFcorHN6X3ABSf8k0wsuF595bwiZhen85vXa+js88juekKI4xLRbU611u8A7Sf8k0wseHe9jOQkfnTZTPoGffzw2c30DXhlYFEIMSam3+ZUKXWLUmqVUmpVa2trqN42KqpKM/nCmRN5c1sLT6xpHBHSUgYRQkRayIJaa32P1rpaa12dm5sbqreNCpfbwycXljGnOJ0/vLmTD2oPBL4vZRAhRKTJrI9DGGGcak/k7hvmk2hRfO/pzWxr7pL51UKIqJCgPkTwwGJhhoM7rpxNzf4e7nptB1rrQEhLCUQIESljmZ73CLAcmKqUalBK3RT+ZkVP8MAiwOmVOXxyYSmvbtnPX96tDexbLSUQIUSkHHVlotb6ukg0xIyMQP72BVPp6Bvkb+/VkpWSxPkz88lz2qUEIoSICCl9HIFRBkl3JPHra+ZSVZLBXa/V8NKmfTITRAhxGNnmNAqCyyADXj93Xj2HWYVO7nq1hj+8uQOQmSBCiINkm9MoMsI4N83GP79wCjfd/yF3vlpDe+8gXzhzkswEEcKEZJvTOBM8E8RuTeC+zy7g7Gl53LtsD79/Y8eIk2GkDCKEkG1Oo+DQLVH7PT5+cvksbM9v4aEP6vFpzc8/fhLdwwfkyoEDQkSfbHMax4IXxPzh+nlcMa+IR1bu5ab7P8TV7wn0vKVnLUT8ido2p2Kk4DKIxaL41VVzuObkYt7c1spXH1kLyACjEPEuGtuciiCHLojpHvDy9XOn8u3zp7K+oYvLfv8eDe19MsAoRJwL5TanUqM+AcEH5N66ZDK5aUk8tbYJpZCQFiIOjbbNaShIUJ+A4DKIy+3hjMo8qkozsSiFy+2RsBZChIQE9QkwZoME96zznfbA1yA9ayHEiZOgDoHgnjUcDGeLUtFslhBxSWuNMvHfnj6OSQYymBgChw4wwlBYHzr/WggRXna7nba2tuMKw0jQWtPW1obdbj+m10mSCCFiRnFxMQ0NDZj5OEC73U5xcfExvUaCWggRM6xWKxUVFdFuRshJ6UMIIUxOgloIIUxOgloIIUxOhWN0VCnVCtSF/I3HpxzgQLQbYXJyjY5Mrs+Rxcr1KdNa5472QFiCWhyklFqlta6OdjvMTK7Rkcn1ObJ4uD5S+hBCCJOToBZCCJOToA6/e6LdgHFArtGRyfU5spi/PlKjFkIIk5MetRBCmJwEtRBCmJwEdYgopS5QSm1XSu1USv3XKI+nK6WeU0qtV0ptVkp9NhrtjBal1L1KqRal1KaPeFwppX43fP02KKXmRbqN0TSG6/PJ4euyQSn1vlJqTqTbGE1Huz5BzztZKeVTSn0iUm2LBAnqEFBKJQB/BC4EZgDXKaVmHPK024AtWus5wFnAr5RSSRFtaHTdB1xwhMcvBKYM/3MLcHcE2mQm93Hk61MLnKm1ng38hDgYQDvEfRz5+hh/h/8LvBKJBkWSBHVoLAB2aq13a60HgUeBjx3yHA2kqaEdzVOBdsAb2WZGj9b6HYb+mz/Kx4AH9JAVQIZSakJkWhd9R7s+Wuv3tdYdw1+uAI5tn8xxbgz//wH4CvAE0BL+FkWWBHVoFAF7g75uGP5esD8A04EmYCNwu9baH5nmjQtjuYZiyE3AS9FuhJkopYqAjwN/jnZbwkH2ow6N0c79OXTe4/nAOmApMAl4TSn1rtbaFea2jRdjuYZxTym1hKGgPi3abTGZ3wD/qbX2mfkYruMlQR0aDUBJ0NfFDPWcg30WuEMPTVzfqZSqBaYBKyPTRNMbyzWMa0qp2cBfgQu11m3Rbo/JVAOPDod0DnCRUsqrtX46qq0KESl9hMaHwBSlVMXwAOG1wLOHPKceOBtAKZUPTAV2R7SV5vYs8Knh2R+LgC6tdXO0G2UWSqlS4EngRq11TbTbYzZa6wqtdbnWuhx4HLg1VkIapEcdElprr1LqywyNNicA92qtNyulvjj8+J8ZGqm/Tym1kaHb/P/UWsfC1oxjopR6hKHZLjlKqQbgB4AVAtfnReAiYCfQx9AdSNwYw/X5PpAN/Gm41+iN9R3jgo3h+sQ0WUIuhBAmJ6UPIYQwOQlqIYQwOQlqIYQwOQlqIYQwOQlqIYQ4QWPdNGr4ub9WSq0b/qdGKdV51NfIrA8hhDgxSqkzgB6G9quZdQyv+wpQpbX+3JGeJz1qIYQ4QaNtGqWUmqSUelkptVop9a5SatooL70OeORo7y8LXoQQIjzuAb6otd6hlFoI/ImhvX4AUEqVARXAm0d7IwlqIYQIMaVUKrAYeCxokyjbIU+7Fnhca+072vtJUAshROhZgE6t9dwjPOdahg4UGdObCSGECKHh7YtrlVJXQeCoucDxaUqpqUAmsHws7ydBLYQQJ2h406jlwFSlVINS6ibgk8BNSqn1wGZGnvp0HfCoHuO0O5meJ4QQJic9aiGEMDkJaiGEMDkJaiGEMDkJaiGEMDkJaiGEMDkJaiGEMDkJaiGEMLn/D04f5V/fZILXAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1334,266 +1313,16 @@ ] }, { - "cell_type": "code", - "execution_count": 66, - "id": "94e01138", + "cell_type": "markdown", + "id": "1f6449a8", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "> \u001b[1;32mc:\\users\\surrey\\appdata\\local\\temp\\ipykernel_13892\\952329596.py\u001b[0m(2)\u001b[0;36mplot_windows\u001b[1;34m()\u001b[0m\n", - "\n", - "ipdb> data\n", - "'/dev4797/demods/0/sample.r'\n", - "ipdb> u\n", - "> \u001b[1;32mc:\\users\\surrey\\appdata\\local\\temp\\ipykernel_13892\\204029398.py\u001b[0m(4)\u001b[0;36m\u001b[1;34m()\u001b[0m\n", - "\n", - "ipdb> data\n", - "{'/dev4797/demods/0/sample.r': [\n", - "array([[2.29439020e-06, 2.52993391e-06, 2.75723595e-06, 2.98964174e-06,\n", - " 3.23372421e-06, 3.47543592e-06, 3.69586935e-06, 3.86975728e-06,\n", - " 3.99453325e-06, 4.10223783e-06, 4.21237993e-06, 4.30662357e-06,\n", - " 4.36115085e-06, 4.36670876e-06, 4.33322519e-06, 4.27960630e-06,\n", - " 4.22439338e-06, 4.17741629e-06, 4.13593279e-06, 4.08753749e-06,\n", - " 4.02874103e-06, 3.95674119e-06, 3.87274721e-06, 3.79136368e-06,\n", - " 3.72070539e-06, 3.65714470e-06, 3.58999562e-06, 3.51539276e-06,\n", - " 3.43128253e-06, 3.35685548e-06, 3.30350007e-06, 3.26843706e-06,\n", - " 3.23733412e-06, 3.19184358e-06, 3.12635385e-06, 3.04183879e-06,\n", - " 2.95828005e-06, 2.89284067e-06, 2.84518915e-06, 2.79303547e-06,\n", - " 2.72350220e-06, 2.63936473e-06, 2.55017957e-06, 2.47914483e-06,\n", - " 2.43590789e-06, 2.41025881e-06, 2.38641620e-06, 2.36224347e-06,\n", - " 2.33238955e-06, 2.30657503e-06, 2.29964887e-06, 2.31467439e-06,\n", - " 2.33662861e-06, 2.35641173e-06, 2.37137087e-06, 2.38875241e-06,\n", - " 2.42555734e-06, 2.49442274e-06, 2.58710829e-06, 2.68124350e-06,\n", - " 2.75955172e-06, 2.82052129e-06, 2.87733610e-06, 2.94696905e-06,\n", - " 3.03768035e-06, 3.13974719e-06, 3.23803296e-06, 3.32327326e-06,\n", - " 3.40098870e-06, 3.48106394e-06, 3.57135224e-06, 3.67332004e-06,\n", - " 3.78727824e-06, 3.91105568e-06, 4.02480781e-06, 4.12381018e-06,\n", - " 4.21972722e-06, 4.31759716e-06, 4.41018414e-06, 4.48567219e-06,\n", - "...\n", - " 2.49041063e-06, 2.77321990e-06, 3.04061728e-06, 3.26562599e-06,\n", - " 3.44617836e-06, 3.58972559e-06, 3.69229437e-06, 3.75108819e-06,\n", - " 3.76720779e-06, 3.73676126e-06, 3.65942105e-06, 3.54173062e-06,\n", - " 3.41260856e-06, 3.28993658e-06, 3.17870027e-06, 3.06211020e-06,\n", - " 2.92779449e-06, 2.76865066e-06, 2.58377712e-06, 2.39732687e-06,\n", - " 2.21843778e-06, 2.04805936e-06, 1.87623089e-06, 1.69492947e-06,\n", - " 1.51086329e-06, 1.34456821e-06, 1.20792319e-06, 1.09852803e-06,\n", - " 1.00639479e-06, 9.19625063e-07, 8.44927226e-07, 8.15115365e-07,\n", - " 8.58987718e-07, 9.56215893e-07, 1.06088387e-06, 1.15851062e-06,\n", - " 1.26361235e-06, 1.39030224e-06, 1.54894590e-06, 1.72907054e-06,\n", - " 1.90543392e-06, 2.06391881e-06, 2.19265471e-06, 2.30466124e-06,\n", - " 2.43189865e-06, 2.58057748e-06, 2.73695739e-06, 2.88338072e-06,\n", - " 3.01131268e-06, 3.11764855e-06, 3.21544555e-06, 3.32338756e-06,\n", - " 3.44148308e-06, 3.56020619e-06, 3.66604179e-06, 3.73940926e-06,\n", - " 3.77729370e-06, 3.79550785e-06, 3.81162227e-06, 3.83121596e-06,\n", - " 3.83801799e-06, 3.81025605e-06, 3.74768403e-06, 3.65945180e-06,\n", - " 3.56566226e-06, 3.47721041e-06, 3.39734862e-06, 3.31565888e-06,\n", - " 3.20964794e-06, 3.07155526e-06, 2.91646888e-06, 2.76448281e-06,\n", - " 2.61645019e-06, 2.46580987e-06, 2.30503591e-06, 2.12691576e-06,\n", - " 1.93655526e-06, 1.75273664e-06, 1.59066020e-06, 1.44488484e-06]])\n", - "Coordinates:\n", - " time (row, col) float64 7.02e+11 7.02e+11 7.02e+11 ... 7.1e+11 7.1e+11\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1692865553]\n", - " createdtimestamp: [42118520536]\n", - " changedtimestamp: [42601097176]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 000 10:25:53.4101\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [0]\n", - " gridrows: [3]\n", - " gridcols: [228]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [7.46666667e-05]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]\n", - " systemtime_converted: [2.82144259e+10]\n", - " createdtimestamp_converted: [7.01975342e+11]\n", - " changedtimestamp_converted: [7.10018286e+11]\n", - " device_serial: DEV4797\n", - " channel_name: /dev4797/demods/0/sample.r, \n", - "array([[2.12723580e-06, 2.23760496e-06, 2.34409608e-06, 2.45480986e-06,\n", - " 2.58202348e-06, 2.72373432e-06, 2.86547936e-06, 2.98613365e-06,\n", - " 3.07858441e-06, 3.15821730e-06, 3.23723439e-06, 3.31806729e-06,\n", - " 3.39932789e-06, 3.46726144e-06, 3.51720831e-06, 3.55372838e-06,\n", - " 3.58906441e-06, 3.62552331e-06, 3.64921291e-06, 3.64333921e-06,\n", - " 3.60605962e-06, 3.54393165e-06, 3.46699686e-06, 3.38404802e-06,\n", - " 3.28601593e-06, 3.16905198e-06, 3.03066450e-06, 2.87579468e-06,\n", - " 2.72516862e-06, 2.59823510e-06, 2.49870358e-06, 2.40657131e-06,\n", - " 2.30013378e-06, 2.18125044e-06, 2.06650061e-06, 1.97663842e-06,\n", - " 1.92529736e-06, 1.89963432e-06, 1.89520970e-06, 1.91491517e-06,\n", - " 1.97301594e-06, 2.07674031e-06, 2.22201373e-06, 2.38616190e-06,\n", - " 2.53732547e-06, 2.65875511e-06, 2.75416234e-06, 2.84033838e-06,\n", - " 2.92825281e-06, 3.01419835e-06, 3.08829442e-06, 3.13888585e-06,\n", - " 3.16163393e-06, 3.16126428e-06, 3.13547824e-06, 3.10393859e-06,\n", - " 3.05537995e-06, 2.97224076e-06, 2.85407977e-06, 2.70814828e-06,\n", - " 2.55225994e-06, 2.40195230e-06, 2.26487340e-06, 2.13223182e-06,\n", - " 1.98766554e-06, 1.83429333e-06, 1.68131171e-06, 1.53953459e-06,\n", - " 1.40899339e-06, 1.27077339e-06, 1.10317071e-06, 9.23855788e-07,\n", - " 7.71482125e-07, 6.71456432e-07, 6.36486775e-07, 6.55454995e-07,\n", - " 7.09842874e-07, 7.94481532e-07, 9.18602846e-07, 1.07654530e-06,\n", - "...\n", - " 3.94304602e-06, 3.92870392e-06, 3.90450220e-06, 3.87259374e-06,\n", - " 3.82262580e-06, 3.74567750e-06, 3.64802577e-06, 3.54361136e-06,\n", - " 3.44860437e-06, 3.37175451e-06, 3.31278739e-06, 3.25490795e-06,\n", - " 3.19235866e-06, 3.12515312e-06, 3.04788860e-06, 2.97411551e-06,\n", - " 2.91372563e-06, 2.86059908e-06, 2.79919563e-06, 2.71266144e-06,\n", - " 2.60229858e-06, 2.49230289e-06, 2.40453032e-06, 2.35249273e-06,\n", - " 2.32529326e-06, 2.29418343e-06, 2.24682171e-06, 2.17982707e-06,\n", - " 2.09702633e-06, 2.00666827e-06, 1.91139311e-06, 1.80598320e-06,\n", - " 1.67930926e-06, 1.52765746e-06, 1.36086519e-06, 1.19204382e-06,\n", - " 1.02652401e-06, 8.64534336e-07, 6.98939543e-07, 5.23912313e-07,\n", - " 3.55569145e-07, 2.99238890e-07, 4.31552196e-07, 6.25134298e-07,\n", - " 8.18765462e-07, 1.00547451e-06, 1.19518006e-06, 1.39348493e-06,\n", - " 1.61278473e-06, 1.85055243e-06, 2.08680283e-06, 2.30467341e-06,\n", - " 2.51322364e-06, 2.71778978e-06, 2.92172724e-06, 3.12142407e-06,\n", - " 3.30191267e-06, 3.44331645e-06, 3.53988173e-06, 3.60607388e-06,\n", - " 3.65136013e-06, 3.68227528e-06, 3.69619206e-06, 3.68109756e-06,\n", - " 3.63249346e-06, 3.56305266e-06, 3.49473954e-06, 3.43892607e-06,\n", - " 3.39039549e-06, 3.34318950e-06, 3.29465898e-06, 3.25042605e-06,\n", - " 3.22296643e-06, 3.22503742e-06, 3.26336285e-06, 3.33671955e-06,\n", - " 3.43454020e-06, 3.54592527e-06, 3.65842302e-06, 3.76783180e-06]])\n", - "Coordinates:\n", - " time (row, col) float64 7.14e+11 7.14e+11 ... 7.221e+11 7.221e+11\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1692865565]\n", - " createdtimestamp: [42842295896]\n", - " changedtimestamp: [43323317976]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 001 10:26:05.5124\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [1]\n", - " gridrows: [3]\n", - " gridcols: [228]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [7.46666667e-05]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]\n", - " systemtime_converted: [2.82144261e+10]\n", - " createdtimestamp_converted: [7.14038265e+11]\n", - " changedtimestamp_converted: [7.220553e+11]\n", - " device_serial: DEV4797\n", - " channel_name: /dev4797/demods/0/sample.r, \n", - "array([[2.79262726e-06, 2.79339751e-06, 2.82217203e-06, 2.88056241e-06,\n", - " 2.95310839e-06, 3.01499023e-06, 3.06179701e-06, 3.09597215e-06,\n", - " 3.12131343e-06, 3.13378712e-06, 3.12411928e-06, 3.07715484e-06,\n", - " 2.98358734e-06, 2.85706070e-06, 2.71564218e-06, 2.57667845e-06,\n", - " 2.46745593e-06, 2.39234392e-06, 2.34263476e-06, 2.30327467e-06,\n", - " 2.27420455e-06, 2.26380410e-06, 2.28060478e-06, 2.32386238e-06,\n", - " 2.38739313e-06, 2.45775869e-06, 2.51761694e-06, 2.56769643e-06,\n", - " 2.61412652e-06, 2.67399000e-06, 2.75499425e-06, 2.86163773e-06,\n", - " 2.97733546e-06, 3.07722970e-06, 3.16598875e-06, 3.25576346e-06,\n", - " 3.35898646e-06, 3.47217865e-06, 3.59113766e-06, 3.71320443e-06,\n", - " 3.81895359e-06, 3.90954786e-06, 3.98830342e-06, 4.06249413e-06,\n", - " 4.14424551e-06, 4.22680061e-06, 4.30422724e-06, 4.36571725e-06,\n", - " 4.40926062e-06, 4.44258258e-06, 4.48156961e-06, 4.52630871e-06,\n", - " 4.56888815e-06, 4.59477942e-06, 4.59834265e-06, 4.58300461e-06,\n", - " 4.54452397e-06, 4.48350220e-06, 4.41033290e-06, 4.32362421e-06,\n", - " 4.22282891e-06, 4.11940521e-06, 4.01891875e-06, 3.92727138e-06,\n", - " 3.84787777e-06, 3.77289640e-06, 3.68947346e-06, 3.58688210e-06,\n", - " 3.46944214e-06, 3.34788523e-06, 3.21801208e-06, 3.07146738e-06,\n", - " 2.91309509e-06, 2.73817889e-06, 2.54764266e-06, 2.34712637e-06,\n", - " 2.15276381e-06, 1.98188004e-06, 1.82792359e-06, 1.66951343e-06,\n", - "...\n", - " 2.18201987e-06, 2.21679803e-06, 2.24835478e-06, 2.26302432e-06,\n", - " 2.25136247e-06, 2.21603749e-06, 2.15799395e-06, 2.07788505e-06,\n", - " 1.97901834e-06, 1.85691843e-06, 1.69909991e-06, 1.51266192e-06,\n", - " 1.31823588e-06, 1.13678757e-06, 9.78015190e-07, 8.33718609e-07,\n", - " 6.90393314e-07, 5.34693456e-07, 3.70656540e-07, 2.21539753e-07,\n", - " 1.22670757e-07, 1.27768775e-07, 1.93610322e-07, 2.82684197e-07,\n", - " 3.92947022e-07, 5.18975722e-07, 6.44946036e-07, 7.54553378e-07,\n", - " 8.49543740e-07, 9.34776770e-07, 1.02796742e-06, 1.13058844e-06,\n", - " 1.23852123e-06, 1.33367012e-06, 1.40267240e-06, 1.43066637e-06,\n", - " 1.43042025e-06, 1.41879443e-06, 1.40802429e-06, 1.39637804e-06,\n", - " 1.37179232e-06, 1.32372484e-06, 1.24864587e-06, 1.15479332e-06,\n", - " 1.05958924e-06, 9.68016586e-07, 8.85974042e-07, 8.23572727e-07,\n", - " 7.78173531e-07, 7.46997584e-07, 7.28239475e-07, 7.24959819e-07,\n", - " 7.44458592e-07, 7.97958600e-07, 8.80279119e-07, 9.81560872e-07,\n", - " 1.09481635e-06, 1.21047572e-06, 1.33014059e-06, 1.45888109e-06,\n", - " 1.59521543e-06, 1.74241577e-06, 1.88925184e-06, 2.00906439e-06,\n", - " 2.09886371e-06, 2.16600461e-06, 2.22529855e-06, 2.28458072e-06,\n", - " 2.35115533e-06, 2.41597634e-06, 2.46188217e-06, 2.47378364e-06,\n", - " 2.45832351e-06, 2.41744537e-06, 2.35310032e-06, 2.27776603e-06,\n", - " 2.19571905e-06, 2.09161968e-06, 1.94733021e-06, 1.77332086e-06]])\n", - "Coordinates:\n", - " time (row, col) float64 7.261e+11 7.261e+11 ... 7.341e+11 7.341e+11\n", - "Dimensions without coordinates: row, col\n", - "Attributes:\n", - " systemtime: [1692865577]\n", - " createdtimestamp: [43565202136]\n", - " changedtimestamp: [44047133656]\n", - " flags: [1849]\n", - " moduleflags: [0]\n", - " chunksizebytes: [0]\n", - " name: 002 10:26:17.4266\n", - " status: [0]\n", - " groupindex: [0]\n", - " color: [0]\n", - " activerow: [2]\n", - " triggernumber: [2]\n", - " gridrows: [3]\n", - " gridcols: [228]\n", - " gridmode: [4]\n", - " gridoperation: [1]\n", - " griddirection: [0]\n", - " gridrepetitions: [1]\n", - " gridcoldelta: [7.46666667e-05]\n", - " gridcoloffset: [-0.001]\n", - " gridrowdelta: [1.]\n", - " gridrowoffset: [0.]\n", - " bandwidth: [nan]\n", - " center: [0.]\n", - " nenbw: [nan]\n", - " systemtime_converted: [2.82144263e+10]\n", - " createdtimestamp_converted: [7.26086702e+11]\n", - " changedtimestamp_converted: [7.34118894e+11]\n", - " device_serial: DEV4797\n", - " channel_name: /dev4797/demods/0/sample.r]}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ipdb> r\n" - ] - } - ], "source": [ - "%debug" + "And now we update the post processing method for the test pulse. The now used method averages each window into one float (for each channel)." ] }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 65, "id": "eb3982ba", "metadata": {}, "outputs": [ @@ -1601,7 +1330,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "\\\\Janeway\\User AG Bluhm\\Surrey\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:551: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", + "\\\\Janeway\\User AG Bluhm\\Surrey\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:473: UserWarning: The channel auxins/0/sample.AuxIn0.avg does not have an interface for enabling it. If needed, this can be done using the web interface.\n", " warnings.warn(\n" ] } @@ -1613,8 +1342,8 @@ }, { "cell_type": "code", - "execution_count": 72, - "id": "97961792", + "execution_count": 66, + "id": "643e2dcd", "metadata": {}, "outputs": [], "source": [ @@ -1627,49 +1356,41 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 67, "id": "0c875430", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\\\\Janeway\\User AG Bluhm\\Surrey\\git\\qupulse\\qupulse\\hardware\\dacs\\mfli.py:236: UserWarning: The received data for channel auxins/0/sample.AuxIn0.avg is empty.\n", - " warnings.warn(f\"The received data for channel {_cn} is empty.\")\n" - ] - } - ], + "outputs": [], "source": [ "data = my_lockin.measure_program(wait=False, return_raw=False)#(wait=False, fail_if_incomplete=False)" ] }, { "cell_type": "code", - "execution_count": 75, - "id": "b66d0af1", + "execution_count": 68, + "id": "72f03e04", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[{'X': {'/dev4797/demods/0/sample.x': [-1.6976033251434238e-07]},\n", - " 'R': {'/dev4797/demods/0/sample.r': [2.7888774838955474e-06,\n", - " 2.803098860263337e-06]},\n", - " 'A': {'/dev4797/auxins/0/sample.auxin0.avg': [-0.0011679467272793786,\n", - " -0.0011265247281813495]}},\n", - " {'X': {'/dev4797/demods/0/sample.x': [6.544044351717994e-07]},\n", - " 'R': {'/dev4797/demods/0/sample.r': [1.2454712756408315e-06,\n", - " 2.5542675760151297e-06]},\n", - " 'A': {}},\n", - " {'X': {'/dev4797/demods/0/sample.x': [-8.034974107565979e-07]},\n", - " 'R': {'/dev4797/demods/0/sample.r': [1.921719080586302e-06,\n", - " 8.421336791063582e-07]},\n", - " 'A': {'/dev4797/auxins/0/sample.auxin0.avg': [-0.0006591849960386753,\n", - " -0.0006591849960386753]}}]" + "[{'X': {'/dev4797/demods/0/sample.x': [-8.374052309193912e-07]},\n", + " 'R': {'/dev4797/demods/0/sample.r': [1.897792407086812e-06,\n", + " 1.88463595050441e-06]},\n", + " 'A': {'/dev4797/auxins/0/sample.auxin0.avg': [-0.0006865006859413381,\n", + " -0.0007787358912281217]}},\n", + " {'X': {'/dev4797/demods/0/sample.x': [3.604728756535074e-07]},\n", + " 'R': {'/dev4797/demods/0/sample.r': [2.364331002210214e-06,\n", + " 2.9312913797709533e-06]},\n", + " 'A': {'/dev4797/auxins/0/sample.auxin0.avg': [-0.0007400825382437581,\n", + " 0.00018226951462407825]}},\n", + " {'X': {'/dev4797/demods/0/sample.x': [-2.4209894273510995e-06]},\n", + " 'R': {'/dev4797/demods/0/sample.r': [3.1073928878419446e-06,\n", + " 3.342666574049693e-06]},\n", + " 'A': {'/dev4797/auxins/0/sample.auxin0.avg': [6.325705627574507e-05,\n", + " 2.2823844206265598e-05]}}]" ] }, - "execution_count": 75, + "execution_count": 68, "metadata": {}, "output_type": "execute_result" } @@ -1689,7 +1410,7 @@ { "cell_type": "code", "execution_count": null, - "id": "b53d2f80", + "id": "ea38299a", "metadata": {}, "outputs": [], "source": [] @@ -1697,7 +1418,7 @@ { "cell_type": "code", "execution_count": null, - "id": "77491fc3", + "id": "cec39828", "metadata": {}, "outputs": [], "source": [] @@ -1705,7 +1426,7 @@ { "cell_type": "code", "execution_count": null, - "id": "5f8a9a09", + "id": "8bc55042", "metadata": {}, "outputs": [], "source": [] diff --git a/qupulse/hardware/dacs/mfli.py b/qupulse/hardware/dacs/mfli.py index 392c21588..eacaf8c0f 100644 --- a/qupulse/hardware/dacs/mfli.py +++ b/qupulse/hardware/dacs/mfli.py @@ -47,82 +47,12 @@ def is_endless(self): return np.isinf(self.measurement_count) or self.measurement_count == 0 -@dataclasses.dataclass -class MFLIProgram: - default_channels: Optional[Set[str]] = dataclasses.field(default=None) - channel_mapping: Optional[Dict[str, Set[str]]] = dataclasses.field(default=None) - windows: Optional[Dict[str, Tuple[np.ndarray, np.ndarray]]] = dataclasses.field(default=None) - trigger_settings: Optional[TriggerSettings] = dataclasses.field(default=None) - other_settings: Dict[str, Any] = dataclasses.field(default_factory=dict) - operations: Any = dataclasses.field(default=None) - - def get_minimal_duration(self) -> float: - return max(np.max(begins + lengths) for (begins, lengths) in self.windows.values()) - - def required_channels(self) -> Set[str]: - channels = set() - for window_name in self.windows: - channels |= self.channel_mapping.get(window_name, self.default_channels) - return channels - - def merge(self, other: 'MFLIProgram') -> 'MFLIProgram': - - new_program = MFLIProgram() - - new_program.default_channels = self.default_channels - if new_program.default_channels is None: - new_program.default_channels = other.default_channels - elif isinstance(new_program.default_channels, set): - new_program.default_channels = new_program.default_channels.union(other.default_channels) - - new_program.channel_mapping = {**self.channel_mapping} - if other.channel_mapping is not None: - for k, v in other.channel_mapping.items(): - new_program.channel_mapping[k].update(v) - - if self.windows is not None or other.windows is not None: - new_program.windows = {} - - def add_to_windows(name, begins, lengths): - if name not in new_program.windows: - new_program.windows[name] = [[], []] - for b, l in zip(begins, lengths): - if b not in new_program.windows[name][0]: - new_program.windows[name][0].append(b) - new_program.windows[name][1].append(l) - - if self.windows is not None: - for wn, v in self.windows.items(): - add_to_windows(wn, v[0], v[1]) - if other.windows is not None: - for wn, v in other.windows.items(): - add_to_windows(wn, v[0], v[1]) - - for k, v in new_program.windows.items(): - new_program.windows[k][0] = np.array(new_program.windows[k][0]) - new_program.windows[k][1] = np.array(new_program.windows[k][1]) - - if self.trigger_settings is not None: - new_program.trigger_settings = self.trigger_settings - if other.trigger_settings is not None: - new_program.trigger_settings = other.trigger_settings - - new_program.other_settings.update(self.other_settings) - new_program.other_settings.update(other.other_settings) - - if self.operations is not None: - new_program.operations = self.operations - if other.operations is not None: - new_program.operations = other.operations - - return new_program - def postprocessing_crop_windows( serial:str, recorded_data: Mapping[str, List[xr.DataArray]], - program: MFLIProgram, - fail_on_empty: bool = True) -> Mapping[str, Mapping[str, List[xr.DataArray]]]: + program: "MFLIProgram", + fail_on_empty: bool = True, average_window:bool=False) -> Mapping[str, Mapping[str, List[Union[float, xr.DataArray]]]]: """ This function parses the recorded data and extracts the measurement masks """ @@ -176,11 +106,15 @@ def postprocessing_crop_windows( 0] * 1e9 + _time_of_first_not_nan_value foo = applicable_data.where((applicable_data["time"] >= (time_of_trigger + b)[:, None]) & ( - applicable_data["time"] <= (time_of_trigger + b + l)[:, None]), drop=False).copy() - foo2 = foo.where(~np.isnan(foo), drop=True) - rows_with_data = np.sum(~np.isnan(foo), axis=-1) > 0 - foo2["time"] -= time_of_trigger[rows_with_data, None] - extracted_data.append(foo2) + applicable_data["time"] <= (time_of_trigger + b + l)[:, None]), drop=False) + if not average_window: + foo = foo.copy() + foo2 = foo.where(~np.isnan(foo), drop=True) + rows_with_data = np.sum(~np.isnan(foo), axis=-1) > 0 + foo2["time"] -= time_of_trigger[rows_with_data, None] + extracted_data.append(foo2) + else: + extracted_data.append(np.nanmean(foo)) data_by_channel.update({cn: extracted_data}) masked_data[window_name] = data_by_channel @@ -191,56 +125,89 @@ def postprocessing_crop_windows( def postprocessing_average_within_windows( serial:str, recorded_data: Mapping[str, List[xr.DataArray]], - program: MFLIProgram, + program: "MFLIProgram", fail_on_empty: bool = True) -> Mapping[str, Mapping[str, List[float]]]: """ This function returns one float per window that averages each channel individually for that window. """ - # targeted structure: - # results[][] -> [data] + return postprocessing_crop_windows( + serial = serial, + recorded_data = recorded_data, + program = program, + fail_on_empty = fail_on_empty, + average_window = True) - masked_data = {} - shot_index = 0 # TODO make this more flexible to not lose things +@dataclasses.dataclass +class MFLIProgram: + default_channels: Optional[Set[str]] = dataclasses.field(default=None) + channel_mapping: Optional[Dict[str, Set[str]]] = dataclasses.field(default=None) + windows: Optional[Dict[str, Tuple[np.ndarray, np.ndarray]]] = dataclasses.field(default=None) + trigger_settings: Optional[TriggerSettings] = dataclasses.field(default=None) + other_settings: Dict[str, Any] = dataclasses.field(default_factory=dict) + operations: Any = dataclasses.field(default=postprocessing_crop_windows) - for window_name, (begins, lengths) in program.windows.items(): - data_by_channel = {} - # _wind = program["windows"][window_name] - for ci, _cn in enumerate(program.channel_mapping[window_name]): - cn = f"/{serial}/{_cn}".lower() + def get_minimal_duration(self) -> float: + return max(np.max(begins + lengths) for (begins, lengths) in self.windows.values()) - if len(recorded_data[cn]) <= shot_index: - # then we do not have data for this shot_index, which is intended to cover multiple not yet collected measurements. And thus will not have anything to save. - warnings.warn( - f"for channel '{cn}' only {len(recorded_data[cn])} shots are given. This does not allow for taking element [-1-{shot_index}]") - continue - applicable_data = recorded_data[cn][-1 - shot_index] - applicable_data = applicable_data.where(~np.isnan(applicable_data), drop=True) + def required_channels(self) -> Set[str]: + channels = set() + for window_name in self.windows: + channels |= self.channel_mapping.get(window_name, self.default_channels) + return channels - if len(applicable_data) == 0 or np.product([*applicable_data.shape]) == 0: - if fail_on_empty: - raise ValueError(f"The received data for channel {_cn} is empty.") - else: - warnings.warn(f"The received data for channel {_cn} is empty.") - continue + def merge(self, other: 'MFLIProgram') -> 'MFLIProgram': - extracted_data = [] - for b, l in zip(begins, lengths): - # _time_of_first_not_nan_value = applicable_data.where(~np.isnan(applicable_data), drop=True)["time"][:, 0].values + new_program = MFLIProgram() - _time_of_first_not_nan_value = applicable_data["time"][:, 0].values + new_program.default_channels = self.default_channels + if new_program.default_channels is None: + new_program.default_channels = other.default_channels + elif isinstance(new_program.default_channels, set): + new_program.default_channels = new_program.default_channels.union(other.default_channels) - time_of_trigger = -1 * applicable_data.attrs["gridcoloffset"][ - 0] * 1e9 + _time_of_first_not_nan_value + new_program.channel_mapping = {**self.channel_mapping} + if other.channel_mapping is not None: + for k, v in other.channel_mapping.items(): + new_program.channel_mapping[k].update(v) - foo = np.nanmean(applicable_data.where((applicable_data["time"] >= (time_of_trigger + b)[:, None]) & ( - applicable_data["time"] <= (time_of_trigger + b + l)[:, None]), drop=False)) - extracted_data.append(foo) + if self.windows is not None or other.windows is not None: + new_program.windows = {} - data_by_channel.update({cn: extracted_data}) - masked_data[window_name] = data_by_channel + def add_to_windows(name, begins, lengths): + if name not in new_program.windows: + new_program.windows[name] = [[], []] + for b, l in zip(begins, lengths): + if b not in new_program.windows[name][0]: + new_program.windows[name][0].append(b) + new_program.windows[name][1].append(l) + + if self.windows is not None: + for wn, v in self.windows.items(): + add_to_windows(wn, v[0], v[1]) + if other.windows is not None: + for wn, v in other.windows.items(): + add_to_windows(wn, v[0], v[1]) + + for k, v in new_program.windows.items(): + new_program.windows[k][0] = np.array(new_program.windows[k][0]) + new_program.windows[k][1] = np.array(new_program.windows[k][1]) + + if self.trigger_settings is not None: + new_program.trigger_settings = self.trigger_settings + if other.trigger_settings is not None: + new_program.trigger_settings = other.trigger_settings + + new_program.other_settings.update(self.other_settings) + new_program.other_settings.update(other.other_settings) + + if self.operations is not None: + new_program.operations = self.operations + if other.operations is not None: + new_program.operations = other.operations + + return new_program - return masked_data class MFLIDAQ(DAC): """ This class contains the driver for using the DAQ module of an Zuerich Instruments MFLI with qupulse. @@ -463,39 +430,6 @@ def register_operations(self, program_name: str, operations) -> None: self.programs.setdefault(program_name, MFLIProgram()).operations = operations - def _get_channels_for_window(self, program_name: Union[str, None], window_name: Union[str, List[str], None] = None): - """ Returns the channels to be measured for a given window - """ - raise NotImplementedError("removed") - - # if window_name is None: - # window_name = list(self.programs[program_name]["windows"].keys()) - # if not isinstance(window_name, list): - # window_name = [window_name] - # - # channels: Set[str] = set() - # - # for wn in window_name: - # try: - # channels.update(self.programs[program_name]["channel_mapping"][wn]) - # except KeyError: - # try: - # channels.update(self.programs[program_name]["channel_mapping"][None]) - # except KeyError: - # try: - # channels.update(self.programs[None]["channel_mapping"][wn]) - # except KeyError: - # try: - # channels.update(self.programs[None]["channel_mapping"][None]) - # except KeyError: - # pass - # - # if len(channels) == 0: - # warnings.warn(f"No channels registered to measure with program {program_name} and window {window_name}.") - # - # channels = set([e.lower() for e in channels]) - # return channels - def _get_demod(self, channel: str): """ This function gets the demodulator corresponding to a channel """