arbok-driver 0.0.0__tar.gz

arbok_driver-0.0.0/.gitattributes

@@ -0,0 +1 @@
+ * text=auto eol=lf

arbok_driver-0.0.0/.gitignore

@@ -0,0 +1,153 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/

arbok_driver-0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Andreas Nickl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

arbok_driver-0.0.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: arbok_driver
+Version: 0.0.0
+Summary: QCoDeS compatible driver for the OPX+ from Quantum Machines
+Author-email: Andreas Nickl <a.nickl@unsw.edu.au>
+License: BSD-3-Clause
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jupyterlab
+Requires-Dist: numpy>=1.23
+Requires-Dist: matplotlib
+Requires-Dist: plottr
+Requires-Dist: ipython
+Requires-Dist: scipy
+Requires-Dist: qm-qua==1.2.1
+Requires-Dist: qcodes==0.43
+Requires-Dist: qualang_tools==0.19.1
+Requires-Dist: qcodes-contrib-drivers==0.18
+Requires-Dist: rich==13.7.1
+Dynamic: license-file
+
+# arbok_driver
+QCoDeS compatible driver for the OPX+ from Quantum Machines
+Arbok is taylored for routines using the Quantum Machines OPX(+) quantum control hardware.
+
+## Installation
+To install the arbok python module locally follow the steps below
+
+### 1) Clone github repository
+```bash
+git clone https://github.com/andncl/arbok_driver.git
+```
+
+### 2) Prepare conda environment
+We create an empty conda environment to avoid interference with other python packages and to manage package dependencies for measurements. Remember to fix the python version as shown below when creating the environment, since some of the modules are not yet compatible with the latest 3.12.
+```bash
+conda create --name <your_env_name> python=3.12
+conda activate <your_env_name>
+conda install pip
+```
+
+### 3) Go to repo folder and install local arbok module
+
+```bash
+pip install -e .
+```
+**Do not forget the dot after '-e' **. Arbok should now install
+all its requirements automatically. If you need additional
+packages, install them in your new environment called <your_env_name>
+
+### 4) Install git hooks
+Install the git hook so that your notebooks are stripped before committing.
+### To do this with Microsoft :
+```
+.\tools\git.hooks\setupMicrosoft.ps1
+```
+### To do this with Linux :
+```
+./tools/git.hooks/setupLinux.sh
+```
+
+
+### Optional 1) Adding your environment to ipykernel
+
+I recommend running measurements from jupyter lab, which is automatically
+installed when executing 3). To pick the environment you just created within
+the jupyter lab application, add it to the ipython kernel.
+
+```bash
+python -m ipykernel install --user --name <your_env_name>
+```
+### Optional 2) Live plotting and data inspection with plottr
+ Data inslection and live plotting can be done with the `plottr-inpectr` module. To launch it open a terminal and activate your conda environment...
+ ```bash
+conda activate <your-env-name>
+```
+... and launch plottr
+
+```bash
+plottr-inspectr --dbpath <path-to-your-database>
+```
+The data inspector is now running independently of all measurement while beiong connected to the selected database. Select auto-update intervals to have new measurements displayed in real time
+
+## Tutorial: Launch jupyter-lab to run measurements
+
+Jupyter notebooks are a very convenient way of cinducting measurements. Code cells can be run one after another data analysis can be done concurrently to measurements. Keeping measurements in notbooks also guaratees a clear separation between the underlying code base and the configuration files of devices and sequences.
+
+Again activate your conda environment and launch `jupyterlab`
+
+For example to run the first tutorial:
+```bash
+jupyter lab docs/1_parameterizing_sequences.ipynb
+```
+## Re-launching an existing arbok session
+If all running applications have been closed for example when the hosting PC is being restarted, a previously run arbok session can be easily restarted in a few steps.
+
+### 1) Launching the jupyter notebook
+Activate your conda install environment that you created initally. If you are unsure what the name of your environment is type `conda env list`. After that launch jupyter lab as shown below. To simplyfy navigation, launch jupyter in the directory where your notebooks are saved.
+```bash
+conda activate <your-env-name>
+jupyter lab
+```
+### 2) Launching plottr-inspectr
+Exactly as described above!
+
+## Todos:
+- [ ] validators in custom parameter classes for times (4ns -> 1 qm-cycle)
+- [ ] change the way to create sweeps!
+    - [ ] sset list of dicts -> list entry per axis, dict entry per param
+    - [ ] sweeps should be properties with setters for save measurement management
+- [ ] TESTS!
+    - [ ] issue: stubbing OPX/ errors raised by instrument

arbok_driver-0.0.0/README.md

