iqm-benchmarks 1.11__py3-none-any.whl → 2.0__py3-none-any.whl

iqm/benchmarks/entanglement/ghz.py

@@ -28,7 +28,7 @@ import networkx
 from networkx import Graph, all_pairs_shortest_path, is_connected, minimum_spanning_tree
 import numpy as np
 import pycurl
-from qiskit import QuantumCircuit, transpile
+from qiskit import QuantumRegister, transpile
 from qiskit.quantum_info import random_clifford
 from qiskit.transpiler import CouplingMap
 from qiskit_aer import Aer
@@ -44,6 +44,7 @@ from iqm.benchmarks.benchmark_definition import (
     BenchmarkRunResult,
     add_counts_to_dataset,
 )
+from iqm.benchmarks.circuit_containers import BenchmarkCircuit, CircuitGroup, Circuits
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.readout_mitigation import apply_readout_error_mitigation
 from iqm.benchmarks.utils import (
@@ -55,6 +56,7 @@ from iqm.benchmarks.utils import (
     timeit,
     xrvariable_to_counts,
 )
+from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
@@ -94,16 +96,13 @@ def append_rms(
             rm_circ.compose(rand_clifford, qubits=[q], inplace=True)
 
         rm_circ.measure_active()
-        # if backend is not None and backend.name != "IQMNdonisBackend" and optimize_sqg:
-        #     rm_circuits.append(optimize_single_qubit_gates(rm_circ))
-        # else:
         rm_circuits.append(transpile(rm_circ, basis_gates=backend.operation_names))
 
     return rm_circuits
 
 
 def fidelity_ghz_randomized_measurements(
-    dataset: xr.Dataset, qubit_layout, ideal_probabilities: List[Dict[str, int]], num_qubits: int
+    dataset: xr.Dataset, qubit_layout, ideal_probabilities: List[Dict[str, int]], num_qubits: int, circuits: Circuits
 ) -> tuple[dict[str, Any], dict[str, Any]]:
     """
     Estimates GHZ state fidelity through cross-correlations of RMs.
@@ -113,7 +112,8 @@ def fidelity_ghz_randomized_measurements(
         dataset (xr.Dataset):
         qubit_layout: List[int]: The subset of system-qubits used in the protocol
         ideal_probabilities (List[Dict[str, int]]):
-        num_qubits (int):
+        num_qubits (int): Number of qubits
+        circuits (Circuits): Instance of `Circuits` containing transpiled circuits
     Returns:
         values: dict[str, Any]
             The fidelities
@@ -125,7 +125,7 @@ def fidelity_ghz_randomized_measurements(
     fid_rm = []
 
     # Loop through RMs and add each contribution
-    num_rms = len(dataset.attrs["transpiled_circuits"][f"{idx}"])
+    num_rms = len(circuits["transpiled_circuits"][f"{idx}_native_ghz"].circuits)
     for u in range(num_rms):
         # Probability estimates for noisy measurements
         probabilities_sample = {}
@@ -168,7 +168,7 @@ def fidelity_ghz_randomized_measurements(
     return values, uncertainties
 
 
-def fidelity_ghz_coherences(dataset: xr.Dataset, qubit_layout: List[int]) -> list[Any]:
+def fidelity_ghz_coherences(dataset: xr.Dataset, qubit_layout: List[int], circuits: Circuits) -> list[Any]:
     """
     Estimates the GHZ state fidelity based on the multiple quantum coherences method based on [Mooney, 2021]
 
@@ -177,6 +177,8 @@ def fidelity_ghz_coherences(dataset: xr.Dataset, qubit_layout: List[int]) -> lis
             An xarray dataset containing the measurement data
         qubit_layout: List[int]
             The subset of system-qubits used in the protocol
+        circuits: Circuits
+            Instance of `Circuits` containing transpiled circuits
 
     Returns:
         dict[str, dict[str, Any]]: The ghz fidelity or, if rem=True, fidelity and readout error mitigated fidelity
@@ -185,9 +187,9 @@ def fidelity_ghz_coherences(dataset: xr.Dataset, qubit_layout: List[int]) -> lis
     num_qubits = len(qubit_layout)
     phases = [np.pi * i / (num_qubits + 1) for i in range(2 * num_qubits + 2)]
     idx = BenchmarkObservationIdentifier(qubit_layout).string_identifier
-    transpiled_circuits = dataset.attrs["transpiled_circuits"][idx]
+    transpiled_circuits = circuits["transpiled_circuits"]
     num_shots = dataset.attrs["shots"]
-    num_circuits = len(transpiled_circuits)
+    num_circuits = len(transpiled_circuits[f"{qubit_layout}_native_ghz"].circuits)
 
     # Computing the phase acquired by the |11...1> component for each interval
     complex_coefficients = np.exp(1j * num_qubits * np.array(phases))
@@ -250,45 +252,50 @@ def fidelity_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
 
     observation_list: list[BenchmarkObservation] = []
     for qubit_layout in qubit_layouts:
-        if routine == "randomized_measurements":
-            ideal_simulator = Aer.get_backend("statevector_simulator")
-            ideal_probabilities = []
-            idx = BenchmarkObservationIdentifier(qubit_layout).string_identifier
-            all_circuits = run.dataset.attrs["transpiled_circuits"][idx]
-            for qc in all_circuits:
-                qc_copy = qc.copy()
-                qc_copy.remove_final_measurements()
-                deflated_qc = reduce_to_active_qubits(qc_copy, backend_name)
-                ideal_probabilities.append(dict(sorted(ideal_simulator.run(deflated_qc).result().get_counts().items())))
-            values, uncertainties = fidelity_ghz_randomized_measurements(
-                dataset, qubit_layout, ideal_probabilities, len(qubit_layout)
-            )
-            observation_list.extend(
-                [
-                    BenchmarkObservation(
-                        name=key,
-                        identifier=BenchmarkObservationIdentifier(qubit_layout),
-                        value=value,
-                        uncertainty=uncertainties[key],
-                    )
-                    for key, value in values.items()
-                ]
-            )
-        else:  # default routine == "coherences":
-            fidelity = fidelity_ghz_coherences(dataset, qubit_layout)
-            observation_list.extend(
-                [
-                    BenchmarkObservation(
-                        name="fidelity", identifier=BenchmarkObservationIdentifier(qubit_layout), value=fidelity[0]
-                    )
-                ]
-            )
-            if len(fidelity) > 1:
-                observation_list.append(
-                    BenchmarkObservation(
-                        name="fidelity_rem", identifier=BenchmarkObservationIdentifier(qubit_layout), value=fidelity[1]
+        match routine:
+            case "randomized_measurements":
+                ideal_simulator = Aer.get_backend("statevector_simulator")
+                ideal_probabilities = []
+                idx = BenchmarkObservationIdentifier(qubit_layout).string_identifier
+                all_circuits = run.circuits["transpiled_circuits"][f"{idx}_native_ghz"].circuits
+                for qc in all_circuits:
+                    qc_copy = qc.copy()
+                    qc_copy.remove_final_measurements()
+                    deflated_qc = reduce_to_active_qubits(qc_copy, backend_name)
+                    ideal_probabilities.append(
+                        dict(sorted(ideal_simulator.run(deflated_qc).result().get_counts().items()))
                     )
+                values, uncertainties = fidelity_ghz_randomized_measurements(
+                    dataset, qubit_layout, ideal_probabilities, len(qubit_layout), run.circuits
                 )
+                observation_list.extend(
+                    [
+                        BenchmarkObservation(
+                            name=key,
+                            identifier=BenchmarkObservationIdentifier(qubit_layout),
+                            value=value,
+                            uncertainty=uncertainties[key],
+                        )
+                        for key, value in values.items()
+                    ]
+                )
+            case "coherences":
+                fidelity = fidelity_ghz_coherences(dataset, qubit_layout, run.circuits)
+                observation_list.extend(
+                    [
+                        BenchmarkObservation(
+                            name="fidelity", identifier=BenchmarkObservationIdentifier(qubit_layout), value=fidelity[0]
+                        )
+                    ]
+                )
+                if len(fidelity) > 1:
+                    observation_list.append(
+                        BenchmarkObservation(
+                            name="fidelity_rem",
+                            identifier=BenchmarkObservationIdentifier(qubit_layout),
+                            value=fidelity[1],
+                        )
+                    )
     plots = {"All layout fidelities": plot_fidelities(observation_list, qubit_layouts)}
     return BenchmarkAnalysisResult(dataset=dataset, observations=observation_list, plots=plots)
 
@@ -304,7 +311,8 @@ def generate_ghz_linear(num_qubits: int) -> QuantumCircuit:
         A quantum circuit generating a GHZ state of n qubits
     """
     s = int(num_qubits / 2)
-    qc = QuantumCircuit(num_qubits)
+    quantum_register = QuantumRegister(num_qubits)
+    qc = QuantumCircuit(quantum_register, name="GHZ_linear")
     qc.h(s)
 
     for m in range(s, 0, -1):
@@ -325,7 +333,8 @@ def generate_ghz_log_cruz(num_qubits: int) -> QuantumCircuit:
     Returns:
         A quantum circuit generating a GHZ state of n qubits
     """
-    qc = QuantumCircuit(num_qubits)
+    quantum_register = QuantumRegister(num_qubits)
+    qc = QuantumCircuit(quantum_register, name="GHZ_log_Cruz")
     qc.h(0)
 
     for m in range(num_qubits):
@@ -346,7 +355,8 @@ def generate_ghz_log_mooney(num_qubits: int) -> QuantumCircuit:
     Returns:
         A quantum circuit generating a GHZ state of n qubits
     """
-    qc = QuantumCircuit(num_qubits)
+    quantum_register = QuantumRegister(num_qubits)
+    qc = QuantumCircuit(quantum_register, name="GHZ_log_Mooney")
     qc.h(0)
 
     aux_n = int(np.ceil(np.log2(num_qubits)))
@@ -389,7 +399,8 @@ def generate_ghz_spanning_tree(
     participating_qubits = set(qubit for pair in cx_map[: n_state - 1] for qubit in pair)
 
     relabeling = {idx_old: idx_new for idx_new, idx_old in enumerate(participating_qubits)}
-    qc = QuantumCircuit(n_state, name="ghz")
+    n_state_register = QuantumRegister(n_state)
+    qc = QuantumCircuit(n_state_register, name="ghz")
     qc.h([relabeling[cx_map[0][0]]])
     for _, pair in zip(np.arange(n_state - 1), cx_map):
         relabeled_pair = [relabeling[pair[0]], relabeling[pair[1]]]
@@ -594,7 +605,6 @@ class GHZBenchmark(Benchmark):
         super().__init__(backend, configuration)
 
         self.state_generation_routine = configuration.state_generation_routine
-        # self.choose_qubits_routine = configuration.choose_qubits_routine
         if configuration.custom_qubits_array:
             self.custom_qubits_array = configuration.custom_qubits_array
         else:
@@ -606,7 +616,6 @@ class GHZBenchmark(Benchmark):
             if any(np.max(configuration.qubit_counts) > [len(layout) for layout in self.custom_qubits_array]):
                 raise ValueError("The maximum given qubit count is larger than the size of the smallest qubit layout.")
             self.qubit_counts = configuration.qubit_counts
-        # self.layout_idx_mapping = {str(qubit_layout): idx for idx, qubit_layout in enumerate(self.custom_qubits_array)}
 
         self.qiskit_optim_level = configuration.qiskit_optim_level
         self.optimize_sqg = configuration.optimize_sqg
@@ -617,11 +626,7 @@ class GHZBenchmark(Benchmark):
         self.cal_url = configuration.cal_url
         self.timestamp = strftime("%Y%m%d-%H%M%S")
 
-    # @staticmethod
-    # def name() -> str:
-    #     return "ghz"
-
-    def generate_native_ghz(self, qubit_layout: List[int], qubit_count: int, routine: str) -> QuantumCircuit:
+    def generate_native_ghz(self, qubit_layout: List[int], qubit_count: int, routine: str) -> CircuitGroup:
         """
         Generate a circuit preparing a GHZ state,
         according to a given routine and transpiled to the native gate set and topology.
@@ -638,13 +643,13 @@ class GHZBenchmark(Benchmark):
         Returns:
             QuantumCircuit implementing GHZ native state
         """
-        # num_qubits = len(qubit_layout)
+        circuit_group = CircuitGroup(name=f"{qubit_layout}_native_ghz")
         fixed_coupling_map = set_coupling_map(qubit_layout, self.backend, "fixed")
-        idx = BenchmarkObservationIdentifier(qubit_layout).string_identifier
         ghz_native_transpiled: List[QuantumCircuit]
+
         if routine == "naive":
-            ghz = generate_ghz_linear(qubit_count)
-            self.untranspiled_circuits[idx].update({qubit_count: ghz})
+            ghz: QuantumCircuit = generate_ghz_linear(qubit_count)
+            circuit_group.add_circuit(ghz)
             ghz_native_transpiled, _ = perform_backend_transpilation(
                 [ghz],
                 self.backend,
@@ -661,7 +666,7 @@ class GHZBenchmark(Benchmark):
             else:
                 graph = get_edges(self.backend.coupling_map, qubit_layout)
             ghz, _ = generate_ghz_spanning_tree(graph, qubit_layout, qubit_count)
-            self.untranspiled_circuits[idx].update({qubit_count: ghz})
+            circuit_group.add_circuit(ghz)
             ghz_native_transpiled, _ = perform_backend_transpilation(
                 [ghz],
                 self.backend,
@@ -685,12 +690,13 @@ class GHZBenchmark(Benchmark):
             if ghz_native_transpiled[0].depth() == ghz_native_transpiled[1].depth():
                 index_min_2q = np.argmin([c.count_ops()["cz"] for c in ghz_native_transpiled])
                 final_ghz = ghz_native_transpiled[index_min_2q]
-                self.untranspiled_circuits[idx].update({qubit_count: ghz_log[index_min_2q]})
+                circuit_group.add_circuit(ghz_log[index_min_2q])
             else:
                 index_min_depth = np.argmin([c.depth() for c in ghz_native_transpiled])
                 final_ghz = ghz_native_transpiled[index_min_depth]
-                self.untranspiled_circuits[idx].update({qubit_count: ghz_log[index_min_depth]})
-        return final_ghz[0]
+                circuit_group.add_circuit([ghz_log[index_min_depth]])
+        self.circuits["untranspiled_circuits"].circuit_groups.append(circuit_group)
+        return CircuitGroup(name=f"{qubit_layout}_native_ghz", circuits=[final_ghz[0]])
 
     def generate_coherence_meas_circuits(self, qubit_layout: List[int], qubit_count: int) -> List[QuantumCircuit]:
         """
@@ -708,9 +714,9 @@ class GHZBenchmark(Benchmark):
         """
 
         idx = BenchmarkObservationIdentifier(qubit_layout).string_identifier
-        qc = self.untranspiled_circuits[idx][qubit_count]
-        qc_list = [qc.copy()]
+        qc_list = self.circuits["untranspiled_circuits"][f"{qubit_layout}_native_ghz"].circuits
 
+        qc = qc_list[0].copy()
         qc.remove_final_measurements()
         qc_inv = qc.inverse()
         phases = [np.pi * i / (qubit_count + 1) for i in range(2 * qubit_count + 2)]
@@ -733,10 +739,11 @@ class GHZBenchmark(Benchmark):
             qiskit_optim_level=self.qiskit_optim_level,
             optimize_sqg=self.optimize_sqg,
         )
-        self.untranspiled_circuits[idx].update({qubit_count: qc_list})
+        circuit_group = CircuitGroup(name=idx, circuits=qc_list)
+        self.circuits["untranspiled_circuits"].circuit_groups.append(circuit_group)
         return qc_list_transpiled
 
-    def generate_readout_circuit(self, qubit_layout, qubit_count):
+    def generate_readout_circuit(self, qubit_layout: List[int], qubit_count: int) -> CircuitGroup:
         """
         A wrapper for the creation of different circuits to estimate the fidelity
 
@@ -752,22 +759,23 @@ class GHZBenchmark(Benchmark):
                 A list of transpiled quantum circuits to be measured
         """
         # Generate the list of circuits
-        idx = BenchmarkObservationIdentifier(qubit_layout).string_identifier
-        self.untranspiled_circuits[idx] = {}
-        self.transpiled_circuits[idx] = {}
 
         qcvv_logger.info(f"Now generating a {len(qubit_layout)}-qubit GHZ state on qubits {qubit_layout}")
-        transpiled_ghz = self.generate_native_ghz(qubit_layout, qubit_count, self.state_generation_routine)
-
-        if self.fidelity_routine == "randomized_measurements":
-            all_circuits_list, _ = append_rms(transpiled_ghz, cast(int, self.num_RMs), self.backend)
-        elif self.fidelity_routine == "coherences":
-            all_circuits_list = self.generate_coherence_meas_circuits(qubit_layout, qubit_count)
-        else:
-            all_circuits_list = transpiled_ghz
+        transpiled_ghz_group: CircuitGroup = self.generate_native_ghz(
+            qubit_layout, qubit_count, self.state_generation_routine
+        )
 
-        self.transpiled_circuits.update({idx: all_circuits_list})
-        return all_circuits_list
+        match self.fidelity_routine:
+            case "randomized_measurements":
+                all_circuits_list, _ = append_rms(
+                    transpiled_ghz_group.circuits[0], cast(int, self.num_RMs), self.backend
+                )
+                transpiled_ghz_group.circuits = all_circuits_list
+            case "coherences":
+                all_circuits_list = self.generate_coherence_meas_circuits(qubit_layout, qubit_count)
+                transpiled_ghz_group.circuits = all_circuits_list
+        self.circuits["transpiled_circuits"].circuit_groups.append(transpiled_ghz_group)
+        return transpiled_ghz_group
 
     def add_configuration_to_dataset(self, dataset: xr.Dataset):  # CHECK
         """
@@ -785,8 +793,7 @@ class GHZBenchmark(Benchmark):
             else:
                 dataset.attrs[key] = value
         dataset.attrs[f"backend_name"] = self.backend.name
-        dataset.attrs[f"untranspiled_circuits"] = self.untranspiled_circuits
-        dataset.attrs[f"transpiled_circuits"] = self.transpiled_circuits
+        dataset.attrs["fidelity_routine"] = self.fidelity_routine
 
     def execute(self, backend) -> xr.Dataset:
         """
@@ -797,13 +804,17 @@ class GHZBenchmark(Benchmark):
 
         # Submit all
         all_jobs: Dict = {}
+
+        self.circuits = Circuits()
+        self.circuits.benchmark_circuits.append(BenchmarkCircuit(name="transpiled_circuits"))
+        self.circuits.benchmark_circuits.append(BenchmarkCircuit(name="untranspiled_circuits"))
         for qubit_layout in aux_custom_qubits_array:
             Id = BenchmarkObservationIdentifier(qubit_layout)
             idx = Id.string_identifier
             # for qubit_count in self.qubit_counts[idx]:
             qubit_count = len(qubit_layout)
-            circuits = self.generate_readout_circuit(qubit_layout, qubit_count)
-            transpiled_circuit_dict = {tuple(qubit_layout): circuits}
+            circuit_group: CircuitGroup = self.generate_readout_circuit(qubit_layout, qubit_count)
+            transpiled_circuit_dict = {tuple(qubit_layout): circuit_group.circuits}
             all_jobs[idx], _ = submit_execute(
                 transpiled_circuit_dict,
                 backend,
@@ -811,6 +822,7 @@ class GHZBenchmark(Benchmark):
                 self.calset_id,
                 max_gates_per_batch=self.max_gates_per_batch,
             )
+
         # Retrieve all
         qcvv_logger.info(f"Retrieving counts and adding counts to dataset...")
         for qubit_layout in aux_custom_qubits_array:
@@ -822,8 +834,8 @@ class GHZBenchmark(Benchmark):
             dataset, _ = add_counts_to_dataset(counts, idx, dataset)
             if self.rem:
                 qcvv_logger.info(f"Applying readout error mitigation")
-                circuits = self.transpiled_circuits[idx]
-                rem_results, _ = apply_readout_error_mitigation(backend, circuits, counts, self.mit_shots)
+                circuit_group = self.circuits["transpiled_circuits"][f"{idx}_native_ghz"]
+                rem_results, _ = apply_readout_error_mitigation(backend, circuit_group.circuits, counts, self.mit_shots)
                 rem_results_dist = [counts_mit.nearest_probability_distribution() for counts_mit in rem_results]
                 dataset, _ = add_counts_to_dataset(rem_results_dist, f"{idx}_rem", dataset)
 

iqm/benchmarks/optimization/qscore.py

@@ -17,20 +17,21 @@ Q-score benchmark
 """
 
 import itertools
+import logging
 from time import strftime
-from typing import Callable, Dict, List, Optional, Tuple, Type
+from typing import Callable, Dict, List, Literal, Optional, Tuple, Type
 
 from matplotlib.figure import Figure
 import matplotlib.pyplot as plt
 from networkx import Graph
 import networkx as nx
 import numpy as np
-from qiskit import QuantumCircuit
 from scipy.optimize import basinhopping, minimize
 
 from iqm.benchmarks.benchmark import BenchmarkBase, BenchmarkConfigurationBase
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.utils import perform_backend_transpilation, retrieve_all_counts, submit_execute, timeit
+from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
@@ -209,6 +210,7 @@ class QScoreBenchmark(BenchmarkBase):
 
             else:
                 coupling_map = self.backend.coupling_map.reduce(qubit_set)
+                qcvv_logger.setLevel(logging.WARNING)
                 transpiled_qc_list, _ = perform_backend_transpilation(
                     [qc],
                     backend=self.backend,
@@ -230,6 +232,7 @@ class QScoreBenchmark(BenchmarkBase):
                 )
 
                 counts = retrieve_all_counts(jobs)[0][0]
+                qcvv_logger.setLevel(logging.INFO)
 
             return self.compute_expectation_value(counts, graph)
 
@@ -595,7 +598,7 @@ class QScoreBenchmark(BenchmarkBase):
 
         for i in range(self.num_instances):
             graph = nx.generators.erdos_renyi_graph(num_nodes, 0.5, seed=seed)
-            print(f"graph: {graph}")
+            qcvv_logger.debug(f"graph: {graph}")
             self.graph_physical = graph.copy()
             self.virtual_nodes = []
             if self.use_virtual_node:
@@ -619,14 +622,14 @@ class QScoreBenchmark(BenchmarkBase):
             if graph.number_of_edges() == 0:
                 cut_sizes.append(0)
                 seed += 1
-                qcvv_logger.info(f"Graph {i+1}/{self.num_instances} had no edges: cut size = 0.")
+                qcvv_logger.debug(f"Graph {i+1}/{self.num_instances} had no edges: cut size = 0.")
                 continue
 
             # Choose the qubit layout
             qubit_set = []
             if self.choose_qubits_routine.lower() == "naive":
                 qubit_set = self.choose_qubits_naive(num_nodes)
-            elif self.choose_qubits_routine.lower() == "custom" or self.choose_qubits_routine.lower() == "mapomatic":
+            elif self.choose_qubits_routine.lower() == "custom":
                 qubit_set = self.choose_qubits_custom(num_nodes)
             else:
                 raise ValueError('choose_qubits_routine must either be "naive" or "custom".')
@@ -634,7 +637,7 @@ class QScoreBenchmark(BenchmarkBase):
             # Solve the maximum cut size with QAOA
             cut_sizes.append(self.run_QAOA(graph, qubit_set))
             seed += 1
-            qcvv_logger.info(f"Solved the MaxCut on graph {i+1}/{self.num_instances}.")
+            qcvv_logger.debug(f"Solved the MaxCut on graph {i+1}/{self.num_instances}.")
 
         average_cut_size = np.mean(cut_sizes) - num_nodes * (num_nodes - 1) / 8
         average_best_cut_size = 0.178 * pow(num_nodes, 3 / 2)
@@ -677,7 +680,7 @@ class QScoreBenchmark(BenchmarkBase):
         list_of_cut_sizes = []
 
         for num_nodes in range(self.min_num_nodes, max_num_nodes + 1):
-            qcvv_logger.info(f"Executing on {self.num_instances} random graphs with {num_nodes} nodes.")
+            qcvv_logger.debug(f"Executing on {self.num_instances} random graphs with {num_nodes} nodes.")
             is_successful, approximation_ratio, cut_sizes = self.execute_single_benchmark(num_nodes)[0:3]
             approximation_ratios.append(approximation_ratio)
 
@@ -711,7 +714,7 @@ class QScoreConfiguration(BenchmarkConfigurationBase):
     max_num_nodes: Optional[int] = None
     use_virtual_node: bool = True
     use_classically_optimized_angles: bool = True
-    choose_qubits_routine: str = "naive"
+    choose_qubits_routine: Literal["naive", "custom"] = "naive"
     min_num_qubits: int = 2  # If choose_qubits_routine is "naive"
     custom_qubits_array: Optional[list[list[int]]] = None
     qiskit_optim_level: int = 3

iqm/benchmarks/quantum_volume/clops.py

@@ -25,13 +25,13 @@ import matplotlib as mpl
 from matplotlib.figure import Figure
 import matplotlib.pyplot as plt
 import numpy as np
-from qiskit import QuantumCircuit
 from qiskit.circuit import ParameterVector
 import xarray as xr
 
 from iqm.benchmarks import Benchmark
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
 from iqm.benchmarks.benchmark_definition import BenchmarkAnalysisResult, BenchmarkRunResult
+from iqm.benchmarks.circuit_containers import BenchmarkCircuit, CircuitGroup, Circuits
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.utils import (
     count_2q_layers,
@@ -44,6 +44,7 @@ from iqm.benchmarks.utils import (
     submit_execute,
     timeit,
 )
+from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 from iqm.qiskit_iqm.iqm_transpilation import optimize_single_qubit_gates
 
@@ -251,9 +252,10 @@ def clops_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     all_times_retrieve = dataset.attrs["all_times_retrieve"]
 
     transpiled_qc_list = []
-    for _, value in dataset.attrs["transpiled_circuits"].items():
-        for _, transpiled_circuit in value.items():
-            transpiled_qc_list.extend(transpiled_circuit)
+    for group in run.circuits["transpiled_circuits"].circuit_groups:
+        transpiled_qc_list.extend(group.circuits)
+    # for _, value in dataset.attrs["transpiled_circuits"].items():
+    #     for _, transpiled_circuit in value.items():
 
     # CLOPS_V
     clops_v: float = num_circuits * num_updates * num_shots * depth / clops_time
@@ -387,26 +389,6 @@ class CLOPSBenchmark(Benchmark):
         dataset.attrs["u_per_layer"] = self.u_per_layer
         dataset.attrs["num_parameters"] = self.num_parameters
 
-    def add_all_circuits_to_dataset(self, dataset: xr.Dataset):
-        """Adds all generated circuits during execution to the dataset variable
-
-        Args:
-            dataset (xr.Dataset):  The xarray dataset
-
-        Returns:
-
-        """
-        qcvv_logger.info(f"Adding all circuits to the dataset")
-        for key, circuit in zip(
-            ["transpiled_circuits", "untranspiled_circuits"], [self.transpiled_circuits, self.untranspiled_circuits]
-        ):
-            dictionary = {}
-            for outer_key, outer_value in circuit.items():
-                dictionary[str(outer_key)] = {
-                    str(inner_key): inner_values for inner_key, inner_values in outer_value.items()
-                }
-            dataset.attrs[key] = dictionary
-
     def append_parameterized_unitary(
         self,
         qc: QuantumCircuit,
@@ -593,8 +575,6 @@ class CLOPSBenchmark(Benchmark):
             Dict[str, QuantumCircuit]: a dictionary of quantum circuits with keys being str(qubit layout)
         """
         # Generate the list of QV circuits
-        self.untranspiled_circuits = {}
-        self.transpiled_circuits = {}
 
         qc_list, self.time_circuit_generate = self.generate_circuit_list()
 
@@ -622,11 +602,9 @@ class CLOPSBenchmark(Benchmark):
             # Sort circuits according to their final measurement mappings
             (sorted_transpiled_qc_list, _), self.time_sort_batches = sort_batches_by_final_layout(transpiled_qc_list)
 
-        self.untranspiled_circuits.update({str(self.qubits): {str(self.qubits): qc_list}})
-        self.transpiled_circuits.update(
-            {str(self.qubits): {str(key): value for key, value in sorted_transpiled_qc_list.items()}}
-        )
-        # self.transpiled_circuits[str(self.qubits)].update(sorted_transpiled_qc_list)
+        self.untranspiled_circuits.circuit_groups.append(CircuitGroup(name=self.qubits, circuits=qc_list))
+        for key in sorted_transpiled_qc_list.keys():
+            self.transpiled_circuits.circuit_groups.append(CircuitGroup(name=f"{self.qubits}_{key}", circuits=qc_list))
 
         return sorted_transpiled_qc_list
 
@@ -635,6 +613,9 @@ class CLOPSBenchmark(Benchmark):
 
         self.execution_timestamp = strftime("%Y-%m-%d_%H:%M:%S")
 
+        self.circuits = Circuits()
+        self.transpiled_circuits = BenchmarkCircuit(name="transpiled_circuits")
+        self.untranspiled_circuits = BenchmarkCircuit(name="untranspiled_circuits")
         dataset = xr.Dataset()
         self.add_all_meta_to_dataset(dataset)
 
@@ -691,7 +672,7 @@ class CLOPSBenchmark(Benchmark):
             }
         )
 
-        self.add_all_circuits_to_dataset(dataset)
+        self.circuits = Circuits([self.transpiled_circuits, self.untranspiled_circuits])
 
         return dataset