sqil-core 0.1.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

sqil_core/experiment/instruments/local_oscillator.py

@@ -0,0 +1,205 @@
+from abc import ABC, abstractmethod
+
+import yaml
+from qcodes.instrument_drivers.rohde_schwarz import RohdeSchwarzSGS100A
+from qcodes_contrib_drivers.drivers.SignalCore.SignalCore import SC5521A
+
+from sqil_core.config_log import logger
+from sqil_core.experiment.instruments import Instrument
+from sqil_core.utils._formatter import format_number
+
+from .drivers.SignalCore_SC5511A import SignalCore_SC5511A
+
+
+class LocalOscillatorBase(Instrument, ABC):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    @abstractmethod
+    def set_frequency(self, value) -> None:
+        """Set the frequency of the local oscillator."""
+        pass
+
+    @abstractmethod
+    def set_power(self, value) -> None:
+        """Set the power of the local oscillator."""
+        pass
+
+    @abstractmethod
+    def turn_on(self) -> None:
+        """Turn the local oscillator on."""
+        pass
+
+    @abstractmethod
+    def turn_off(self) -> None:
+        """Turn the local oscillator off."""
+        pass
+
+
+class SqilRohdeSchwarzSGS100A(LocalOscillatorBase):
+    """
+    Frequency:
+        [1 MHz, 20 GHz], resolution 0.001 Hz
+    Power:
+        [-120 dB, 25 dB], resolution 0.01 dB
+    """
+
+    def _default_connect(self, *args, **kwargs):
+        logger.info(f"Connecting to {self.name} ({self.model})")
+        return RohdeSchwarzSGS100A(self.name, self.address)
+
+    def _default_disconnect(self, *args, **kwargs):
+        logger.info(f"Disconnecting from {self.name} ({self.model})")
+        self.turn_off()
+
+    def _default_setup(self, *args, **kwargs):
+        logger.info(f"Setting up {self.name}")
+        self.turn_off()
+        self.set_power(-60)
+
+    def set_frequency(self, value) -> None:
+        self.device.frequency(value)
+
+    def set_power(self, value) -> None:
+        self.device.power(value)
+
+    def turn_on(self) -> None:
+        self.device.on()
+
+    def turn_off(self) -> None:
+        self.device.off()
+
+
+class SqilSignalCoreSC5511A(LocalOscillatorBase):
+    """
+    PORT 1 specifications
+    Frequency:
+        [100 MHz, 20 GHz], resolution 1 Hz
+    Power:
+        @ freq < 18 GHz: [-20 dBm, 15 dBm], resolution 0.01 dBm
+        @ freq > 18 GHz: [-20 dBm, 10 dBm], resolution 0.01 dBm
+    """
+
+    def _default_connect(self, *args, **kwargs):
+        logger.info(f"Connecting to {self.name} ({self.model})")
+        return SignalCore_SC5511A(self.name, self.address)
+
+    def _default_disconnect(self, *args, **kwargs):
+        logger.info(f"Disconnecting from {self.name} ({self.model})")
+        self.turn_off()
+
+    def _default_setup(self, *args, **kwargs):
+        logger.info(f"Setting up {self.name}")
+        self.turn_off()
+        self.set_power(-40)
+        self.device.do_set_reference_source(1)  # to enable phase locking
+        self.device.do_set_standby(True)  # update PLL locking
+        self.device.do_set_standby(False)
+
+    def set_frequency(self, value) -> None:
+        self.device.do_set_ref_out_freq(value)
+
+    def set_power(self, value) -> None:
+        self.device.power(value)
+
+    def turn_on(self) -> None:
+        self.device.do_set_output_status(1)
+
+    def turn_off(self) -> None:
+        self.device.do_set_output_status(0)
+
+
+class SqilSignalCoreSC5521A(LocalOscillatorBase):
+    """
+    Frequency:
+        [160 MHz, 40 GHz], resolution 1 Hz
+    Power:
+        @ freq < 30 GHz: [-10 dBm, 15 dBm], resolution 0.1 dBm
+        @ freq < 35 GHz: [-10 dBm, 10 dBm], resolution 0.1 dBm
+        @ freq > 35 GHz: [-10 dBm, 3 dBm], resolution 0.1 dBm
+    """
+
+    def _default_connect(self, *args, **kwargs):
+        logger.info(f"Connecting to {self.name} ({self.model})")
+        return SC5521A(self.name)
+
+    def _default_disconnect(self, *args, **kwargs):
+        logger.info(f"Disconnecting from {self.name} ({self.model})")
+        self.turn_off()
+
+    def _default_setup(self, *args, **kwargs):
+        logger.info(f"Setting up {self.name}")
+        self.turn_off()
+        self.set_power(-40)
+
+    def set_frequency(self, value) -> None:
+        self.device.clock_frequency(value)
+
+    def set_power(self, value) -> None:
+        self.device.power(value)
+
+    def turn_on(self) -> None:
+        self.device.status("on")
+
+    def turn_off(self) -> None:
+        self.device.status("off")
+
+
+class LocalOscillator(LocalOscillatorBase):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        model = kwargs.get("config", {}).get("model", "")
+        if model == "RohdeSchwarzSGS100A":
+            self._device_class = SqilRohdeSchwarzSGS100A
+        elif model == "SignalCore_SC5511A":
+            self._device_class = SqilSignalCoreSC5511A
+        elif model == "SC5521A":
+            self._device_class = SqilSignalCoreSC5521A
+        else:
+            raise ValueError(f"Unsupported model: {model}")
+
+        self.instrument = self._device_class(self.id, self.config)
+
+    def _default_connect(self, *args, **kwargs):
+        pass
+
+    def _default_disconnect(self, *args, **kwargs):
+        pass
+
+    def _default_setup(self, *args, **kwargs):
+        pass
+
+    def _default_on_before_experiment(self, *args, sender=None, **kwargs):
+        self.turn_on()
+
+    def _default_on_before_sequence(self, *args, sender=None, **kwargs):
+        freq = self.get_variable("frequency", sender)
+        power = self.get_variable("power", sender)
+        if freq:
+            self.set_frequency(freq)
+        if power:
+            self.set_power(power)
+
+    def _default_on_after_experiment(self, *args, sender=None, **kwargs):
+        self.turn_off()
+
+    def set_frequency(self, value) -> None:
+        logger.info(
+            f"Setting frequency to {format_number(value, 5, unit="Hz", latex=False)} for {self.name}"
+        )
+        self.instrument.set_frequency(value)
+
+    def set_power(self, value) -> None:
+        logger.info(
+            f"Setting power to {format_number(value, 4, unit="dB", latex=False)} for {self.name}"
+        )
+        self.instrument.set_power(value)
+
+    def turn_on(self) -> None:
+        logger.info(f"Turning on {self.name}")
+        self.instrument.turn_on()
+
+    def turn_off(self) -> None:
+        logger.info(f"Turning off {self.name}")
+        self.instrument.turn_off()

