Handling global backend for protocols involving circuits

src/qibocal/auto/transpile.py

@@ -1,16 +1,32 @@
 from typing import Optional
 
 from qibo import Circuit
-from qibo.backends.abstract import Backend
+from qibo.backends import construct_backend, get_backend
 from qibo.transpiler.pipeline import Passes
 from qibo.transpiler.unroller import NativeGates, Unroller
+from qibolab import MetaBackend
+from qibolab.platform import Platform
 from qibolab.qubits import QubitId
 
 
+def _get_platforms():
+    """Qibolab platforms."""
+    try:
+        platforms = list(MetaBackend().list_available())
+    except RuntimeError:
+        platforms = []
+
+    return platforms + ["dummy"]
+
+
+AVAILABLE_PLATFORMS = _get_platforms()
+"""Available qibolab platforms."""
+
+
 def transpile_circuits(
     circuits: list[Circuit],
     qubit_maps: list[list[QubitId]],
-    backend: Backend,
+    platform: Platform,
     transpiler: Optional[Passes],
 ):
     """Transpile and pad `circuits` according to the platform.
@@ -28,14 +44,13 @@ def transpile_circuits(
         are all string or all integers.
     """
     transpiled_circuits = []
-
-    qubits = list(backend.platform.qubits)
-    if isinstance(qubit_maps[0][0], str):
-        for i, qubit_map in enumerate(qubit_maps):
-            qubit_map = map(lambda x: qubits.index(x), qubit_map)
-            qubit_maps[i] = list(qubit_map)
-    if backend.name == "qibolab":
-        platform_nqubits = backend.platform.nqubits
+    if platform.name in AVAILABLE_PLATFORMS:
+        qubits = list(platform.qubits)
+        if isinstance(qubit_maps[0][0], str):
+            for i, qubit_map in enumerate(qubit_maps):
+                qubit_map = map(lambda x: qubits.index(x), qubit_map)
+                qubit_maps[i] = list(qubit_map)
+        platform_nqubits = platform.nqubits
         for circuit, qubit_map in zip(circuits, qubit_maps):
             new_circuit = pad_circuit(platform_nqubits, circuit, qubit_map)
             transpiled_circ, _ = transpiler(new_circuit)
