Update layer_fidelity_analysis.py to have benchmark suffix (#1583)

Co-authored-by: Will Shanks <wshaos@posteo.net>

Author: andrehche

qiskit_experiments/library/randomized_benchmarking/layer_fidelity.py

@@ -139,6 +139,7 @@ def __init__(
         one_qubit_basis_gates: Optional[Sequence[str]] = None,
         layer_barrier: Optional[bool] = True,
         min_delay: Optional[Sequence[int]] = None,
+        benchmark_suffix: Optional[str] = "",
     ):
         """Initialize a layer fidelity experiment.
 
@@ -172,6 +173,9 @@ def __init__(
                 this options requires at least one 1Q edge (a qubit in physical_qubits but
                 not in two_qubit_layers) to be applied. Also will not have an impact on the 2Q gates
                 if layer_barrier=False.
+            benchmark_suffix (str): Optional. Suffix string to be appended to the end of the names of the
+                associated analysis results. Intended to allow for easier bookeeping if multiple types of
+                gates are being tracked.
 
         Raises:
             QiskitError: If any invalid argument is supplied.
@@ -192,6 +196,8 @@ def __init__(
         super().__init__(
             physical_qubits, analysis=LayerFidelityAnalysis(full_layers), backend=backend
         )
+
+        self.analysis.benchmark_suffix = benchmark_suffix
         # assert isinstance(backend, BackendV2)
 
         # Verify parameters

qiskit_experiments/library/randomized_benchmarking/layer_fidelity_analysis.py

@@ -60,7 +60,7 @@ class _ProcessFidelityAnalysis(curve.CurveAnalysis):
         .. ref_arxiv:: 1 2311.05933
     """
 
-    def __init__(self, physical_qubits):
+    def __init__(self, physical_qubits, benchmark_suffix=""):
         super().__init__(
             models=[
                 lmfit.models.ExpressionModel(
@@ -77,6 +77,17 @@ def __init__(self, physical_qubits):
         self.plotter.set_figure_options(
             figure_title=f"Simultaneous Direct RB on Qubit{physical_qubits}",
         )
+        self._benchmark_suffix = benchmark_suffix
+
+    @property
+    def benchmark_suffix(self):
+        """Getter function for benchmark suffix parameter."""
+        return self._benchmark_suffix
+
+    @benchmark_suffix.setter
+    def benchmark_suffix(self, value):
+        """Setter function for benchmark suffix parameter."""
+        self._benchmark_suffix = value
 
     @classmethod
     def _default_options(cls):
@@ -157,7 +168,7 @@ def _create_analysis_results(
         metadata.update(fit_data.params)
         outcomes.append(
             AnalysisResultData(
-                name="ProcessFidelity",
+                name="ProcessFidelity" + self.benchmark_suffix,
                 value=pf,
                 chisq=fit_data.reduced_chisq,
                 quality=quality,
@@ -166,7 +177,7 @@ def _create_analysis_results(
         )
         outcomes.append(
             AnalysisResultData(
-                name="EPL",
+                name="EPL" + self.benchmark_suffix,
                 value=epl,
                 chisq=fit_data.reduced_chisq,
                 quality=quality,
@@ -188,7 +199,7 @@ def _run_analysis(
                 traceback.format_exc(),
             )
             failed_result = AnalysisResultData(
-                name="ProcessFidelity",
+                name="ProcessFidelity" + self.benchmark_suffix,
                 value=None,
                 quality="bad",
                 extra={"qubits": self._physical_qubits, "reason": "analysis_failure"},
@@ -234,15 +245,36 @@ def _evaluate_quality_with_reason(
 class _SingleLayerFidelityAnalysis(CompositeAnalysis):
     """A class to estimate a process fidelity per disjoint layer."""
 
-    def __init__(self, layer, analyses=None):
+    def __init__(self, layer, analyses=None, benchmark_suffix=""):
         if analyses:
             if len(layer) != len(analyses):
                 raise AnalysisError("'analyses' must have the same length with 'layer'")
         else:
-            analyses = [_ProcessFidelityAnalysis(qubits) for qubits in layer]
+            analyses = [
+                _ProcessFidelityAnalysis(qubits, benchmark_suffix=benchmark_suffix)
+                for qubits in layer
+            ]
 
         super().__init__(analyses, flatten_results=True)
         self._layer = layer
+        self._benchmark_suffix = benchmark_suffix
+        self._set_benchmark_suffix_on_subanalyses(benchmark_suffix)
+
+    @property
+    def benchmark_suffix(self):
+        """Getter function for benchmark suffix parameter."""
+        return self._benchmark_suffix
+
+    @benchmark_suffix.setter
+    def benchmark_suffix(self, value):
+        """Setter function for benchmark suffix parameter."""
+        self._benchmark_suffix = value
+        self._set_benchmark_suffix_on_subanalyses(value)
+
+    def _set_benchmark_suffix_on_subanalyses(self, value):
+        for subanalysis in self._analyses:
+            if hasattr(subanalysis, "benchmark_suffix"):
+                subanalysis.benchmark_suffix = value
 
     def _run_analysis(
         self, experiment_data: ExperimentData
@@ -251,12 +283,16 @@ def _run_analysis(
             # Run composite analysis and extract sub-experiments results
             analysis_results, figures = super()._run_analysis(experiment_data)
             # Calculate single layer fidelity from process fidelities of subsystems
-            pf_results = [res for res in analysis_results if res.name == "ProcessFidelity"]
+            pf_results = [
+                res
+                for res in analysis_results
+                if res.name == "ProcessFidelity" + self.benchmark_suffix
+            ]
             pfs = [res.value for res in pf_results]
             slf = np.prod(pfs)
             quality_slf = "good" if all(sub.quality == "good" for sub in pf_results) else "bad"
             slf_result = AnalysisResultData(
-                name="SingleLF",
+                name="SingleLF" + self.benchmark_suffix,
                 value=slf,
                 quality=quality_slf,
                 extra={"qubits": [q for qubits in self._layer for q in qubits]},
@@ -267,7 +303,7 @@ def _run_analysis(
         except Exception:  # pylint: disable=broad-except
             LOG.error("%s failed: %s", self.__class__.__name__, traceback.format_exc())
             failed_result = AnalysisResultData(
-                name="SingleLF",
+                name="SingleLF" + self.benchmark_suffix,
                 value=None,
                 quality="bad",
                 extra={
@@ -295,7 +331,7 @@ class LayerFidelityAnalysis(CompositeAnalysis):
         .. ref_arxiv:: 1 2311.05933
     """
 
-    def __init__(self, layers, analyses=None):
+    def __init__(self, layers, analyses=None, benchmark_suffix=""):
         if analyses:
             if len(layers) != len(analyses):
                 raise AnalysisError("'analyses' must have the same length with 'layers'")
@@ -305,6 +341,23 @@ def __init__(self, layers, analyses=None):
         super().__init__(analyses, flatten_results=True)
         self.num_layers = len(layers)
         self.num_2q_gates = sum(1 if len(qs) == 2 else 0 for lay in layers for qs in lay)
+        self._benchmark_suffix = benchmark_suffix
+
+    @property
+    def benchmark_suffix(self):
+        """Getter function for benchmark suffix parameter."""
+        return self._benchmark_suffix
+
+    @benchmark_suffix.setter
+    def benchmark_suffix(self, value):
+        """Setter function for benchmark suffix parameter."""
+        self._benchmark_suffix = value
+        self._set_benchmark_suffix_on_subanalyses(value)
+
+    def _set_benchmark_suffix_on_subanalyses(self, value):
+        for subanalysis in self._analyses:
+            if hasattr(subanalysis, "benchmark_suffix"):
+                subanalysis.benchmark_suffix = value
 
     def _run_analysis(
         self, experiment_data: ExperimentData
@@ -328,18 +381,20 @@ def _run_analysis(
             # Run composite analysis and extract sub-experiments results
             analysis_results, figures = super()._run_analysis(experiment_data)
             # Calculate full layer fidelity from single layer fidelities
-            slf_results = [res for res in analysis_results if res.name == "SingleLF"]
+            slf_results = [
+                res for res in analysis_results if res.name == "SingleLF" + self.benchmark_suffix
+            ]
             slfs = [res.value for res in slf_results]
             lf = np.prod(slfs)
             quality_lf = "good" if all(sub.quality == "good" for sub in slf_results) else "bad"
             lf_result = AnalysisResultData(
-                name="LF",
+                name="LF" + self.benchmark_suffix,
                 value=lf,
                 quality=quality_lf,
             )
             eplg = 1 - (lf ** (1 / self.num_2q_gates))
             eplg_result = AnalysisResultData(
-                name="EPLG",
+                name="EPLG" + self.benchmark_suffix,
                 value=eplg,
                 quality=quality_lf,
             )
@@ -350,13 +405,13 @@ def _run_analysis(
             LOG.error("%s failed: %s", self.__class__.__name__, traceback.format_exc())
             failed_results = [
                 AnalysisResultData(
-                    name="LF",
+                    name="LF" + self.benchmark_suffix,
                     value=None,
                     quality="bad",
                     extra={"reason": "analysis_failure"},
                 ),
                 AnalysisResultData(
-                    name="EPLG",
+                    name="EPLG" + self.benchmark_suffix,
                     value=None,
                     quality="bad",
                     extra={"reason": "analysis_failure"},

qiskit_experiments/library/randomized_benchmarking/layer_fidelity_unitary.py

@@ -135,6 +135,7 @@ def __init__(
         one_qubit_basis_gates: Optional[Sequence[str]] = None,
         layer_barrier: Optional[bool] = True,
         min_delay: Optional[Sequence[int]] = None,
+        benchmark_suffix: Optional[str] = "",
     ):
         """Initialize a unitary layer fidelity experiment.
 
@@ -170,6 +171,9 @@ def __init__(
                 this options requires at least one 1Q edge (a qubit in physical_qubits but
                 not in two_qubit_layers) to be applied. Also will not have an impact on the 2Q gates
                 if layer_barrier=False.
+            benchmark_suffix (str): Optional. Suffix string to be appended to the end of the names of the
+                associated analysis results. Intended to allow for easier bookeeping if multiple types of
+                gates are being tracked.
 
         Raises:
             QiskitError: If any invalid argument is supplied.
@@ -190,6 +194,8 @@ def __init__(
         super().__init__(
             physical_qubits, analysis=LayerFidelityAnalysis(full_layers), backend=backend
         )
+
+        self.analysis.benchmark_suffix = benchmark_suffix
         # assert isinstance(backend, BackendV2)
 
         # Verify parameters

releasenotes/notes/add-benchmark-suffix-c3ab8c14c89edb33.yaml

@@ -0,0 +1,7 @@
+---
+features:
+  - |
+    A new ``benchmark_suffix`` argument for the :class:`~.LayerFidelity`
+    and :class:`~.LayerFidelityUnitary` classes has been added which enables
+    users to append a descriptive suffix to the names of the analysis results in
+    these experiments, which makes bookkeeping for different types of gates easier.