6965255504

Committed 23 Nov 2023 03:25AM UTC coverage: 43.601%. First build

Build # 6965255504

Build Type

push

github

Committed by

feihoo87

Commit Message

add var name in cbit

Run Details

182 of 306 new or added lines in 5 files covered. (59.48%)

7553 of 17323 relevant lines covered (43.6%)

3.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

57.82

/waveforms/qlisp/libs/stdlib.py

import re
from pathlib import Path

from numpy import mod, pi

from waveforms.waveform import (cos, cosPulse, gaussian, mixing, sin, square,
                                zero)
from waveforms.waveform_parser import wave_eval

from ..base import Capture
from ..library import Library

EPS = 1e-9

std = Library()
std.qasmLib = {
    'qelib1.inc': Path(__file__).parent.parent / 'qasm' / 'libs' / 'qelib1.inc'
}


@std.gate()
def u3(qubit, theta, phi, lambda_):
    yield (('U', theta, phi, lambda_), qubit)


@std.gate()
def u2(qubit, phi, lambda_):
    yield (('U', pi / 2, phi, lambda_), qubit)


@std.gate()
def u1(qubit, lambda_):
    yield (('U', 0, 0, lambda_), qubit)


@std.gate()
def H(qubit):
    yield (('u2', 0, pi), qubit)


@std.gate()
def U(q, theta, phi, lambda_):
    # yield (('rfUnitary', pi / 2, -lambda_), qubit)
    # yield (('rfUnitary', pi / 2, -pi - theta - lambda_), qubit)
    # yield (('P', theta + phi + lambda_), qubit)

    if abs(theta) < EPS:
        yield (('P', phi + lambda_), q)
    else:
        yield (('P', lambda_), q)
        if abs(theta - pi / 2) < EPS:
            yield (('rfUnitary', pi / 2, pi / 2), q)
        else:
            yield (('rfUnitary', pi / 2, 0), q)
            yield (('rfUnitary', pi / 2, pi - theta), q)
            yield (('P', theta), q)
        yield (('P', phi), q)


@std.gate()
def X(q):
    yield (('u3', pi, 0, pi), q)


@std.gate()
def Y(q):
    yield (('u3', pi, pi / 2, pi / 2), q)


@std.gate()
def Z(q):
    yield (('u1', pi), q)


@std.gate()
def S(q):
    yield (('u1', pi / 2), q)


@std.gate(name='-S')
def Sdg(q):
    yield (('u1', -pi / 2), q)


@std.gate()
def T(q):
    yield (('u1', pi / 4), q)


@std.gate(name='-T')
def Tdg(q):
    yield (('u1', -pi / 4), q)


@std.gate(name='X/2')
def sx(q):
    yield ('-S', q)
    yield ('H', q)
    yield ('-S', q)


@std.gate(name='-X/2')
def sxdg(q):
    yield ('S', q)
    yield ('H', q)
    yield ('S', q)


@std.gate(name='Y/2')
def sy(q):
    yield ('Z', q)
    yield ('H', q)


@std.gate(name='-Y/2')
def sydg(q):
    yield ('H', q)
    yield ('Z', q)


@std.gate()
def Rx(q, theta):
    yield (('u3', theta, -pi / 2, pi / 2), q)


@std.gate()
def Ry(q, theta):
    yield (('u3', theta, 0, 0), q)


@std.gate(name='W/2')
def W2(q):
    yield (('u3', pi / 2, -pi / 4, pi / 4), q)


@std.gate(name='-W/2')
def W2(q):
    yield (('u3', -pi / 2, -pi / 4, pi / 4), q)


@std.gate(name='V/2')
def W2(q):
    yield (('u3', pi / 2, -3 * pi / 4, 3 * pi / 4), q)


@std.gate(name='-V/2')
def W2(q):
    yield (('u3', -pi / 2, -3 * pi / 4, 3 * pi / 4), q)


@std.gate()
def Rz(q, phi):
    yield (('u1', phi), q)


@std.gate(2)
def Cnot(qubits):
    c, t = qubits
    yield ('H', t)
    yield ('CZ', (c, t))
    yield ('H', t)


