qubitclient 0.1.4__py3-none-any.whl

qubitclient/draw/rabicospltplotter.py

@@ -0,0 +1,74 @@
+from .pltplotter import QuantumDataPltPlotter
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.lines import Line2D
+
+
+class RabiCosDataPltPlotter(QuantumDataPltPlotter):
+    def __init__(self):
+        super().__init__("rabicos")
+
+    def plot_result_npy(self, **kwargs):
+        result     = kwargs.get('result')
+        dict_param = kwargs.get('dict_param')
+
+        if not result or not dict_param:
+            fig, ax = plt.subplots()
+            ax.text(0.5, 0.5, "No data", ha='center', transform=ax.transAxes)
+            plt.close(fig)
+            return fig
+
+        data = dict_param.item() if isinstance(dict_param, np.ndarray) else dict_param
+        image_dict = data.get("image", {})
+        qubit_names = list(image_dict.keys())
+        if not qubit_names:
+            fig, ax = plt.subplots()
+            ax.text(0.5, 0.5, "No qubits", ha='center', transform=ax.transAxes)
+            plt.close(fig)
+            return fig
+
+        cols = min(3, len(qubit_names))
+        rows = (len(qubit_names) + cols - 1) // cols
+
+        fig = plt.figure(figsize=(5.8 * cols, 4.5 * rows))
+        fig.suptitle("RabiCos Peak Detection", fontsize=14, y=0.96)
+
+        peaks_list = result.get("peaks", [])
+        confs_list = result.get("confs", [])
+
+        for q_idx, q_name in enumerate(qubit_names):
+            ax = fig.add_subplot(rows, cols, q_idx + 1)
+            item = image_dict[q_name]
+            if not isinstance(item, (list, tuple)) or len(item) < 2:
+                continue
+
+            x = np.asarray(item[0])
+            y = np.asarray(item[1])
+
+            ax.plot(x, y, 'b-', alpha=0.7, linewidth=1.5)
+            legend_elements = [Line2D([0], [0], color='blue', lw=1.5, label='Signal')]
+
+            if q_idx < len(peaks_list):
+                peaks = peaks_list[q_idx]
+                confs = confs_list[q_idx] if q_idx < len(confs_list) else []
+                for p_idx, (p, c) in enumerate(zip(peaks, confs)):
+                    idx = np.argmin(np.abs(x - p))
+                    ax.scatter(x[idx], y[idx], color='red', s=80, zorder=5)
+                    ax.axvline(p, color='red', linestyle='--', alpha=0.8, linewidth=1.2)
+                    ax.annotate(f"x={p:.4f}\nconf={c:.3f}",
+                                (x[idx], y[idx]),
+                                xytext=(8, 8), textcoords='offset points',
+                                fontsize=8, color='darkred',
+                                bbox=dict(boxstyle="round,pad=0.3", facecolor="yellow", alpha=0.7))
+                    if p_idx == 0:
+                        legend_elements.append(Line2D([0], [0], color='red', linestyle='--', lw=1.2, label='Peak'))
+
+            ax.set_title(q_name, fontsize=11, pad=10)
+            ax.set_xlabel("Time (µs)")
+            ax.set_ylabel("P(|1>)")
+            ax.grid(True, linestyle='--', alpha=0.5)
+            ax.legend(handles=legend_elements, fontsize=8, loc='upper right', framealpha=0.9)
+
+        plt.tight_layout(rect=[0, 0, 1, 0.94])
+        plt.close(fig)
+        return fig

qubitclient/draw/rabicosplyplotter.py

