q1simulator 1.0.1__py3-none-any.whl

q1simulator/__init__.py

@@ -0,0 +1,8 @@
+__version__ = "1.0.1"
+
+from .q1simulator import Q1Simulator
+from .cluster import Cluster, ClusterModule
+from .q1plotter import Q1Plotter
+from .q1viewer import plot_q1asm_file, plot_q1asm_files, PlotDef
+
+from .gui.program_browser import Q1ProgramBrowser

q1simulator/analogue_filter.py

@@ -0,0 +1,56 @@
+import os
+
+import numpy as np
+import xarray as xr
+
+
+class AnalogueFilter:
+    warned = False
+
+    def __init__(self, model_name: str, output_frequency: float = 4e9):
+        self.output_frequency = output_frequency
+
+        if not AnalogueFilter.warned:
+            print(f"WARNING: Analogue output of simulated {model_name} can differ "
+                  "significantly from real hardware!")
+            AnalogueFilter.warned = True
+
+        pulse_response_dir = os.path.dirname(__file__)
+        if model_name == "QCM":
+            fname = pulse_response_dir + "/Qblox_QCM_pulse_response.hdf5"
+            amplitude_correction = 1.003
+            self.min_vstep = 5.0/2**16  # 0.076 mV
+        else:
+            raise Exception(f"Uknown model_name {model_name}")
+
+        pulse_response = xr.open_dataset(fname, engine='h5netcdf')
+        t_response = pulse_response.coords['t'].data
+        self.pulse_response = pulse_response['y'].data * amplitude_correction
+        sr = round(1/(t_response[1]-t_response[0]))
+        sub_sample = int(round(sr / (output_frequency*1e-9)))
+        self.sr = sr // sub_sample
+        self.pulse_response = self.pulse_response[::sub_sample]
+
+        self.n_before = round(-t_response[0] * self.sr)
+        self.n_after = len(self.pulse_response) - self.n_before - 1
+
+    def quantize_amplitude(self, wave):
+        return np.round(wave/self.min_vstep) * self.min_vstep
+
+    def get_awg_output(self, t, samples, analogue_shift: float | None = 0.0):
+        samples = self.quantize_amplitude(samples)
+        if t[1] - t[0] != 1:
+            raise Exception(f"Expecting input with 1 ns sample period. Got {t[1]-t[0]}")
+        t = np.linspace(t[0], t[-1]+1, len(t)*self.sr, endpoint=False)
+        d = np.zeros(len(samples)*self.sr)
+        d[::self.sr] = samples
+
+        d = np.convolve(d, self.pulse_response)
+        return t+analogue_shift, d[self.n_before: -self.n_after]
+
+    def apply_filter(self, samples):
+        """Apply filter to samples without quantizing or shifting time."""
+        d = np.zeros(len(samples)*self.sr)
+        d[::self.sr] = samples
+        d = np.convolve(d, self.pulse_response)
+        return d[self.n_before: -self.n_after]