@@ -48,7 +63,7 @@ def transpile_circuits(
 def execute_transpiled_circuits(
     circuits: list[Circuit],
     qubit_maps: list[list[QubitId]],
-    backend: Backend,
+    platform: Platform,
     transpiler: Optional[Passes],
     initial_states=None,
     nshots=1000,
@@ -66,9 +81,13 @@ def execute_transpiled_circuits(
     transpiled_circuits = transpile_circuits(
         circuits,
         qubit_maps,
-        backend,
+        platform,
         transpiler,
     )
+    if platform.name in AVAILABLE_PLATFORMS:
+        backend = construct_backend(backend="qibolab", platform=platform)
+    else:
+        backend = get_backend()
     return transpiled_circuits, backend.execute_circuits(
         transpiled_circuits, initial_states=initial_states, nshots=nshots
     )
@@ -77,7 +96,7 @@ def execute_transpiled_circuits(
 def execute_transpiled_circuit(
     circuit: Circuit,
     qubit_map: list[QubitId],
-    backend: Backend,
+    platform: Platform,
     transpiler: Optional[Passes],
     initial_state=None,
     nshots=1000,
@@ -96,22 +115,26 @@ def execute_transpiled_circuit(
     transpiled_circ = transpile_circuits(
         [circuit],
         [qubit_map],
-        backend,
+        platform,
         transpiler,
     )[0]
+    if platform.name in AVAILABLE_PLATFORMS:
+        backend = construct_backend(backend="qibolab", platform=platform)
+    else:
+        backend = get_backend()
     return transpiled_circ, backend.execute_circuit(
         transpiled_circ, initial_state=initial_state, nshots=nshots
     )
 
 
-def dummy_transpiler(backend) -> Optional[Passes]:
+def dummy_transpiler(platform) -> Optional[Passes]:
     """
     If the backend is `qibolab`, a transpiler with just an unroller is returned,
     otherwise None.
     """
-    if backend.name == "qibolab":
+    if platform.name in AVAILABLE_PLATFORMS:
         unroller = Unroller(NativeGates.default())
-        return Passes(connectivity=backend.platform.topology, passes=[unroller])
+        return Passes(connectivity=platform.topology, passes=[unroller])
     return None
 
 

src/qibocal/protocols/randomized_benchmarking/utils.py

@@ -439,7 +439,7 @@ def get_circuits(
     return circuits, indexes, npulses_per_clifford
 
 
-def execute_circuits(circuits, targets, params, backend, single_qubit=True):
+def execute_circuits(circuits, targets, params, platform, single_qubit=True):
     """
     Executes a list of circuits on a given backend.
 
@@ -455,7 +455,7 @@ def execute_circuits(circuits, targets, params, backend, single_qubit=True):
 
     """
     # Execute the circuits
-    transpiler = dummy_transpiler(backend)
+    transpiler = dummy_transpiler(platform)
     qubit_maps = (
         [[i] for i in targets] * (len(params.depths) * params.niter)
         if single_qubit
@@ -465,7 +465,7 @@ def execute_circuits(circuits, targets, params, backend, single_qubit=True):
         _, executed_circuits = execute_transpiled_circuits(
             circuits,
             qubit_maps=qubit_maps,
-            backend=backend,
+            platform=platform,
             nshots=params.nshots,
             transpiler=transpiler,
         )
@@ -474,7 +474,7 @@ def execute_circuits(circuits, targets, params, backend, single_qubit=True):
             execute_transpiled_circuit(
                 circuit,
                 qubit_map=qubit_map,
-                backend=backend,
+                platform=platform,
                 nshots=params.nshots,
                 transpiler=transpiler,
             )[1]

src/qibocal/protocols/readout_mitigation_matrix.py

@@ -5,7 +5,6 @@
 import numpy.typing as npt
 import plotly.express as px
 from qibo import gates
-from qibo.backends import get_backend
 from qibo.models import Circuit
 from qibolab.platform import Platform
 from qibolab.qubits import QubitId
@@ -61,9 +60,8 @@ def _acquisition(
     data = ReadoutMitigationMatrixData(
         nshots=params.nshots, qubit_list=[list(qq) for qq in targets]
     )
-    backend = get_backend()
-    backend.platform = platform
-    transpiler = dummy_transpiler(backend)
+
+    transpiler = dummy_transpiler(platform)
     qubit_map = [i for i in range(platform.nqubits)]
     for qubits in targets:
         nqubits = len(qubits)
@@ -77,7 +75,7 @@ def _acquisition(
                     c.add(gates.X(q))
             c.add(gates.M(*range(nqubits)))
             _, results = execute_transpiled_circuit(
-                c, qubits, backend, nshots=params.nshots, transpiler=transpiler
+                c, qubits, platform, nshots=params.nshots, transpiler=transpiler
             )
             frequencies = np.zeros(2 ** len(qubits))
             for i, freq in results.frequencies().items():

src/qibocal/protocols/state_tomography.py

@@ -8,7 +8,7 @@
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 from qibo import Circuit, gates
-from qibo.backends import NumpyBackend, get_backend, matrices
+from qibo.backends import NumpyBackend, matrices
 from qibo.quantum_info import fidelity, partial_trace
 from qibolab.platform import Platform
 from qibolab.qubits import QubitId
@@ -102,9 +102,7 @@ def _acquisition(
     if params.circuit is None:
         params.circuit = Circuit(len(targets))
 
-    backend = get_backend()
-    backend.platform = platform
-    transpiler = dummy_transpiler(backend)
+    transpiler = dummy_transpiler(platform)
 
     data = StateTomographyData(
         circuit=params.circuit, targets={target: i for i, target in enumerate(targets)}
@@ -121,7 +119,7 @@ def _acquisition(
         _, results = execute_transpiled_circuit(
             basis_circuit,
             targets,
-            backend,
+            platform,
             nshots=params.nshots,
             transpiler=transpiler,
         )

src/qibocal/protocols/two_qubit_interaction/chsh/protocol.py

@@ -8,7 +8,6 @@
 import numpy as np
 import numpy.typing as npt
 import plotly.graph_objects as go
-from qibo.backends import get_backend
 from qibolab import ExecutionParameters
 from qibolab.platform import Platform
 from qibolab.qubits import QubitId, QubitPairId
@@ -222,9 +221,7 @@ def _acquisition_circuits(
         bell_states=params.bell_states,
         thetas=thetas.tolist(),
     )
-    backend = get_backend()
-    backend.platform = platform
-    transpiler = dummy_transpiler(backend)
+    transpiler = dummy_transpiler(platform)
     if params.apply_error_mitigation:
         mitigation_data = mitigation_acquisition(
             mitigation_params(nshots=params.nshots), platform, targets
@@ -252,7 +249,7 @@ def _acquisition_circuits(
                         circuit,
                         nshots=params.nshots,
                         transpiler=transpiler,
-                        backend=backend,
+                        platform=platform,
                         qubit_map=pair,
                     )
                     frequencies = result.frequencies()

src/qibocal/protocols/two_qubit_state_tomography.py

@@ -9,7 +9,7 @@
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 from qibo import Circuit, gates
-from qibo.backends import NumpyBackend, get_backend
+from qibo.backends import NumpyBackend
 from qibo.quantum_info import fidelity, partial_trace
 from qibo.result import QuantumState
 from qibolab.platform import Platform
@@ -97,10 +97,8 @@ def _acquisition(
     if params.circuit is None:
         params.circuit = Circuit(len(qubits))
 
-    backend = get_backend()
-    backend.platform = platform
     simulator = NumpyBackend()
-    transpiler = dummy_transpiler(backend)
+    transpiler = dummy_transpiler(platform)
 
     simulated_state = simulator.execute_circuit(deepcopy(params.circuit))
     data = StateTomographyData(simulated=simulated_state)
@@ -127,7 +125,7 @@ def _acquisition(
         _, results = execute_transpiled_circuit(
             basis_circuit,
             qubits,
-            backend,
+            platform,
             nshots=params.nshots,
             transpiler=transpiler,
         )

tests/test_transpile.py

@@ -31,9 +31,10 @@ def test_execute_transpiled_circuit():
     qubit_map = [1, 2]
     set_backend("qibolab", platform="dummy")
     backend = get_backend()
-    transpiler = dummy_transpiler(backend)
+    platform = backend.platform
+    transpiler = dummy_transpiler(platform)
     transpiled_circuit, _ = execute_transpiled_circuit(
-        circuit, qubit_map, backend, transpiler=transpiler
+        circuit, qubit_map, platform, transpiler=transpiler
     )
     true_circuit = Circuit(5)
     true_circuit.add(gates.GPI2(1, np.pi / 2))
@@ -53,9 +54,10 @@ def test_execute_transpiled_circuits():
     qubit_map = [1, 2]
     set_backend("qibolab", platform="dummy")
     backend = get_backend()
-    transpiler = dummy_transpiler(backend)
+    platform = backend.platform
+    transpiler = dummy_transpiler(platform)
     transpiled_circuits, _ = execute_transpiled_circuits(
-        [circuit], [qubit_map], backend, transpiler=transpiler
+        [circuit], [qubit_map], platform, transpiler=transpiler
     )
     true_circuit = Circuit(5)
     true_circuit.add(gates.GPI2(1, np.pi / 2))