[QHC-649] Move initialization of _qm into initial_setup

src/qililab/instruments/quantum_machines/quantum_machines_cluster.py

@@ -245,7 +245,6 @@ def _get_elements_and_mixers_config(self) -> tuple:
     _config: DictQuaConfig
     _octave_config: QmOctaveConfig | None = None
     _is_connected_to_qm: bool = False
-    _config_created: bool = False
     _compiled_program_cache: dict[str, str] = {}
 
     @property
@@ -269,26 +268,30 @@ def initial_setup(self):
             host=self.settings.address, cluster_name=self.settings.cluster, octave=self._octave_config
         )
         self._config = self.settings.to_qua_config()
-        self._config_created = True
 
-    @Instrument.CheckDeviceInitialized
-    def turn_on(self):
-        """Turns on the instrument."""
+        self._qm = self._qmm.open_qm(config=self._config, close_other_machines=True)
         if not self._is_connected_to_qm:
-            self._qm = self._qmm.open_qm(config=self._config, close_other_machines=True)
             self._compiled_program_cache = {}
             self._is_connected_to_qm = True
 
             if self.settings.run_octave_calibration:
                 self.run_octave_calibration()
 
+    @Instrument.CheckDeviceInitialized
+    def turn_on(self):
+        """Turns on the instrument."""
+        if not self._is_connected_to_qm:
+            self.initial_setup()
+
     @Instrument.CheckDeviceInitialized
     def reset(self):
         """Resets instrument settings."""
 
     @Instrument.CheckDeviceInitialized
     def turn_off(self):
-        """Turns off an instrument."""
+        """Turns off an instrument. To turn it on again, run `initial_setup()`."""
+        # TODO: Weird, since now the `turn_on()`` doesn't do anything... Maybe it should be renamed disconnect?
+        # TODO: I think this is used for handling multiple users, and stuff, take a look into it...
         if self._is_connected_to_qm:
             self._qm.close()
             self._is_connected_to_qm = False