@@ -0,0 +1,91 @@
+# arbok_driver
+QCoDeS compatible driver for the OPX+ from Quantum Machines
+Arbok is taylored for routines using the Quantum Machines OPX(+) quantum control hardware.
+
+## Installation
+To install the arbok python module locally follow the steps below
+
+### 1) Clone github repository
+```bash
+git clone https://github.com/andncl/arbok_driver.git
+```
+
+### 2) Prepare conda environment
+We create an empty conda environment to avoid interference with other python packages and to manage package dependencies for measurements. Remember to fix the python version as shown below when creating the environment, since some of the modules are not yet compatible with the latest 3.12.
+```bash
+conda create --name <your_env_name> python=3.12
+conda activate <your_env_name>
+conda install pip
+```
+
+### 3) Go to repo folder and install local arbok module
+
+```bash
+pip install -e .
+```
+**Do not forget the dot after '-e' **. Arbok should now install
+all its requirements automatically. If you need additional
+packages, install them in your new environment called <your_env_name>
+
+### 4) Install git hooks
+Install the git hook so that your notebooks are stripped before committing.
+### To do this with Microsoft :
+```
+.\tools\git.hooks\setupMicrosoft.ps1
+```
+### To do this with Linux :
+```
+./tools/git.hooks/setupLinux.sh
+```
+
+
+### Optional 1) Adding your environment to ipykernel
+
+I recommend running measurements from jupyter lab, which is automatically
+installed when executing 3). To pick the environment you just created within
+the jupyter lab application, add it to the ipython kernel.
+
+```bash
+python -m ipykernel install --user --name <your_env_name>
+```
+### Optional 2) Live plotting and data inspection with plottr
+ Data inslection and live plotting can be done with the `plottr-inpectr` module. To launch it open a terminal and activate your conda environment...
+ ```bash
+conda activate <your-env-name>
+```
+... and launch plottr
+
+```bash
+plottr-inspectr --dbpath <path-to-your-database>
+```
+The data inspector is now running independently of all measurement while beiong connected to the selected database. Select auto-update intervals to have new measurements displayed in real time
+
+## Tutorial: Launch jupyter-lab to run measurements
+
+Jupyter notebooks are a very convenient way of cinducting measurements. Code cells can be run one after another data analysis can be done concurrently to measurements. Keeping measurements in notbooks also guaratees a clear separation between the underlying code base and the configuration files of devices and sequences.
+
+Again activate your conda environment and launch `jupyterlab`
+
+For example to run the first tutorial:
+```bash
+jupyter lab docs/1_parameterizing_sequences.ipynb
+```
+## Re-launching an existing arbok session
+If all running applications have been closed for example when the hosting PC is being restarted, a previously run arbok session can be easily restarted in a few steps.
+
+### 1) Launching the jupyter notebook
+Activate your conda install environment that you created initally. If you are unsure what the name of your environment is type `conda env list`. After that launch jupyter lab as shown below. To simplyfy navigation, launch jupyter in the directory where your notebooks are saved.
+```bash
+conda activate <your-env-name>
+jupyter lab
+```
+### 2) Launching plottr-inspectr
+Exactly as described above!
+
+## Todos:
+- [ ] validators in custom parameter classes for times (4ns -> 1 qm-cycle)
+- [ ] change the way to create sweeps!
+    - [ ] sset list of dicts -> list entry per axis, dict entry per param
+    - [ ] sweeps should be properties with setters for save measurement management
+- [ ] TESTS!
+    - [ ] issue: stubbing OPX/ errors raised by instrument

arbok_driver-0.0.0/arbok_driver/__init__.py

@@ -0,0 +1,17 @@
+from .abstract_readout import AbstractReadout
+from .experiment import Experiment
+from .gettable_parameter import GettableParameter
+from .generic_tunig_interface import GenericTuningInterface
+from .measurement_helpers import (
+    run_arbok_measurement, create_measurement_loop
+)
+from .observable import Observable, AbstractObservable, ObservableBase
+from .arbok_driver import ArbokDriver
+from .read_sequence import ReadSequence
+from .sample import Sample
+from .measurement import Measurement
+from .sequence_parameter import SequenceParameter
+from .signal import Signal
+from .sub_sequence import SubSequence
+from .sweep import Sweep
+from . import utils

arbok_driver-0.0.0/arbok_driver/abstract_readout.py