@@ -0,0 +1,90 @@
+from .plyplotter import QuantumDataPlyPlotter
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import numpy as np
+
+
+class RabiCosDataPlyPlotter(QuantumDataPlyPlotter):
+    def __init__(self):
+        super().__init__("rabicos")
+
+    def plot_result_npy(self, **kwargs):
+        result     = kwargs.get('result')
+        dict_param = kwargs.get('dict_param')
+
+        if not result or not dict_param:
+            fig = go.Figure()
+            fig.add_annotation(text="No data", xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+            return fig
+
+        data = dict_param.item() if isinstance(dict_param, np.ndarray) else dict_param
+        image_dict = data.get("image", {})
+        qubit_names = list(image_dict.keys())
+        if not qubit_names:
+            fig = go.Figure()
+            fig.add_annotation(text="No qubits", xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+            return fig
+
+        cols = min(3, len(qubit_names))
+        rows = (len(qubit_names) + cols - 1) // cols
+
+        fig = make_subplots(
+            rows=rows, cols=cols,
+            subplot_titles=qubit_names,
+            vertical_spacing=0.08,
+            horizontal_spacing=0.08,
+        )
+
+        peaks_list = result.get("peaks", [])
+        confs_list = result.get("confs", [])
+
+        show_legend = True
+        for q_idx, q_name in enumerate(qubit_names):
+            row = q_idx // cols + 1
+            col = q_idx % cols + 1
+
+            item = image_dict[q_name]
+            if not isinstance(item, (list, tuple)) or len(item) < 2:
+                continue
+
+            x = np.asarray(item[0])
+            y = np.asarray(item[1])
+
+            fig.add_trace(
+                go.Scatter(x=x, y=y, mode='lines', name='Signal',
+                           line=dict(color='blue'), showlegend=show_legend),
+                row=row, col=col
+            )
+            if show_legend:
+                show_legend = False
+
+            if q_idx < len(peaks_list):
+                peaks = peaks_list[q_idx]
+                confs = confs_list[q_idx] if q_idx < len(confs_list) else []
+                for p, c in zip(peaks, confs):
+                    fig.add_trace(
+                        go.Scatter(x=[p, p], y=[y.min(), y.max()],
+                                   mode='lines', line=dict(color='red', dash='dash'),
+                                   name='Peak', showlegend=(q_idx == 0)),
+                        row=row, col=col
+                    )
+                    fig.add_trace(
+                        go.Scatter(x=[p], y=[y.max() * 1.05],
+                                   mode='text', text=[f"conf: {c:.3f}"],
+                                   textposition="top center",
+                                   showlegend=False, textfont=dict(color="red", size=10)),
+                        row=row, col=col
+                    )
+
+            if row == rows:
+                fig.update_xaxes(title_text="Time", row=row, col=col)
+            if col == 1:
+                fig.update_yaxes(title_text="Amp", row=row, col=col)
+
+        fig.update_layout(
+            height=400 * rows,
+            width=520 * cols,
+            title_text="RabiCos – Peak Detection",
+            title_x=0.5,
+        )
+        return fig

qubitclient/draw/rabipltplotter.py

@@ -0,0 +1,66 @@
+# src/draw/rabipltplotter.py
+from .pltplotter import QuantumDataPltPlotter
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class RabiDataPltPlotter(QuantumDataPltPlotter):
+    def __init__(self):
+        super().__init__("rabi")
+
+    def plot_result_npy(self, **kwargs):
+        result     = kwargs.get('result')
+        dict_param = kwargs.get('dict_param')
+
+        if not result or not dict_param:
+            fig, ax = plt.subplots()
+            ax.text(0.5, 0.5, "No data", ha='center', transform=ax.transAxes)
+            plt.close(fig)
+            return fig
+
+        data = dict_param.item() if isinstance(dict_param, np.ndarray) else dict_param
+        image_dict = data.get('image', {})
+        qubit_names = list(image_dict.keys())
+        cols = min(3, len(qubit_names))
+        rows = (len(qubit_names) + cols - 1) // cols
+
+        fig = plt.figure(figsize=(5.8 * cols, 4.8 * rows))
+        fig.suptitle("Rabi Oscillation Fit", fontsize=14, y=0.96)
+
+        params_list   = result.get("params_list", [])
+        r2_list       = result.get("r2_list", [])
+        fit_data_list = result.get("fit_data_list", [])
+
+        for q_idx, q_name in enumerate(qubit_names):
+            ax = fig.add_subplot(rows, cols, q_idx + 1)
+            item = image_dict[q_name]
+            if not isinstance(item, (list, tuple)) or len(item) < 2:
+                continue
+
+            x_raw = np.asarray(item[0])
+            y_raw = np.asarray(item[1])
+
+            ax.plot(x_raw, y_raw, 'o', color='orange', markersize=5, label='Data', alpha=0.8)
+
+            if q_idx < len(fit_data_list):
+                y_fit = np.asarray(fit_data_list[q_idx])
+                x_fit = x_raw if len(y_fit) == len(x_raw) else np.linspace(x_raw.min(), x_raw.max(), len(y_fit))
+                ax.plot(x_fit, y_fit, '-', color='blue', linewidth=2.2, label='Fit')
+
+            if q_idx < len(params_list):
+                A, B, freq, phi, T2 = params_list[q_idx]
+                r2 = r2_list[q_idx] if q_idx < len(r2_list) else 0.0
+                text = (f"A={A:.3f}\nB={B:.3f}\nf={freq/1e6:.3f}MHz\n"
+                        f"φ={phi:.3f}\nT2={T2:.1f}µs\nR²={r2:.4f}")
+                ax.text(0.04, 0.96, text, transform=ax.transAxes, va='top', fontsize=8,
+                        bbox=dict(boxstyle="round,pad=0.4", facecolor="white", alpha=0.9))
+
+            ax.set_title(q_name, fontsize=11)
+            ax.set_xlabel("Time (ns)")
+            ax.set_ylabel("P(|1>)")
+            ax.grid(True, linestyle='--', alpha=0.5)
+            ax.legend(fontsize=8)
+
+        plt.tight_layout(rect=[0, 0, 1, 0.94])
+        plt.close(fig)
+        return fig

qubitclient/draw/rabiplyplotter.py

@@ -0,0 +1,86 @@
+# src/draw/rabiplyplotter.py
+from .plyplotter import QuantumDataPlyPlotter
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import numpy as np
+
+
+class RabiDataPlyPlotter(QuantumDataPlyPlotter):
+    def __init__(self):
+        super().__init__("rabi")
+
+    def plot_result_npy(self, **kwargs):
+        result     = kwargs.get('result')
+        dict_param = kwargs.get('dict_param')
+
+        if not result or not dict_param:
+            fig = go.Figure()
+            fig.add_annotation(text="Missing data", xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+            return fig
+
+        data = dict_param.item() if isinstance(dict_param, np.ndarray) else dict_param
+        image_dict = data.get("image", {})
+        if not image_dict:
+            fig = go.Figure()
+            fig.add_annotation(text="No image data", xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False)
+            return fig
+
+        qubit_names = list(image_dict.keys())
+        cols = min(3, len(qubit_names))
+        rows = (len(qubit_names) + cols - 1) // cols
+
+        fig = make_subplots(
+            rows=rows, cols=cols,
+            subplot_titles=qubit_names,
+            vertical_spacing=0.08,
+            horizontal_spacing=0.08,
+        )
+
+        params_list   = result.get("params_list", [])
+        r2_list       = result.get("r2_list", [])
+        fit_data_list = result.get("fit_data_list", [])
+
+        data_legend = False
+        fit_legend  = False
+
+        for q_idx, q_name in enumerate(qubit_names):
+            row = q_idx // cols + 1
+            col = q_idx % cols + 1
+
+            item = image_dict[q_name]
+            if not isinstance(item, (list, tuple)) or len(item) < 2:
+                continue
+
+            x_raw = np.asarray(item[0])
+            y_raw = np.asarray(item[1])
+
+            fig.add_trace(go.Scatter(x=x_raw, y=y_raw, mode='markers',
+                                    marker=dict(color='orange', size=7),
+                                    name='Data', showlegend=not data_legend), row=row, col=col)
+            if not data_legend:
+                data_legend = True
+
+            if q_idx < len(fit_data_list):
+                y_fit = np.asarray(fit_data_list[q_idx])
+                x_fit = x_raw if len(y_fit) == len(x_raw) else np.linspace(x_raw.min(), x_raw.max(), len(y_fit))
+                fig.add_trace(go.Scatter(x=x_fit, y=y_fit, mode='lines',
+                                        line=dict(color='blue', width=2.5),
+                                        name='Fit', showlegend=not fit_legend), row=row, col=col)
+                if not fit_legend:
+                    fit_legend = True
+
+            if q_idx < len(params_list):
+                A, B, freq, phi, T2 = params_list[q_idx]
+                r2 = r2_list[q_idx] if q_idx < len(r2_list) else 0.0
+                txt = f"A={A:.3f}<br>B={B:.3f}<br>freq={freq/1e6:.3f}MHz<br>φ={phi:.3f}<br>T2={T2:.1f}µs<br>R²={r2:.4f}"
+                fig.add_annotation(x=x_raw[0], y=max(y_raw)*1.08, text=txt, showarrow=False,
+                                  font=dict(size=9), align="left",
+                                  bgcolor="rgba(255,255,255,0.8)", row=row, col=col)
+
+            if row == rows:
+                fig.update_xaxes(title_text="Time (ns)", row=row, col=col)
+            if col == 1:
+                fig.update_yaxes(title_text="P(|1>)", row=row, col=col)
+
+        fig.update_layout(height=420*rows, width=540*cols, title_text="Rabi Oscillation Fit", title_x=0.5)
+        return fig

qubitclient/draw/s21peakpltplotter.py

@@ -0,0 +1,67 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from .pltplotter import QuantumDataPltPlotter
+
+class S21PeakDataPltPlotter(QuantumDataPltPlotter):
+    def __init__(self):
+        super().__init__("s21peak")
+
+    def plot_result_npy(self, **kwargs):
+        result = kwargs.get('result')
+        dict_param = kwargs.get('dict_param')
+
+        dict_param = dict_param.item()
+
+        image = dict_param["image"]
+        q_list = image.keys()
+        x_list = []
+        amp_list = []
+        phi_list = []
+        q_name_list =[]
+        for idx, q_name in enumerate(q_list):
+            image_q = image[q_name]
+            x = image_q[0]
+            amp = image_q[1]
+            phi = image_q[2]
+            x_list.append((x))
+            amp_list.append((amp))
+            phi_list.append((phi))
+            q_name_list.append(q_name)
+        peaks_list = result['peaks']
+        confs_list = result['confs']
+
+        nums = len(x_list)
+        row = (nums // 3) + 1 if nums % 3 != 0 else nums // 3
+        col = 3
+
+        fig = plt.figure(figsize=(20, 20))
+        for i in range(len(x_list)):
+            x = x_list[i]
+            y1 = amp_list[i]
+            y2 = phi_list[i]
+            peaks = peaks_list[i]
+            confs = confs_list[i]
+
+            ax = fig.add_subplot(row, col, i + 1)
+            ax.plot(x, y1, 'b-', label='Amp Curve', linewidth=2)
+            ax.plot(x, y2, c='green', label='Phi Curve')
+            for j in range(len(peaks)):
+                ax.scatter(x[peaks[j]], y1[peaks[j]],
+                color = 'red', marker = '*', s = 100,
+                label = f'peak (conf: {confs[j]:.2f})',
+                zorder = 5)
+                ax.annotate(f'{confs[j]:.2f}',
+                (x[peaks[j]], y1[peaks[j]]),
+                textcoords = "offset points",
+                xytext = (0, 15), ha = 'center',
+                fontsize = 10, color = 'darkred',
+                label = f'(final (conf: {confs[j]:.2f})')
+                ax.axvline(x[peaks[j]], color="red", linestyle='--', alpha=0.8)
+                ax.set_title(f'{q_name_list[i]}', fontsize=14, fontweight='bold', pad=15)
+                # ax.legend()
+            plt.tight_layout()
+
+
+
+        return fig
+

qubitclient/draw/s21peakplyplotter.py

@@ -0,0 +1,124 @@
+from .plyplotter import QuantumDataPlyPlotter
+import numpy as np
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+class S21PeakDataPlyPlotter(QuantumDataPlyPlotter):
+
+    def __init__(self):
+        super().__init__("s21peak")
+
+
+    def plot_result_npy(self, **kwargs):
+
+        result_param = kwargs.get('result')
+        dict_param = kwargs.get('dict_param')
+        dict_param = dict_param.item()
+
+        image = dict_param["image"]
+        q_list = image.keys()
+        x_list = []
+        amp_list = []
+        phi_list = []
+        qname_list=[]
+        for idx, q_name in enumerate(q_list):
+            image_q = image[q_name]
+            x = image_q[0]
+            amp = image_q[1]
+            phi = image_q[2]
+            x_list.append((x))
+            amp_list.append((amp))
+            phi_list.append((phi))
+            qname_list.append(q_name)
+
+
+
+
+        peaks_list = result_param['peaks']
+        confs_list = result_param['confs']
+
+        nums = len(x_list)
+        row = (nums // 3) + 1 if nums % 3 != 0 else nums // 3
+        col = 3
+
+        fig = make_subplots(
+            rows=row, cols=col,
+            subplot_titles=qname_list,
+            vertical_spacing=0.015,
+            horizontal_spacing=0.1
+            # x_title="Bias",
+            # y_title="Frequency (GHz)"
+        )
+
+        for i in range(len(x_list)):
+            x = x_list[i]
+            y1 = amp_list[i]
+            y2 = phi_list[i]
+            peaks = peaks_list[i]
+            confs = confs_list[i]
+
+            current_row = i // col + 1
+            current_col = i % col + 1
+
+            # 添加幅度曲线
+            fig.add_trace(
+                go.Scatter(x=x, y=y1, mode='lines',
+                           name='Amp Curve', line=dict(color='blue', width=2)),
+                row=current_row, col=current_col
+            )
+
+            # 添加相位曲线
+            fig.add_trace(
+                go.Scatter(x=x, y=y2, mode='lines',
+                           name='Phi Curve', line=dict(color='green')),
+                row=current_row, col=current_col
+            )
+
+            # 添加峰值点
+            for j in range(len(peaks)):
+                peak_x = x[peaks[j]]
+                peak_y = y1[peaks[j]]
+                conf = confs[j]
+
+                fig.add_trace(
+                    go.Scatter(x=[peak_x], y=[peak_y], mode='markers',
+                               marker=dict(symbol='star', size=12, color='red')),
+                               row=current_row, col=current_col
+                               )
+
+                # 添加峰值标注
+                fig.add_annotation(
+                    x=peak_x, y=peak_y,
+                    text=f'{conf:.2f}',
+                    showarrow=False,
+                    ax=0, ay=-30,
+                    font=dict(size=10, color='darkred'),
+                    row=current_row, col=current_col
+                )
+
+                # 添加垂直线
+                fig.add_vline(
+                    x=peak_x, line_dash="dash",
+                    line_color="red", opacity=0.8,
+                    row=current_row, col=current_col
+                )
+
+                # 更新布局配置
+                fig.update_layout(
+                    height=500 * row,
+                    width=900 * col,
+                    margin=dict(r=60, t=60, b=60, l=60),
+                    showlegend=False
+                )
+
+                fig.update_xaxes(
+                    title_text="Bias",
+                    title_font=dict(size=10),  # 缩小字体
+                    title_standoff=8  # 增加标题与坐标轴的距离（单位：像素）
+                )
+                fig.update_yaxes(
+                    title_text="Frequency (GHz)",
+                    title_font=dict(size=10),
+                    title_standoff=8
+                )
+        return fig

qubitclient/draw/s21vfluxpltplotter.py

@@ -0,0 +1,84 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from .pltplotter import QuantumDataPltPlotter
+
+
+class S21VfluxDataPltPlotter(QuantumDataPltPlotter):
+    def __init__(self):
+        super().__init__("s21vflux")
+
+    def plot_result_npy(self, **kwargs):
+        result = kwargs.get('result')
+        dict_param = kwargs.get('dict_param')
+
+        data = dict_param.item()
+        image = data["image"]
+        q_list = image.keys()
+        volt_list = []
+        freq_list = []
+        s_list = []
+        q_name_list=[]
+        for idx, q_name in enumerate(q_list):
+            image_q = image[q_name]
+
+            volt = image_q[0]
+            freq = image_q[1]
+            s = image_q[2]
+            volt_list.append(volt)
+            freq_list.append(freq)
+            s_list.append(s)
+            q_name_list.append(q_name)
+        coscurves_list = result['coscurves_list']
+        cosconfs_list = result['cosconfs_list']
+        lines_list = result['lines_list']
+        lineconfs_list = result['lineconfs_list']
+
+
+        nums = len(volt_list) * 2
+        row = (nums // 2) + 1 if nums % 2 != 0 else nums // 2
+        col = 2
+
+        fig, axes = plt.subplots(row, col, figsize=(10 * col, 4 * row))
+
+        axes = axes.flatten()  # Flatten in case of multiple rows
+
+        for ii in range(nums):
+            ax = axes[ii]
+
+            volt = volt_list[ii//2]
+            freq = freq_list[ii//2]
+            s = s_list[ii//2]
+
+            c = ax.pcolormesh(freq, volt, s.T, shading='auto', cmap='viridis')
+            fig.colorbar(c, ax=ax, label='Intensity')
+            if (ii % 2 != 0):
+                centcol = len(freq) // 2
+
+                if coscurves_list[ii// 2]:
+                    for j, curve in enumerate(coscurves_list[ii// 2]):
+                        final_x_cos = [item[0] for item in curve]
+                        final_y_cos = [item[1] for item in curve]
+                        ax.plot(final_x_cos, final_y_cos, 'r')
+                        if centcol < len(final_x_cos):
+                            ax.text(final_x_cos[centcol], final_y_cos[centcol],
+                                    f"conf:{cosconfs_list[ii// 2][j]:.2f}", color='r', fontsize=12)
+
+                if lines_list[ii// 2]:
+                    for j, line in enumerate(lines_list[ii// 2]):
+                        final_x_line = [item[0] for item in line]
+                        final_y_line = [item[1] for item in line]
+                        ax.plot(final_x_line, final_y_line, 'r')
+                        if centcol < len(final_x_line):
+                            ax.text(final_x_line[centcol], final_y_line[centcol],
+                                    f"conf:{lineconfs_list[ii// 2][j]:.2f}", color='r', fontsize=12)
+
+            # ax.set_title('Smoothed Heatmap')
+            ax.set_xlabel('X-axis')
+            ax.set_ylabel('Y-axis')
+            ax.set_title(f"{q_name_list[ii//2]}")
+        # Hide unused subplots if any
+        for jj in range(nums, len(axes)):
+            fig.delaxes(axes[jj])
+
+        fig.tight_layout()
+        return fig  # ✅ 返回 Figure 对象