sqil_core/experiment/instruments/server.py

@@ -0,0 +1,175 @@
+import os
+import pickle
+import sys
+from typing import cast
+
+import Pyro5.api as pyro
+import Pyro5.errors as pyro_errors
+
+from sqil_core.config_log import logger
+from sqil_core.experiment.instruments import Instrument
+from sqil_core.experiment.instruments.local_oscillator import LocalOscillator
+from sqil_core.experiment.instruments.zurich_instruments import ZI_Instrument
+from sqil_core.utils._read import read_yaml
+from sqil_core.utils._utils import _extract_variables_from_module, _hash_file
+
+_instrument_classes = {
+    "LO": LocalOscillator,
+    "ZI": ZI_Instrument,
+}
+
+
+@pyro.expose
+class InstrumentServer:
+    """
+    Instruments server. Configures the instruments once and distributes instrument instances to other modules.
+    Providing the path of the setup file is not required, but it allows to detect changes in the setup file that
+    require the server to restart.
+    The server is available at PYRO:SERVER@localhost:9090.
+    """
+
+    NAME = "SERVER"
+    PORT = 9090
+    URI = f"PYRO:{NAME}@localhost:{PORT}"
+
+    def __init__(self, instrument_dict: dict, setup_path="") -> None:
+        logger.info("Starting server")
+        self._instruments = connect_instruments(instrument_dict)
+        self._daemon = pyro.Daemon(port=InstrumentServer.PORT)
+        self._services: dict[str, pyro.URI] = {}
+
+        self._setup_path = os.path.abspath(setup_path)
+        self._setup_hash = None
+        if setup_path:
+            self._setup_hash = _hash_file(self._setup_path)
+            logger.info(f"Setup path: {self._setup_path}")
+            logger.info(f"Setup hash: {str(self.setup_hash)}")
+
+    def serve(self) -> None:
+        self._expose()
+        for id, instrument in self._instruments.items():
+            uri = self._daemon.register(instrument, objectId=instrument.id)
+            self._services[id] = uri
+            logger.info(f"Registered {instrument = } with daemon at {uri = }.")
+        self._daemon.register(self, objectId=InstrumentServer.NAME)
+        with self._daemon:
+            logger.info("Local server setup complete! Now listening for requests...")
+            self._daemon.requestLoop()
+
+    def _expose(self) -> None:
+        classes = {instrument.__class__ for _, instrument in self._instruments.items()}
+        # classes |= {Session}
+        for cls in classes:
+            pyro.expose(cls)
+            logger.info(f"Exposed class {cls} to Pyro5.")
+
+    def shutdown(self) -> None:
+        logger.info("Shutting down the local server...")
+        self._disconnect_all()
+        with self._daemon:
+            self._daemon.shutdown()
+        logger.info("Local server shutdown complete!")
+
+    def _disconnect_all(self) -> None:
+        logger.info("Disonnecting instruments...")
+        for _, instrument in self._instruments.items():
+            instrument.disconnect()
+
+    @property
+    def services(self) -> dict[str, pyro.URI]:
+        return {**self._services}
+
+    @property
+    def setup_hash(self) -> str | None:
+        return self._setup_hash
+
+    @property
+    def setup_path(self) -> str:
+        return self._setup_path
+
+
+def link_instrument_server() -> tuple[pyro.Proxy, dict[str, pyro.Proxy]]:
+    """Link to the instruments server."""
+    server = pyro.Proxy(InstrumentServer.URI)
+
+    if server.setup_path:
+        current_hash = _hash_file(server.setup_path)
+        print(server.setup_hash, current_hash)
+        if current_hash != server.setup_hash:
+            message = (
+                f"Changes detected in the setup file {server.setup_path}. "
+                + "Please restart the server to apply the changes."
+            )
+            logger.error(message)
+            raise Exception(message)
+
+    try:
+        services = cast(dict[str, pyro.URI], server.services)
+    except pyro_errors.CommunicationError as err:
+        logger.error(f"Local server not found at {InstrumentServer.URI}")
+        raise err from None
+    else:
+        instruments = {id: pyro.Proxy(uri) for id, uri in services.items()}
+        return (server, instruments)
+
+
+def unlink_instrument_server(server: pyro.Proxy, **instruments: pyro.Proxy) -> None:
+    """Unlink from the instruments server."""
+    server._pyroRelease()
+    for _, instrument in instruments.items():
+        instrument._pyroRelease()
+
+
+def start_instrument_server(setup_path: str = ""):
+    """Start a new instruments server using the provided setup file.
+    If the path to the setup file is not provided it will be guessedby readig ./config.yaml.
+    """
+    if not setup_path:
+        config = read_yaml("config.yaml")
+        setup_path = config.get("setup_path", "setup.py")
+    setup = _extract_variables_from_module("setup", setup_path)
+
+    instrument_dict = setup.get("instruments", None)
+    if not instrument_dict:
+        logger.warning(
+            f"Unable to find any instruments in {setup_path}"
+            + "Do you have an `instruments` entry in your setup file?"
+        )
+        return None
+
+    server = InstrumentServer(instrument_dict, setup_path=setup_path)
+    server.serve()
+
+    return server
+
+
+def connect_instruments(
+    instrument_dict: dict | None,
+) -> dict[str, Instrument]:
+    if not instrument_dict:
+        return {}
+
+    instance_dict = {}
+    for instrument_id, config in instrument_dict.items():
+        instrument_type = config.get("type")
+        instrument_factory = _instrument_classes.get(instrument_type)
+
+        if not instrument_factory:
+            logger.warning(
+                f"Unknown instrument type '{instrument_type}' for '{instrument_id}'. "
+                f"Available types: {list(_instrument_classes.keys())}"
+            )
+            continue
+
+        try:
+            instance = instrument_factory(instrument_id, config=config)
+            instance_dict[instrument_id] = instance
+            logger.info(
+                f"Successfully connected to {config.get('name', instrument_id)}"
+            )
+        except Exception as e:
+            logger.error(
+                f"Failed to connect to {config.get('name', instrument_id)}: {str(e)}"
+            )
+            sys.exit(-1)
+    return instance_dict

sqil_core/experiment/instruments/setup.yaml

@@ -0,0 +1,21 @@
+param_dict_path: >
+  ./param_dict.py
+
+instruments:
+  sgsa:
+    name: "SGSA100"
+    address: "TCPIP0::128.178.120.72::inst0::INSTR"
+    model: "RohdeSchwarzSGS100A"
+    type: "LO"
+
+  SC5511A:
+    name: "SC"
+    address: "10003C68"
+    model: "SignalCore_SC5511A"
+    type: "LO"
+
+  SC5521A:
+    name: "mw1"
+    address: "" #name based connection, don't need address
+    model: "SC5521A"
+    type: "LO"

sqil_core/experiment/instruments/zurich_instruments.py

@@ -0,0 +1,55 @@
+from laboneq.dsl.quantum import QPU
+from laboneq.simple import DeviceSetup, Session
+
+from sqil_core.experiment.instruments import Instrument
+
+
+class ZI_Instrument(Instrument):
+    _descriptor = ""
+    _generate_setup = None
+    _generate_qpu = None
+
+    def __init__(self, id, config):
+        super().__init__(id, config)
+        self._descriptor = config.get("descriptor", "")
+
+        self._generate_setup = config.get("generate_setup", None)
+        if not self._generate_setup:
+            raise NotImplementedError(
+                "get_setup is not implemented in your setup file.\n"
+                + "You should define it as part of the zi section of your instruments dictionary.\n"
+                + "instruments['zi']['generate_setup']"
+            )
+
+        self._generate_qpu = config.get("generate_qpu", None)
+        if not self._generate_qpu:
+            raise NotImplementedError(
+                "get_qpu is not implemented in your setup file.\n"
+                + "You should define it as part of the zi section of your instruments dictionary.\n"
+                + "instruments['zi']['generate_qpu']"
+            )
+
+    def generate_setup(self, *params, **kwargs) -> DeviceSetup:
+        return self._generate_setup(*params, **kwargs)
+
+    def generate_qpu(self, *params, **kwargs) -> QPU:
+        return self._generate_qpu(*params, **kwargs)
+
+    def _default_connect(self):
+        pass
+        # setup = self.config.get("setup_obj", None)
+        # if setup is not None:
+        #     self._session = Session(setup)
+        #     return self.session
+        # raise "Zuirch instruments needs a 'setup_obj' field in your setup file"
+
+    def _default_setup(self):
+        pass
+
+    def _default_disconnect(self):
+        pass
+
+    @property
+    def descriptor(self):
+        """LaboneQ descriptor (read-only) - deprecated."""
+        return self._descriptor

sqil_core/fit/__init__.py

@@ -11,6 +11,29 @@ from ._fit import (
     fit_decaying_oscillations,
     fit_gaussian,
     fit_lorentzian,
+    fit_many_decaying_oscillations,
+    fit_oscillations,
     fit_qubit_relaxation_qp,
     fit_skewed_lorentzian,
+    fit_two_gaussians_shared_x0,
+    fit_two_lorentzians_shared_x0,
+    transform_data,
+)
+from ._guess import (
+    decaying_oscillations_bounds,
+    decaying_oscillations_guess,
+    estimate_peak,
+    gaussian_bounds,
+    gaussian_guess,
+    lorentzian_bounds,
+    lorentzian_guess,
+    oscillations_bounds,
+    oscillations_guess,
+)
+from ._quality import (
+    FIT_QUALITY_THRESHOLDS,
+    FitQuality,
+    evaluate_fit_quality,
+    get_best_fit,
+    get_best_fit_nrmse_aic,
 )