QuLab 2.10.10__cp313-cp313-macosx_10_13_universal2.whl

qulab/visualization/plot_layout.py

@@ -0,0 +1,408 @@
+import functools
+import operator
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib import cm
+from matplotlib.colors import Normalize
+
+layout_example = {
+    'qubits': {
+        'Q0': {
+            'pos': (0, 1)
+        },
+        'Q1': {
+            'pos': (1, 0)
+        },
+        'Q2': {
+            'pos': (0, -1)
+        },
+        'Q3': {
+            'pos': (-1, 0)
+        }
+    },
+    'couplers': {
+        'C0': {
+            'qubits': ['Q0', 'Q1'],
+        },
+        'C1': {
+            'qubits': ['Q1', 'Q2'],
+        },
+        'C2': {
+            'qubits': ['Q2', 'Q3'],
+        },
+        'C3': {
+            'qubits': ['Q0', 'Q3'],
+        }
+    }
+}
+
+
+def complete_layout(layout):
+    for c in layout['couplers']:
+        qubits = layout['couplers'][c]['qubits']
+        for q in qubits:
+            if q not in layout['qubits']:
+                raise ValueError('qubit {} not found'.format(q))
+            if 'couplers' not in layout['qubits'][q]:
+                layout['qubits'][q]['couplers'] = []
+            if c not in layout['qubits'][q]['couplers']:
+                layout['qubits'][q]['couplers'].append(c)
+    return layout
+
+
+def get_shared_coupler(layout, q1, q2):
+    for c in layout['qubits'][q1]['couplers']:
+        if q2 in layout['couplers'][c]['qubits']:
+            return c
+    return None
+
+
+def get_neighbours(layout,
+                   qubit_or_coupler,
+                   distance=1,
+                   type='qubit',
+                   inrange=False):
+
+    def _qubits(couplers):
+        ret = set()
+        for c in couplers:
+            ret = ret | set(layout['couplers'][c]['qubits'])
+        return ret
+
+    def _couplers(qubits):
+        ret = set()
+        for q in qubits:
+            ret = ret | set(layout['qubits'][q]['couplers'])
+        return ret
+
+    couplers = []
+    neighbors = []
+
+    if qubit_or_coupler in layout['qubits']:
+        couplers.append(set(layout['qubits'][qubit_or_coupler]['couplers']))
+        neighbors.append(_qubits(couplers[0]) - {qubit_or_coupler})
+    elif qubit_or_coupler in layout['couplers']:
+        if type == 'coupler':
+            distance += 1
+        neighbors.append(set(layout['couplers'][qubit_or_coupler]['qubits']))
+        couplers.append({qubit_or_coupler})
+    else:
+        raise ValueError(f'qubit or coupler {qubit_or_coupler!r} not found')
+    distance -= 1
+
+    while distance > 0:
+        couplers.append(_couplers(neighbors[-1]) - couplers[-1])
+        neighbors.append(_qubits(couplers[-1]) - neighbors[-1])
+        distance -= 1
+
+    if type == 'qubit':
+        if inrange:
+            return list(functools.reduce(operator.or_, neighbors, set()))
+        else:
+            return list(neighbors[-1])
+    elif type == 'coupler':
+        if inrange:
+            if qubit_or_coupler in couplers[0]:
+                couplers = couplers[1:]
+            return list(functools.reduce(operator.or_, couplers, set()))
+        else:
+            return list(couplers[-1])
+    else:
+        raise ValueError("type must be 'qubit' or 'coupler'")
+
+
+def plot_range(ax,
+               path,
+               text='',
+               color=None,
+               text_color='k',
+               bounder_color='k',
+               lw=0.5,
+               fontsize=9):
+    x, y = path
+    center = x.mean(), y.mean()
+
+    if color:
+        ax.fill(x, y, color=color, lw=0)
+
+    if lw is not None and lw > 0:
+        ax.plot(np.hstack([x, [x[0]]]),
+                np.hstack([y, [y[0]]]),
+                color=bounder_color,
+                lw=lw)
+
+    if text:
+        ax.text(center[0],
+                center[1],
+                text,
+                ha='center',
+                va='center',
+                color=text_color,
+                fontsize=fontsize)
+
+
+def circle_path(pos, r, n=40):
+    x, y = pos
+    t = 2 * np.pi * np.linspace(0, 1, n, endpoint=False)
+    xx = r * np.cos(t) + x
+    yy = r * np.sin(t) + y
+    return xx, yy
+
+
+def circle_link_path(pos1, pos2, r1, r2, width, n=20):
+    width = min(2 * max(r1, r2), width)
+
+    x1, y1 = pos1
+    x2, y2 = pos2
+
+    phi = np.arctan2(y2 - y1, x2 - x1)
+
+    theta1 = np.arcsin(width / 2 / r1)
+    theta2 = np.arcsin(width / 2 / r2)
+
+    t = np.linspace(-theta1, theta1, n) + phi
+    xx1 = r1 * np.cos(t) + x1
+    yy1 = r1 * np.sin(t) + y1
+
+    t = np.linspace(-theta2, theta2, n) + phi + np.pi
+    xx2 = r2 * np.cos(t) + x2
+    yy2 = r2 * np.sin(t) + y2
+
+    return np.hstack([xx2[-1], xx1,
+                      xx2[:-1]]), np.hstack([yy2[-1], yy1, yy2[:-1]])
+
+
+def circle_half_directed_link_path(pos1, pos2, r1, r2, width, n=20):
+    width = min(max(r1, r2), width)
+
+    x1, y1 = pos1
+    x2, y2 = pos2
+
+    phi = np.arctan2(y2 - y1, x2 - x1)
+
+    theta1 = np.arcsin(width / r1)
+    theta2 = np.arcsin(width / r2)
+
+    t = np.linspace(0.2 * theta1, theta1, n) + phi
+    xx1 = r1 * np.cos(t) + x1
+    yy1 = r1 * np.sin(t) + y1
+
+    t = np.linspace(-theta2, -0.2 * theta2, n) + phi + np.pi
+    xx2 = r2 * np.cos(t) + x2
+    yy2 = r2 * np.sin(t) + y2
+
+    v = (xx2[0] - xx1[-1]) + 1j * (yy2[0] - yy1[-1])
+    c = (xx2[0] + xx1[-1]) / 2 + 1j * (yy2[0] + yy1[-1]) / 2
+
+    a = np.array([1 / 6, 1 / 12]) + 1j * np.array([0, 0.4 * width / np.abs(v)])
+    a = a * v + c
+
+    return np.hstack([xx2[-1], xx1, a.real,
+                      xx2[:-1]]), np.hstack([yy2[-1], yy1, a.imag, yy2[:-1]])
+
+
+def draw(layout, ax=None, qubit_cbar=True, coupler_cbar=True, origin='upper'):
+    if ax is None:
+        ax = plt.gca()
+
+    for qubit in layout['qubits'].values():
+        pos = qubit['pos']
+        if origin == 'upper':
+            pos = pos[0], -pos[1]
+        path = circle_path(pos, qubit.get('radius', 0.5))
+        plot_range(ax,
+                   path,
+                   qubit.get('text', ''),
+                   qubit.get('color', None),
+                   lw=qubit.get('lw', 0.5),
+                   fontsize=qubit.get('fontsize', 9),
+                   text_color=qubit.get('text_color', 'k'),
+                   bounder_color=qubit.get('bounder_color', 'k'))
+
+    for coupler in layout['couplers'].values():
+        q1, q2 = coupler['qubits']
+        pos1 = layout['qubits'][q1]['pos']
+        pos2 = layout['qubits'][q2]['pos']
+        if origin == 'upper':
+            pos1 = pos1[0], -pos1[1]
+            pos2 = pos2[0], -pos2[1]
+        r1 = layout['qubits'][q1].get('radius', 0.5)
+        r2 = layout['qubits'][q2].get('radius', 0.5)
+        width = coupler.get('width', 0.5)
+        lw = coupler.get('lw', 0.5)
+
+        path = circle_link_path(pos1, pos2, r1, r2, width)
+        plot_range(ax,
+                   path,
+                   coupler.get('text', ''),
+                   color=coupler.get('color', None),
+                   lw=0,
+                   fontsize=coupler.get('fontsize', 9),
+                   text_color=coupler.get('text_color', 'k'))
+        if lw > 0:
+            x, y = circle_link_path(pos1, pos2, r1, r2, width, n=2)
+            ax.plot(x[:2],
+                    y[:2],
+                    lw=lw,
+                    color=coupler.get('bounder_color', 'k'))
+            ax.plot(x[2:],
+                    y[2:],
+                    lw=lw,
+                    color=coupler.get('bounder_color', 'k'))
+
+    ax.axis('equal')
+    ax.set_axis_off()
+
+    if qubit_cbar and layout['__colorbar__']['qubit']['norm'] is not None:
+        cbar = plt.colorbar(cm.ScalarMappable(
+            norm=layout['__colorbar__']['qubit']['norm'],
+            cmap=layout['__colorbar__']['qubit']['cmap']),
+                            ax=ax,
+                            location='bottom',
+                            orientation='horizontal',
+                            pad=0.01,
+                            shrink=0.5)
+        cbar.set_label(layout['__colorbar__']['qubit']['label'])
+    if coupler_cbar and layout['__colorbar__']['coupler']['norm'] is not None:
+        cbar = plt.colorbar(cm.ScalarMappable(
+            norm=layout['__colorbar__']['coupler']['norm'],
+            cmap=layout['__colorbar__']['coupler']['cmap']),
+                            ax=ax,
+                            location='bottom',
+                            orientation='horizontal',
+                            pad=0.01,
+                            shrink=0.5)
+        cbar.set_label(layout['__colorbar__']['coupler']['label'])
+
+
+def get_norm(params, elms, vmin=None, vmax=None):
+    data = []
+    for elm in elms:
+        if elm in params:
+            if isinstance(params[elm], (int, float)):
+                data.append(params[elm])
+            elif 'value' in params[elm] and params[elm]['value'] is not None:
+                data.append(params[elm]['value'])
+    if data:
+        if vmin is None:
+            vmin = min(data)
+        if vmax is None:
+            vmax = max(data)
+        return Normalize(vmin=vmin, vmax=vmax)
+    else:
+        return None
+
+
+def fill_layout(layout,
+                params,
+                qubit_size=0.5,
+                coupler_size=0.5,
+                qubit_fontsize=9,
+                coupler_fontsize=9,
+                qubit_color=None,
+                coupler_color=None,
+                qubit_cmap='hot',
+                qubit_vmax=None,
+                qubit_vmin=None,
+                qubit_norm=None,
+                coupler_cmap='binary',
+                coupler_vmax=None,
+                coupler_vmin=None,
+                coupler_norm=None,
+                bounder_color='k',
+                lw=0.5):
+
+    qubit_cmap = plt.get_cmap(qubit_cmap)
+    coupler_cmap = plt.get_cmap(coupler_cmap)
+
+    if qubit_norm is None:
+        qubit_norm = get_norm(params,
+                              layout['qubits'].keys(),
+                              vmin=qubit_vmin,
+                              vmax=qubit_vmax)
+    if coupler_norm is None:
+        coupler_norm = get_norm(params,
+                                layout['couplers'].keys(),
+                                vmin=coupler_vmin,
+                                vmax=coupler_vmax)
+    layout['__colorbar__'] = {
+        'coupler': {
+            'cmap': coupler_cmap,
+            'norm': coupler_norm,
+            'label': ''
+        },
+        'qubit': {
+            'cmap': qubit_cmap,
+            'norm': qubit_norm,
+            'label': ''
+        }
+    }
+
+    for qubit in layout['qubits']:
+        layout['qubits'][qubit]['radius'] = qubit_size
+        layout['qubits'][qubit]['fontsize'] = qubit_fontsize
+        if qubit in params:
+            layout['qubits'][qubit]['lw'] = 0
+            if not isinstance(params[qubit], dict):
+                params[qubit] = {'value': params[qubit]}
+            if 'color' in params[qubit]:
+                layout['qubits'][qubit]['color'] = params[qubit]['color']
+            elif 'value' in params[qubit] and params[qubit][
+                    'value'] is not None:
+                layout['qubits'][qubit]['color'] = qubit_cmap(
+                    qubit_norm(params[qubit]['value']))
+            else:
+                layout['qubits'][qubit]['color'] = qubit_color
+                if qubit_color is None:
+                    layout['qubits'][qubit]['lw'] = lw
+            layout['qubits'][qubit]['radius'] = params[qubit].get(
+                'radius', qubit_size)
+            layout['qubits'][qubit]['fontsize'] = params[qubit].get(
+                'fontsize', qubit_fontsize)
+            layout['qubits'][qubit]['text'] = params[qubit].get('text', '')
+            layout['qubits'][qubit]['text_color'] = params[qubit].get(
+                'text_color', 'k')
+        else:
+            layout['qubits'][qubit]['color'] = qubit_color
+            if qubit_color is None:
+                layout['qubits'][qubit]['lw'] = lw
+            else:
+                layout['qubits'][qubit]['lw'] = 0
+            layout['qubits'][qubit]['bounder_color'] = bounder_color
+
+    for coupler in layout['couplers']:
+        layout['couplers'][coupler]['width'] = coupler_size
+        layout['couplers'][coupler]['fontsize'] = coupler_fontsize
+        layout['couplers'][coupler]['bounder_color'] = bounder_color
+        if coupler in params:
+            layout['couplers'][coupler]['lw'] = 0
+            if not isinstance(params[coupler], dict):
+                params[coupler] = {'value': params[coupler]}
+            if 'color' in params[coupler]:
+                layout['couplers'][coupler]['color'] = params[coupler]['color']
+            elif 'value' in params[coupler] and params[coupler][
+                    'value'] is not None:
+                layout['couplers'][coupler]['color'] = coupler_cmap(
+                    coupler_norm(params[coupler]['value']))
+            else:
+                layout['couplers'][coupler]['color'] = coupler_color
+                if coupler_color is None:
+                    layout['couplers'][coupler]['lw'] = lw
+            layout['couplers'][coupler]['width'] = params[coupler].get(
+                'width', coupler_size)
+            layout['couplers'][coupler]['fontsize'] = params[coupler].get(
+                'fontsize', coupler_fontsize)
+            layout['couplers'][coupler]['text'] = params[coupler].get(
+                'text', '')
+            layout['couplers'][coupler]['text_color'] = params[coupler].get(
+                'text_color', 'k')
+        else:
+            layout['couplers'][coupler]['color'] = coupler_color
+            if coupler_color is None:
+                layout['couplers'][coupler]['lw'] = lw
+            else:
+                layout['couplers'][coupler]['lw'] = 0
+            layout['couplers'][coupler]['bounder_color'] = bounder_color
+
+    return layout

qulab/visualization/plot_seq.py

@@ -0,0 +1,242 @@
+import itertools
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.patches import PathPatch
+from matplotlib.path import Path
+
+
+def cycle(x0, y0, r, a=0, b=2 * np.pi):
+    t = np.linspace(a, b, 101)
+    x = r * np.cos(t) + x0
+    y = r * np.sin(t) + y0
+    return x, y
+
+
+def plotSquare(xc, yc, xs, ys, radius=0, color='C0', ax=None):
+    ax = plt.gca() if ax is None else ax
+
+    l, r, b, u = xc - xs / 2, xc + xs / 2, yc - ys / 2, yc + ys / 2
+    x = np.linspace(l + radius, r - radius, 2)
+    y = np.linspace(b + radius, u - radius, 2)
+
+    ax.plot(x, [u, u], color=color)
+    ax.plot(x, [b, b], color=color)
+    ax.plot([l, l], y, color=color)
+    ax.plot([r, r], y, color=color)
+
+    xx, yy = cycle(x[-1], y[-1], radius, 0, np.pi / 2)
+    ax.plot(xx, yy, color=color)
+
+    xx, yy = cycle(x[0], y[-1], radius, np.pi / 2, np.pi)
+    ax.plot(xx, yy, color=color)
+
+    xx, yy = cycle(x[0], y[0], radius, np.pi, np.pi * 3 / 2)
+    ax.plot(xx, yy, color=color)
+
+    xx, yy = cycle(x[-1], y[0], radius, np.pi * 3 / 2, np.pi * 2)
+    ax.plot(xx, yy, color=color)
+
+
+def plotMesure(x0=0, y0=0, size=1, color='C0', ax=None):
+
+    ax = plt.gca() if ax is None else ax
+
+    x, y = cycle(x0, y0 - 0.37 * size, 0.57 * size, np.pi / 4, np.pi * 3 / 4)
+    ax.plot(x, y, color=color)
+
+    plotSquare(x0, y0, size, 0.8 * size, radius=0.2 * size, color=color, ax=ax)
+
+    angle = np.pi / 6
+
+    ax.arrow(x0,
+             y0 - 0.25 * size,
+             0.55 * size * np.sin(angle),
+             0.55 * size * np.cos(angle),
+             head_width=0.07 * size,
+             head_length=0.1 * size,
+             color=color)
+
+
+def plot_seq(ax, waves, measure=[1], gap=4, maxTime=20, xlim=None):
+    t = np.linspace(0, maxTime, 1001)
+    tt = np.linspace(0, maxTime - gap, 1001)
+    styles = ['-', '--', ':', '-.']
+    colors = ['C0', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9']
+    for i, (wavgroup, color) in enumerate(zip(waves, itertools.cycle(colors))):
+        if i in measure:
+            time = tt
+        else:
+            time = t
+        if not isinstance(wavgroup, tuple):
+            wavgroup = (wavgroup, )
+
+        for wav, style in zip(wavgroup, itertools.cycle(styles)):
+            ax.plot(time, wav(time) - gap * i, style, color=color)
+            if i in measure:
+                plotMesure(maxTime - gap / 2,
+                           -gap * i,
+                           gap,
+                           color='black',
+                           ax=ax)
+
+    ax.axis('equal')
+
+    ax.spines['left'].set_visible(False)
+    ax.spines['right'].set_visible(False)
+    ax.spines['bottom'].set_visible(False)
+    ax.spines['top'].set_visible(False)
+    ax.set_xticks([])
+    ax.set_yticks([])
+    if xlim is not None:
+        ax.set_xlim(xlim)
+
+
+def make_path(fx, fy, dfx, dfy, t):
+
+    def p(fx, fy, dfx, dfy, t0, t1):
+        x1, x2 = fx(t0), fx(t1)
+        y1, y2 = fy(t0), fy(t1)
+        dx1, dx2 = dfx(t0), dfx(t1)
+        dy1, dy2 = dfy(t0), dfy(t1)
+
+        xp = (dy1 * dx2 * x1 - dy2 * dx1 * x2 - dx1 * dx2 *
+              (y1 - y2)) / (dy1 * dx2 - dy2 * dx1)
+
+        yp = (dy1 * dx2 * y2 - dy2 * dx1 * y1 + dy1 * dy2 *
+              (x1 - x2)) / (dy1 * dx2 - dy2 * dx1)
+
+        return xp, yp
+
+    path = [(fx(t[0]), fy(t[0]))]
+    codes = [Path.MOVETO]
+
+    for i in range(1, len(t)):
+        x, y = p(fx, fy, dfx, dfy, t[i - 1], t[i])
+        path.append((x, y))
+        codes.append(Path.CURVE3)
+        path.append((fx(t[i]), fy(t[i])))
+        codes.append(Path.CURVE3)
+    return path, codes
+
+
+def plot_square(ax,
+                x=0,
+                y=0,
+                width=1,
+                hight=1,
+                r=0.2,
+                ls='-',
+                lw=2,
+                fc='none',
+                ec='black'):
+
+    path = np.array([(0, 1), (1 - 2 * r, 1), (1, 1), (1, 1 - 2 * r),
+                     (1, -1 + 2 * r), (1, -1), (1 - 2 * r, -1),
+                     (-1 + 2 * r, -1), (-1, -1), (-1, -1 + 2 * r),
+                     (-1, 1 - 2 * r), (-1, 1), (-1 + 2 * r, 1), (0, 1)])
+    path[:, 0] = path[:, 0] * width / 2 + x
+    path[:, 1] = path[:, 1] * hight / 2 + y
+    codes = [
+        Path.MOVETO,
+        Path.LINETO,
+        Path.CURVE3,
+        Path.CURVE3,
+        Path.LINETO,
+        Path.CURVE3,
+        Path.CURVE3,
+        Path.LINETO,
+        Path.CURVE3,
+        Path.CURVE3,
+        Path.LINETO,
+        Path.CURVE3,
+        Path.CURVE3,
+        Path.CLOSEPOLY,
+    ]
+    pp1 = PathPatch(Path(path, codes),
+                    ls=ls,
+                    lw=lw,
+                    fc=fc,
+                    ec=ec,
+                    transform=ax.transData)
+
+    ax.add_patch(pp1)
+
+
+def plot_measure(ax,
+                 x=0,
+                 y=0,
+                 size=1,
+                 r=0.2,
+                 ls='-',
+                 lw=2,
+                 fc='none',
+                 ec='black'):
+    width = size
+    hight = 0.8 * size
+    plot_square(ax, x, y, width, hight, r, ls, lw, fc, ec)
+
+    fx = lambda t: 0.5 * width * np.cos(t) + x
+    fy = lambda t: 0.5 * hight * np.sin(t) + y - 0.2 * hight
+    dfx = lambda t: -0.5 * width * np.sin(t)
+    dfy = lambda t: 0.5 * hight * np.cos(t)
+    t = np.linspace(1 / 6, 5 / 6, 5) * np.pi
+    path, codes = make_path(fx, fy, dfx, dfy, t)
+
+    pp1 = PathPatch(Path(path, codes),
+                    ls=ls,
+                    lw=lw,
+                    fc=fc,
+                    ec=ec,
+                    transform=ax.transData)
+
+    ax.add_patch(pp1)
+
+    angle = np.pi / 6
+
+    ax.arrow(x,
+             y - 0.25 * width,
+             0.55 * width * np.sin(angle),
+             0.55 * width * np.cos(angle),
+             head_width=0.07 * width,
+             head_length=0.1 * width,
+             lw=lw,
+             color=ec)
+
+    return (x - width / 2, x + width / 2)
+
+
+def plot_gate(ax,
+              x=0,
+              y=0,
+              size=1,
+              text="$U$",
+              ls='-',
+              lw=2,
+              r=0.2,
+              fc='none',
+              ec='black',
+              fontsize=16):
+    width = size
+    hight = 0.8 * size
+    plot_square(ax, x, y, width, hight, r, ls, lw, fc, ec)
+    ax.text(x, y, text, ha='center', va='center', color=ec, fontsize=fontsize)
+
+    return (x - width / 2, x + width / 2)
+
+
+def plot_waveform(ax,
+                  wav,
+                  offset,
+                  gaps=[],
+                  ec='black',
+                  fc='none',
+                  ls='-',
+                  lw=2):
+    t = np.linspace(wav.start, wav.stop, 1001)
+    points = wav(t) + offset
+    for a, b in gaps:
+        points[(t > a) * (t < b)] = np.nan
+    ax.plot(t, points, ls=ls, color=ec, lw=lw)
+    if fc != 'none':
+        ax.fill_between(t, points, offset, color=fc)