@@ -0,0 +1,175 @@
+"""Module containing abstract class for dependent readouts"""
+from abc import ABC, abstractmethod
+import logging
+
+from qm import qua
+from .read_sequence import ReadSequence
+from .observable import ObservableBase
+
+class AbstractReadout(ABC):
+    """
+    Abstract base class for abstract readouts. This base class handles qua
+    variable and stream declaration, saving and streaming. The child class only
+    needs to handle the abstract method `qua_measure`
+    """
+    def __init__(
+        self,
+        name: str,
+        sequence: ReadSequence,
+        attr_name: str,
+        save_results: bool = True,
+        params: dict = {}
+    ):
+        """
+        Constructor method of `AbstractReadout`
+        
+        Args:
+            name (str): name of readout
+            sequence (ReadSequence): Sequence generating the given readout
+            attr_name (str): Name of the attribute as which the readout will be
+                added in the signal
+            save_results (bool, optional): Whether to save the results
+            params (dict, optional): Parameters to be added to the read sequence
+        """
+        self.name = name
+        self.sequence = sequence
+        self.attr_name = attr_name
+        self.save_results = save_results
+        self.observables = {}
+
+        ### Parameters are added to the sequence with the readout prefix
+        self.add_qc_params_from_config(params)
+
+    def qua_declare_variables(self):
+        """Declares all necessary qua variables for readout"""
+        for observable_name, observable in self.observables.items():
+            logging.debug(
+                "Declaring variables for observable %s on abstract readout %s",
+                observable_name, self.name)
+            observable.qua_var = qua.declare(observable.qua_type)
+            observable.qua_stream = qua.declare_stream(
+                adc_trace = observable.adc_trace)
+
+    def qua_save_variables(self):
+        """Saves the qua variables of all observables in this readout"""
+        if self.save_results:
+            for observable_name, observable in self.observables.items():
+                logging.debug(
+                    "Saving variables of observable %s on abstract readout %s",
+                    observable_name, self.name)
+                qua.save(observable.qua_var, observable.qua_stream)
+
+    def qua_save_streams(self):
+        """Saves acquired results to qua stream"""
+        if self.save_results:
+            for observable_name, observable in self.observables.items():
+                logging.debug(
+                    "Saving streams of observable %s on abstract readout %s",
+                    observable_name, self.name)
+                sweep_size = self.sequence.measurement.sweep_size
+                buffer = observable.qua_stream.buffer(sweep_size)
+                buffer.save(f"{observable.full_name}_buffer")
+        else:
+            logging.debug(
+                "NOT saving streams of abstract readout %s", self.name)
+
+    def qua_measure_and_save(self):
+        """Measures ans saves the result of the given readout"""
+        self.qua_measure()
+        self.qua_save_variables()
+
+    def add_qc_params_from_config(self, param_dict: dict) -> None:
+        """
+        Adds the given parameters to the sequence with the readout prefix
+        
+        Args:
+            params (list): List of parameter names to be added to the sequence
+        """
+        full_params = {f'{self.name}__{k}': v for k, v in param_dict.items()}
+        self.sequence.add_qc_params_from_config(full_params)
+        for param_name, conf in param_dict.items():
+            if 'value' in conf:
+                parameter = getattr(self.sequence, f"{self.name}__{param_name}")
+                setattr(self, param_name, parameter)
+
+    def get_params_with_prefix(self, prefix: str) -> dict:
+        """
+        Finds the element parameters with the given prefix
+        
+        Args:
+            prefix (str): Prefix of the element parameters
+        
+        Returns:
+            dict: Dictionary with elemets as keys and parameters as values
+        """
+        all_params = self.sequence.parameters
+        full_prefix = f"{self.name}__{prefix}"
+        param_names = [x for x in all_params if full_prefix in x]
+        element_list = [x.split(full_prefix)[-1].split('_')[-1] for x in param_names]
+        return {e: all_params[p] for e, p in zip(element_list, param_names)}
+
+    def get_signals_and_observables(self, prefix: str) -> dict:
+        """
+        Returns observables found at the path given from the param storing it.
+        Works very similarly to `get_params_with_prefix`. First finds params
+        with the given prefix and then tries to find the observable from the
+        path stored in the parameter
+
+        Args:
+            prefix (str): Prefix of the element parameters
+        
+        Returns:
+            dict: Dictionary with signals as keys and observables
+        """
+        obs_dict = {}
+        for signal, obs in self.get_params_with_prefix(prefix).items():
+            obs_dict[signal] = self._find_observable_from_path(obs())
+        return obs_dict
+
+    def _find_observable_from_path(self, attr_path: str) -> ObservableBase:
+        """
+        Returns the observable from a given path from a given string. If the
+        string leads to an AbstractReadout it is being tried to find a single
+        observable associated to that AbstractReadout
+        
+        Args:
+            attr_path (str): Path to the given observable relative to the
+                ReadSequence
+        
+        Returns:
+            ObservableBase: The found observable from the given path
+        """
+        attributes = attr_path.split('.')
+        current_obj = self.sequence
+        for attr_name in attributes:
+            try:
+                current_obj = getattr(current_obj, attr_name)
+            except AttributeError as exc:
+                raise AttributeError(
+                    f'Attribute {attr_name} not found in {current_obj.name}'
+                ) from exc
+        if isinstance(current_obj, AbstractReadout):
+            current_obj = current_obj.observable
+        if not isinstance(current_obj, ObservableBase):
+            raise ValueError(
+                f"The given path {attr_path} yields a {type(current_obj)}-type",
+                "not a child class of ObservableBase"
+            )
+        return current_obj
+
+    def get_qm_elements_from_observables(self):
+        """
+        Collects all qm read elements from the readouts observables and their
+        signal. Duplicates are removed
+
+        Returns:
+            list: List of read elements used in observables
+        """
+        qm_elements = []
+        for _, obs in self.observables.items():
+            qm_elements += obs.qm_elements
+        return list(dict.fromkeys(qm_elements))
+
+    @abstractmethod
+    def qua_measure(self):
+        """Measures the qua variables for the given abstract readout"""