From 7b6d57177b2572be21d2efd136adf7bc13c7c081 Mon Sep 17 00:00:00 2001 From: maxbeer99 Date: Tue, 12 Nov 2024 17:12:50 +0100 Subject: [PATCH] implement atssimple support --- .../_MinimalExampleHdawg8Atssimple.ipynb | 466 ++++++++++++++++++ qupulse/hardware/dacs/atssimple.py | 267 ++++++++++ 2 files changed, 733 insertions(+) create mode 100644 doc/source/examples/_MinimalExampleHdawg8Atssimple.ipynb create mode 100644 qupulse/hardware/dacs/atssimple.py diff --git a/doc/source/examples/_MinimalExampleHdawg8Atssimple.ipynb b/doc/source/examples/_MinimalExampleHdawg8Atssimple.ipynb new file mode 100644 index 00000000..52bd4f00 --- /dev/null +++ b/doc/source/examples/_MinimalExampleHdawg8Atssimple.ipynb @@ -0,0 +1,466 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Minimal example of using QuPulse 2-channel pulse and ATSaverage `chunkedAverage`\n", + "\n", + "This notebook uses QuPulse to put out a 2-channel pulse, where some interesting pulse it played on channel `1-A` and a less interesting pulse for triggering is played on channel `3-B`. It also sets up an atssimple measurement for measuring the output when using channel `3-B` as a trigger.\n", + "\n", + "The notebook does not make use of dedicated marker channels." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import qupulse\n", + "import qupulse.pulses.plotting\n", + "import qupulse.hardware.awgs.zihdawg\n", + "import qupulse.hardware.dacs.atssimple\n", + "\n", + "import atssimple\n", + "import atssimple.atsapi\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as pltpatches\n", + "\n", + "import logging\n", + "import sys\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Setup logging" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "logging.basicConfig(stream=sys.stdout)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "QuPulse pulse shenanigans, now with measurements" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pulse_template = qupulse.pulses.TablePT(\n", + " {\n", + " \"playback_channel_A\": [\n", + " (0, 0),\n", + " (\"t_delay * time_unit\", 0, \"hold\"),\n", + " (\"(t_delay + 1000) * time_unit\", \"holdc0v1\", \"hold\"),\n", + " (\"(t_delay + 1000 + 2000) * time_unit\", \"holdc0v2\", \"hold\"),\n", + " (\"(t_delay + 3000 + 2000) * time_unit\", \"linc0v3\", \"linear\"),\n", + " (\"(t_delay + 5000 + 3000) * time_unit\", \"jumpc0v4\", \"jump\"),\n", + " (\"(t_delay + 8000 + 2000) * time_unit\", \"jumpc0v5\", \"jump\"),\n", + " ],\n", + " \"playback_channel_B\": [\n", + " (0, -0.5),\n", + " (\"100 * time_unit\", 0.5, \"hold\"),\n", + " (\"(t_delay/2 + 10000/2) * time_unit\", -0.5, \"hold\"),\n", + " (\"(t_delay + 10000) * time_unit\", -0.5, \"hold\"),\n", + " ],\n", + " },\n", + " measurements=[\n", + " (\"M1\", \"0 * time_unit\", \"t_delay * time_unit\"),\n", + " (\"M2\", \"t_delay * time_unit\", \"1000 * time_unit\"),\n", + " (\"M3\", \"(t_delay + 1000) * time_unit\", \"2000 * time_unit\"),\n", + " (\"M4\", \"(t_delay + 3000) * time_unit\", \"2000 * time_unit\"),\n", + " (\"M5\", \"(t_delay + 5000) * time_unit\", \"2500 * time_unit\"), # This mask leaves a gap\n", + " (\"M6\", \"(t_delay + 8000) * time_unit\", \"2000 * time_unit\"),\n", + " ],\n", + ")\n", + "\n", + "reps = 2\n", + "pulse_template = pulse_template.with_repetition(reps)\n", + "\n", + "params = {\n", + " \"t_delay\": 100,\n", + " \"holdc0v1\": 0.25,\n", + " \"holdc0v2\": 0.5,\n", + " \"linc0v3\": 0.25,\n", + " \"jumpc0v4\": 0.5,\n", + " \"jumpc0v5\": 0,\n", + " \"time_unit\": 1,\n", + "}\n", + "\n", + "_ = qupulse.pulses.plotting.plot(\n", + " pulse_template,\n", + " params,\n", + " sample_rate=0.1/1,\n", + " plot_measurements=pulse_template.measurement_names,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initialize program with the given parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "pulse_program = pulse_template.create_program(parameters=params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Setup AlazarCard configuration" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "board = atssimple.atsapi.Board(systemId=1, boardId=1)\n", + "\n", + "samples_per_sec = 125000000.0\n", + "board.setCaptureClock(\n", + " atssimple.atsapi.INTERNAL_CLOCK,\n", + " atssimple.atsapi.SAMPLE_RATE_125MSPS,\n", + " atssimple.atsapi.CLOCK_EDGE_RISING,\n", + " 0,\n", + ")\n", + "\n", + "board.inputControlEx(\n", + " atssimple.atsapi.CHANNEL_A,\n", + " atssimple.atsapi.DC_COUPLING,\n", + " atssimple.atsapi.INPUT_RANGE_PM_1_V,\n", + " atssimple.atsapi.IMPEDANCE_50_OHM,\n", + ")\n", + "\n", + "board.inputControlEx(\n", + " atssimple.atsapi.CHANNEL_B,\n", + " atssimple.atsapi.DC_COUPLING,\n", + " atssimple.atsapi.INPUT_RANGE_PM_1_V,\n", + " atssimple.atsapi.IMPEDANCE_50_OHM,\n", + ")\n", + "\n", + "board.inputControlEx(\n", + " atssimple.atsapi.CHANNEL_C,\n", + " atssimple.atsapi.DC_COUPLING,\n", + " atssimple.atsapi.INPUT_RANGE_PM_1_V,\n", + " atssimple.atsapi.IMPEDANCE_50_OHM,\n", + ")\n", + "\n", + "board.inputControlEx(\n", + " atssimple.atsapi.CHANNEL_D,\n", + " atssimple.atsapi.DC_COUPLING,\n", + " atssimple.atsapi.INPUT_RANGE_PM_1_V,\n", + " atssimple.atsapi.IMPEDANCE_50_OHM,\n", + ")\n", + "\n", + "board.setTriggerOperation(\n", + " atssimple.atsapi.TRIG_ENGINE_OP_J,\n", + " atssimple.atsapi.TRIG_ENGINE_J,\n", + " atssimple.atsapi.TRIG_CHAN_B,\n", + " atssimple.atsapi.TRIGGER_SLOPE_POSITIVE,\n", + " 150,\n", + " atssimple.atsapi.TRIG_ENGINE_K,\n", + " atssimple.atsapi.TRIG_DISABLE,\n", + " atssimple.atsapi.TRIGGER_SLOPE_POSITIVE,\n", + " 128,\n", + ")\n", + "\n", + "board.setExternalTrigger(atssimple.atsapi.DC_COUPLING, atssimple.atsapi.ETR_5V)\n", + "\n", + "triggerDelay_sec = 0\n", + "triggerDelay_samples = int(triggerDelay_sec * samples_per_sec + 0.5)\n", + "board.setTriggerDelay(triggerDelay_samples)\n", + "\n", + "triggerTimeout_sec = 0\n", + "triggerTimeout_clocks = int(triggerTimeout_sec / 10e-6 + 0.5)\n", + "board.setTriggerTimeOut(triggerTimeout_clocks)\n", + "\n", + "board.configureAuxIO(atssimple.atsapi.AUX_OUT_TRIGGER, 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create HardwareSetup object that holds awgs and dacs and handles their shared information" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "HardwareSetup = qupulse.hardware.setup.HardwareSetup()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create awg handle and register its used playback channel to the HardwareSetup.\n", + "This also creates the connection between the channel name in the program and the physical device channel" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "awg = qupulse.hardware.awgs.zihdawg.HDAWGRepresentation(device_serial=\"DEV8899\", device_interface=\"USB\", timeout=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "HardwareSetup.set_channel(\n", + " \"playback_channel_A\",\n", + " [qupulse.hardware.setup.PlaybackChannel(awg.channel_tuples[0], 0)],\n", + ")\n", + "HardwareSetup.set_channel(\n", + " \"playback_channel_B\",\n", + " qupulse.hardware.setup.PlaybackChannel(awg.channel_tuples[0], 1),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create qupulse dac (AlazarCard) handle. This is required in order to communicate the measurement windows with the AlazarCard." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "dac = qupulse.hardware.dacs.atssimple.ATSSimpleCard()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let QuPulse know the connection between the pulse measurement windows and atssimple measurements." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "HardwareSetup.set_measurement('M1', [qupulse.hardware.setup.MeasurementMask(dac, 'M1')])\n", + "HardwareSetup.set_measurement('M2', [qupulse.hardware.setup.MeasurementMask(dac, 'M2')])\n", + "HardwareSetup.set_measurement('M3', [qupulse.hardware.setup.MeasurementMask(dac, 'M3')])\n", + "HardwareSetup.set_measurement('M4', [qupulse.hardware.setup.MeasurementMask(dac, 'M4')])\n", + "HardwareSetup.set_measurement('M5', [qupulse.hardware.setup.MeasurementMask(dac, 'M5')])\n", + "HardwareSetup.set_measurement('M6', [qupulse.hardware.setup.MeasurementMask(dac, 'M6')])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This completes the HardwareSetup, we can thus register program.\n", + "Here `run_callback` needs to be specified because otherwise no trigger action is performed." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# This disables the Software trigger for the HDAWG\n", + "awg.channel_tuples[0]._program_manager._compiler_settings[0][1][\"trigger_wait_code\"] = \"\"\n", + "\n", + "HardwareSetup.remove_program(\"playground_program\")\n", + "HardwareSetup.register_program(\"playground_program\", pulse_program, run_callback=awg.channel_tuples[0].run_current_program)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Register additional operation information. AtsSimple simply requires the sample rate used for each measurement." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "operations = {\n", + " \"M1\": 25e06,\n", + " \"M2\": 25e06,\n", + " \"M3\": 25e06,\n", + " \"M4\": 25e06,\n", + " \"M5\": 25e06,\n", + " \"M6\": 25e06,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "dac.register_operations(\"playground_program\", operations)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run the program. This also compiles and uploads it to the awg.\n", + "\n", + "**Remember to turn on Outputs!**" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "HardwareSetup.run_program(\"playground_program\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get the results and plot." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "my_scanline_result = dac.measure_program([\"M1\", \"M2\", \"M3\", \"M4\", \"M5\", \"M6\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "voltages = {}\n", + "voltages['A'] = np.concatenate([np.concatenate([my_scanline_result[f\"M{index}\"][rep][1][0] for index in [1,2,3,4,5,6]]) for rep in range(reps)]) * 1e03 # mV\n", + "voltages['B'] = np.concatenate([np.concatenate([my_scanline_result[f\"M{index}\"][rep][1][1] for index in [1,2,3,4,5,6]]) for rep in range(reps)]) * 1e03 # mV\n", + "voltages['C'] = np.concatenate([np.concatenate([my_scanline_result[f\"M{index}\"][rep][1][2] for index in [1,2,3,4,5,6]]) for rep in range(reps)]) * 1e03 # mV\n", + "voltages['D'] = np.concatenate([np.concatenate([my_scanline_result[f\"M{index}\"][rep][1][3] for index in [1,2,3,4,5,6]]) for rep in range(reps)]) * 1e03 # mV\n", + "\n", + "t = np.concatenate([np.concatenate([my_scanline_result[f\"M{index}\"][rep][0] for index in [1,2,3,4,5,6]]) for rep in range(reps)]) * 1e09 # ns\n", + "\n", + "plt.plot(t, voltages[\"A\"], marker='.', linestyle='solid', label=\"A\")\n", + "plt.plot(t, voltages[\"B\"], marker='.', linestyle='solid', label=\"B\")\n", + "plt.plot(t, voltages[\"C\"], marker='.', linestyle='solid', label=\"C\")\n", + "plt.plot(t, voltages[\"D\"], marker='.', linestyle='solid', label=\"D\")\n", + "\n", + "ax = plt.gca()\n", + "mcolors = [\"red\", \"blue\", \"green\", \"yellow\", \"purple\", \"gray\"]\n", + "for index in [1,2,3,4,5,6]:\n", + " for rep in range(reps):\n", + " r = pltpatches.Rectangle(((x0 := my_scanline_result[f\"M{index}\"][rep][0][0] * 1e09), -750), my_scanline_result[f\"M{index}\"][rep][0][-1] * 1e09 - x0, 1500, facecolor=mcolors[index-1], alpha=0.2)\n", + " ax.add_patch(r)\n", + " \n", + "\n", + "plt.xlabel('Time (ns)')\n", + "plt.ylabel('Voltage (mV)')\n", + "\n", + "plt.grid()\n", + "plt.legend()\n", + "\n", + "plt.show()" + ] + } + ], + "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.11.9" + }, + "vscode": { + "interpreter": { + "hash": "1ffa1ec66b98135bc5235b821096bbaf2b3953fc4daa325d28b445a2a64f1366" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/qupulse/hardware/dacs/atssimple.py b/qupulse/hardware/dacs/atssimple.py new file mode 100644 index 00000000..5e419714 --- /dev/null +++ b/qupulse/hardware/dacs/atssimple.py @@ -0,0 +1,267 @@ +from typing import Iterable, Dict, Tuple, Union +import logging + +import time + +import numpy + +from qupulse.hardware.dacs.dac_base import DAC + +from atssimple import acquire_sample_rates_time_windows, ATSSimpleCard + +logger = logging.getLogger(__name__) + + +class ATSSimpleCard(ATSSimpleCard): + def __init__( + self, + board_ids: Tuple[int, int] = (1, 1), + samples_per_second: float = 125_000_000, + channel_mask: int = 0b1111, + voltage_range: Union[float, Tuple[float, float, float, float]] = 1.0, + ): + """ + QuPulse DAC interface for ATSSimple. + + Args: + board_ids, (int, int) (optional, default: (1, 1)): + systemId, boardId to select the alazar card + samples_per_second, float (optional, default: 125_000_000): + Sample rate configured on board. + channel_mask, int (optional, default: 0b1111): + Bitmap representing the channels to be acquired. + 0b0001 = Channel A + 0b0010 = Channel B + 0b0100 = Channel C + 0b1000 = Channel D + voltage_range, float or 4-tuple of floats (optional, default: 1.0): + The voltage ranges of each channel. + """ + + super().__init__( + acquisition_function=acquire_sample_rates_time_windows, board_ids=board_ids + ) + + self.samples_per_second = samples_per_second + self.channel_mask = channel_mask + self.voltage_range = voltage_range + + self.current_program = None + self.registered_programs = {} + + self._armed_sample_windows = None + self._armed_window_names = None + + self._results_raw = None + self._samples_raw = None + + self._results = {} + + def _pad_and_validate_measurement_windows( + self, windows: Dict[str, Tuple[numpy.ndarray, numpy.ndarray]] + ) -> Dict[str, Tuple[numpy.ndarray, numpy.ndarray]]: + """ + Only non-overlapping measurement windows are allowed. Gaps are padded with padding windows. + """ + + # Strip previous padding + windows["_padding"] = [numpy.array([]), numpy.array([])] + + # Collect all windows and discard names + windows_flat = [numpy.array([]), numpy.array([])] + for k, v in windows.items(): + windows_flat[0] = numpy.append(windows_flat[0], v[0]) + windows_flat[1] = numpy.append(windows_flat[1], v[1]) + + # Sort by window starts + args = numpy.argsort(windows_flat[0]) + windows_flat[0] = windows_flat[0][args] + windows_flat[1] = windows_flat[1][args] + + padding_windows = [numpy.array([]), numpy.array([])] + # Prepend padding in case that the first measurement window starts with some delay + if windows_flat[0][0] > 0: + padding_windows[0] = numpy.append( + padding_windows[0], 0 + ) + padding_windows[1] = numpy.append( + padding_windows[1], + windows_flat[0][0] + ) + + # Pad between windows + for index in range(len(windows_flat[0]) - 1): + # Raise error if windows overlap + if ( + windows_flat[0][index] + windows_flat[1][index] + > windows_flat[0][index + 1] + ): + raise ValueError("Overlapping measurement windows not allowed!") + + # Calculate necessary padding + if ( + windows_flat[0][index] + windows_flat[1][index] + < windows_flat[0][index + 1] + ): + padding_windows[0] = numpy.append( + padding_windows[0], windows_flat[0][index] + windows_flat[1][index] + ) + padding_windows[1] = numpy.append( + padding_windows[1], + windows_flat[0][index + 1] + - (windows_flat[0][index] + windows_flat[1][index]), + ) + + windows["_padding"] = padding_windows + + return windows + + def _smallest_compatible_sample_rate( + self, window_length: float, sample_rate: float + ): + if sample_rate < 1e-6: + raise RuntimeError("Could not find sample rate for too short window!") + + if (sample_rate / 10) * window_length > 1: + return self._smallest_compatible_sample_rate( + window_length, sample_rate / 10 + ) + else: + return sample_rate + + def register_measurement_windows( + self, program_name: str, windows: Dict[str, Tuple[numpy.ndarray, numpy.ndarray]] + ) -> None: + + self.registered_programs[program_name] = { + "windows": (self._pad_and_validate_measurement_windows(windows)) + } + + def set_measurement_mask( + self, + program_name: str, + mask_name: str, + begins: numpy.ndarray, + lengths: numpy.ndarray, + ) -> Tuple[numpy.ndarray, numpy.ndarray]: + + windows = self.registered_programs[program_name]["windows"].copy() + windows[mask_name] = ( + begins, + lengths, + ) + + self.registered_programs[program_name]["windows"] = ( + self._pad_and_validate_measurement_windows(windows) + ) + + def register_operations( + self, program_name: str, operations: Dict[str, float] + ) -> None: + """ + Operations: {"mask1": sample_rate1, "mask2": sample_rate2, ...} + """ + + if not "_padding" in operations.keys(): + operations["_padding"] = 125000000 # 125000000 Hz acquisition padding + + self.registered_programs[program_name]["operations"] = operations + + def arm_program(self, program_name: str) -> None: + if not program_name in self.registered_programs.keys(): + raise ValueError(f'"{program_name}" not registered!') + self.current_program = program_name + + # Collect all windows and discard names + windows_flat = [numpy.array([]), numpy.array([]), numpy.array([])] + for k, v in self.registered_programs[program_name]["windows"].items(): + windows_flat[0] = numpy.append(windows_flat[0], v[0]) + windows_flat[1] = numpy.append(windows_flat[1], v[1]) + windows_flat[2] = numpy.append( + windows_flat[2], numpy.array(len(v[0]) * [k]) + ) + + # Sort by window starts + args = numpy.argsort(windows_flat[0]) + windows_flat[0] = windows_flat[0][args] + windows_flat[1] = windows_flat[1][args] + windows_flat[2] = windows_flat[2][args] + + # Compile acquisition parameters + window_names = windows_flat[2] + window_lengths = windows_flat[1] / 1e09 # In sec. + sample_rates = [] + for i, window_name in enumerate(window_names): + # If measurement would result in 0 samples due to too small sample rate, + # modify sample rate such that at least on sample is acquired. + if ( + 1.0 + / ( + sample_rate := self.registered_programs[program_name]["operations"][ + window_name + ] + ) + <= window_lengths[i] + ): + sample_rates.append(sample_rate) + else: + sample_rates.append( + self._smallest_compatible_sample_rate( + window_lengths[i], self.samples_per_second + ) + ) + + self._armed_sample_windows = numpy.array([window_lengths, sample_rates]).T + self._armed_window_names = window_names + + self._results = {} + self._results_raw = {} + self._samples_raw = {} + + # Start Acquisition + self.start_acquisition( + sample_rates=self._armed_sample_windows, + channel_mask=self.channel_mask, + samples_per_second=self.samples_per_second, + voltage_range=self.voltage_range, + return_samples_in_seconds=True, + ) + + # Additional wait to get acquisition ready before continuing + time.sleep(0.1) + + def delete_program(self, program_name: str) -> None: + self.registered_programs.pop(program_name) + + def clear(self) -> None: + self.registered_programs.clear() + + def measure_program( + self, channels: Iterable[str] = None + ) -> Dict[str, numpy.ndarray]: + if self.current_program == None: + raise RuntimeError("No programm armed yet!") + + # Collect thread and data + self._acquisition_process.join() + self._results_raw, self._samples_raw = self._result_queue.get(timeout=1) + + # Sort results by window + total_samples = 0 + window_boundries = numpy.insert(numpy.cumsum(self._armed_sample_windows[:, 0]), 0, 0) + for i, window_name in enumerate(self._armed_window_names): + samples = self._samples_raw[numpy.where((self._samples_raw >= window_boundries[i]) * (self._samples_raw < window_boundries[i+1]))[0]] + results = self._results_raw[:, numpy.where((self._samples_raw >= window_boundries[i]) * (self._samples_raw < window_boundries[i+1]))[0]] + + if self._results.get(window_name) == None: + self._results[window_name] = [] + + self._results[window_name] += [[samples, results]] + total_samples += len(samples) + + # Compile result dict + result_dict = {} + for channel in channels: + result_dict[channel] = self._results[channel] + + return result_dict