@std.gate(2)
def crz(qubits, lambda_):
    c, t = qubits

    yield (('u1', lambda_ / 2), t)
    yield ('Cnot', (c, t))
    yield (('u1', -lambda_ / 2), t)
    yield ('Cnot', (c, t))


@std.opaque('Delay')
def delay(ctx, qubits, time):
    qubit, = qubits
    yield ('!add_time', time), qubit


@std.opaque('P')
def P(ctx, qubits, phi):
    # (('rfUnitary', pi / 2, arb_phase), qubit)
    # (('rfUnitary', pi / 2, arb_phase), qubit)
    # (('rfUnitary', pi / 2, phi / 2 + arb_phase + k * pi), qubit)
    # (('rfUnitary', pi / 2, phi / 2 + arb_phase + k * pi), qubit)
    import numpy as np

    from ..compiler import call_opaque

    phi += ctx.phases[qubits[0]]
    yield ('!set_phase', 0), qubits[0]
    x = 2 * np.pi * np.random.random()
    y = np.pi * np.random.randint(0, 2) + x

    call_opaque((('rfUnitary', pi / 2, x), *qubits), ctx, std)
    call_opaque((('rfUnitary', pi / 2, x), *qubits), ctx, std)
    call_opaque((('rfUnitary', pi / 2, phi / 2 + y), *qubits), ctx, std)
    call_opaque((('rfUnitary', pi / 2, phi / 2 + y), *qubits), ctx, std)


@std.opaque('Barrier')
def barrier(ctx, qubits):
    time = max(ctx.time[qubit] for qubit in qubits)
    for qubit in qubits:
        yield ('!set_time', time), qubit


@std.opaque('rfPulse')
def rfPulse(ctx, qubits, waveform):
    qubit, = qubits

    if isinstance(waveform, str):
        waveform = wave_eval(waveform)

    yield ('!play', waveform >> ctx.time[qubit]), ('RF', qubit)


@std.opaque('fluxPulse')
def fluxPulse(ctx, qubits, waveform):
    qubit, = qubits

    if isinstance(waveform, str):
        waveform = wave_eval(waveform)

    yield ('!play', waveform >> ctx.time[qubit]), ('Z', qubit)


@std.opaque('Pulse')
def Pulse(ctx, qubits, channel, waveform):

    if isinstance(waveform, str):
        waveform = wave_eval(waveform)

    t = max(ctx.time[qubit] for qubit in qubits)

    yield ('!play', waveform >> t), (channel, *qubits)


@std.opaque('setBias')
def setBias(ctx, qubits, channel, bias, edge=0, buffer=0):
    if channel.startswith('coupler.') and len(qubits) == 2:
        qubits = sorted(qubits)
    yield ('!set_bias', (bias, edge, buffer)), (channel, *qubits)
    time = max(ctx.time[qubit] for qubit in qubits)
    for qubit in qubits:
        yield ('!set_time', time + buffer), qubit


@std.opaque('I')
def I(ctx, qubits):
    qubit = qubits[0]
    yield ('!play', zero()), ('RF', qubit)
    yield ('!play', zero()), ('Z', qubit)
    yield ('!play', zero()), ('readoutLine.RF', qubit)


