iqm-benchmarks 2.54__py3-none-any.whl → 2.55__py3-none-any.whl

iqm/benchmarks/benchmark.py

@@ -109,10 +109,12 @@ class BenchmarkConfigurationBase(BaseModel):
 
     benchmark: Type[BenchmarkBase]
     shots: int = 2**8
+    quantum_computer: str | None = None
     max_gates_per_batch: Optional[int] = None
     max_circuits_per_batch: Optional[int] = None
     calset_id: Optional[str] = None
     routing_method: Literal["basic", "lookahead", "stochastic", "sabre", "none"] = "sabre"
     physical_layout: Literal["fixed", "batching"] = "fixed"
     use_dd: Optional[bool] = False
+    active_reset_cycles: int | None = None
     dd_strategy: Optional[DDStrategy] = None

iqm/benchmarks/benchmark_definition.py

@@ -254,11 +254,16 @@ class Benchmark(ABC):
                 qcvv_logger.warning(
                     f"Beware that activating dynamical decoupling will change fidelities, error models and their interpretation."
                 )
-            self.circuit_compilation_options = CircuitCompilationOptions(
-                dd_mode=DDMode.ENABLED, dd_strategy=self.configuration.dd_strategy
-            )
+            dd_mode = DDMode.ENABLED
+
         else:
-            self.circuit_compilation_options = CircuitCompilationOptions(dd_mode=DDMode.DISABLED)
+            dd_mode = DDMode.DISABLED
+
+        self.circuit_compilation_options = CircuitCompilationOptions(
+            dd_mode=dd_mode,
+            dd_strategy=self.configuration.dd_strategy,
+            active_reset_cycles=self.configuration.active_reset_cycles
+            )
 
     @classmethod
     @abstractmethod
@@ -294,7 +299,7 @@ class Benchmark(ABC):
         """
         backend_for_execute = copy.copy(self.backend)
         backend_for_execute.run = functools.partial(
-            self.backend.run, calibration_set_id=calibration_set_id
+            self.backend.run
         )  # type: ignore
         dataset = self.execute(backend_for_execute)
         run = BenchmarkRunResult(dataset, self.circuits)

iqm/benchmarks/entanglement/ghz.py

@@ -19,6 +19,7 @@ GHZ state benchmark
 from itertools import chain
 from time import strftime
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Type, cast
+import warnings
 
 from matplotlib.figure import Figure
 import matplotlib.pyplot as plt
@@ -27,7 +28,6 @@ from networkx import Graph, all_pairs_shortest_path, is_connected, minimum_spann
 import numpy as np
 from qiskit import ClassicalRegister, QuantumRegister
 from qiskit.quantum_info import random_clifford
-from qiskit.transpiler import CouplingMap
 from qiskit_aer import Aer
 from scipy.spatial.distance import hamming
 import xarray as xr
@@ -45,7 +45,7 @@ from iqm.benchmarks.circuit_containers import BenchmarkCircuit, CircuitGroup, Ci
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.readout_mitigation import apply_readout_error_mitigation
 from iqm.benchmarks.utils import (
-    extract_fidelities,
+    extract_fidelities_unified,
     perform_backend_transpilation,
     reduce_to_active_qubits,
     retrieve_all_counts,
@@ -309,7 +309,7 @@ def generate_ghz_log_cruz(num_qubits: int) -> QuantumCircuit:
 
 
 def generate_ghz_star_optimal(
-    qubit_layout: List[int], cal_url: str, backend: IQMBackendBase, inv: bool = False
+    qubit_layout: List[int], iqm_server_url: str, backend: IQMBackendBase, quantum_computer: str, inv: bool = False,
 ) -> QuantumCircuit:
     """
     Generates the circuit for creating a GHZ state by maximizing the number of CZ gates between a pair of MOVE gates.