q1simulator/channel_data.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+import numpy as np
+from numpy.typing import NDArray
+
+
+@dataclass
+class SampledOutput:
+    t_min: int
+    t_max: int
+    sample_rate: int  # GSa/s
+    data: NDArray
+
+    def get_time_data(self):
+        """Time is [ns]"""
+        n = (self.t_max-self.t_min)*self.sample_rate
+        return np.linspace(self.t_min, self.t_max, n, endpoint=False)
+
+    def __add__(self, rhs: SampledOutput):
+        if self.t_min != rhs.t_min:
+            raise Exception(f"t_min not equal for sample output: {self.t_min} <> {rhs.t_min}")
+        if self.sample_rate != rhs.sample_rate:
+            raise Exception(f"sample rates not equal for sample output: {self.sample_rate} <> {rhs.sample_rate}")
+
+        t_max = max(self.t_max, rhs.t_max)
+        if self.t_max < t_max:
+            lhs_data = np.zeros(t_max * self.sample_rate)
+            lhs_data[:self.t_max * self.sample_rate] = self.data
+        else:
+            lhs_data = self.data
+        if rhs.t_max < t_max:
+            rhs_data = np.zeros(t_max * self.sample_rate)
+            rhs_data[:rhs.t_max * self.sample_rate] = rhs.data
+        else:
+            rhs_data = rhs.data
+
+        return SampledOutput(self.t_min, t_max, self.sample_rate, lhs_data+rhs_data)
+
+
+@dataclass
+class MarkerOutput:
+    t_min: int
+    t_max: int
+    points: list[tuple[int, int]]
+
+    def get_xy_lines(self):
+        line = np.array(self.points).T
+        return (line[0], line[1])
+
+    def to_samples(self):
+        n = self.t_max - self.t_min
+        data = np.zeros(n)
+        ip = 0
+        points = self.points
+        while points[ip][0] < self.t_min:
+            ip += 1
+        if int(points[ip][1]) == int(points[ip+1][1]):
+            # Skip point if level doesn't change.
+            # This can occur at start: [[0, 0], [0, 0], [0, 1], ...]
+            ip += 1
+        it = points[ip][0]
+        data[:it] = points[ip][1]
+        ip += 1
+        while ip+1 < len(points) and points[ip+1][0] <= self.t_max:
+            it1 = points[ip][0]
+            it2 = points[ip+1][0]
+            data[it1:it2] = points[ip][1]
+            ip += 2
+        return SampledOutput(self.t_min, self.t_max, 1, data)
+
+    def __add__(self, rhs: MarkerOutput | SampledOutput):
+        if isinstance(rhs, MarkerOutput):
+            rhs = rhs.to_samples()
+        return self.to_samples() + rhs
+
+    def __radd__(self, lhs: MarkerOutput | SampledOutput):
+        return self + lhs

q1simulator/cluster.py

@@ -0,0 +1,216 @@
+import logging
+from functools import partial
+
+import matplotlib.pyplot as pt
+import qcodes as qc
+
+from qblox_instruments import (
+        InstrumentClass, InstrumentType,
+        SystemStatuses, SystemStatus, SystemStatusSlotFlags,
+        )
+
+from .qblox_version import check_qblox_instrument_version
+from .q1simulator import Q1Module, run_sequencers
+
+
+logger = logging.getLogger(__name__)
+
+
+class ClusterModule(qc.InstrumentChannel, Q1Module):
+    def __init__(self, root_instrument, name, slot, n_sequencers=6, sim_type=None):
+        super().__init__(root_instrument, name)
+        self._slot = slot
+        super().init_module(n_sequencers, sim_type)
+
+    def present(self):
+        return True
+
+    @property
+    def slot_idx(self):
+        return self._slot
+
+
+class EmptySlot(qc.InstrumentChannel):
+    def __init__(self, root_instrument, name):
+        super().__init__(root_instrument, name)
+
+    def present(self):
+        return False
+
+
+class Cluster(qc.Instrument):
+    _cluster_parameters = [
+        'trigger_monitor_latest',
+        ]
+    _log_only_params = [
+        'led_brightness',
+        ]
+
+    def __init__(self, name, modules={}):
+        check_qblox_instrument_version()
+        super().__init__(name)
+
+        # TODO return trigger count
+        for par_name in self._cluster_parameters:
+            self.add_parameter(par_name, set_cmd=partial(self._set, par_name))
+        for i in range(1, 16):
+            par_name = f'trigger{i}_monitor_count'
+            self.add_parameter(par_name, set_cmd=partial(self._set, par_name))
+
+        for par_name in self._log_only_params:
+            self.add_parameter(par_name,
+                               set_cmd=partial(self._log_set, par_name))
+
+        self._modules = {}
+        for slot in range(1, 21):
+            name = f'module{slot}'
+            if slot in modules:
+                module = ClusterModule(self, name, slot, sim_type=modules[slot])
+            else:
+                module = EmptySlot(self, name)
+            self.add_submodule(name, module)
+            self._modules[slot] = module
+
+    def get_idn(self):
+        return dict(vendor='Q1Simulator', model='Cluster', serial='', firmware='')
+
+    @property
+    def instrument_class(self):
+        return InstrumentClass.CLUSTER
+
+    @property
+    def instrument_type(self):
+        return InstrumentType.MM
+
+    def get_num_system_error(self):
+        return 0
+
+    def get_system_error(self):
+        return '0,"No error"'
+
+    def get_system_status(self):
+        return SystemStatus(
+            SystemStatuses.OKAY,
+            [],
+            SystemStatusSlotFlags({}))
+
+    def get_connected_modules(self, filter_fn=None):
+        result = {}
+        for slot, module in self._modules.items():
+            if module.present():
+                result[slot] = module
+        return result
+
+    def _check_module_present(self, slot):
+        if not self._modules[slot].present():
+            raise Exception(f'No module in slot {slot}')
+
+    def _set(self, name, value):
+        logger.info(f'{self.name}:{name}={value}')
+
+    def get_sequencer_status(self, slot, seq_nr, timeout=0):
+        return self._modules[slot].get_sequencer_status(seq_nr, timeout)
+
+    def get_acquisition_status(self, slot, seq_nr, timeout=0):
+        return self.self._modules[slot].get_acquisition_status(seq_nr, timeout)
+
+    def arm_sequencer(self, slot: int | None = None, sequencer: int | None = None) -> None:
+        if slot is not None:
+            self._check_module_present(slot)
+            self._modules[slot].arm_sequencer(sequencer)
+        else:
+            for module in self.get_connected_modules().values():
+                module.arm_sequencer(sequencer)
+
+    def start_sequencer(self, slot: int | None = None, sequencer: int | None = None) -> None:
+        if slot is not None:
+            self._check_module_present(slot)
+            modules = [self._modules[slot]]
+        else:
+            modules = self.get_connected_modules().values()
+
+        # Get list of armed sequencers
+        # pass to sequence executor
+        sequencers = []
+        for module in modules:
+            seq_numbers = [sequencer] if sequencer is not None else module.armed_seq
+            for seq_number in seq_numbers:
+                sequencers.append(module.sequencers[seq_number])
+
+        run_sequencers(sequencers)
+
+    def stop_sequencer(self, slot: int | None = None, sequencer: int | None = None) -> None:
+        if slot is not None:
+            self._check_module_present(slot)
+            self._modules[slot].stop_sequencer(sequencer)
+        else:
+            for module in self.get_connected_modules().values():
+                module.stop_sequencer(sequencer)
+
+    @property
+    def modules(self):
+        return list(self.submodules.values())
+
+    def reset(self):
+        self.invalidate_cache()
+        for module in self.get_connected_modules().values():
+            module.reset()
+
+    def _log_set(self, name, value):
+        logger.info(f'{self.name}: {name}={value}')
+
+    def config(self, name, value):
+        for module in self.get_connected_modules().values():
+            module.config(name, value)
+
+    def get_simulation_end_time(self):
+        return max(module.get_simulation_end_time() for module in self.get_connected_modules().values())
+
+    def plot(self,
+             t_min: float | None = None,
+             t_max: float | None = None,
+             channels: list[str] | list[int] | None = None,
+             modules: list[int] | None = None,
+             create_figure: bool | str = True,
+             analogue_filter: bool = False,
+             analogue_output_frequency: float = 4e9,
+             output_per_sequencer: bool = True,
+             **kwargs):
+        """Plots the simulated output of the cluster.
+
+        Args:
+            t_min: minimum time in the plot.
+            t_max: maximum time in the plot.
+            channels: If not None specifies the channels to plot by name or sequencer number.
+            modules: If not None specifies the modules to plot by slot number.
+            create_figure:
+                If True create a new figure.
+                If False only pyplot.plot() is called without creating figure or setting axis labels.
+                If "modules" creates a new figure per module.
+            analogue_filter: plot result after applying (estimated) analog filter.
+            analogue_output_frequency: sample rate of analogue output
+            output_per_sequencer:
+                if True: plot data for individual sequencers.
+                if False: plot data for physical front panel output.
+        """
+        if create_figure is True:
+            pt.figure()
+            pt.title('Cluster')
+            pt.grid(True)
+            pt.xlabel('[ns]')
+            pt.ylabel('[V]')
+        for slot, module in self.get_connected_modules().items():
+            if modules is not None and slot not in modules:
+                # skip module
+                continue
+            if create_figure == "module":
+                pt.figure()
+                pt.title(module.label)
+                pt.grid(True)
+                pt.xlabel('[ns]')
+                pt.ylabel('[V]')
+            module.plot(t_min=t_min, t_max=t_max, channels=channels, analogue_filter=analogue_filter,
+                        analogue_output_frequency=analogue_output_frequency,
+                        output_per_sequencer=output_per_sequencer)
+            pt.legend()
+        pt.show()