def _rfUnitary(ctx, qubits, theta, phi, level1=0, level2=1):
    from numpy import interp

    qubit, = qubits

    if theta < 0:
        theta = -theta
        phi += pi
    theta = mod(theta, 2 * pi)
    if theta > pi:
        theta = 2 * pi - theta
        phi += pi

    phi = mod(
        phi + ctx.phases_ext[qubit][level1] - ctx.phases_ext[qubit][level2],
        2 * pi)
    phi = phi if abs(level2 - level1) % 2 else phi - pi
    if phi > pi:
        phi -= 2 * pi
    phi = phi / (level2 - level1)

    shape = ctx.params.get('shape', 'CosPulse')
    buffer = ctx.params.get('buffer', 0)
    alpha = ctx.params.get('alpha', 1)
    beta = ctx.params.get('beta', 0)
    delta = ctx.params.get('delta', 0)
    edge = ctx.params.get('edge', 0)
    edge_type = ctx.params.get('edge_type', 'cos')

    phase = pi * interp(phi / pi, *ctx.params['phase'])

    pulseLib = {
        'CosPulse': cosPulse,
        'Gaussian': gaussian,
        'Square': square,
        'cosPulse': cosPulse,
        'gaussian': gaussian,
        'square': square,
        'DC': square,
    }

    while theta > 0:
        if theta > pi / 2:
            theta1 = pi / 2
            theta -= pi / 2
        else:
            theta1 = theta
            theta = 0

        duration = interp(theta1 / pi, *ctx.params['duration'])
        amp = interp(theta1 / pi, *ctx.params['amp'])
        if shape == 'square':
            pulse = square(duration, type=edge_type, edge=edge)
        else:
            pulse = pulseLib[shape](duration)

        if duration > 0 and amp > 0:
            I, Q = mixing(amp * alpha * pulse,
                          phase=phase,
                          freq=delta,
                          DRAGScaling=beta / alpha)
            t = (duration + buffer) / 2 + ctx.time[qubit]
            if 'levels' in ctx.params:
                freq = (ctx.params['levels'][level2] -
                        ctx.params['levels'][level1]) / (level2 - level1)
            else:
                freq = ctx.params['frequency']
            wav, _ = mixing(I >> t, Q >> t, freq=freq)
            yield ('!play', wav), ('RF', qubit)
            yield ('!add_time', duration + buffer), qubit


@std.opaque('rfUnitary')
def rfUnitary(ctx, qubits, theta, phi):
    yield from _rfUnitary(ctx, qubits, theta, phi)


@std.opaque('rfUnitary', type='BB1')
def rfUnitary_BB1(ctx, qubits, theta, phi):
    import numpy as np

    p1 = np.arccos(-theta / (4 * pi))
    p2 = 3 * p1
    p1, p2 = p1 + phi, p2 + phi

    yield from _rfUnitary(ctx, qubits, pi, p1)
    yield from _rfUnitary(ctx, qubits, pi, p2)
    yield from _rfUnitary(ctx, qubits, pi, p2)
    yield from _rfUnitary(ctx, qubits, pi, p1)
    yield from _rfUnitary(ctx, qubits, theta, phi)


@std.opaque('Measure')
def measure(ctx, qubits, cbit=None):
    from waveforms import cos, exp, pi, step

    def extract_variable_and_index_if_match(s):
        pattern = r'^(\w+)\[(\d+)\]$'
        match = re.search(pattern, s)

        if match:
            name, index = match.groups()
            return (name, int(index))
        else:
            return (s, 0)

    qubit, = qubits

    if cbit is None:
        if len(ctx.measures['result']) == 0:
            cbit = 0
        else:
            cbit = max(ctx.measures['result'].keys()) + 1

    if isinstance(cbit, int):
        cbit = ('result', cbit)
    elif isinstance(cbit, str):
        cbit = extract_variable_and_index_if_match(cbit)

    # lo = ctx.cfg._getReadoutADLO(qubit)
    amp = ctx.params['amp']
    duration = ctx.params['duration']
    frequency = ctx.params['frequency']
    bias = ctx.params.get('bias', None)
    signal = ctx.params.get('signal', 'state')
    ring_up_amp = ctx.params.get('ring_up_amp', amp)
    ring_up_time = ctx.params.get('ring_up_time', 50e-9)
    rsing_edge_time = ctx.params.get('rsing_edge_time', 5e-9)

    try:
        w = ctx.params['w']
        weight = None
    except:
        weight = ctx.params.get('weight',
                                f'square({duration}) >> {duration/2}')
        w = None

    t = ctx.time[qubit]

    # phi = 2 * np.pi * (lo - frequency) * t

    pulse = (ring_up_amp * (step(rsing_edge_time) >> t) - (ring_up_amp - amp) *
             (step(rsing_edge_time) >>
              (t + ring_up_time)) - amp * (step(rsing_edge_time) >>
                                           (t + duration)))
    yield ('!play', pulse * cos(2 * pi * frequency)), ('readoutLine.RF', qubit)
    if bias is not None:
        yield ('!set_bias', bias), ('Z', qubit)

    # pulse = square(2 * duration) >> duration
    # ctx.channel['readoutLine.AD.trigger', qubit] |= pulse.marker

    params = {k: v for k, v in ctx.params.items()}
    params['w'] = w
    params['weight'] = weight
    if not (cbit[0] == 'state' and cbit[1] < 0):
        yield ('!capture', Capture(qubit, cbit, ctx.time[qubit], signal,
                                   params)), cbit
    yield ('!set_time', t + duration), qubit
    yield ('!set_phase', 0), qubit