@@ -317,10 +317,12 @@ def generate_ghz_star_optimal(
     Args:
         qubit_layout: List[int]
             The layout of qubits for the GHZ state.
-        cal_url: str
-            The calibration URL for extracting fidelities.
+        iqm_server_url: str
+            The IQM server URL for extracting fidelities.
         backend: IQMBackendBase
             The backend to be used for the quantum circuit.
+        quantum_computer: str
+            The name of the quantum computer to be used for calbration data, i.e. "garnet", "emerald", ...
         inv: bool
             Whether to generate the inverse circuit.
 
@@ -330,49 +332,48 @@ def generate_ghz_star_optimal(
     num_qubits = len(qubit_layout)
 
     # Initialize quantum and classical registers
-    comp_r = QuantumRegister(1, "comp_r")  # Computational resonator
     q = QuantumRegister(backend.num_qubits, "q")  # Qubits
     c = ClassicalRegister(num_qubits, "c")
-    qc = QuantumCircuit(comp_r, q, c, name="GHZ_star_optimal")
-
-    cal_data = extract_fidelities(cal_url, all_metrics=True)
+    qc = QuantumCircuit(q, c, name="GHZ_star_optimal")
+    # Extract calibration data
+    cal_data = extract_fidelities_unified(iqm_server_url, backend, quantum_computer)
     # Determine the best move qubit
-    move_dict = {q + 1: cal_data[1][q] for q in qubit_layout}  ## +1 to match qubit indexing in cal data
+    double_move_fidelities = {k[0]: v for k, v in list(cal_data[-1]["double_move_gate_fidelity"].items())[::2]}
+    move_dict = {q: double_move_fidelities[q + 1] for q in qubit_layout}  ## +1 to match qubit indexing in cal data
+    # move_dict = {q + 1: cal_data[1][q] for q in qubit_layout}  ## +1 to match qubit indexing in cal data
     best_move = max(move_dict, key=move_dict.get)
 
-    T2 = cal_data[-1]["t2_echo_time"]
-    t2_dict = {qubit + 1: T2[qubit + 1] for qubit in qubit_layout}  ## +1 to match qubit indexing in cal data
+    T2 = cal_data[-1]["t2_time"]
+    t2_dict = {qubit: T2[qubit + 1] for qubit in qubit_layout}  ## +1 to match qubit indexing in cal data
     cz_order = dict(sorted(t2_dict.items(), key=lambda item: item[1], reverse=True))
     qubits_to_measure = list(cz_order.keys())
     cz_order.pop(best_move)
 
     # Construct the quantum circuit
-    qc.h(best_move)
-    qc.move(best_move, 0)
+    qc.r(np.pi/2, 3*np.pi/2, best_move)
+    qc.barrier(best_move)
     for qubit in cz_order.keys():
-        qc.cx(0, qubit)
-        qc.barrier()
-    qc.move(best_move, 0)
+        qc.barrier(qubit)
+        qc.r(np.pi/2, 3*np.pi/2, qubit)
+        qc.cz(best_move, qubit)
+        qc.r(np.pi/2, 5*np.pi/2, qubit)
+        qc.barrier(qubit)
     qc.barrier()
     qc.measure(sorted(qubits_to_measure), list(range(num_qubits)))
-
+    qcvv_logger.info(f"Best MOVE qubit selected: {best_move} with double MOVE fidelity {move_dict[best_move]:.4f} and T2 time {t2_dict[best_move]:.2f} us.")
     if inv:
-        comp_r = QuantumRegister(1, "comp_r")  # Computational resonator
         q = QuantumRegister(backend.num_qubits, "q")  # Qubits
         c = ClassicalRegister(num_qubits, "c")
-        qc = QuantumCircuit(comp_r, q, c, name="GHZ_star_optimal_inv")
-
-        qc.move(best_move, 0)
+        qc = QuantumCircuit(q, c, name="GHZ_star_optimal_inv")
         for qubit in reversed(cz_order.keys()):
-            qc.cx(0, qubit)
-            qc.barrier()
-        qc.move(best_move, 0)
-        qc.h(best_move)
-        qc.barrier()
-
+            qc.barrier(qubit)
+            qc.r(np.pi/2, 5*np.pi/2, qubit)
+            qc.cz(best_move, qubit)
+            qc.r(np.pi/2, 3*np.pi/2, qubit)
+            qc.barrier(qubit)
+        qc.r(np.pi/2, 3*np.pi/2, best_move)
     return qc
 
-
 def generate_ghz_star(num_qubits: int) -> QuantumCircuit:
     """
     Generates the circuit for creating a GHZ state by maximizing the number of CZ gates between a pair of MOVE gates.
@@ -456,7 +457,7 @@ def generate_ghz_spanning_tree(
 
 
 def get_edges(
-    coupling_map: CouplingMap,
+    coupling_map: list[tuple[int]],
     qubit_layout: List[int],
     edges_cal: Optional[List[List[int]]] = None,
     fidelities_cal: Optional[List[float]] = None,
@@ -482,7 +483,7 @@ def get_edges(
     for idx, edge in enumerate(coupling_map):
         if edge[0] in qubit_layout and edge[1] in qubit_layout:
             if not set(edge) in edges_patch:
-                edges_patch.append(set(edge))
+                edges_patch.append(edge)
 
     if fidelities_cal is not None and edges_cal is not None:
         fidelities_cal = list(
@@ -491,9 +492,15 @@ def get_edges(
         fidelities_patch = []
         for edge in edges_patch:
             for idx, edge_2 in enumerate(edges_cal):
-                if edge == set(edge_2):
+                if set(edge) == set(edge_2):
                     fidelities_patch.append(fidelities_cal[idx])
-        weights = -np.log(np.array(fidelities_patch))
+        if len(fidelities_patch) != len(edges_patch):
+            warnings.warn(
+                f"Not all calibration fidelities were found for the selected qubit layout {qubit_layout}, using unweighted graph for circuit creation."
+            )
+            weights = np.ones(len(edges_patch))
+        else:
+            weights = -np.log(np.array(fidelities_patch))
     else:
         weights = np.ones(len(edges_patch))
     graph = Graph()
@@ -646,7 +653,8 @@ class GHZBenchmark(Benchmark):
         self.num_RMs = configuration.num_RMs
         self.rem = configuration.rem
         self.mit_shots = configuration.mit_shots
-        self.cal_url = configuration.cal_url
+        self.iqm_server_url = configuration.iqm_server_url
+        self.quantum_computer = configuration.quantum_computer
         self.timestamp = strftime("%Y%m%d-%H%M%S")
         self.execution_timestamp = ""
 
@@ -689,8 +697,13 @@ class GHZBenchmark(Benchmark):
                 qcvv_logger.warning(
                     f"The current backend is a star architecture for which a suboptimal state generation routine is chosen. Consider setting state_generation_routine={routine}."
                 )
-            if self.cal_url:
-                edges_cal, fidelities_cal, _, _ = extract_fidelities(self.cal_url)
+            if self.iqm_server_url is not None:
+                edges_cal, fidelities_cal, _, _, _ = extract_fidelities_unified(self.iqm_server_url, self.backend, self.quantum_computer)
+                # Replace fidelities >= 1.0 with median of fidelities < 1.0
+                valid_fidelities = [f for f in fidelities_cal if f < 1.0]
+                if valid_fidelities:
+                    median_fidelity = np.median(valid_fidelities)
+                    fidelities_cal = [f if f < 1.0 else median_fidelity for f in fidelities_cal]
                 graph = get_edges(self.backend.coupling_map, qubit_layout, edges_cal, fidelities_cal)
             else:
                 graph = get_edges(self.backend.coupling_map, qubit_layout)
@@ -718,15 +731,14 @@ class GHZBenchmark(Benchmark):
             )
             final_ghz = ghz_native_transpiled
         elif routine == "star_optimal":
-            if self.cal_url is None:
-                raise ValueError("Calibration URL must be provided for 'star_optimal' routine.")
-            ghz = generate_ghz_star_optimal(qubit_layout, self.cal_url, self.backend)
+            if self.iqm_server_url is None or self.quantum_computer is None:
+                raise ValueError("IQM server url and quantum_computer argument must be provided "
+                                 "for 'star_optimal' routine.")
+            ghz = generate_ghz_star_optimal(qubit_layout, self.iqm_server_url, self.backend, self.quantum_computer)
             circuit_group.add_circuit(ghz)
             ghz_native_transpiled = transpile_to_IQM(
                 ghz,
                 self.backend,
-                existing_moves_handling=True,
-                perform_move_routing=False,
                 optimize_single_qubits=self.optimize_sqg,
                 optimization_level=self.qiskit_optim_level,
             )
@@ -775,7 +787,7 @@ class GHZBenchmark(Benchmark):
         qc.remove_final_measurements()
         phases = [np.pi * i / (qubit_count + 1) for i in range(2 * qubit_count + 2)]
         if self.state_generation_routine == "star_optimal":
-            qc_inv = generate_ghz_star_optimal(qubit_layout, self.cal_url, self.backend, inv=True)
+            qc_inv = generate_ghz_star_optimal(qubit_layout, self.iqm_server_url, self.backend, self.quantum_computer, inv=True)
             for phase in phases:
                 qc_phase = qc.copy()
                 qc_phase.barrier()
@@ -804,8 +816,6 @@ class GHZBenchmark(Benchmark):
                 transpile_to_IQM(
                     ghz,
                     self.backend,
-                    existing_moves_handling=True,
-                    perform_move_routing=False,
                     optimize_single_qubits=self.optimize_sqg,
                     optimization_level=self.qiskit_optim_level,
                 )
@@ -1026,7 +1036,7 @@ class GHZConfiguration(BenchmarkConfigurationBase):
             * Default: True
         mit_shots (int): Total number of shots for readout error mitigation
             * Default: 1000
-        cal_url (Optional[str]): Optional URL where the calibration data for the selected backend can be retrieved from
+        iqm_server_url (Optional[str]): Optional iqm server URL where the calibration data for the selected backend can be retrieved from
             The calibration data is used for the "tree" state generation routine to prioritize couplings with high
             CZ fidelity.
             * Default: None
@@ -1043,4 +1053,4 @@ class GHZConfiguration(BenchmarkConfigurationBase):
     num_RMs: Optional[int] = 100
     rem: bool = True
     mit_shots: int = 1_000
-    cal_url: Optional[str] = None
+    iqm_server_url: Optional[str] = None

iqm/benchmarks/quantum_volume/clops.py

@@ -170,15 +170,23 @@ def retrieve_clops_elapsed_times(job_meta: Dict[str, Dict[str, Any]]) -> Dict[st
             # ["timestamps"] might be empty if backend is a simulator
             if job_meta[update][batch]["timestamps"] is not None:
                 x = job_meta[update][batch]["timestamps"]
-                job_time_format = "%Y-%m-%dT%H:%M:%S.%f%z"  # Is it possible to extract this automatically?
-                compile_f = datetime.strptime(x["compilation_ended"], job_time_format)
-                compile_i = datetime.strptime(x["compilation_started"], job_time_format)
-                # submit_f = datetime.strptime(x["submit_end"], job_time_format)
-                # submit_i = datetime.strptime(x["submit_start"], job_time_format)
-                execution_f = datetime.strptime(x["execution_ended"], job_time_format)
-                execution_i = datetime.strptime(x["execution_started"], job_time_format)
-                job_f = datetime.strptime(x["ready"], job_time_format)
-                job_i = datetime.strptime(x["received"], job_time_format)
+
+                # Check if timestamps need parsing or are already datetime objects
+                if isinstance(x["compilation_ended"], str):
+                    job_time_format = "%Y-%m-%dT%H:%M:%S.%f%z"
+                    compile_f = datetime.strptime(x["compilation_ended"], job_time_format)
+                    compile_i = datetime.strptime(x["compilation_started"], job_time_format)
+                    execution_f = datetime.strptime(x["execution_ended"], job_time_format)
+                    execution_i = datetime.strptime(x["execution_started"], job_time_format)
+                    job_f = datetime.strptime(x["ready"], job_time_format)
+                    job_i = datetime.strptime(x["received"], job_time_format)
+                else:
+                    compile_f = x["compilation_ended"]
+                    compile_i = x["compilation_started"]
+                    execution_f = x["execution_ended"]
+                    execution_i = x["execution_started"]
+                    job_f = x["ready"]
+                    job_i = x["received"]
 
                 all_job_elapsed[update][batch] = {
                     "job_total": job_f - job_i,
@@ -187,6 +195,7 @@ def retrieve_clops_elapsed_times(job_meta: Dict[str, Dict[str, Any]]) -> Dict[st
                     "execution_total": execution_f - execution_i,
                 }
 
+
                 # Save the keys, will be needed later
                 totals_keys = all_job_elapsed[update][batch].keys()
 
@@ -574,6 +583,7 @@ class CLOPSBenchmark(Benchmark):
         # Retrieve and save all job metadata
         all_job_metadata = retrieve_all_job_metadata(all_jobs)
         self.job_meta_per_update["update_" + str(update + 1)] = all_job_metadata
+        self.all_jobs = all_jobs
 
         return time_parameter_assign, time_submit, time_retrieve
 

iqm/benchmarks/quantum_volume/quantum_volume.py

@@ -470,6 +470,7 @@ class QuantumVolumeBenchmark(Benchmark):
 
         self.qiskit_optim_level = configuration.qiskit_optim_level
         self.optimize_sqg = configuration.optimize_sqg
+        self.approximation_degree = configuration.approximation_degree
 
         self.rem = configuration.rem
         self.mit_shots = configuration.mit_shots
@@ -529,65 +530,6 @@ class QuantumVolumeBenchmark(Benchmark):
                 }
             dataset.attrs[key] = dictionary
 
-    # def get_mapomatic_average_qv_scores(self) -> List[List[int]]:
-    #     """Estimate the average mapomatic scores for N quantum volume circuit samples
-    #     Returns:
-    #         List[List[object]]: the mapomatic layout scores sorted from the smallest mean*(1+std/sqrt(N)) cost score
-    #     """
-    #     qv_circ_samples = self.mapomatic_qv_samples
-    #
-    #     # Get calibration data once
-    #     token = input("Trying to access IQM calibration data\nEnter your IQM token (without quote marks): ")
-    #     calibration_data = get_calibration_fidelities(self.backend.architecture.name, token)
-    #
-    #     qcvv_logger.info(
-    #         "Evaluating matching layouts for QV",
-    #     )
-    #
-    #     all_scores: Dict[Tuple, List[float]] = {}
-    #     for mapomatic_qv_sample in range(qv_circ_samples):
-    #         qcvv_logger.info(
-    #             f"Estimating layout costs for QV circuit sample {mapomatic_qv_sample+1}"
-    #         )
-    #         # Generate a representative quantum circuit sample
-    #         qv_circ = get_circuit("quantum_volume", self.mapomatic_num_qubits)
-    #         # Get all matching layouts
-    #         layouts = matching_layouts(
-    #             qv_circ,
-    #             self.backend,
-    #             self.backend.coupling_map,
-    #             self.qiskit_optim_level,
-    #         )
-    #         # Evaluate all layouts
-    #         scores = evaluate_costs(
-    #             layouts,
-    #             qv_circ,
-    #             self.backend,
-    #             calibration_data,
-    #             self.qiskit_optim_level,
-    #         )
-    #         for score in scores:
-    #             all_scores.setdefault(tuple(cast(list[int], score[0])), []).extend([cast(float, score[1])])
-    #         qv_circ.clear()
-    #
-    #     # Consider mean and std of the cost scores as mean*(1+std/sqrt(N))
-    #     all_scores_mean_plus_std = {
-    #         s_k: np.mean(s_v) * (1 + np.std(s_v) / np.sqrt(qv_circ_samples)) for s_k, s_v in all_scores.items()
-    #     }
-    #     # Turn into an array ([[tuple_layout0, score0], [tuple_layout1,score1], ... ])
-    #     sorted_scores_mean_plus_std = list(sorted(all_scores_mean_plus_std.items(), key=lambda y: y[1]))
-    #     # Return indices to list type for layouts ([[list_layout0, score0], [list_layout1,score1], ... ])
-    #     layout_meanscore = [[list(s[0]), s[1]] for s in sorted_scores_mean_plus_std]
-    #
-    #     mapomatic_qv_layouts = [x[0] for x in layout_meanscore[: self.mapomatic_num_layouts]]
-    #     mapomatic_qv_costs = [x[1] for x in layout_meanscore[: self.mapomatic_num_layouts]]
-    #
-    #     qcvv_logger.info(
-    #         f"Will execute QV on layouts {mapomatic_qv_layouts}, of mapomatic average costs {mapomatic_qv_costs}"
-    #     )
-    #
-    #     return mapomatic_qv_layouts
-
     @staticmethod
     def generate_single_circuit(
         num_qubits: int,
@@ -755,6 +697,7 @@ class QuantumVolumeBenchmark(Benchmark):
                 qiskit_optim_level=self.qiskit_optim_level,
                 optimize_sqg=self.optimize_sqg,
                 routing_method=self.routing_method,
+                approximation_degree=self.approximation_degree,
             )
             # Batching
             sorted_transpiled_qc_list: Dict[Tuple[int, ...], List[QuantumCircuit]] = {}
@@ -845,27 +788,23 @@ class QuantumVolumeConfiguration(BenchmarkConfigurationBase):
     Attributes:
         benchmark (Type[Benchmark]): QuantumVolumeBenchmark
         num_circuits (int): The number of circuits to use.
-                            * Should be at least 100 for a meaningful QV experiment.
+            Should be at least 100 for a meaningful QV experiment.
         num_sigmas (int): The number of sample standard deviations to consider with for the threshold criteria.
-                            * Default by consensus is 2
+            Default by consensus is 2
         choose_qubits_routine (Literal["custom"]): The routine to select qubit layouts.
-                            * Default is "custom".
+            Default is "custom".
         custom_qubits_array (Optional[Sequence[Sequence[int]]]): The physical qubit layouts to perform the benchmark on.
-                            * Default is [[0, 2]].
+            Default is [[0, 2]].
         qiskit_optim_level (int): The Qiskit transpilation optimization level.
-                            * Default is 3.
+            Default is 3.
         optimize_sqg (bool): Whether Single Qubit Gate Optimization is performed upon transpilation.
-                            * Default is True.
-        routing_method (Literal["basic", "lookahead", "stochastic", "sabre", "none"]): The Qiskit transpilation routing method to use.
-                            * Default is "sabre".
-        physical_layout (Literal["fixed", "batching"]): Whether the coupling map is restricted to qubits in the input layout or not.
-                            - "fixed": Restricts the coupling map to only the specified qubits.
-                            - "batching": Considers the full coupling map of the backend and circuit execution is batched per final layout.
-                            * Default is "fixed"
-        rem (bool): Whether Readout Error Mitigation is applied in post-processing. When set to True, both results (readout-unmitigated and -mitigated) are produced.
-                            - Default is True.
+            Default is True.
+        approximation_degree (float): The target fidelity to which arbitrary two qubit gates are approximated.
+        rem (bool): Whether Readout Error Mitigation is applied in post-processing. When set to True, both results
+            (readout-unmitigated and -mitigated) are produced.
+            Default is True.
         mit_shots (int): The measurement shots to use for readout calibration.
-                            * Default is 1_000.
+            Default is 1_000.
     """
 
     benchmark: Type[Benchmark] = QuantumVolumeBenchmark
@@ -875,5 +814,6 @@ class QuantumVolumeConfiguration(BenchmarkConfigurationBase):
     custom_qubits_array: Sequence[Sequence[int]]
     qiskit_optim_level: int = 3
     optimize_sqg: bool = True
+    approximation_degree: float = 1.0
     rem: bool = True
     mit_shots: int = 1_000

iqm/benchmarks/randomized_benchmarking/eplg/eplg.py

@@ -245,7 +245,8 @@ class EPLGBenchmark(Benchmark):
         self.chain_length = configuration.chain_length
         self.chain_path_samples = configuration.chain_path_samples
         self.num_disjoint_layers = configuration.num_disjoint_layers
-        self.calibration_url = configuration.calibration_url
+        self.iqm_server_url = configuration.iqm_server_url
+        self.quantum_computer = configuration.quantum_computer
         self.max_hamiltonian_path_tries = configuration.max_hamiltonian_path_tries
 
     def add_all_meta_to_dataset(self, dataset: xr.Dataset):
@@ -298,8 +299,8 @@ class EPLGBenchmark(Benchmark):
             raise ValueError("The number of chain path samples must be a positive integer.")
 
         # Check calibration URL - this is a temporary solution, normally the backend should be enough to specify this
-        if self.calibration_url is None:
-            raise ValueError("The calibration URL must be specified if custom qubits array is not specified.")
+        if self.iqm_server_url is None:
+            raise ValueError("The IQM server URL must be specified if custom qubits array is not specified.")
 
         if self.num_disjoint_layers is None:
             self.num_disjoint_layers = 2
@@ -332,11 +333,14 @@ class EPLGBenchmark(Benchmark):
             self.validate_random_chain_inputs()
             num_qubits = cast(int, self.chain_length)
             qcvv_logger.info("Generating linear chain path")
+            if self.iqm_server_url is None or self.quantum_computer is None:
+                raise ValueError("IQM server URL and quantum computer name must be specified for random chain evaluation.")
             h_path_costs = evaluate_hamiltonian_paths(
                 self.chain_length,
                 self.chain_path_samples,
                 self.backend,
-                self.calibration_url,
+                self.iqm_server_url,
+                self.quantum_computer,
                 self.max_hamiltonian_path_tries,
             )
             qcvv_logger.info("Extracting the path that maximizes total 2Q calibration fidelity")
@@ -391,7 +395,7 @@ class EPLGConfiguration(BenchmarkConfigurationBase):
                 * Default is None: assigns 2 disjoint layers (arbitrary).
         max_hamiltonian_path_tries (Optional[int]): The maximum number of tries to find a Hamiltonian path.
                 * Default is None: assigns 10 tries (arbitrary).
-        calibration_url (Optional[str]): The URL of the IQM station to retrieve calibration data from.
+        iqm_server_url (Optional[str]): The URL of the IQM station to retrieve calibration data from.
                 * It must be specified if custom_qubits_array is not specified.
                 * Default is None - raises an error if custom_qubits_array is not specified.
 
@@ -405,4 +409,4 @@ class EPLGConfiguration(BenchmarkConfigurationBase):
     chain_path_samples: Optional[int] = None
     num_disjoint_layers: Optional[int] = None
     max_hamiltonian_path_tries: Optional[int] = None
-    calibration_url: Optional[str] = None
+    iqm_server_url: Optional[str] = None

iqm/benchmarks/utils.py

@@ -16,11 +16,13 @@
 General utility functions
 """
 from collections import defaultdict
+from enum import Enum
 from functools import wraps
 import itertools
 from math import floor
 import os
 import random
+import re
 from time import time
 from typing import Any, Dict, Iterable, List, Literal, Optional, Sequence, Set, Tuple, Union, cast
 import warnings
@@ -38,6 +40,7 @@ import requests
 import xarray as xr
 
 from iqm.benchmarks.logging_config import qcvv_logger
+from iqm.iqm_client import IQMClient
 from iqm.iqm_client.models import CircuitCompilationOptions
 from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm import IQMFakeDeneb, optimize_single_qubit_gates, transpile_to_IQM
@@ -286,11 +289,23 @@ def get_active_qubits(qc: QuantumCircuit) -> List[int]:
     return list(active_qubits)
 
 
-def extract_fidelities(cal_url: str, all_metrics: bool = False) -> Union[
-    Tuple[List[List[int]], List[float], str, Dict[int, int]],
-    Tuple[List[List[int]], List[float], str, Dict[int, int], Dict[str, Dict[Union[int, Tuple[int, int]], float]]],
-]:
-    """Returns couplings and CZ-fidelities from calibration data URL
+class ObservationType(Enum):
+    """Enumeration representing relevant keys to fetch for each operation in the observations."""
+
+    CZ = "cz"
+    CLIFFORD = ("cz", "clifford")
+    SQG = "prx"
+    READOUT = ("measure_fidelity", ".fidelity")
+    READOUT_QNDNESS = ("measure", "qndness", ".fidelity")
+    DOUBLE_MOVE = "move"
+    T1 = ("t1", "QB")
+    T2 = ("t2", "QB")
+
+
+def extract_fidelities_unified(
+    iqm_server_url: str, backend: IQMBackendBase, quantum_computer: str
+) -> tuple[list[list[int]], list[float], str, dict[Any, int], dict[str, dict[int | tuple[int, int], float]]]:
+    """Returns couplings and CZ-fidelities from calibration data URL for external station API
 
     Args:
         cal_url: str
@@ -304,73 +319,93 @@ def extract_fidelities(cal_url: str, all_metrics: bool = False) -> Union[
             data contains a fidelity.
         list_fids: List[float]
             A list of CZ fidelities from the calibration url, ordered in the same way as list_couplings
-        topology: str
-            Name of the chip topology layout, currently either "star" or "crystal"
-        qubit_mapping: Dict[int, int]
-            Enumerating all calibrated qubits starting from 0. For instance if on a 5 qubit chip the qubits 2, 3 are calibrated,
-            the mapping will be {2: 0, 3: 1}.
         metrics_dict: Dict
             Dictionary of all metrics (returned only if all_metrics=True)
             Format: {metric_name: {qubit: value}} for single qubit metrics
             Format: {metric_name: {(qubit_1, qubit_2): value}} for two qubit metrics
     """
-    headers = {"Accept": "application/json", "Authorization": "Bearer " + os.environ["IQM_TOKEN"]}
-    r = requests.get(cal_url, headers=headers, timeout=60)
-    calibration = r.json()
-    cal_keys = {
-        el2["key"]: (i, j) for i, el1 in enumerate(calibration["calibrations"]) for j, el2 in enumerate(el1["metrics"])
-    }
-    resonator_names = ["COMPR", "COMP_R", "MPR1", "MPR_1"]
+    # Create dictionaries to map key names to their corresponding metrics
+    cz_fidelity: Dict[Union[int, Tuple[int, int]], float] = {}
+    single_qubit_fidelity: Dict[int, float] = {}
+    readout_fidelity: Dict[int, float] = {}
+    t1: Dict[int, float] = {}
+    t2: Dict[int, float] = {}
+    move_fidelity: Dict[Tuple[int, int], float] = {}
+    quality_metric_set = IQMClient(iqm_server_url, quantum_computer=quantum_computer).get_quality_metric_set()
+    calibration_metrics = quality_metric_set.observations
+
     list_couplings = []
     list_fids = []
-    if "double_move_gate_fidelity" in cal_keys.keys():
-        i, j = cal_keys["double_move_gate_fidelity"]
+    gates_info: Dict[str, Dict[str, Any]] = {}
+    for gate in backend.architecture.gates.keys():
+        gates_info[gate] = {
+            x: backend.architecture.gates[gate].implementations[x].loci
+            for x in backend.architecture.gates[gate].implementations.keys()
+        }
+
+    if backend.has_resonators():
         topology = "star"
     else:
-        i, j = cal_keys["cz_gate_fidelity"]
         topology = "crystal"
-    for item in calibration["calibrations"][i]["metrics"][j]["metrics"]:
-        qb1 = (
-            int(item["locus"][0][2:])
-            if not any(resonator in item["locus"][0] for resonator in resonator_names)
-            else 0
-        )
-        qb2 = (
-            int(item["locus"][1][2:])
-            if not any(resonator in item["locus"][1] for resonator in resonator_names)
-            else 0
-        )
-        list_couplings.append([qb1, qb2])
-        list_fids.append(float(item["value"]))
-    calibrated_qubits = set(np.array(list_couplings).reshape(-1))
-
-    # Process all metrics if all_metrics is True
-    metrics_dict: Dict[str, Dict[Union[int, Tuple[int, int]], float]] = {}
-    for metric_key, (i, j) in cal_keys.items():
-        metric_data = calibration["calibrations"][i]["metrics"][j]["metrics"]
-        metrics_dict[metric_key] = {}
-
-        for item in metric_data:
-            # Determine if it's a single or two-qubit metric
-            if "component" in item:
-                # Single qubit metric
-                component = item["component"]
-                if not any(resonator in component for resonator in resonator_names):
-                    qb = int(component[2:])
-                    metrics_dict[metric_key][qb] = float(item["value"])
-                    calibrated_qubits.add(qb) # Add qubits that have a single qubit metric
-            if "locus" in item and len(item["locus"]) == 2:
-                # Two qubit metric
-                locus = item["locus"]
-                if not (any(resonator in locus[0] for resonator in resonator_names) or any(resonator in locus[1] for resonator in resonator_names)):
-                    qb1 = int(locus[0][2:])
-                    qb2 = int(locus[1][2:])
-                    metrics_dict[metric_key][(qb1, qb2)] = float(item["value"])
 
+        # Iterate over the calibration metrics
+    for metrics in calibration_metrics:
+        dut_field = metrics.dut_field
+        values = metrics.value
+        if all(obs in dut_field for obs in ObservationType.READOUT.value):
+            qubit_index = int(dut_field.split("QB")[1].split(".")[0])
+            readout_fidelity[qubit_index] = values
+        elif ObservationType.SQG.value in dut_field and any(
+            x in dut_field for x in gates_info[ObservationType.SQG.value]
+        ):
+            qubit_index = int(dut_field.split("QB")[1].split(".")[0])
+            single_qubit_fidelity[qubit_index] = values
+        elif all(obs in dut_field for obs in ObservationType.T1.value):
+            qubit_index = int(dut_field.split("QB")[1].split(".")[0])
+            t1[qubit_index] = values * 10**6
+        elif all(obs in dut_field for obs in ObservationType.T2.value):
+            qubit_index = int(dut_field.split("QB")[1].split(".")[0])
+            t2[qubit_index] = values * 10**6
+        elif ObservationType.DOUBLE_MOVE.value in dut_field and any(
+            x in dut_field for x in gates_info[ObservationType.DOUBLE_MOVE.value]
+        ):
+            qb_matches = re.findall(r"QB\d+", dut_field)
+            qbx = int(qb_matches[0].split("QB")[1])
+            move_fidelity[(qbx, 0)] = values
+            move_fidelity[(0, qbx)] = values
+        elif (
+            ObservationType.CZ.value in dut_field
+            and any(x in dut_field for x in gates_info[ObservationType.CZ.value])
+            and backend.has_resonators()
+        ):
+            qb_matches = re.findall(r"QB\d+", dut_field)
+            qbx = int(qb_matches[0].split("QB")[1])
+            list_couplings.append([qbx, 0])
+            list_fids.append(values)
+            cz_fidelity[(qbx, 0)] = values
+            cz_fidelity[(0, qbx)] = values
+        elif ObservationType.CZ.value in dut_field and any(
+            x in dut_field for x in gates_info[ObservationType.CZ.value]
+        ):
+            qb_matches = re.findall(r"QB\d+", dut_field)
+            qbx, qby = int(qb_matches[0].split("QB")[1]), int(qb_matches[1].split("QB")[1])
+            cz_fidelity[(qbx, qby)] = values
+            cz_fidelity[(qby, qbx)] = values
+            list_couplings.append([qbx, qby])
+            list_fids.append(values)
+
+    metrics_dict: Dict[str, Dict[Union[int, Tuple[int, int]], float]] = {
+        "cz_gate_fidelity": cz_fidelity,
+        "fidelity_1qb_gates_averaged": single_qubit_fidelity,
+        "single_shot_readout_fidelity": readout_fidelity,
+        "t1_time": t1,
+        "t2_time": t2,
+        "double_move_gate_fidelity": move_fidelity,
+    }
     # Enumerate all calibrated qubits starting from 0
+    calibrated_qubits = set(np.array(list_couplings).reshape(-1))
     qubit_mapping = {qubit: idx for idx, qubit in enumerate(calibrated_qubits)}
     list_couplings = [[qubit_mapping[edge[0]], qubit_mapping[edge[1]]] for edge in list_couplings]
-
     # Apply the qubit mapping to metrics_dict
     remapped_metrics_dict = {}
     for metric_key, metric_values in metrics_dict.items():
@@ -384,10 +419,6 @@ def extract_fidelities(cal_url: str, all_metrics: bool = False) -> Union[
                 remapped_metrics_dict[metric_key][qubit_mapping[key]] = value
     metrics_dict = remapped_metrics_dict
 
-    # If all_metrics is False, only return everything related to CZ fidelites
-    if not all_metrics:
-        return list_couplings, list_fids, topology, qubit_mapping
-
     return list_couplings, list_fids, topology, qubit_mapping, metrics_dict
 
 
@@ -606,6 +637,7 @@ def perform_backend_transpilation(
     optimize_sqg: bool = False,
     drop_final_rz: bool = True,
     routing_method: Optional[str] = "sabre",
+    approximation_degree: float = 1.0,
 ) -> List[QuantumCircuit]:
     """
     Transpile a list of circuits to backend specifications.
@@ -620,6 +652,7 @@ def perform_backend_transpilation(
         optimize_sqg (bool): Whether SQG optimization is performed taking into account virtual Z.
         drop_final_rz (bool): Whether the SQG optimizer drops a final RZ gate.
         routing_method (Optional[str]): The routing method employed by Qiskit's transpilation pass.
+        approximation_degree (int): The target fidelity to which arbitrary two qubit gates are approximated.
 
     Returns:
         List[QuantumCircuit]: A list of transpiled quantum circuits.
@@ -641,6 +674,7 @@ def perform_backend_transpilation(
                 optimize_single_qubits=optimize_sqg,
                 remove_final_rzs=drop_final_rz,
                 coupling_map=coupling_map_red,
+                approximation_degree=approximation_degree,
                 # initial_layout=qubits if aux_qc is None else None,
             )
         else:
@@ -651,6 +685,7 @@ def perform_backend_transpilation(
                 optimization_level=qiskit_optim_level,
                 initial_layout=qubits if aux_qc is None else None,
                 routing_method=routing_method,
+                approximation_degree=approximation_degree,
             )
             if aux_qc is not None:
                 transpiled = aux_qc.compose(transpiled, qubits=qubits, clbits=list(range(qc.num_clbits)))
@@ -797,31 +832,45 @@ def retrieve_all_counts(iqm_jobs: List[IQMJob], identifier: Optional[str] = None
 
 
 def retrieve_all_job_metadata(
-    iqm_jobs: List[IQMJob],
-) -> Dict[str, Dict[str, Any]]:
-    """Retrieve the counts from a list of IQMJob objects.
+    iqm_jobs: list[IQMJob],
+) -> dict[str, dict[str, Any]]:
+    """Retrieve the metadata from a list of Job objects.
+
     Args:
-        iqm_jobs List[IQMJob]: The list of IQMJob objects.
+        iqm_jobs : List[IQMJob]
+            The list of IQMJob objects.
 
     Returns:
         Dict[str, Dict[str, Any]]: Relevant metadata of all the IQMJob objects.
+
     """
     all_meta = {}
-
     for index, j in enumerate(iqm_jobs):
         all_attributes_j = dir(j)
+        if not hasattr(j, "_iqm_job"):
+            shots = j.metadata["shots"] if "shots" in j.metadata.keys() else None
+            timestamps = j.metadata["timestamps"] if "timestamps" in j.metadata.keys() else None
+        else:
+            job_parameters = j._iqm_job._parameters
+            if job_parameters is not None:
+                shots = job_parameters.shots if "shots" in job_parameters.__dict__.keys() else None
+            else:
+                raise ValueError("Job parameters return None, cannot retrieve shots information.")
+            timestamps = {}
+            for entry in j._iqm_job.data.timeline:
+                timestamps.update({entry.status: entry.timestamp})
         all_meta.update(
             {
                 "batch_job_"
                 + str(index + 1): {
                     "job_id": j.job_id() if "job_id" in all_attributes_j else None,
-                    "backend": j.backend().name if "backend" in all_attributes_j else None,
-                    "status": j.status().value if "status" in all_attributes_j else None,
+                    "backend": (j.backend().name if "backend" in all_attributes_j else None),
+                    "status": (j.status().value if "status" in all_attributes_j else None),
                     "circuits_in_batch": (
-                        len(cast(List, j.circuit_metadata)) if "circuit_metadata" in all_attributes_j else None
+                        len(cast(list, j.circuit_metadata)) if "circuit_metadata" in all_attributes_j else None
                     ),
-                    "shots": j.metadata["shots"] if "shots" in j.metadata.keys() else None,
-                    "timestamps": j.metadata["timestamps"] if "timestamps" in j.metadata.keys() else None,
+                    "shots": shots,
+                    "timestamps": timestamps,
                 }
             }
         )

iqm/benchmarks/utils_plots.py

@@ -25,11 +25,11 @@ import matplotlib.pyplot as plt
 import networkx as nx
 import numpy as np
 from qiskit.transpiler import CouplingMap
-import requests
 from rustworkx import PyGraph, spring_layout, visualization  # pylint: disable=no-name-in-module
 
+from iqm.benchmarks.entanglement.ghz import get_cx_map, get_edges
 from iqm.benchmarks.logging_config import qcvv_logger
-from iqm.benchmarks.utils import extract_fidelities, get_iqm_backend, random_hamiltonian_path
+from iqm.benchmarks.utils import extract_fidelities_unified, get_iqm_backend, random_hamiltonian_path
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
@@ -189,6 +189,10 @@ class GraphPositions:
         "iqmfakedeneb": deneb_positions,
         "emerald": emerald_positions,
         "sirius": sirius_positions,
+        "crystal54": emerald_positions,
+        "crystal20": garnet_positions,
+        "star": sirius_positions,
+        "star24": sirius_positions,
     }
 
     @staticmethod
@@ -359,6 +363,7 @@ def evaluate_hamiltonian_paths(
     path_samples: int,
     backend_arg: str | IQMBackendBase,
     url: str,
+    quantum_computer: str,
     max_tries: int = 10,
 ) -> Dict[int, List[Tuple[int, int]]]:
     """Evaluates Hamiltonian paths according to the product of 2Q gate fidelities on the corresponding edges of the backend graph.
@@ -400,32 +405,23 @@ def evaluate_hamiltonian_paths(
 
     # Get scores for all paths
     # Retrieve fidelity data
-    two_qubit_fidelity = {}
-
-    headers = {"Accept": "application/json", "Authorization": "Bearer " + os.environ["IQM_TOKEN"]}
-    r = requests.get(url, headers=headers, timeout=60)
-    calibration = r.json()
-
-    for iq in calibration["calibrations"][0]["metrics"][0]["metrics"]:
-        temp = list(iq.values())
-        two_qubit_fidelity[str(temp[0])] = temp[1]
-        two_qubit_fidelity[str([temp[0][1], temp[0][0]])] = temp[1]
-
+    cal_data = extract_fidelities_unified(url, backend, quantum_computer=quantum_computer)
+    two_qubit_fidelity = cal_data[-1]["cz_gate_fidelity"]
     # Rate all the paths
     path_costs = {}  # keys are costs, values are edge paths
     for h_path in all_paths:
         total_cost = 1
         for edge in h_path:
             if len(edge) == 2:
-                total_cost *= two_qubit_fidelity[
-                    str([backend.index_to_qubit_name(edge[0]), backend.index_to_qubit_name(edge[1])])
-                ]
+                total_cost *= two_qubit_fidelity[edge]
         path_costs[total_cost] = h_path
 
     return path_costs
 
 
-def calculate_node_radii(metric_dict: Dict[str, Dict[int, float]], qubit_nodes: List[int], sq_metric: str) -> np.ndarray:
+def calculate_node_radii(
+    metric_dict: Dict[str, Dict[int, float]], qubit_nodes: List[int], sq_metric: str
+) -> np.ndarray:
     """Calculate node radii based on the specified single qubit metric. For the coherence metric, the fidelity is calculated as the idling fidelity of a single qubit gate duration.
 
     Args:
@@ -443,9 +439,7 @@ def calculate_node_radii(metric_dict: Dict[str, Dict[int, float]], qubit_nodes:
     if sq_metric == "fidelity":
         radii = -np.log(np.array([metric_dict["fidelity_1qb_gates_averaged"][node] for node in qubit_nodes]))
         if "fidelity_1qb_gates_averaged" not in metric_dict:
-            raise ValueError(
-                "The metric 'fidelity_1qb_gates_averaged' is not available in the backend metrics."
-            )
+            raise ValueError("The metric 'fidelity_1qb_gates_averaged' is not available in the backend metrics.")
     elif sq_metric == "coherence":
         if "t1_time" not in metric_dict or "t2_time" not in metric_dict:
             raise ValueError(
@@ -458,9 +452,7 @@ def calculate_node_radii(metric_dict: Dict[str, Dict[int, float]], qubit_nodes:
         radii = -np.log(idle_fidelities)
     elif sq_metric == "readout":
         if "single_shot_readout_fidelity" not in metric_dict:
-            raise ValueError(
-                "The metric 'single_shot_readout_fidelity' is both available in the backend metrics."
-            )
+            raise ValueError("The metric 'single_shot_readout_fidelity' is both available in the backend metrics.")
         readout_fidelities = [metric_dict["single_shot_readout_fidelity"][node] for node in qubit_nodes]
         radii = -np.log(readout_fidelities)
     else:
@@ -469,11 +461,14 @@ def calculate_node_radii(metric_dict: Dict[str, Dict[int, float]], qubit_nodes:
         )
     return radii
 
+
 def plot_layout_fidelity_graph(
-    cal_url: str,
+    iqm_server_url: str,
+    backend: IQMBackendBase,
     qubit_layouts: Optional[list[list[int]]] = None,
-    station: Optional[str] = None,
+    quantum_computer: Optional[str] = None,
     sq_metric: Optional[str] = "coherence",
+    show_ghz_path: bool = False,
 ):
     """Plot a graph showing the quantum chip layout with fidelity information.
 
@@ -482,33 +477,61 @@ def plot_layout_fidelity_graph(
     (thinner edges mean better fidelity) and selected qubits are highlighted in orange.
 
     Args:
-        cal_url: URL to retrieve calibration data from
+        iqm_server_url: URL to retrieve calibration data from.
+        backend: IQM backend instance.
         qubit_layouts: List of qubit layouts where each layout is a list of qubit indices
-        station: Name of the quantum computing station to use predefined positions for.
+        quantum_computer: Name of the quantum computing station to use predefined positions for.
                 If None, positions will be generated algorithmically.
         sq_metric: Optional single qubit metric to use for the visualization, can be either "fidelity", "coherence",
                 or "readout".
+        show_ghz_path: Whether to highlight the edges that are part of the GHZ state creation tree path.
 
     Returns:
         matplotlib.figure.Figure: The generated figure object containing the graph visualization
     """
     # pylint: disable=unbalanced-tuple-unpacking, disable=too-many-statements
-    edges_cal, fidelities_cal, topology, qubit_mapping, metric_dict = extract_fidelities(cal_url, all_metrics=True)
+
+    edges_cal, fidelities_cal, topology, qubit_mapping, metric_dict = extract_fidelities_unified(
+        iqm_server_url, backend, quantum_computer
+    )
+
     if topology == "star":
         idx_to_qubit = {idx: qubit for qubit, idx in qubit_mapping.items()}
+        qubit_to_idx = qubit_mapping
         qubit_nodes = list(idx_to_qubit.keys())[1:]
         fig, ax = plt.subplots(figsize=(len(qubit_nodes), 3))
     else:
         # For other topologies, qubits are indexed starting from 0 as per the Qiskit convention
         idx_to_qubit = {idx: qubit - 1 for qubit, idx in qubit_mapping.items()}
+        qubit_to_idx = {qubit - 1: idx for qubit, idx in qubit_mapping.items()}
         qubit_nodes = list(idx_to_qubit.keys())
         fig, ax = plt.subplots(figsize=(1.5 * np.sqrt(len(qubit_nodes)), 1.5 * np.sqrt(len(qubit_nodes))))
 
+    # Filter out any edges that are not in the backend's coupling map
+    fidelities_cal = [
+        fidelity
+        for edge, fidelity in zip(edges_cal, fidelities_cal, strict=True)
+        if (edge[0], edge[1]) in backend.coupling_map or (edge[1], edge[0]) in backend.coupling_map
+    ]
+    edges_cal = [edge for edge in edges_cal if (edge[0], edge[1])
+                 in backend.coupling_map or (edge[1], edge[0]) in backend.coupling_map]
+
     weights = -np.log(np.array(fidelities_cal))
     calibrated_nodes = list(idx_to_qubit.keys())
 
+    if show_ghz_path and qubit_layouts is not None and any(len(layout) >= 2 for layout in qubit_layouts):
+        valid_fidelities = [f for f in fidelities_cal if f < 1.0]
+        if valid_fidelities:
+            median_fidelity = np.median(valid_fidelities)
+            fidelities_cal = [f if f < 1.0 else median_fidelity for f in fidelities_cal]
+        from iqm.benchmarks.entanglement.ghz import generate_ghz_spanning_tree, get_cx_map, get_edges
+
+        graph = get_edges(backend.coupling_map, qubit_layouts[0], edges_cal, fidelities_cal)
+        cx_map = get_cx_map(qubit_layouts[0], graph)
+        print(f"Edge map:", cx_map)
+
     # Define qubit positions in plot
-    qubit_positions = GraphPositions.get_positions(station=station, graph=None, num_qubits=len(calibrated_nodes))
+    qubit_positions = GraphPositions.get_positions(station=quantum_computer, graph=None, num_qubits=len(calibrated_nodes))
 
     graph = PyGraph()
     nodes = list(set(qubit_positions.keys()))
@@ -520,24 +543,47 @@ def plot_layout_fidelity_graph(
         else:
             graph.add_edge(idx_to_qubit[edge[0]], idx_to_qubit[edge[1]], weight)
 
-    # Draw the main graph
+    # # Draw the main graph
     visualization.mpl_draw(
         graph,
         ax=ax,
         with_labels=True,
         node_color="none",  # No node color since we're using circles
         pos=qubit_positions,
-        labels=lambda node: node,
+        labels=lambda node: str(qubit_to_idx[node]) if node in qubit_to_idx else "",
         font_color="white",
-        width=graph.edges() / np.max(graph.edges()) * 10,
-    )  # type: ignore[call-arg]
+        edge_color="white",
+    )
+
+    # Draw edges manually with custom styles and colors
+    graph_edge_pairs = [list(edge) for edge in graph.edge_list()]
+    for _, (edge, weight) in enumerate(zip(graph_edge_pairs, graph.edges(), strict=True)):
+        x1, y1 = qubit_positions[edge[0]]
+        x2, y2 = qubit_positions[edge[1]]
+
+        # Define edge properties (customize these as needed)
+        edge_width = weight / np.max(list(graph.edges())) * 10 + 0.1
+        edge_color = "black"
+        edge_style = "solid"
+
+        # Highlight edges with zero weight (wrong calibration)
+        if weight == 0:
+            edge_width = 1
+            edge_style = "dashed"
+        # Highlight edges that are part of the GHZ path
+        if show_ghz_path and qubit_layouts is not None and any(len(layout) >= 2 for layout in qubit_layouts):
+            mapped_edge = [qubit_to_idx[edge[0]], qubit_to_idx[edge[1]]]
+            if mapped_edge in cx_map or list(reversed(mapped_edge)) in cx_map:
+                edge_color = "red"
+
+        ax.plot([x1, x2], [y1, y2], color=edge_color, linewidth=edge_width, linestyle=edge_style, zorder=1)
 
     # Draw nodes as circles with varying radii given by the single qubit metric
     radii = calculate_node_radii(metric_dict, qubit_nodes, sq_metric)
     node_colors = ["darkgray" for _ in range(len(nodes))]
     if qubit_layouts is not None:
         for qb in {qb for layout in qubit_layouts for qb in layout}:
-            node_colors[qb] = "orange"
+            node_colors[idx_to_qubit[qb]] = "orange"
     max_radius = 0.12 + np.max(radii) / np.max(radii) / 2.5
 
     for idx, node in enumerate(qubit_nodes):
@@ -548,7 +594,7 @@ def plot_layout_fidelity_graph(
 
     # Add edge labels using matplotlib's annotate
     # for idx, edge in enumerate(edges_cal):
-    for edge, weight in zip(list(graph.edge_list()), graph.edges()):
+    for edge, weight in zip(graph_edge_pairs, list(graph.edges()), strict=True):
         x1, y1 = qubit_positions[edge[0]]
         x2, y2 = qubit_positions[edge[1]]
         x = (x1 + x2) / 2

{iqm_benchmarks-2.54.dist-info → iqm_benchmarks-2.55.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.54
+Version: 2.55
 Summary: A package for implementation of Quantum Characterization, Verification and Validation (QCVV) techniques on IQM's hardware at gate level abstraction
 Author-email: IQM Finland Oy <developers@meetiqm.com>, Adrian Auer <adrian.auer@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Alessio Calzona <alessio.calzona@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Amin Hosseinkhani <amin.hosseinkhani@meetiqm.com>, Miikka Koistinen <miikka@meetiqm.com>, Nadia Milazzo <nadia.milazzo@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks

{iqm_benchmarks-2.54.dist-info → iqm_benchmarks-2.55.dist-info}/RECORD

@@ -1,11 +1,11 @@
 iqm/benchmarks/__init__.py,sha256=-drZ_whue067Tu4I9RxBCqrrzu38Tm5Kqf9jHTftUPk,3070
-iqm/benchmarks/benchmark.py,sha256=3E7g7RQjCIGIpSI1gOSrI3V9SAVs-XEOMrPgToK_7vw,4972
-iqm/benchmarks/benchmark_definition.py,sha256=lDu__vowp15udoo1tFl_h0LQA8WHyyHdIRi7UDbwAzg,11323
+iqm/benchmarks/benchmark.py,sha256=w5dexVB9G9KKSBgMMIlZP1OA7AMp_ZmeMPOVfhGcK0A,5055
+iqm/benchmarks/benchmark_definition.py,sha256=_fvMCGP2b6OjtQwfO8_FSXy1FJRvYc3nNgEe3sjlq28,11332
 iqm/benchmarks/circuit_containers.py,sha256=anEtZEsodYqOX-34oZRmuKGeEpp_VfgG5045Mz4-4hI,7562
 iqm/benchmarks/logging_config.py,sha256=U7olP5Kr75AcLJqNODf9VBhJLVqIvA4AYR6J39D5rww,1052
 iqm/benchmarks/readout_mitigation.py,sha256=Q2SOGWTNgmklOYkNxepAaSaXlxSj0QQyymYY1bOkT8A,11756
-iqm/benchmarks/utils.py,sha256=kJz9T9nJXpLl_iFYYUDtSq83N-Y3JFQBuvW1o7-AVSM,44137
-iqm/benchmarks/utils_plots.py,sha256=CaqA9fJNgRnrbYqwBdpzFUlhwvKw5lhZX3KfRlroQV4,24420
+iqm/benchmarks/utils.py,sha256=yCTWo0lGMg82DK1fkUICEntzF0aocJktMfcY231pUxg,46114
+iqm/benchmarks/utils_plots.py,sha256=Ei7_dsp94q652UMq5CszxoPCfJ1TNo6A7t-wSAAdpP8,26805
 iqm/benchmarks/utils_shadows.py,sha256=e77PV_uaAO5m_woox9lAzompKAvFeDJ-0AKJrNJ7NFg,9728
 iqm/benchmarks/coherence/__init__.py,sha256=yeyhk-_Lp8IbJ-f5lQj0HP5Q1HSKK_FzuXHazotUrVY,704
 iqm/benchmarks/coherence/coherence.py,sha256=RvbOxV2sJpAyr_bXqjBfSjk9v8XjRN-nrkK8w7RyfH0,21596
@@ -13,13 +13,13 @@ iqm/benchmarks/compressive_gst/__init__.py,sha256=LneifgYXtcwo2jcXo7GdUEHL6_peip
 iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=_thQfc9qmIJqAcS3Kg4ITEYl8Ofi8xgC_oZotrmyzVk,28484
 iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=H6EQGbpI_sig69Jy6hflg6alMTtjB0t9tHftygzA2YA,41240
 iqm/benchmarks/entanglement/__init__.py,sha256=sHVVToRWRCz0LSntk1rQaoSNNeyZLPoiTjUKWZWrk1E,778
-iqm/benchmarks/entanglement/ghz.py,sha256=L4NyOaSlIgUjqOPzWDz8Kxob1A9d-rK7fQqNWB6fRXA,45949
+iqm/benchmarks/entanglement/ghz.py,sha256=Tq7gPqOgS8WWywgp-1Jlu2ZgeTYEJNSiSxH2S8_D66E,47379
 iqm/benchmarks/entanglement/graph_states.py,sha256=6qACedd3UXpiowXc9GW4QhSwO-CzHXnBA3dIC6nCIbE,62788
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
 iqm/benchmarks/optimization/qscore.py,sha256=7JJIVrJvmec77kSdwM4YkwJJoNBCT-LuZ7Ay8JMZ7Nc,46847
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
-iqm/benchmarks/quantum_volume/clops.py,sha256=EUtO-_OYBYvwqb4xY3aubI2gc2Z6cBokRzt_E0608WA,31242
-iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=af9C4SdEPcYyZgQgtJYy2h_F8QWv1a0hEtN6hr4KeM0,36861
+iqm/benchmarks/quantum_volume/clops.py,sha256=HwO0bTRfDZrDtINLNtbXCIMqlqqFhsb6kmyma1gsDJU,31562
+iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=zKaD4ze3Msblo9tIxMmP8l_huq9mfDNukIJhSL72QYo,33576
 iqm/benchmarks/randomized_benchmarking/__init__.py,sha256=IkKo-7zUChxZZd3my_csQCJfJfZNsV3-JTvdG8uqys4,734
 iqm/benchmarks/randomized_benchmarking/clifford_1q.pkl,sha256=yrmSJqhv7Lb1yqiqU9-2baqTljJPNmTUPQR-AH6GGfc,7800
 iqm/benchmarks/randomized_benchmarking/clifford_2q.pkl,sha256=mJQLubWPOb-DbmFi4oKYJqAMW_Yyo3eJjRjLGl9Sqmo,10282247
@@ -30,12 +30,12 @@ iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=1BOYA9x
 iqm/benchmarks/randomized_benchmarking/direct_rb/__init__.py,sha256=lCIIeWMFZHnMUUEUTjUBvrhhUur6uBTHIVkxFBSfHC4,681
 iqm/benchmarks/randomized_benchmarking/direct_rb/direct_rb.py,sha256=X4MVojCcv1KabopKql4-58sNXP_q0WcFZBeUbDTY83w,49399
 iqm/benchmarks/randomized_benchmarking/eplg/__init__.py,sha256=1MeGZTErElXJypQV2rQf7hwqLLvIp_JNVbwNhaP5vyI,696
-iqm/benchmarks/randomized_benchmarking/eplg/eplg.py,sha256=3A_gxzAs6mi3APKvqCwYDcNwRogIZNy5SDL33Cro89E,17036
+iqm/benchmarks/randomized_benchmarking/eplg/eplg.py,sha256=kmet3yxF1bl1spKf-UrHqHxyEQhRnM7954oRmUKJrX8,17332
 iqm/benchmarks/randomized_benchmarking/interleaved_rb/__init__.py,sha256=sq6MgN_hwlpkOj10vyCU4e6eKSX-oLcF2L9na6W2Gt4,681
 iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py,sha256=OHoAWajCE48dRDInwQUT8VvtzKad0ExefdqvZFTaYzs,28918
 iqm/benchmarks/randomized_benchmarking/mirror_rb/__init__.py,sha256=jRKbivWCZ3xdO1k0sx-ygC3s5DUkGSModd975PoAtcg,692
 iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=ijieNymik3BeEUpXS-m64mtgdHz9iAFELuLooHeZY0E,33252
-iqm_benchmarks-2.54.dist-info/licenses/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
+iqm_benchmarks-2.55.dist-info/licenses/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
 mGST/LICENSE,sha256=TtHNq55cUcbglb7uhVudeBLUh_qPdUoAEvU0BBwFz-k,1098
 mGST/README.md,sha256=v_5kw253csHF4-RfE-44KqFmBXIsSMRmOtN0AUPrRxE,5050
 mGST/additional_fns.py,sha256=MV0Pm5ap59IjhT_E3QhsZyM7lXOF1RZ9SD11zoaf43A,31781
@@ -46,7 +46,7 @@ mGST/optimization.py,sha256=x9tJ9wMQ5aONWpNpBMVtK0rwE6DRcOU33htNgrt0tx4,11015
 mGST/qiskit_interface.py,sha256=uCdn-Q9CXI2f4FQSxGUy8GmmzQhr9NhCOFb2VPj0gTs,10061
 mGST/reporting/figure_gen.py,sha256=xFPAHx1Trdqz7swn0kRqwc_jbRaNxhG9Nvx0jeitooo,25847
 mGST/reporting/reporting.py,sha256=Wss1-zFsMEhzrrXKfP-RICau80ezjDIzcN555KhSehc,34160
-iqm_benchmarks-2.54.dist-info/METADATA,sha256=YW717J-dTO5FVIaGkmYeuZwK_FYSS71uqxvGc3-vI70,11009
-iqm_benchmarks-2.54.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-iqm_benchmarks-2.54.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-2.54.dist-info/RECORD,,
+iqm_benchmarks-2.55.dist-info/METADATA,sha256=ZkaOMyHFWMsU0fPFyG2qMu1L8fnAcQ5oUeT_It0dxOQ,11009
+iqm_benchmarks-2.55.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+iqm_benchmarks-2.55.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
+iqm_benchmarks-2.55.dist-info/RECORD,,

{iqm_benchmarks-2.54.dist-info → iqm_benchmarks-2.55.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any