q1simulator/gui/program_browser.py

@@ -0,0 +1,114 @@
+import logging
+import os
+
+from qtpy import QtCore, QtWidgets
+
+from q1simulator.gui.program_details import ProgramDetailsWidget
+from q1simulator.gui.qt_utils import (
+    # qt_log_exception,
+    qt_init,
+    qt_create_app,
+    qt_run_app,
+    qt_set_darkstyle,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+_app = None
+
+
+class Q1ProgramBrowser(QtWidgets.QMainWindow):
+    """
+    Q1Program browser.
+    """
+
+    _WINDOW_TITLE: str = "Q1Program Browser"
+
+    def __init__(
+        self,
+        path: str | None = None,
+        gui_style: str | None = None
+    ):
+        """Creates program browser
+
+        Args:
+            path: base directory. If None uses current working directory.
+            gui_style: if "dark" uses dark style, otherwise normal style.
+        """
+        global _app
+        logger.debug("Init program browser")
+
+        qt_app_runing = qt_init()
+        if not qt_app_runing:
+            # note: store reference to avoid garbage collection.
+            # reference is also used to restart browser 2nd time in Python console.
+            _app = qt_create_app()
+
+        if gui_style == "dark":
+            qt_set_darkstyle()
+
+        super().__init__()
+
+        if path is None:
+            path = os.getcwd()
+
+        self._path = path
+
+        self.setWindowTitle(self._WINDOW_TITLE)
+        self.resize(860, 600)
+        self.create_ui()
+        self.fill_program_list()
+        self.show()
+
+        if _app is not None:
+            qt_run_app(_app)
+
+    def create_ui(self):
+        content = QtWidgets.QWidget()
+        self._list_widget = QtWidgets.QListWidget()
+        self._list_widget.setMinimumWidth(300)
+        self._list_widget.itemSelectionChanged.connect(self._show_program_info)
+
+        self._program_details = ProgramDetailsWidget(self)
+
+        layout = QtWidgets.QHBoxLayout()
+        layout.addWidget(self._list_widget)
+        layout.addWidget(self._program_details, 1)
+
+        content.setLayout(layout)
+        self.setCentralWidget(content)
+
+    @QtCore.Slot()
+    def _show_program_info(self):
+        selected_items = self._list_widget.selectedItems()
+        if not selected_items:
+            return
+        item = selected_items[0]
+        path = item.data(QtCore.Qt.UserRole)
+        self._program_details.show_details(path)
+
+    def fill_program_list(self):
+        w = self._list_widget
+        w.clear()
+        for entry in os.scandir(self._path):
+            if not entry.is_dir():
+                continue
+            i = w.count()
+            w.addItem(entry.name)
+            item = w.item(i)
+            item.setData(QtCore.Qt.UserRole, entry.path)
+
+    def _show_error_message(self, title, message):
+        msg = QtWidgets.QMessageBox()
+        msg.setIcon(QtWidgets.QMessageBox.Critical)
+        msg.setText(message)
+        msg.setWindowTitle("Q1ProgramBrowser: " + title)
+        msg.setStandardButtons(QtWidgets.QMessageBox.Ok)
+        msg.exec_()
+
+
+if __name__ == "__main__":
+    path = r"C:\measurements\qblox_programs"
+    ui = Q1ProgramBrowser(path, gui_style="dark")

q1simulator/gui/program_details.py

@@ -0,0 +1,138 @@
+import json
+from qtpy import QtWidgets, QtCore
+
+from .program_plotter import plot_simulation
+
+
+class ProgramDetailsWidget(QtWidgets.QWidget):
+    def __init__(self,
+                 parent: QtWidgets.QWidget,
+                 ):
+        super().__init__(parent)
+        self._prog_config = None
+        self._path = None
+
+        layout = QtWidgets.QVBoxLayout()
+        layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(layout)
+
+        self._table = self.create_table()
+        layout.addWidget(self._table, 1)
+        layout.addLayout(self.create_controls())
+
+        self._plot_btn.clicked.connect(self.plot)
+
+    def create_table(self):
+        table = QtWidgets.QTreeWidget()
+        table.setMinimumHeight(400)
+        table.setMinimumWidth(540)
+        table.setColumnCount(7)
+        table.setColumnWidth(0, 100)
+        table.setColumnWidth(1, 100)
+        table.setColumnWidth(2, 50)
+        table.setColumnWidth(3, 50)
+        table.setColumnWidth(4, 50)
+        table.setColumnWidth(5, 90)
+        table.setColumnWidth(6, 80)
+        table.setHeaderLabels([
+            "Channel",
+            "Module",
+            "Paths",
+            "Out",
+            "In",
+            "NCO",
+            "Duration",
+            ])
+        table.setRootIsDecorated(False)
+        return table
+
+    def create_controls(self):
+        min_time = QtWidgets.QSpinBox()
+        min_time.setRange(0, 100_000_000)
+        min_time.setSingleStep(1000)
+        self._min_time_spin = min_time
+        max_time = QtWidgets.QSpinBox()
+        max_time.setSpecialValueText("Duration")
+        max_time.setRange(0, 100_000_000)
+        max_time.setSingleStep(1000)
+        self._max_time_spin = max_time
+
+        self._analogue_cb = QtWidgets.QCheckBox("Analogue filter")
+        self._plot_btn = QtWidgets.QPushButton("Plot")
+
+        layout = QtWidgets.QHBoxLayout()
+        layout.addWidget(QtWidgets.QLabel("t min."))
+        layout.addWidget(min_time)
+        layout.addWidget(QtWidgets.QLabel("t max."))
+        layout.addWidget(max_time)
+        layout.addWidget(self._analogue_cb)
+        layout.addWidget(self._plot_btn)
+
+        return layout
+
+    def show_details(self, path):
+        table = self._table
+        table.clear()
+        self._prog_config = None
+        try:
+            with open(path + "/q1program.json", "r") as fp:
+                data = json.load(fp)
+            self._path = path
+            self._prog_config = data
+            duration = -1
+            rows = []
+            for ch_name, settings in data.items():
+                f_nco = settings["nco"]
+                seq_duration = settings.get("duration")
+                if seq_duration is not None:
+                    duration = max(seq_duration, duration)
+                    duration_text = f"{seq_duration} ns"
+                else:
+                    duration_text = "--"
+                q1asm = settings.get("sequence")
+                if not q1asm:
+                    duration_text = "no sequence"
+
+                item = QtWidgets.QTreeWidgetItem(table)
+                item.setText(0, ch_name)
+                item.setData(0, QtCore.Qt.CheckStateRole, QtCore.Qt.Checked if q1asm else QtCore.Qt.Unchecked)
+
+                item.setText(1, settings["module"])
+                item.setText(2, str(settings["paths"]))
+                item.setText(3, str(settings["out_channels"]))
+                item.setText(4, str(settings.get("in_channels", "")))
+                item.setText(5, f"{f_nco/1e6} MHz" if f_nco is not None else "")
+                item.setText(6, duration_text)
+                rows.append(item)
+            table.insertTopLevelItems(0, rows)
+
+            # Show duration
+
+        except FileNotFoundError:
+            print("'program_config.json' not found")
+
+    def plot(self):
+        if not self._prog_config:
+            print("no program")
+            return
+        table = self._table
+        channels = []
+        for i in range(table.topLevelItemCount()):
+            item = table.topLevelItem(i)
+            if item.checkState(0) == QtCore.Qt.Checked:
+                channels.append(item.text(0))
+
+        min_time = self._min_time_spin.value()
+        max_time = self._max_time_spin.value()
+        if max_time == 0:
+            max_time = None
+
+        plot_simulation(
+            self._path,
+            self._prog_config,
+            channels,
+            min_time=min_time,
+            max_time=max_time,
+            analogue_filter=self._analogue_cb.isChecked(),
+            analogue_output_frequency=4e9,
+            )