@@ -302,7 +305,7 @@ def append_configuration(self, configuration: dict):
         Raises:
             ValueError: Raised if the `_config` dictionary does not exist.
         """
-        if not self._config_created:
+        if not self._is_connected_to_qm:
             raise ValueError("The QM `config` dictionary does not exist. Please run `initial_setup()` first.")
 
         merged_configuration = merge_dictionaries(dict(self._config), configuration)
@@ -352,41 +355,37 @@ def set_parameter_of_bus(self, bus: str, parameter: Parameter, value: float | st
 
         # Now we will set the parameter in 3 places:
         # 1) In the settings runtime dataclass (always).
-        # 2) If created: In the `_config`` dictionary.
-        # 3) If connected: In the instrument itself.
+        # 2) If connected: In the `_config`` dictionary and in the instrument itself.
         if parameter == Parameter.LO_FREQUENCY:
             lo_frequency = float(value)
             settings_octave_rf_output["lo_frequency"] = lo_frequency
-            if self._config_created:
-                self._config["octaves"][octave_name]["RF_outputs"][out_port]["LO_frequency"] = lo_frequency
             if self._is_connected_to_qm:
+                self._config["octaves"][octave_name]["RF_outputs"][out_port]["LO_frequency"] = lo_frequency
                 self._qm.octave.set_lo_frequency(element=bus, lo_frequency=lo_frequency)
             if in_port is not None:
                 settings_octave_rf_input = next(
                     rf_input for rf_input in settings_octave["rf_inputs"] if rf_input["port"] == in_port
                 )
                 settings_octave_rf_input["lo_frequency"] = lo_frequency
-                if self._config_created:
+                if self._is_connected_to_qm:
                     self._config["octaves"][octave_name]["RF_inputs"][in_port]["LO_frequency"] = lo_frequency
             return
 
         if parameter == Parameter.GAIN:
             gain_in_db = float(value)
             settings_octave_rf_output["gain"] = gain_in_db
-            if self._config_created:
-                self._config["octaves"][octave_name]["RF_outputs"][out_port]["gain"] = gain_in_db
             if self._is_connected_to_qm:
+                self._config["octaves"][octave_name]["RF_outputs"][out_port]["gain"] = gain_in_db
                 self._qm.octave.set_rf_output_gain(element=bus, gain_in_db=gain_in_db)
             return
 
         if parameter == Parameter.IF:
             intermediate_frequency = float(value)
             element["intermediate_frequency"] = intermediate_frequency
-            if self._config_created:
+            if self._is_connected_to_qm:
                 self._config["elements"][bus]["intermediate_frequency"] = intermediate_frequency
                 if f"mixer_{bus}" in self._config["mixers"]:
                     self._config["mixers"][f"mixer_{bus}"][0]["intermediate_frequency"] = intermediate_frequency
-            if self._is_connected_to_qm:
                 self._qm.set_intermediate_frequency(element=bus, freq=intermediate_frequency)
             return
         if parameter == Parameter.THRESHOLD_ROTATION:

tests/instruments/quantum_machines/test_quantum_machines_cluster.py

@@ -124,26 +124,36 @@ class TestQuantumMachinesCluster:
     """This class contains the unit tests for the ``QuantumMachinesCluster`` class."""
 
     @patch("qililab.instruments.quantum_machines.quantum_machines_cluster.QuantumMachinesManager")
+    @patch("qililab.instruments.quantum_machines.quantum_machines_cluster.QuantumMachine")
     @patch("qililab.instruments.Instrument.initial_setup")
     @pytest.mark.parametrize("qmm_name", ["qmm", "qmm_with_octave"])
     def test_initial_setup(
-        self, mock_instrument_init: MagicMock, mock_init: MagicMock, qmm_name, request
+        self, mock_qmm: MagicMock, mock_qm: MagicMock, mock_init: MagicMock, qmm_name, request
     ):  # pylint: disable=unused-argument
         """Test QMM class initialization."""
         qmm = request.getfixturevalue(qmm_name)
 
         # Before initial_setup no _config should exist
-        assert qmm._config_created is False and "_config" not in dir(qmm)
+        assert qmm._is_connected_to_qm is False and "_config" not in dir(qmm)
 
         qmm.initial_setup()
         mock_init.assert_called()
 
         assert isinstance(qmm._qmm, MagicMock)
+        assert isinstance(qmm._qm, MagicMock)
         assert isinstance(qmm._config, dict)
         assert isinstance(qmm.config, dict)
 
         # Assert that the _config has been created correctly (in synch):
-        assert qmm._config_created is True
+        assert qmm._is_connected_to_qm is True and "_config" in dir(qmm)
+
+        if qmm.settings.run_octave_calibration:
+            calls = [
+                call(element) for element in qmm._config["elements"] if "RF_inputs" in qmm._config["elements"][element]
+            ]
+            qmm._qm.calibrate_element.assert_has_calls(calls)
+
+        # Assert that the _config is stll in synch with the settings:
         assert qmm._config == qmm.settings.to_qua_config()
 
     @pytest.mark.parametrize("qmm_name", ["qmm", "qmm_with_octave"])
@@ -156,19 +166,15 @@ def test_settings(self, qmm_name, request):
     @patch("qililab.instruments.quantum_machines.quantum_machines_cluster.QuantumMachinesManager")
     @patch("qililab.instruments.quantum_machines.quantum_machines_cluster.QuantumMachine")
     @pytest.mark.parametrize("qmm_name", ["qmm", "qmm_with_octave"])
-    def test_turn_on(self, mock_qmm, mock_qm, qmm_name, request):
+    def test_turn_on_after_a_turn_off(self, mock_qmm, mock_qm, qmm_name, request):
         """Test turn_on method"""
 
         qmm = request.getfixturevalue(qmm_name)
         qmm.initial_setup()
+        qmm.turn_off()
         qmm.turn_on()
 
-        assert isinstance(qmm._qm, MagicMock)
-        if qmm.settings.run_octave_calibration:
-            calls = [
-                call(element) for element in qmm._config["elements"] if "RF_inputs" in qmm._config["elements"][element]
-            ]
-            qmm._qm.calibrate_element.assert_has_calls(calls)
+        assert qmm._is_connected_to_qm is True
 
         # Assert that the settings are still in synch:
         assert qmm._config == qmm.settings.to_qua_config()
@@ -185,7 +191,7 @@ def test_turn_off(self, mock_qmm, mock_qm, qmm_name, request):
         qmm.turn_off()
 
         # Assert that the settings are still in synch:
-        assert qmm._config == qmm.settings.to_qua_config()
+        assert qmm._is_connected_to_qm is False
 
         assert isinstance(qmm._qm, MagicMock)
         qmm._qm.close.assert_called_once()
@@ -279,7 +285,7 @@ def test_run(
         assert isinstance(job, MagicMock)
 
         # Assert that the settings are in synch:
-        assert qmm._config_created is False and "_config" not in dir(qmm)
+        assert qmm._is_connected_to_qm is False and "_config" not in dir(qmm)
 
     @patch("qililab.instruments.quantum_machines.quantum_machines_cluster.QuantumMachinesManager")
     @patch("qililab.instruments.quantum_machines.quantum_machines_cluster.QuantumMachine")
@@ -308,7 +314,7 @@ def test_get_acquisitions(self, qmm: QuantumMachinesCluster):
         assert "Q" in results
 
         # Assert that the settings are in synch:
-        assert qmm._config_created is False and "_config" not in dir(qmm)
+        assert qmm._is_connected_to_qm is False and "_config" not in dir(qmm)
 
     @patch("qm.QuantumMachine")
     def test_simulate(
@@ -322,7 +328,7 @@ def test_simulate(
         assert isinstance(job, MagicMock)
 
         # Assert that the settings are in synch:
-        assert qmm._config_created is False and "_config" not in dir(qmm)
+        assert qmm._is_connected_to_qm is False and "_config" not in dir(qmm)
 
     @pytest.mark.parametrize(
         "bus, parameter, value",
@@ -535,7 +541,7 @@ def test_get_parameter_of_bus_method(
             assert value == element.get("threshold_rotation", None)
 
         # Assert that the settings are in synch:
-        assert qmm._config_created is False and "_config" not in dir(qmm)
+        assert qmm._is_connected_to_qm is False and "_config" not in dir(qmm)
 
     @pytest.mark.parametrize("parameter", [(Parameter.MAX_CURRENT), (Parameter.OUT0_ATT)])
     @patch("qililab.instruments.quantum_machines.quantum_machines_cluster.QuantumMachinesManager")
@@ -578,6 +584,6 @@ def test_get_parameter_doesnt_create_a_config(
         self, mock_qmm, mock_qm, bus: str, parameter: Parameter, qmm: QuantumMachinesCluster
     ):
         """Test the get_parameter_of_bus method doesn't create a `_config`."""
-        assert qmm._config_created is False
+        assert qmm._is_connected_to_qm is False and "_config" not in dir(qmm)
         qmm.get_parameter_of_bus(bus, parameter)
-        assert qmm._config_created is False
+        assert qmm._is_connected_to_qm is False and "_config" not in dir(qmm)