iqm-benchmarks 2.43__py3-none-any.whl → 2.44__py3-none-any.whl

iqm/benchmarks/entanglement/ghz.py

@@ -145,7 +145,6 @@ def fidelity_ghz_coherences(dataset: xr.Dataset, qubit_layout: List[int], circui
     phases = [np.pi * i / (num_qubits + 1) for i in range(2 * num_qubits + 2)]
     idx = BenchmarkObservationIdentifier(qubit_layout).string_identifier
     transpiled_circuits = circuits["transpiled_circuits"]
-    num_shots = dataset.attrs["shots"]
     num_circuits = len(transpiled_circuits[f"{qubit_layout}_native_ghz"].circuits)
 
     # Computing the phase acquired by the |11...1> component for each interval
@@ -155,8 +154,9 @@ def fidelity_ghz_coherences(dataset: xr.Dataset, qubit_layout: List[int], circui
     counts = xrvariable_to_counts(dataset, f"{idx}", num_circuits)
     all_zero_probability_list = []  # An ordered list for storing the probabilities of returning to the |00..0> state
     for count in counts[1:]:
+        normalization = np.sum(list(count.values()))
         if "0" * num_qubits in count.keys():
-            probability = count["0" * num_qubits] / num_shots
+            probability = count["0" * num_qubits] / normalization
         else:
             probability = 0
         all_zero_probability_list.append(probability)
@@ -165,7 +165,7 @@ def fidelity_ghz_coherences(dataset: xr.Dataset, qubit_layout: List[int], circui
     i_n = np.abs(np.dot(complex_coefficients, np.array(all_zero_probability_list))) / (len(phases))
 
     # Extracting the probabilities of the 00...0 and 11...1 bit strings
-    probs_direct = {label: count / num_shots for label, count in counts[0].items()}
+    probs_direct = {label: count / np.sum(list(counts[0].values())) for label, count in counts[0].items()}
 
     # Computing GHZ state fidelity from i_n and the probabilities according to the method in [Mooney, 2021]
     p0 = probs_direct["0" * num_qubits] if "0" * num_qubits in probs_direct.keys() else 0

iqm/benchmarks/entanglement/graph_states.py

@@ -439,34 +439,29 @@ def plot_max_negativities_graph(
     fig = plt.figure()
     ax = plt.axes()
 
-    if station is not None:
-        if station.lower() in GraphPositions.predefined_stations:
-            qubit_positions = GraphPositions.predefined_stations[station.lower()]
-        else:
-            graph_backend = backend_coupling_map.graph.to_undirected(multigraph=False)
-            qubit_positions = GraphPositions.create_positions(graph_backend)
-    else:
-        graph_backend = backend_coupling_map.graph.to_undirected(multigraph=False)
-        if num_qubits in (20, 7):
-            station = "garnet" if num_qubits == 20 else "deneb"
-            qubit_positions = GraphPositions.predefined_stations[station]
-        else:
-            qubit_positions = GraphPositions.create_positions(graph_backend)
+    qubit_positions = GraphPositions.get_positions(
+        station=station, graph=backend_coupling_map.graph.to_undirected(multigraph=False), num_qubits=num_qubits
+    )
 
     # Normalize negativity values to the range [0, 1] for color mapping
     norm = plt.Normalize(vmin=cast(float, min(negativity_values)), vmax=cast(float, max(negativity_values)))
-    edge_colors = [cmap(norm(negativity_edges[edge])) for edge in qubit_pairs]
+    edge_colors = [
+        cmap(norm(negativity_edges[edge])) if edge in qubit_pairs else "lightgray" for edge in backend_coupling_map
+    ]  #
+    nodes = list(set(v for edge in backend_coupling_map for v in edge))
+    active_nodes = list(set(v for edge in qubit_pairs for v in edge))
+    node_colors = ["lightgray" if v not in active_nodes else "k" for v in nodes]
 
     nx.draw_networkx(
         rx_to_nx_graph(backend_coupling_map),
         pos=qubit_positions,
-        nodelist=list(range(num_qubits)),
-        labels={x: qubit_names[x] for x in range(num_qubits)},
+        nodelist=nodes,
+        edgelist=list(backend_coupling_map),
+        labels={x: qubit_names[x] for x in nodes},
         font_size=6.5,
-        edgelist=qubit_pairs,
         width=4.0,
         edge_color=edge_colors,
-        node_color="k",
+        node_color=node_colors,
         font_color="w",
         ax=ax,
     )
@@ -490,6 +485,8 @@ def plot_max_negativities_graph(
             f"{shots_string}; Bootstraps: {num_bootstraps}"
             f"\n{timestamp}"
         )
+    # Invert y-axis to match the intended qubit positions
+    plt.gca().invert_yaxis()
     plt.close()
 
     return fig_name, fig
@@ -955,7 +952,7 @@ def negativity_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     dataset = run.dataset.copy(deep=True)
     qcvv_logger.info("Dataset imported OK")
     backend_name = dataset.attrs["backend_name"]
-    coupling_map = dataset.attrs["coupling_map"]
+    coupling_map_full = dataset.attrs["coupling_map_full"]
     qubit_names = dataset.attrs["qubit_names"]
     execution_timestamp = dataset.attrs["execution_timestamp"]
     tomography = dataset.attrs["tomography"]
@@ -1004,7 +1001,7 @@ def negativity_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
 
     fig_name, fig = plot_max_negativities_graph(
         negativities=max_negativities,
-        backend_coupling_map=coupling_map,
+        backend_coupling_map=coupling_map_full,
         qubit_names=qubit_names,
         timestamp=execution_timestamp,
         tomography=tomography,
@@ -1066,8 +1063,11 @@ class GraphStateBenchmark(Benchmark):
         dataset.attrs["execution_timestamp"] = self.execution_timestamp
         dataset.attrs["backend_configuration_name"] = self.backend_configuration_name
         dataset.attrs["backend_name"] = self.backend.name
-        dataset.attrs["qubit_names"] = {qubit: self.backend.index_to_qubit_name(qubit) for qubit in self.qubits}
+        dataset.attrs["qubit_names"] = {
+            qubit: self.backend.index_to_qubit_name(qubit) for qubit in np.arange(self.backend.num_qubits)
+        }
         dataset.attrs["coupling_map"] = self.coupling_map
+        dataset.attrs["coupling_map_full"] = self.backend.coupling_map
 
         for key, value in self.configuration:
             if key == "benchmark":  # Avoid saving the class object

iqm/benchmarks/quantum_volume/clops.py

@@ -21,7 +21,6 @@ from math import floor, pi
 from time import perf_counter, strftime
 from typing import Any, Dict, List, Sequence, Tuple, Type
 
-import matplotlib as mpl
 from matplotlib.figure import Figure
 import matplotlib.pyplot as plt
 import numpy as np
@@ -178,8 +177,8 @@ def retrieve_clops_elapsed_times(job_meta: Dict[str, Dict[str, Any]]) -> Dict[st
                 # submit_i = datetime.strptime(x["submit_start"], job_time_format)
                 execution_f = datetime.strptime(x["execution_end"], job_time_format)
                 execution_i = datetime.strptime(x["execution_start"], job_time_format)
-                job_f = datetime.strptime(x["job_end"], job_time_format)
-                job_i = datetime.strptime(x["job_start"], job_time_format)
+                job_f = datetime.strptime(x["ready"], job_time_format)
+                job_i = datetime.strptime(x["received"], job_time_format)
 
                 all_job_elapsed[update][batch] = {
                     "job_total": job_f - job_i,

iqm/benchmarks/randomized_benchmarking/eplg/eplg.py

@@ -5,6 +5,7 @@ Error Per Layered Gate (EPLG).
 from time import strftime
 from typing import Dict, Optional, Sequence, Tuple, Type, cast
 
+from matplotlib.colors import to_rgba
 from matplotlib.figure import Figure
 import matplotlib.pyplot as plt
 import networkx as nx
@@ -76,38 +77,35 @@ def plot_layered_fidelities_graph(
     fig = plt.figure()
     ax = plt.axes()
 
-    if station is not None:
-        if station.lower() in GraphPositions.predefined_stations:
-            qubit_positions = GraphPositions.predefined_stations[station.lower()]
-        else:
-            if num_qubits in (20, 7):
-                station = "garnet" if num_qubits == 20 else "deneb"
-                qubit_positions = GraphPositions.predefined_stations[station]
-            else:
-                graph_backend = backend_coupling_map.graph.to_undirected(multigraph=False)
-                qubit_positions = GraphPositions.create_positions(graph_backend)
-    else:
-        graph_backend = backend_coupling_map.graph.to_undirected(multigraph=False)
-        if num_qubits in (20, 7):
-            station = "garnet" if num_qubits == 20 else "deneb"
-            qubit_positions = GraphPositions.predefined_stations[station]
-        else:
-            qubit_positions = GraphPositions.create_positions(graph_backend)
+    qubit_positions = GraphPositions.get_positions(
+        station=station, graph=backend_coupling_map.graph.to_undirected(multigraph=False), num_qubits=num_qubits
+    )
 
     # Normalize fidelity values to the range [0, 1] for color mapping
     norm = plt.Normalize(vmin=cast(float, min(fidelity_values)), vmax=cast(float, max(fidelity_values)))
-    edge_colors = [cmap(norm(fidelity_edges[edge])) for edge in qubit_pairs]
+    edge_colors = []
+    for edge in backend_coupling_map:
+        if edge in fidelity_edges:
+            edge_colors.append(cmap(norm(fidelity_edges[edge])))
+        elif (edge[1], edge[0]) in fidelity_edges:
+            edge_colors.append(cmap(norm(fidelity_edges[(edge[1], edge[0])])))
+        else:
+            edge_colors.append(to_rgba("lightgray"))
+
+    nodes = list(set(v for edge in backend_coupling_map for v in edge))
+    active_nodes = list(set(v for edge in qubit_pairs for v in edge))
+    node_colors = ["lightgray" if v not in active_nodes else "k" for v in nodes]
 
     nx.draw_networkx(
         rx_to_nx_graph(backend_coupling_map),
         pos=qubit_positions,
-        nodelist=list(range(num_qubits)),
-        labels={x: qubit_names[x] for x in range(num_qubits)},
+        nodelist=nodes,
+        edgelist=list(backend_coupling_map),
+        labels={x: qubit_names[x] for x in nodes},
         font_size=6.5,
-        edgelist=qubit_pairs,
         width=4.0,
         edge_color=edge_colors,
-        node_color="k",
+        node_color=node_colors,
         font_color="w",
         ax=ax,
     )
@@ -116,7 +114,7 @@ def plot_layered_fidelities_graph(
     sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
     sm.set_array([])
     cbar = fig.colorbar(sm, ax=ax, shrink=0.5, label="Layered Fidelity (%)", format="%.2f")
-    cbar.set_ticks(np.linspace(min(fidelity_values), max(fidelity_values), 5, endpoint=True))
+    cbar.set_ticks(tuple(np.linspace(min(fidelity_values), max(fidelity_values), 5, endpoint=True)))
 
     station_string = "IQM Backend" if station is None else station.capitalize()
 
@@ -124,6 +122,7 @@ def plot_layered_fidelities_graph(
         f"EPLG estimate: {eplg_estimate['value']:.2e} +/- {eplg_estimate['uncertainty']:.2e}\n" if eplg_estimate else ""
     )
     plt.title(f"Layered fidelities for qubit pairs in {station_string}\n" f"{eplg_string}{timestamp}")
+    plt.gca().invert_yaxis()
     plt.close()
 
     return fig_name, fig
@@ -190,8 +189,8 @@ def eplg_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
         backend_num_qubits=backend_num_qubits,
         edge_list=edges,
         timestamp=timestamp,
-        disjoint_layers=disjoint_layers,
         station=backend_configuration_name,
+        disjoint_layers=disjoint_layers,
         qubit_names=qubit_names,
         is_eplg=True,
     )

iqm/benchmarks/utils.py

@@ -48,6 +48,9 @@ from iqm.qiskit_iqm.iqm_job import IQMJob
 from iqm.qiskit_iqm.iqm_provider import IQMProvider
 
 
+# pylint: disable=too-many-lines
+
+
 def timeit(f):
     """Calculates the amount of time a function takes to execute.
 
@@ -283,12 +286,18 @@ def get_active_qubits(qc: QuantumCircuit) -> List[int]:
     return list(active_qubits)
 
 
-def extract_fidelities(cal_url: str) -> tuple[list[list[int]], list[float], str]:
+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
 
     Args:
         cal_url: str
             The url under which the calibration data for the backend can be found
+        all_metrics: bool
+            If True, returns a dictionary with all metrics from the calibration data
+            Default is False
     Returns:
         list_couplings: List[List[int]]
             A list of pairs, each of which is a qubit coupling for which the calibration
@@ -297,6 +306,13 @@ def extract_fidelities(cal_url: str) -> tuple[list[list[int]], list[float], str]
             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)
@@ -304,6 +320,7 @@ def extract_fidelities(cal_url: str) -> tuple[list[list[int]], list[float], str]
     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"]
     list_couplings = []
     list_fids = []
     if "double_move_gate_fidelity" in cal_keys.keys():
@@ -313,18 +330,65 @@ def extract_fidelities(cal_url: str) -> tuple[list[list[int]], list[float], str]
         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 item["locus"][0] != "COMP_R" else 0
-        qb2 = int(item["locus"][1][2:]) if item["locus"][1] != "COMP_R" else 0
-        if topology == "star":
-            list_couplings.append([qb1, qb2])
-        else:
-            list_couplings.append([qb1 - 1, qb2 - 1])
+        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"])
+
+    # Enumerate all calibrated qubits starting from 0
     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]
 
-    return list_couplings, list_fids, topology
+    # Apply the qubit mapping to metrics_dict
+    remapped_metrics_dict = {}
+    for metric_key, metric_values in metrics_dict.items():
+        remapped_metrics_dict[metric_key] = {}
+        for key, value in metric_values.items():
+            if isinstance(key, tuple):
+                # Two-qubit metric
+                remapped_metrics_dict[metric_key][(qubit_mapping[key[0]], qubit_mapping[key[1]])] = value
+            else:
+                # Single-qubit metric
+                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
 
 
 # pylint: disable=too-many-branches

iqm/benchmarks/utils_plots.py

@@ -17,9 +17,10 @@ Plotting and visualization utility functions
 """
 from dataclasses import dataclass
 import os
-from typing import Dict, List, Literal, Optional, Sequence, Tuple
+from typing import Dict, List, Literal, Optional, Sequence, Tuple, cast
 
 from matplotlib.figure import Figure
+from matplotlib.patches import Circle, FancyBboxPatch
 import matplotlib.pyplot as plt
 import networkx as nx
 import numpy as np
@@ -40,9 +41,9 @@ class GraphPositions:
     provides methods to generate positions for different layout types.
 
     Attributes:
-        garnet_positions (Dict[int, Tuple[int, int]]): Mapping of node indices to (x,y) positions for Garnet chip.
-        deneb_positions (Dict[int, Tuple[int, int]]): Mapping of node indices to (x,y) positions for Deneb chip.
-        predefined_stations (Dict[str, Dict[int, Tuple[int, int]]]): Mapping of chip names to their position dictionaries.
+        garnet_positions (Dict[int, Tuple[float, float]]): Mapping of node indices to (x,y) positions for Garnet chip.
+        deneb_positions (Dict[int, Tuple[float, float]]): Mapping of node indices to (x,y) positions for Deneb chip.
+        predefined_stations (Dict[str, Dict[int, Tuple[float, float]]]): Mapping of chip names to their position dictionaries.
     """
 
     garnet_positions = {
@@ -68,15 +69,116 @@ class GraphPositions:
         19: (3.0, 1.0),
     }
 
+    emerald_positions = {
+        0: (10, 10),
+        1: (11, 9),
+        2: (7, 11),
+        3: (8, 10),
+        4: (9, 9),
+        5: (10, 8),
+        6: (11, 7),
+        7: (5, 11),
+        8: (6, 10),
+        9: (7, 9),
+        10: (8, 8),
+        11: (9, 7),
+        12: (10, 6),
+        13: (11, 5),
+        14: (3, 11),
+        15: (4, 10),
+        16: (5, 9),
+        17: (6, 8),
+        18: (7, 7),
+        19: (8, 6),
+        20: (9, 5),
+        21: (10, 4),
+        22: (2, 10),
+        23: (3, 9),
+        24: (4, 8),
+        25: (5, 7),
+        26: (6, 6),
+        27: (7, 5),
+        28: (8, 4),
+        29: (9, 3),
+        30: (10, 2),
+        31: (2, 8),
+        32: (3, 7),
+        33: (4, 6),
+        34: (5, 5),
+        35: (6, 4),
+        36: (7, 3),
+        37: (8, 2),
+        38: (9, 1),
+        39: (1, 7),
+        40: (2, 6),
+        41: (3, 5),
+        42: (4, 4),
+        43: (5, 3),
+        44: (6, 2),
+        45: (7, 1),
+        46: (1, 5),
+        47: (2, 4),
+        48: (3, 3),
+        49: (4, 2),
+        50: (5, 1),
+        51: (1, 3),
+        52: (2, 2),
+        53: (3, 1),
+    }
+
+    sirius_positions = {
+        # Even nodes on the bottom
+        2: (1, 5),
+        4: (3, 5),
+        6: (5, 5),
+        8: (7, 5),
+        10: (9, 5),
+        12: (11, 5),
+        14: (13, 5),
+        16: (15, 5),
+        18: (17, 5),
+        20: (19, 5),
+        22: (21, 5),
+        24: (23, 5),
+        # Odd nodes on the top
+        1: (1, 1),
+        3: (3, 1),
+        5: (5, 1),
+        7: (7, 1),
+        9: (9, 1),
+        11: (11, 1),
+        13: (13, 1),
+        15: (15, 1),
+        17: (17, 1),
+        19: (19, 1),
+        21: (21, 1),
+        23: (23, 1),
+    }
+    # Add dummy indices for the resonator
+    max_qubit_number = np.max(list(sirius_positions.keys()))
+    previous_nodes = list(sirius_positions.keys())
+    for node in previous_nodes:
+        sirius_positions.update({node + max_qubit_number: (sirius_positions[node][0], 3)})
+    # Node 0 in the middle
+    sirius_positions.update({0: (16.5, 3)})
+
     deneb_positions = {
-        0: (2.0, 2.0),
-        1: (1.0, 1.0),
-        3: (2.0, 1.0),
-        5: (3.0, 1.0),
-        2: (1.0, 3.0),
-        4: (2.0, 3.0),
-        6: (3.0, 3.0),
+        # Even nodes on the bottom
+        2: (1, 5),
+        4: (3, 5),
+        6: (5, 5),
+        # Odd nodes on the top
+        1: (1, 1),
+        3: (3, 1),
+        5: (5, 1),
     }
+    # Add dummy indices for the resonator
+    max_qubit_number = np.max(list(deneb_positions.keys()))
+    previous_nodes = list(deneb_positions.keys())
+    for node in previous_nodes:
+        deneb_positions.update({node + max_qubit_number: (deneb_positions[node][0], 3)})
+    # Node 0 in the middle
+    deneb_positions.update({0: (2.5, 3)})
 
     predefined_stations = {
         "garnet": garnet_positions,
@@ -85,6 +187,8 @@ class GraphPositions:
         "deneb": deneb_positions,
         "fakedeneb": deneb_positions,
         "iqmfakedeneb": deneb_positions,
+        "emerald": emerald_positions,
+        "sirius": sirius_positions,
     }
 
     @staticmethod
@@ -128,6 +232,40 @@ class GraphPositions:
             }
         return pos
 
+    @staticmethod
+    def get_positions(
+        station: Optional[str] = None, graph: Optional[PyGraph] = None, num_qubits: Optional[int] = None
+    ) -> Dict[int, Tuple[float, float]]:
+        """Get predefined positions for a specific station or generate positions for a custom graph.
+
+        Args:
+            station (Optional[str]): The name of the station to get predefined positions for.
+                If None, positions will be generated algorithmically.
+            graph (Optional[PyGraph]): The graph to generate positions for if no predefined positions exist.
+                Used only when station is None and num_qubits doesn't match any predefined layout.
+            num_qubits (Optional[int]): The number of qubits to get a layout for.
+                If matches a known system, predefined positions will be used.
+
+        Returns:
+            Dict[int, Tuple[float, float]]: A dictionary mapping node indices to (x,y) coordinates.
+
+        Raises:
+            ValueError: If none of station, graph, or num_qubits are provided, or if num_qubits doesn't
+                match any predefined layout and graph is None.
+        """
+        if station is not None and station.lower() in GraphPositions.predefined_stations:
+            qubit_positions = cast(Dict[int, Tuple[float, float]], GraphPositions.predefined_stations[station.lower()])
+        else:
+            qubit_station_dict = {6: "deneb", 7: "deneb", 20: "garnet", 24: "sirius", 17: "sirius", 54: "emerald"}
+            if num_qubits is not None and num_qubits in qubit_station_dict:
+                station = qubit_station_dict[num_qubits]
+                qubit_positions = cast(Dict[int, Tuple[float, float]], GraphPositions.predefined_stations[station])
+            elif graph is not None:
+                qubit_positions = GraphPositions.create_positions(graph)
+            else:
+                raise ValueError("Either a station name, a graph, or a qubit count must be provided to get positions.")
+        return qubit_positions
+
 
 def draw_graph_edges(
     backend_coupling_map: CouplingMap,
@@ -165,23 +303,7 @@ def draw_graph_edges(
     fig = plt.figure()
     ax = plt.axes()
 
-    if station is not None:
-        if station.lower() in GraphPositions.predefined_stations:
-            qubit_positions = GraphPositions.predefined_stations[station.lower()]
-        else:
-            if backend_num_qubits in (6, 20):
-                station = "garnet" if backend_num_qubits == 20 else "deneb"
-                qubit_positions = GraphPositions.predefined_stations[station]
-            else:
-                graph_backend = backend_coupling_map.graph.to_undirected(multigraph=False)
-                qubit_positions = GraphPositions.create_positions(graph_backend)
-    else:
-        graph_backend = backend_coupling_map.graph.to_undirected(multigraph=False)
-        if backend_num_qubits in (6, 20):
-            station = "garnet" if backend_num_qubits == 20 else "deneb"
-            qubit_positions = GraphPositions.predefined_stations[station]
-        else:
-            qubit_positions = GraphPositions.create_positions(graph_backend)
+    qubit_positions = GraphPositions.get_positions(station=station, graph=None, num_qubits=backend_num_qubits)
 
     label_station = station if station is not None else f"{backend_num_qubits}-qubit IQM Backend"
     if disjoint_layers is None:
@@ -226,6 +348,7 @@ def draw_graph_edges(
             f"\n{timestamp}"
         )
     ax.set_aspect(0.925)
+    plt.gca().invert_yaxis()
     plt.close()
 
     return fig_name, fig
@@ -302,8 +425,55 @@ def evaluate_hamiltonian_paths(
     return path_costs
 
 
+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:
+        metric_dict (Dict[str, Dict[int, float]]): Dictionary containing various qubit metrics.
+        qubit_nodes (List[int]): List of qubits to calculate the radius for.
+        sq_metric (str): Metric to use for radius calculation.
+                         Options: "fidelity", "coherence", or "readout".
+
+    Returns:
+        numpy.ndarray: Array of radii values for each qubit node.
+
+    Raises:
+        ValueError: If an unsupported metric type is provided.
+    """
+    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."
+            )
+    elif sq_metric == "coherence":
+        if "t1_time" not in metric_dict or "t2_time" not in metric_dict:
+            raise ValueError(
+                "At least one of the metrics 't1_time' and 't2_time' is not available in the backend metrics."
+            )
+        sqg_time = 32e-9
+        t1_times = [metric_dict["t1_time"][node] for node in qubit_nodes]
+        t2_times = [metric_dict["t2_time"][node] for node in qubit_nodes]
+        idle_fidelities = (3 + np.exp(-sqg_time / np.array(t1_times)) + 2 * np.exp(-sqg_time / np.array(t2_times))) / 6
+        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."
+            )
+        readout_fidelities = [metric_dict["single_shot_readout_fidelity"][node] for node in qubit_nodes]
+        radii = -np.log(readout_fidelities)
+    else:
+        raise ValueError(
+            f"Unsupported single qubit metric: {sq_metric}, supported metrics are: fidelity, coherence, readout"
+        )
+    return radii
+
 def plot_layout_fidelity_graph(
-    cal_url: str, qubit_layouts: Optional[list[list[int]]] = None, station: Optional[str] = None
+    cal_url: str,
+    qubit_layouts: Optional[list[list[int]]] = None,
+    station: Optional[str] = None,
+    sq_metric: Optional[str] = "coherence",
 ):
     """Plot a graph showing the quantum chip layout with fidelity information.
 
@@ -316,57 +486,75 @@ def plot_layout_fidelity_graph(
         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.
                 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".
 
     Returns:
         matplotlib.figure.Figure: The generated figure object containing the graph visualization
     """
-    edges_cal, fidelities_cal, topology = extract_fidelities(cal_url)
-    weights = -np.log(np.array(fidelities_cal))
-    edges_graph = [tuple(edge) + (weight,) for edge, weight in zip(edges_cal, weights)]
-
-    graph = PyGraph()
-
-    # Add nodes
-    nodes: set[int] = set()
-    for edge in edges_graph:
-        nodes.update(edge[:2])
-    graph.add_nodes_from(list(nodes))
+    # 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)
+    if topology == "star":
+        idx_to_qubit = {idx: qubit for qubit, idx in qubit_mapping.items()}
+        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_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))))
 
-    # Add edges
-    graph.add_edges_from(edges_graph)
+    weights = -np.log(np.array(fidelities_cal))
+    calibrated_nodes = list(idx_to_qubit.keys())
 
     # Define qubit positions in plot
-    if station is not None and station.lower() in GraphPositions.predefined_stations:
-        pos = GraphPositions.predefined_stations[station.lower()]
-    else:
-        pos = GraphPositions.create_positions(graph, topology)
+    qubit_positions = GraphPositions.get_positions(station=station, graph=None, num_qubits=len(calibrated_nodes))
 
-    # Define node colors
-    node_colors = ["lightgrey" 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"
-
-    plt.subplots(figsize=(1.5 * np.sqrt(len(nodes)), 1.5 * np.sqrt(len(nodes))))
+    graph = PyGraph()
+    nodes = list(set(qubit_positions.keys()))
+    graph.add_nodes_from(nodes)
+    for edge, weight in zip(edges_cal, weights):
+        if topology == "star":
+            max_qubit_number = (np.max(list(qubit_positions.keys())) + 1) // 2
+            graph.add_edge(idx_to_qubit[edge[0]], idx_to_qubit[edge[0]] + max_qubit_number, weight)
+        else:
+            graph.add_edge(idx_to_qubit[edge[0]], idx_to_qubit[edge[1]], weight)
 
-    # Draw the graph
+    # Draw the main graph
     visualization.mpl_draw(
         graph,
+        ax=ax,
         with_labels=True,
-        node_color=node_colors,
-        pos=pos,
+        node_color="none",  # No node color since we're using circles
+        pos=qubit_positions,
         labels=lambda node: node,
-        width=7 * weights / np.max(weights),
+        font_color="white",
+        width=graph.edges() / np.max(graph.edges()) * 10,
     )  # type: ignore[call-arg]
 
+    # 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"
+    max_radius = 0.12 + np.max(radii) / np.max(radii) / 2.5
+
+    for idx, node in enumerate(qubit_nodes):
+        position = qubit_positions[idx_to_qubit[node]]
+        radius = 0.12 + radii[idx] / np.max(radii) / 2.5
+        circle = Circle(position, radius=radius, color=node_colors[idx_to_qubit[node]], fill=True, alpha=1)
+        ax.add_patch(circle)
+
     # Add edge labels using matplotlib's annotate
-    for edge in edges_graph:
-        x1, y1 = pos[edge[0]]
-        x2, y2 = pos[edge[1]]
+    # for idx, edge in enumerate(edges_cal):
+    for edge, weight in zip(list(graph.edge_list()), graph.edges()):
+        x1, y1 = qubit_positions[edge[0]]
+        x2, y2 = qubit_positions[edge[1]]
         x = (x1 + x2) / 2
         y = (y1 + y2) / 2
         plt.annotate(
-            f"{edge[2]:.1e}",
+            f"{weight:.1e}",
             xy=(x, y),
             xytext=(0, 0),
             textcoords="offset points",
@@ -375,12 +563,68 @@ def plot_layout_fidelity_graph(
             bbox={"boxstyle": "round,pad=0.2", "fc": "white", "ec": "none", "alpha": 0.6},
         )
 
-    plt.gca().invert_yaxis()
-    plt.title(
-        "Chip layout with selected qubits in orange\n"
-        + "and gate errors indicated by edge thickness (thinner is better)"
+    # Add horizontal bar representing resonator
+    if topology == "star":
+        resonator_height = 3
+        resonator_thickness = 0.8
+        x_min = 0.5
+        x_max = qubit_positions[idx_to_qubit[qubit_nodes[-1]]][0] + 0.5
+        resonator_width = x_max - x_min
+
+        # Create rectangle with rounded corners
+        resonator = FancyBboxPatch(
+            (x_min, resonator_height - resonator_thickness / 2),
+            resonator_width,
+            resonator_thickness,
+            boxstyle="round,pad=0.01,rounding_size=0.3",
+            color="lightsteelblue",
+            zorder=10,
+        )
+        ax.add_patch(resonator)
+
+        # Add "Resonator" label in the center
+        plt.annotate(
+            "Resonator",
+            xy=((x_min + x_max) / 2, resonator_height),
+            xytext=(0, 0),
+            textcoords="offset points",
+            ha="center",
+            va="center",
+            color="black",
+            fontsize=10,
+            zorder=11,
+            bbox={"boxstyle": "round,pad=0.2", "fc": "white", "ec": "none", "alpha": 0.8},
+        )
+
+    # Calculate axis limits to ensure all circles are visible
+    all_x = [pos[0] for pos in qubit_positions.values()]
+    all_y = [pos[1] for pos in qubit_positions.values()]
+    x_min, x_max = min(all_x), max(all_x)
+    y_min, y_max = min(all_y), max(all_y)
+
+    # Add padding for circles
+    padding = max_radius * 1.5
+    ax.set_xlim(x_min - padding, x_max + padding)
+    ax.set_ylim(y_min - padding, y_max + padding)
+
+    # Adjust layout first
+    plt.tight_layout(pad=2.0)
+    ax.set_aspect("equal")
+    ax.invert_yaxis()
+
+    plt.figtext(
+        0.5,
+        0.99,  # x=0.5 (center), y=0.01 (bottom)
+        f"Qubit connectivity with selected qubits in orange\n"
+        f"CZ errors -log(F) indicated by edge thickness (thinner is better)\n"
+        f"Single qubit errors -log(F) shown as node size with F computed from {sq_metric} metrics",
+        fontsize=10,
+        ha="center",
+        wrap=True,
     )
+
     plt.show()
+    return fig
 
 
 def rx_to_nx_graph(backend_coupling_map: CouplingMap) -> nx.Graph:

{iqm_benchmarks-2.43.dist-info → iqm_benchmarks-2.44.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.43
+Version: 2.44
 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.43.dist-info → iqm_benchmarks-2.44.dist-info}/RECORD

@@ -4,8 +4,8 @@ iqm/benchmarks/benchmark_definition.py,sha256=e4xe0wlWKZqj48_6-zTglMaMeoiA9aGkHr
 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=sItoMsfUYiMWTSCNOTe_RWi2l1xTf2slvXkFiEMRwKU,41091
-iqm/benchmarks/utils_plots.py,sha256=Q4h7gcKXf8Eizm13P0yL2I_P-QobHVFr9JCV83wrUi8,14942
+iqm/benchmarks/utils.py,sha256=kJz9T9nJXpLl_iFYYUDtSq83N-Y3JFQBuvW1o7-AVSM,44137
+iqm/benchmarks/utils_plots.py,sha256=CaqA9fJNgRnrbYqwBdpzFUlhwvKw5lhZX3KfRlroQV4,24420
 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=zX_6A8vCS2zeWesMDXPFZBfrJ8wUG90JI9_tFsonwXk,21191
@@ -13,12 +13,12 @@ iqm/benchmarks/compressive_gst/__init__.py,sha256=LneifgYXtcwo2jcXo7GdUEHL6_peip
 iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=2kiRttog4jR-vtMHu847GTFe5qL_i_uYr_4WMGqt9Ww,25653
 iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=g0kEovWbetoDRvX7JFrS9oOoNrqBxaFmprujJi7qQbU,36297
 iqm/benchmarks/entanglement/__init__.py,sha256=sHVVToRWRCz0LSntk1rQaoSNNeyZLPoiTjUKWZWrk1E,778
-iqm/benchmarks/entanglement/ghz.py,sha256=12bf9ANfgzyR7Vs8REO-Xm68gisqn8Q7_WSfaNnAmOk,41213
-iqm/benchmarks/entanglement/graph_states.py,sha256=7GMxuhbOeQXc3hn3yAwp51S-F-1qaP0AYXm6JtuL9gA,62560
+iqm/benchmarks/entanglement/ghz.py,sha256=nJ0gsLRfl50mcGrBVWjx22gXY9fwn9-sO3St2SbM4MA,41254
+iqm/benchmarks/entanglement/graph_states.py,sha256=saoAw2QF8j7W4nZMOElnjuNylqDAbY9cBwBypWZKUz8,62521
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
 iqm/benchmarks/optimization/qscore.py,sha256=D2BVVNAqO32uGu5_kLVl2XJUOBlRl1C-c6zYenaCBMg,37259
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
-iqm/benchmarks/quantum_volume/clops.py,sha256=fLY0aPHjNbW33SuVM9brAgBYFncDHjY5Bwh6iXzbjiU,31099
+iqm/benchmarks/quantum_volume/clops.py,sha256=QS9iK-gtop0zix6IBeUumQeG01-0dXsv0jsYSDhgEu0,31071
 iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=pro7Lz-A5pPpT9UZ8wtXKTyhdWmTjQjRHt4BylDR-3U,36553
 iqm/benchmarks/randomized_benchmarking/__init__.py,sha256=IkKo-7zUChxZZd3my_csQCJfJfZNsV3-JTvdG8uqys4,734
 iqm/benchmarks/randomized_benchmarking/clifford_1q.pkl,sha256=yrmSJqhv7Lb1yqiqU9-2baqTljJPNmTUPQR-AH6GGfc,7800
@@ -30,12 +30,12 @@ iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=IGBrq_a
 iqm/benchmarks/randomized_benchmarking/direct_rb/__init__.py,sha256=lCIIeWMFZHnMUUEUTjUBvrhhUur6uBTHIVkxFBSfHC4,681
 iqm/benchmarks/randomized_benchmarking/direct_rb/direct_rb.py,sha256=Cbx6B9q8Sqc_uPalX6fUEWJX6UEHCfWRof9u4brtx5A,48977
 iqm/benchmarks/randomized_benchmarking/eplg/__init__.py,sha256=1MeGZTErElXJypQV2rQf7hwqLLvIp_JNVbwNhaP5vyI,696
-iqm/benchmarks/randomized_benchmarking/eplg/eplg.py,sha256=WZ3OwQ4C3K8SzudILAUwt71lb24vQQO9vaT0C9GCSOc,17215
+iqm/benchmarks/randomized_benchmarking/eplg/eplg.py,sha256=3A_gxzAs6mi3APKvqCwYDcNwRogIZNy5SDL33Cro89E,17036
 iqm/benchmarks/randomized_benchmarking/interleaved_rb/__init__.py,sha256=sq6MgN_hwlpkOj10vyCU4e6eKSX-oLcF2L9na6W2Gt4,681
 iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py,sha256=TaR1YFWBhOgm1hmEQzuwLYpp0yl0Xpuo3jAT6YhiXpc,28471
 iqm/benchmarks/randomized_benchmarking/mirror_rb/__init__.py,sha256=jRKbivWCZ3xdO1k0sx-ygC3s5DUkGSModd975PoAtcg,692
 iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=n_5gt9636ZDMsM9hC3Zm5qP2bQr2sy41zxGhOh0XMjI,32932
-iqm_benchmarks-2.43.dist-info/licenses/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
+iqm_benchmarks-2.44.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=_SEJ10FRNM7_CroysT8hCLZTfpm6ZhEIDCY5zPTnhjo,31390
@@ -46,7 +46,7 @@ mGST/optimization.py,sha256=YHwkzIkYvsZOPjclR-BCQWh24jeqjuXp0BB0WX5Lwow,10559
 mGST/qiskit_interface.py,sha256=ajx6Zn5FnrX_T7tMP8xnBLyG4c2ddFRm0Fu2_3r1t30,10118
 mGST/reporting/figure_gen.py,sha256=6Xd8vwfy09hLY1YbJY6TRevuMsQSU4MsWqemly3ZO0I,12970
 mGST/reporting/reporting.py,sha256=B8NWfpZrrSmyH7lwZxd0EbZMYLsAGK1YsHRB4D5qXH4,26002
-iqm_benchmarks-2.43.dist-info/METADATA,sha256=ezkJGO1628fD-X8lXDqtZUeEK9y7kIsfZjDw-JqZBzs,10872
-iqm_benchmarks-2.43.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-iqm_benchmarks-2.43.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-2.43.dist-info/RECORD,,
+iqm_benchmarks-2.44.dist-info/METADATA,sha256=g7tbfF4edqqPEnS50lTJ_0pdp9KzCKMs4RNUQeCxUcU,10872
+iqm_benchmarks-2.44.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+iqm_benchmarks-2.44.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
+iqm_benchmarks-2.44.dist-info/RECORD,,