Feature/instruments initial setup

src/qililab/constants.py

@@ -22,6 +22,7 @@ class RUNCARD:
     """YAML constants."""
 
     NAME = "name"
+    TYPE = "type"
     DEVICE_ID = "device_id"
     ALIAS = "alias"
     INSTRUMENT = "instrument"

src/qililab/drivers/__init__.py

@@ -56,4 +56,5 @@
     ~VoltageSource
     ~Attenuator
 """
-from .instruments import GS200, Cluster, ERASynthPlus, Keithley2600, Pulsar, RhodeSchwarzSGS100A, SpiRack
+from .instruments import GS200, Cluster, ERASynthPlus, Instruments, InstrumentDriverFactory, Keithley2600, Pulsar, RhodeSchwarzSGS100A, SpiRack
+from .interfaces import BaseInstrument

src/qililab/drivers/instruments/__init__.py

@@ -1,5 +1,6 @@
 """__init__.py"""
 from .era_synth import ERASynthPlus
+from .instruments import Instruments
 from .instrument_factory import InstrumentDriverFactory
 from .keithley import Keithley2600
 from .qblox import Cluster, Pulsar, SpiRack

src/qililab/drivers/instruments/instruments.py

@@ -0,0 +1,32 @@
+"""Instruments class"""
+from dataclasses import dataclass
+
+import yaml
+
+from qililab.drivers.interfaces import BaseInstrument
+
+
+@dataclass
+class Instruments:
+    """Instruments class."""
+
+    elements: list[BaseInstrument]
+
+    def get_instrument(self, alias: str | None = None):
+        """Get element given an alias."""
+        return next((element for element in self.elements if element.alias == alias), None)
+
+    def to_dict(self):
+        """Return a dict representation of the Instruments class."""
+        return [instrument.to_dict() for instrument in self.elements]
+
+    def __str__(self) -> str:
+        """
+        Returns:
+            str: String representation of the Instruments class.
+        """
+        return str(yaml.dump(self._short_dict(), sort_keys=False))
+
+    def _short_dict(self):
+        """Return a dict representation of the Instruments class discarding all static elements."""
+        return [instrument.short_dict() for instrument in self.elements]

src/qililab/drivers/instruments/qblox/cluster.py

@@ -65,7 +65,7 @@ def alias(self):
 class QcmQrm(QcodesQcmQrm, BaseInstrument):
     """Qililab's driver for QBlox-instruments QcmQrm"""
 
-    def __init__(self, parent: Instrument, name: str, slot_idx: int):
+    def __init__(self, parent: Instrument, name: str, slot_idx: int, **kwargs):
         """Initialise the instrument.
 
         Args:

src/qililab/drivers/instruments/qblox/pulsar.py

@@ -1,4 +1,5 @@
 """Driver for the Qblox Pulsar class."""
+from typing import Any
 from qblox_instruments.qcodes_drivers import Pulsar as QcodesPulsar
 from qcodes.instrument.channel import ChannelTuple, InstrumentModule
 
@@ -13,25 +14,33 @@
 class Pulsar(QcodesPulsar, BaseInstrument):  # pylint: disable=abstract-method
     """Qililab's driver for QBlox-instruments Pulsar"""
 
-    def __init__(self, name: str, address: str | None = None, **kwargs):
+    def __init__(self, alias: str, address: str | None = None, sequencers: list[str] | None = None, **kwargs):
         """Initialise the instrument.
 
         Args:
-            name (str): Sequencer name
+            alias (str): Pulsar name
             address (str): Instrument address
         """
-        super().__init__(name, identifier=address, **kwargs)
+        self.address = address
+        self.port = kwargs.get('port', None)
+        self.debug = kwargs.get('debug', None)
+        self.dummy_type = kwargs.get('dummy_type', None)
+        super().__init__(name=alias, identifier=address, port=self.port, debug=self.debug, dummy_type=self.dummy_type)
 
         # Add sequencers
         self.submodules: dict[str, SequencerQCM | SequencerQRM] = {}  # resetting superclass submodules
         self.instrument_modules: dict[str, InstrumentModule] = {}  # resetting superclass instrument modules
         self._channel_lists: dict[str, ChannelTuple] = {}  # resetting superclass channel lists
 
         sequencer_class = SequencerQCM if self.is_qcm_type else SequencerQRM
-        for seq_idx in range(6):
-            seq = sequencer_class(parent=self, name=f"sequencer{seq_idx}", seq_idx=seq_idx)  # type: ignore
-            self.add_submodule(f"sequencer{seq_idx}", seq)
-
+        if sequencers is not None:
+            for seq_idx, seq_name in enumerate(sequencers):
+                seq = sequencer_class(parent=self, name=seq_name, seq_idx=seq_idx, map_dict=sequencers[seq_name])  # type: ignore
+                self.add_submodule(seq_name, seq)
+        else:
+            for seq_idx in range(6):
+                seq = sequencer_class(parent=self, name=f"sequencer{seq_idx}", seq_idx=seq_idx)  # type: ignore
+                self.add_submodule(f"sequencer{seq_idx}", seq)
     @property
     def params(self):
         """return the parameters of the instrument"""
@@ -41,3 +50,13 @@ def params(self):
     def alias(self):
         """return the alias of the instrument, which corresponds to the QCodes name attribute"""
         return self.name
+
+    def initial_setup(self, params: dict[str, Any] | None = None):
+        """Initializes the parameters of the instrument and of the submodules.
+
+        Args:
+            setup_dict (dict[str, Any]): Dictionary representation.
+        """
+        if params:
+            for param_name, value in params.items():
+                self.set(param_name=param_name, value=value)

src/qililab/drivers/instruments/qblox/sequencer_qcm.py

@@ -25,13 +25,14 @@ class SequencerQCM(Sequencer, AWG):
 
     _MIN_WAIT_TIME: int = 4
 
-    def __init__(self, parent: Instrument, name: str, seq_idx: int):
+    def __init__(self, parent: Instrument, name: str, seq_idx: int, **kwargs):
         """Initialise the instrument.
 
         Args:
             parent (Instrument): Parent for the sequencer instance.
             name (str): Sequencer name
             seq_idx (int): sequencer identifier index
+            map_dict (dict): mappings parameters
         """
         super().__init__(parent=parent, name=name, seq_idx=seq_idx)
         self.add_parameter(name="swap_paths", set_cmd=None, vals=vals.Bool(), initial_value=False)
@@ -46,6 +47,16 @@ def alias(self):
         """return the alias of the instrument, which corresponds to the QCodes name attribute"""
         return self.name
 
+    def initial_setup(self, params: dict[str, Any] | None = None):
+        """Initializes the parameters of the instrument and of the submodules.
+
+        Args:
+            setup_dict (dict[str, Any]): Dictionary representation.
+        """
+        if params:
+            for param_name, value in params.items():
+                self.set(param_name=param_name, value=value)
+
     def set(self, param_name: str, value: Any):
         """Sets a parameter value checking if is an output mapping.
 
@@ -58,20 +69,22 @@ def set(self, param_name: str, value: Any):
         else:
             super().set(param_name, value)
 
-    def _map_outputs(self, param_name: str, param_value: Any):
+    def _map_outputs(self, param_name: str, param_value: str | int):
         """Map sequencer paths with output channels and set the swapping.
 
         Args:
             param_name (str): Parameter name
             param_value (Any): Parameter value
         """
+        if isinstance(param_value, str):
+            param_value = int(param_value)
         allowed_conf = {("path0", 0), ("path0", 2), ("path1", 1), ("path1", 3)}
         swappable_conf = {("path0", 1), ("path0", 3), ("path1", 0), ("path1", 2)}
         if (param_name, param_value) in allowed_conf:
             self.set(f"channel_map_{param_name}_out{param_value}_en", True)
         elif (param_name, param_value) in swappable_conf:
             self.set("swap_paths", True)
-            self.set(f"channel_map_{param_name}_out{1 - param_value}_en", True)
+            self.set(f"channel_map_{param_name}_out{abs(1 - param_value)}_en", True)
         else:
             raise ValueError(
                 f"Impossible path configuration detected. {param_name} cannot be mapped to output {param_value}."

src/qililab/drivers/instruments/qblox/sequencer_qrm.py

@@ -18,7 +18,7 @@
 class SequencerQRM(SequencerQCM, Digitiser):
     """Qililab's driver for QBlox-instruments digitiser Sequencer"""
 
-    def __init__(self, parent: Instrument, name: str, seq_idx: int):
+    def __init__(self, parent: Instrument, name: str, seq_idx: int, map_dict: dict[str, str] | None = None):
         """Initialise the instrument.
 
         Args:
@@ -28,7 +28,7 @@ def __init__(self, parent: Instrument, name: str, seq_idx: int):
             sequence_timeout (int): timeout to retrieve sequencer state in minutes
             acquisition_timeout (int): timeout to retrieve acquisition state in minutes
         """
-        super().__init__(parent=parent, name=name, seq_idx=seq_idx)
+        super().__init__(parent=parent, name=name, seq_idx=seq_idx, map_dict=map_dict)
         self.add_parameter(name="sequence_timeout", vals=vals.Ints(), set_cmd=None, initial_value=1)
         self.add_parameter(name="acquisition_timeout", vals=vals.Ints(), set_cmd=None, initial_value=1)
         self.add_parameter(name="weights_i", vals=vals.Lists(), set_cmd=None, initial_value=[])

src/qililab/drivers/interfaces/base_instrument.py

@@ -35,3 +35,11 @@ def get(self, param_name: str) -> Any:
         Returns:
             Any: Current value of the parameter.
         """
+
+    @abstractmethod
+    def initial_setup(self, params: dict[str, Any] | None = None):
+        """Initializes the parameters of the instrument and of the submodules.
+
+        Args:
+            setup_dict (dict[str, Any]): Dictionary representation.
+        """