def parametric(ctx, qubits):
    t = max(ctx.time[q] for q in qubits)

    duration = ctx.params['duration']
    amp = ctx.params['amp']
    offset = ctx.params['offset']
    frequency = ctx.params['frequency']

    if duration > 0:
        pulse = square(duration) >> duration / 2
        pulse = offset * pulse + amp * pulse * sin(2 * pi * frequency)
        yield ('!play', pulse >> t), ('coupler.Z', *qubits)

    for qubit in qubits:
        yield ('!set_time', t + duration), qubit

    yield ('!add_phase', ctx.params['phi1']), qubits[0]
    yield ('!add_phase', ctx.params['phi2']), qubits[1]


@std.opaque('CZ')
def CZ(ctx, qubits):
    t = max(ctx.time[q] for q in qubits)

    duration = ctx.params['duration']
    amp = ctx.params['amp']

    if amp != 0 and duration > 0:
        pulse = amp * (cos(pi / duration) * square(duration)) >> duration / 2
        yield ('!play', pulse >> t), ('coupler.Z', *qubits)

    for qubit in qubits:
        yield ('!set_time', t + duration), qubit

    yield ('!add_phase', ctx.params['phi1']), qubits[0]
    yield ('!add_phase', ctx.params['phi2']), qubits[1]


@std.opaque('CZ', type='parametric')
def CZ(ctx, qubits):
    yield from parametric(ctx, qubits)


@std.opaque('iSWAP', type='parametric')
def iSWAP(ctx, qubits):
    yield from parametric(ctx, qubits)

1	import re	9✔
2	from pathlib import Path	9✔
3
4	from numpy import mod, pi	9✔
5
6	from waveforms.waveform import (cos, cosPulse, gaussian, mixing, sin, square,	9✔
7	zero)
8	from waveforms.waveform_parser import wave_eval	9✔
9
10	from ..base import Capture	9✔
11	from ..library import Library	9✔
12
13	EPS = 1e-9	9✔
14
15	std = Library()	9✔
16	std.qasmLib = {	9✔
17	'qelib1.inc': Path(__file__).parent.parent / 'qasm' / 'libs' / 'qelib1.inc'
18	}
19
20
21	@std.gate()	9✔
22	def u3(qubit, theta, phi, lambda_):	9✔
NEW 23	yield (('U', theta, phi, lambda_), qubit)	×
24
25
26	@std.gate()	9✔
27	def u2(qubit, phi, lambda_):	9✔
28	yield (('U', pi / 2, phi, lambda_), qubit)	9✔
29
30
31	@std.gate()	9✔
32	def u1(qubit, lambda_):	9✔
NEW 33	yield (('U', 0, 0, lambda_), qubit)	×
34
35
36	@std.gate()	9✔
37	def H(qubit):	9✔
38	yield (('u2', 0, pi), qubit)	9✔
39
40
41	@std.gate()	9✔
42	def U(q, theta, phi, lambda_):	9✔
43	# yield (('rfUnitary', pi / 2, -lambda_), qubit)
44	# yield (('rfUnitary', pi / 2, -pi - theta - lambda_), qubit)
45	# yield (('P', theta + phi + lambda_), qubit)
46
47	if abs(theta) < EPS:	9✔
NEW 48	yield (('P', phi + lambda_), q)	×
49	else:
50	yield (('P', lambda_), q)	9✔
51	if abs(theta - pi / 2) < EPS:	9✔
52	yield (('rfUnitary', pi / 2, pi / 2), q)	9✔
53	else:
NEW 54	yield (('rfUnitary', pi / 2, 0), q)	×
NEW 55	yield (('rfUnitary', pi / 2, pi - theta), q)	×
NEW 56	yield (('P', theta), q)	×
57	yield (('P', phi), q)	9✔
58
59
60	@std.gate()	9✔
61	def X(q):	9✔
NEW 62	yield (('u3', pi, 0, pi), q)	×
63
64
65	@std.gate()	9✔
66	def Y(q):	9✔
NEW 67	yield (('u3', pi, pi / 2, pi / 2), q)	×
68
69
70	@std.gate()	9✔
71	def Z(q):	9✔
NEW 72	yield (('u1', pi), q)	×
73
74
75	@std.gate()	9✔
76	def S(q):	9✔
NEW 77	yield (('u1', pi / 2), q)	×
78
79
80	@std.gate(name='-S')	9✔
81	def Sdg(q):	9✔
NEW 82	yield (('u1', -pi / 2), q)	×
83
84
85	@std.gate()	9✔
86	def T(q):	9✔
NEW 87	yield (('u1', pi / 4), q)	×
88
89
90	@std.gate(name='-T')	9✔
91	def Tdg(q):	9✔
NEW 92	yield (('u1', -pi / 4), q)	×
93
94
95	@std.gate(name='X/2')	9✔
96	def sx(q):	9✔
NEW 97	yield ('-S', q)	×
NEW 98	yield ('H', q)	×
NEW 99	yield ('-S', q)	×
100
101
102	@std.gate(name='-X/2')	9✔
103	def sxdg(q):	9✔
NEW 104	yield ('S', q)	×
NEW 105	yield ('H', q)	×
NEW 106	yield ('S', q)	×
107
108
109	@std.gate(name='Y/2')	9✔
110	def sy(q):	9✔
NEW 111	yield ('Z', q)	×
NEW 112	yield ('H', q)	×
113
114
115	@std.gate(name='-Y/2')	9✔
116	def sydg(q):	9✔
NEW 117	yield ('H', q)	×
NEW 118	yield ('Z', q)	×
119
120
121	@std.gate()	9✔
122	def Rx(q, theta):	9✔
NEW 123	yield (('u3', theta, -pi / 2, pi / 2), q)	×
124
125
126	@std.gate()	9✔
127	def Ry(q, theta):	9✔
NEW 128	yield (('u3', theta, 0, 0), q)	×
129
130
131	@std.gate(name='W/2')	9✔
132	def W2(q):	9✔
NEW 133	yield (('u3', pi / 2, -pi / 4, pi / 4), q)	×
134
135
136	@std.gate(name='-W/2')	9✔
137	def W2(q):	9✔
NEW 138	yield (('u3', -pi / 2, -pi / 4, pi / 4), q)	×
139
140
141	@std.gate(name='V/2')	9✔
142	def W2(q):	9✔
NEW 143	yield (('u3', pi / 2, -3 * pi / 4, 3 * pi / 4), q)	×
144
145
146	@std.gate(name='-V/2')	9✔
147	def W2(q):	9✔
NEW 148	yield (('u3', -pi / 2, -3 * pi / 4, 3 * pi / 4), q)	×
149
150
151	@std.gate()	9✔
152	def Rz(q, phi):	9✔
NEW 153	yield (('u1', phi), q)	×
154
155
156	@std.gate(2)	9✔
157	def Cnot(qubits):	9✔
158	c, t = qubits	9✔
159	yield ('H', t)	9✔
160	yield ('CZ', (c, t))	9✔
161	yield ('H', t)	9✔
162
163
164	@std.gate(2)	9✔
165	def crz(qubits, lambda_):	9✔
NEW 166	c, t = qubits	×
167
NEW 168	yield (('u1', lambda_ / 2), t)	×
NEW 169	yield ('Cnot', (c, t))	×
NEW 170	yield (('u1', -lambda_ / 2), t)	×
NEW 171	yield ('Cnot', (c, t))	×
172
173
174	@std.opaque('Delay')	9✔
175	def delay(ctx, qubits, time):	9✔
NEW 176	qubit, = qubits	×
NEW 177	yield ('!add_time', time), qubit	×
178
179
180	@std.opaque('P')	9✔
181	def P(ctx, qubits, phi):	9✔
182	# (('rfUnitary', pi / 2, arb_phase), qubit)
183	# (('rfUnitary', pi / 2, arb_phase), qubit)
184	# (('rfUnitary', pi / 2, phi / 2 + arb_phase + k * pi), qubit)
185	# (('rfUnitary', pi / 2, phi / 2 + arb_phase + k * pi), qubit)
NEW 186	import numpy as np	×
187
NEW 188	from ..compiler import call_opaque	×
189
NEW 190	phi += ctx.phases[qubits[0]]	×
NEW 191	yield ('!set_phase', 0), qubits[0]	×
NEW 192	x = 2 * np.pi * np.random.random()	×
NEW 193	y = np.pi * np.random.randint(0, 2) + x	×
194
NEW 195	call_opaque((('rfUnitary', pi / 2, x), *qubits), ctx, std)	×
NEW 196	call_opaque((('rfUnitary', pi / 2, x), *qubits), ctx, std)	×
NEW 197	call_opaque((('rfUnitary', pi / 2, phi / 2 + y), *qubits), ctx, std)	×
NEW 198	call_opaque((('rfUnitary', pi / 2, phi / 2 + y), *qubits), ctx, std)	×
199
200
201	@std.opaque('Barrier')	9✔
202	def barrier(ctx, qubits):	9✔
203	time = max(ctx.time[qubit] for qubit in qubits)	9✔
204	for qubit in qubits:	9✔
205	yield ('!set_time', time), qubit	9✔
206
207
208	@std.opaque('rfPulse')	9✔
209	def rfPulse(ctx, qubits, waveform):	9✔
NEW 210	qubit, = qubits	×
211
NEW 212	if isinstance(waveform, str):	×
NEW 213	waveform = wave_eval(waveform)	×
214
NEW 215	yield ('!play', waveform >> ctx.time[qubit]), ('RF', qubit)	×
216
217
218	@std.opaque('fluxPulse')	9✔
219	def fluxPulse(ctx, qubits, waveform):	9✔
NEW 220	qubit, = qubits	×
221
NEW 222	if isinstance(waveform, str):	×
NEW 223	waveform = wave_eval(waveform)	×
224
NEW 225	yield ('!play', waveform >> ctx.time[qubit]), ('Z', qubit)	×
226
227
228	@std.opaque('Pulse')	9✔
229	def Pulse(ctx, qubits, channel, waveform):	9✔
230
NEW 231	if isinstance(waveform, str):	×
NEW 232	waveform = wave_eval(waveform)	×
233
NEW 234	t = max(ctx.time[qubit] for qubit in qubits)	×
235
NEW 236	yield ('!play', waveform >> t), (channel, *qubits)	×
237
238
239	@std.opaque('setBias')	9✔
240	def setBias(ctx, qubits, channel, bias, edge=0, buffer=0):	9✔
NEW 241	if channel.startswith('coupler.') and len(qubits) == 2:	×
NEW 242	qubits = sorted(qubits)	×
NEW 243	yield ('!set_bias', (bias, edge, buffer)), (channel, *qubits)	×
NEW 244	time = max(ctx.time[qubit] for qubit in qubits)	×
NEW 245	for qubit in qubits:	×
NEW 246	yield ('!set_time', time + buffer), qubit	×
247
248
249	@std.opaque('I')	9✔
250	def I(ctx, qubits):	9✔
NEW 251	qubit = qubits[0]	×
NEW 252	yield ('!play', zero()), ('RF', qubit)	×
NEW 253	yield ('!play', zero()), ('Z', qubit)	×
NEW 254	yield ('!play', zero()), ('readoutLine.RF', qubit)	×
255
256
257	def _rfUnitary(ctx, qubits, theta, phi, level1=0, level2=1):	9✔
258	from numpy import interp	9✔
259
260	qubit, = qubits	9✔
261
262	if theta < 0:	9✔
NEW 263	theta = -theta	×
NEW 264	phi += pi	×
265	theta = mod(theta, 2 * pi)	9✔
266	if theta > pi:	9✔
NEW 267	theta = 2 * pi - theta	×
NEW 268	phi += pi	×
269
270	phi = mod(	9✔
271	phi + ctx.phases_ext[qubit][level1] - ctx.phases_ext[qubit][level2],
272	2 * pi)
273	phi = phi if abs(level2 - level1) % 2 else phi - pi	9✔
274	if phi > pi:	9✔
275	phi -= 2 * pi	9✔
276	phi = phi / (level2 - level1)	9✔
277
278	shape = ctx.params.get('shape', 'CosPulse')	9✔
279	buffer = ctx.params.get('buffer', 0)	9✔
280	alpha = ctx.params.get('alpha', 1)	9✔
281	beta = ctx.params.get('beta', 0)	9✔
282	delta = ctx.params.get('delta', 0)	9✔
283	edge = ctx.params.get('edge', 0)	9✔
284	edge_type = ctx.params.get('edge_type', 'cos')	9✔
285
286	phase = pi * interp(phi / pi, *ctx.params['phase'])	9✔
287
288	pulseLib = {	9✔
289	'CosPulse': cosPulse,
290	'Gaussian': gaussian,
291	'Square': square,
292	'cosPulse': cosPulse,
293	'gaussian': gaussian,
294	'square': square,
295	'DC': square,
296	}
297
298	while theta > 0:	9✔
299	if theta > pi / 2:	9✔
NEW 300	theta1 = pi / 2	×
NEW 301	theta -= pi / 2	×
302	else:
303	theta1 = theta	9✔
304	theta = 0	9✔
305
306	duration = interp(theta1 / pi, *ctx.params['duration'])	9✔
307	amp = interp(theta1 / pi, *ctx.params['amp'])	9✔
308	if shape == 'square':	9✔
NEW 309	pulse = square(duration, type=edge_type, edge=edge)	×
310	else:
311	pulse = pulseLib[shape](duration)	9✔
312
313	if duration > 0 and amp > 0:	9✔
314	I, Q = mixing(amp * alpha * pulse,	9✔
315	phase=phase,
316	freq=delta,
317	DRAGScaling=beta / alpha)
318	t = (duration + buffer) / 2 + ctx.time[qubit]	9✔
319	if 'levels' in ctx.params:	9✔
NEW 320	freq = (ctx.params['levels'][level2] -	×
321	ctx.params['levels'][level1]) / (level2 - level1)
322	else:
323	freq = ctx.params['frequency']	9✔
324	wav, _ = mixing(I >> t, Q >> t, freq=freq)	9✔
325	yield ('!play', wav), ('RF', qubit)	9✔
326	yield ('!add_time', duration + buffer), qubit	9✔
327
328
329	@std.opaque('rfUnitary')	9✔
330	def rfUnitary(ctx, qubits, theta, phi):	9✔
331	yield from _rfUnitary(ctx, qubits, theta, phi)	9✔
332
333
334	@std.opaque('rfUnitary', type='BB1')	9✔
335	def rfUnitary_BB1(ctx, qubits, theta, phi):	9✔
NEW 336	import numpy as np	×
337
NEW 338	p1 = np.arccos(-theta / (4 * pi))	×
NEW 339	p2 = 3 * p1	×
NEW 340	p1, p2 = p1 + phi, p2 + phi	×
341
NEW 342	yield from _rfUnitary(ctx, qubits, pi, p1)	×
NEW 343	yield from _rfUnitary(ctx, qubits, pi, p2)	×
NEW 344	yield from _rfUnitary(ctx, qubits, pi, p2)	×
NEW 345	yield from _rfUnitary(ctx, qubits, pi, p1)	×
NEW 346	yield from _rfUnitary(ctx, qubits, theta, phi)	×
347
348
349	@std.opaque('Measure')	9✔
350	def measure(ctx, qubits, cbit=None):	9✔
351	from waveforms import cos, exp, pi, step	9✔
352
353	def extract_variable_and_index_if_match(s):	9✔
NEW 354	pattern = r'^(\w+)\[(\d+)\]$'	×
NEW 355	match = re.search(pattern, s)	×
356
NEW 357	if match:	×
NEW 358	name, index = match.groups()	×
NEW 359	return (name, int(index))	×
360	else:
NEW 361	return (s, 0)	×
362
363	qubit, = qubits	9✔
364
365	if cbit is None:	9✔
NEW 366	if len(ctx.measures['result']) == 0:	×
NEW 367	cbit = 0	×
368	else:
NEW 369	cbit = max(ctx.measures['result'].keys()) + 1	×
370
371	if isinstance(cbit, int):	9✔
372	cbit = ('result', cbit)	9✔
NEW 373	elif isinstance(cbit, str):	×
NEW 374	cbit = extract_variable_and_index_if_match(cbit)	×
375
376	# lo = ctx.cfg._getReadoutADLO(qubit)
377	amp = ctx.params['amp']	9✔
378	duration = ctx.params['duration']	9✔
379	frequency = ctx.params['frequency']	9✔
380	bias = ctx.params.get('bias', None)	9✔
381	signal = ctx.params.get('signal', 'state')	9✔
382	ring_up_amp = ctx.params.get('ring_up_amp', amp)	9✔
383	ring_up_time = ctx.params.get('ring_up_time', 50e-9)	9✔
384	rsing_edge_time = ctx.params.get('rsing_edge_time', 5e-9)	9✔
385
386	try:	9✔
387	w = ctx.params['w']	9✔
NEW 388	weight = None	×
389	except:	9✔
390	weight = ctx.params.get('weight',	9✔
391	f'square({duration}) >> {duration/2}')
392	w = None	9✔
393
394	t = ctx.time[qubit]	9✔
395
396	# phi = 2 * np.pi * (lo - frequency) * t
397
398	pulse = (ring_up_amp * (step(rsing_edge_time) >> t) - (ring_up_amp - amp) *	9✔
399	(step(rsing_edge_time) >>
400	(t + ring_up_time)) - amp * (step(rsing_edge_time) >>
401	(t + duration)))
402	yield ('!play', pulse * cos(2 * pi * frequency)), ('readoutLine.RF', qubit)	9✔
403	if bias is not None:	9✔
NEW 404	yield ('!set_bias', bias), ('Z', qubit)	×
405
406	# pulse = square(2 * duration) >> duration
407	# ctx.channel['readoutLine.AD.trigger', qubit] \|= pulse.marker
408
409	params = {k: v for k, v in ctx.params.items()}	9✔
410	params['w'] = w	9✔
411	params['weight'] = weight	9✔
412	if not (cbit[0] == 'state' and cbit[1] < 0):	9✔
413	yield ('!capture', Capture(qubit, cbit, ctx.time[qubit], signal,	9✔
414	params)), cbit
415	yield ('!set_time', t + duration), qubit	9✔
416	yield ('!set_phase', 0), qubit	9✔
417
418
419	def parametric(ctx, qubits):	9✔
NEW 420	t = max(ctx.time[q] for q in qubits)	×
421
NEW 422	duration = ctx.params['duration']	×
NEW 423	amp = ctx.params['amp']	×
NEW 424	offset = ctx.params['offset']	×
NEW 425	frequency = ctx.params['frequency']	×
426
NEW 427	if duration > 0:	×
NEW 428	pulse = square(duration) >> duration / 2	×
NEW 429	pulse = offset * pulse + amp * pulse * sin(2 * pi * frequency)	×
NEW 430	yield ('!play', pulse >> t), ('coupler.Z', *qubits)	×
431
NEW 432	for qubit in qubits:	×
NEW 433	yield ('!set_time', t + duration), qubit	×
434
NEW 435	yield ('!add_phase', ctx.params['phi1']), qubits[0]	×
NEW 436	yield ('!add_phase', ctx.params['phi2']), qubits[1]	×
437
438
439	@std.opaque('CZ')	9✔
440	def CZ(ctx, qubits):	9✔
NEW 441	t = max(ctx.time[q] for q in qubits)	×
442
NEW 443	duration = ctx.params['duration']	×
NEW 444	amp = ctx.params['amp']	×
445
NEW 446	if amp != 0 and duration > 0:	×
NEW 447	pulse = amp * (cos(pi / duration) * square(duration)) >> duration / 2	×
NEW 448	yield ('!play', pulse >> t), ('coupler.Z', *qubits)	×
449
NEW 450	for qubit in qubits:	×
NEW 451	yield ('!set_time', t + duration), qubit	×
452
NEW 453	yield ('!add_phase', ctx.params['phi1']), qubits[0]	×
NEW 454	yield ('!add_phase', ctx.params['phi2']), qubits[1]	×
455
456
457	@std.opaque('CZ', type='parametric')	9✔
458	def CZ(ctx, qubits):	9✔
NEW 459	yield from parametric(ctx, qubits)	×
460
461
462	@std.opaque('iSWAP', type='parametric')	9✔
463	def iSWAP(ctx, qubits):	9✔
NEW 464	yield from parametric(ctx, qubits)	×

feihoo87 / waveforms / 6965255504

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous