Native gates directly defined by the platform

src/qibocal/auto/transpile.py

@@ -1,9 +1,10 @@
 from typing import Optional
 
-from qibo import Circuit
+from qibo import Circuit, gates
 from qibo.backends import Backend
 from qibo.transpiler.pipeline import Passes
 from qibo.transpiler.unroller import NativeGates, Unroller
+from qibolab.pulses import PulseSequence
 from qibolab.qubits import QubitId
 
 
@@ -97,19 +98,65 @@ def execute_transpiled_circuit(
         backend,
         transpiler,
     )[0]
-
     return transpiled_circ, backend.execute_circuit(
         transpiled_circ, initial_state=initial_state, nshots=nshots
     )
 
 
+def get_natives(platform):
+    """
+    Return the list of native gates defined in the `platform`.
+    This function assumes the native gates to be the same for each
+    qubit and pair.
+    """
+    pairs = list(platform.pairs.values())[0]
+    qubit = list(platform.qubits.values())[0]
+    two_qubit_natives = list(pairs.native_gates.raw)
+    single_qubit_natives = list(qubit.native_gates.raw)
+    # Solve Qibo-Qibolab mismatch
+    single_qubit_natives.append("RZ")
+    single_qubit_natives.append("Z")
+    single_qubit_natives.remove("RX12")
+    replacements = {
+        "RX": "GPI2",
+        "MZ": "M",
+    }
+    new_single_natives = [replacements.get(i, i) for i in single_qubit_natives]
+    natives = new_single_natives + two_qubit_natives
+    return natives
+
+
+def set_compiler(backend, natives):
+    """
+    Set the compiler to execute the native gates defined by the platform.
+    """
+    compiler = backend.compiler
+    for native in natives:
+        gate = getattr(gates, native)
+        if gate not in compiler.rules:
+
+            def rule(qubits_ids, platform, parameters=None):
+                if len(qubits_ids[1]) == 1:
+                    native_gate = platform.qubits[tuple(qubits_ids[1])].native_gates
+                else:
+                    native_gate = platform.pairs[tuple(qubits_ids[1])].native_gates
+                pulses = getattr(native_gate, native).pulses
+                return PulseSequence(pulses), {}
+
+            backend.compiler[gate] = rule
+
+
 def dummy_transpiler(backend: Backend) -> Passes:
     """
     If the backend is `qibolab`, a transpiler with just an unroller is returned,
     otherwise None.
     """
-    unroller = Unroller(NativeGates.default())
-    return Passes(connectivity=backend.platform.topology, passes=[unroller])
+    platform = backend.platform
+    native_gates = get_natives(platform)
+    set_compiler(backend, native_gates)
+    native_gates = list(map(lambda x: getattr(gates, x), native_gates))
+    unroller = Unroller(NativeGates.from_gatelist(native_gates))
+    return Passes(connectivity=platform.topology, passes=[unroller])
 
 
 def pad_circuit(nqubits, circuit: Circuit, qubit_map: list[int]) -> Circuit: