def test_3q_schedule(self):
"""Test a schedule that was recommended by David McKay :D """
backend = FakeOpenPulse3Q()
inst_map = backend.defaults().instruction_schedule_map
q = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, c)
qc.cx(q[0], q[1])
qc.u2(0.778, 0.122, q[2])
qc.u3(3.14, 1.57, 0., q[0])
qc.u2(3.14, 1.57, q[1])
qc.cx(q[1], q[2])
qc.u2(0.778, 0.122, q[2])
sched = schedule(qc, backend)
expected = Schedule(
inst_map.get('cx', [0, 1]),
(22, inst_map.get('u2', [1], 3.14, 1.57)),
(46, inst_map.get('u2', [2], 0.778, 0.122)),
(50, inst_map.get('cx', [1, 2])),
(72, inst_map.get('u2', [2], 0.778, 0.122)),
(74, inst_map.get('u3', [0], 3.14, 1.57)))
for actual, expected in zip(sched.instructions, expected.instructions):
self.assertEqual(actual[0], expected[0])
self.assertEqual(actual[1].command, expected[1].command)
self.assertEqual(actual[1].channels, expected[1].channels)
def test_3q_schedule(self):
"""Test a schedule that was recommended by David McKay :D"""
# ┌─────────────────┐
# q0_0: ─────────■─────────┤ U3(3.14,1.57,0) ├────────────────────────
# ┌─┴─┐ └┬───────────────┬┘
# q0_1: ───────┤ X ├────────┤ U2(3.14,1.57) ├───■─────────────────────
# ┌──────┴───┴──────┐ └───────────────┘ ┌─┴─┐┌─────────────────┐
# q0_2: ┤ U2(0.778,0.122) ├───────────────────┤ X ├┤ U2(0.778,0.122) ├
# └─────────────────┘ └───┘└─────────────────┘
backend = FakeOpenPulse3Q()
inst_map = backend.defaults().instruction_schedule_map
q = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, c)
qc.cx(q[0], q[1])
qc.append(U2Gate(0.778, 0.122), [q[2]])
qc.append(U3Gate(3.14, 1.57, 0), [q[0]])
qc.append(U2Gate(3.14, 1.57), [q[1]])
qc.cx(q[1], q[2])
qc.append(U2Gate(0.778, 0.122), [q[2]])
sched = schedule(qc, backend)
expected = Schedule(
inst_map.get("cx", [0, 1]),
(22, inst_map.get("u2", [1], 3.14, 1.57)),
(22, inst_map.get("u2", [2], 0.778, 0.122)),
(24, inst_map.get("cx", [1, 2])),
(44, inst_map.get("u3", [0], 3.14, 1.57, 0)),
(46, inst_map.get("u2", [2], 0.778, 0.122)),
)
for actual, expected in zip(sched.instructions, expected.instructions):
self.assertEqual(actual[0], expected[0])
self.assertEqual(actual[1], expected[1])
def test_assemble_parametric(self):
"""Test that parametric pulses can be assembled properly into a PulseQobj."""
sched = pulse.Schedule(name='test_parametric')
sched += Play(pulse.Gaussian(duration=25, sigma=4, amp=0.5j), DriveChannel(0))
sched += Play(pulse.Drag(duration=25, amp=0.2+0.3j, sigma=7.8, beta=4), DriveChannel(1))
sched += Play(pulse.Constant(duration=25, amp=1), DriveChannel(2))
sched += Play(pulse.GaussianSquare(duration=150, amp=0.2,
sigma=8, width=140), MeasureChannel(0)) << sched.duration
backend = FakeOpenPulse3Q()
backend.configuration().parametric_pulses = ['gaussian', 'drag',
'gaussian_square', 'constant']
qobj = assemble(sched, backend)
self.assertEqual(qobj.config.pulse_library, [])
qobj_insts = qobj.experiments[0].instructions
self.assertTrue(all(inst.name == 'parametric_pulse'
for inst in qobj_insts))
self.assertEqual(qobj_insts[0].pulse_shape, 'gaussian')
self.assertEqual(qobj_insts[1].pulse_shape, 'drag')
self.assertEqual(qobj_insts[2].pulse_shape, 'constant')
self.assertEqual(qobj_insts[3].pulse_shape, 'gaussian_square')
self.assertDictEqual(qobj_insts[0].parameters, {'duration': 25, 'sigma': 4, 'amp': 0.5j})
self.assertDictEqual(qobj_insts[1].parameters,
{'duration': 25, 'sigma': 7.8, 'amp': 0.2+0.3j, 'beta': 4})
self.assertDictEqual(qobj_insts[2].parameters, {'duration': 25, 'amp': 1})
self.assertDictEqual(qobj_insts[3].parameters,
{'duration': 150, 'sigma': 8, 'amp': 0.2, 'width': 140})
self.assertEqual(
qobj.to_dict()['experiments'][0]['instructions'][0]['parameters']['amp'],
0.5j)
def test_multiple_measure_in_3Q(self):
"""Test multiple measure, user memslot mapping, 3Q."""
backend = FakeOpenPulse3Q()
cmd_def = backend.defaults().build_cmd_def()
q = QuantumRegister(3)
c = ClassicalRegister(5)
qc = QuantumCircuit(q, c)
qc.measure(q[0], c[2])
qc.measure(q[0], c[4])
sched = schedule(qc, backend)
expected = Schedule(
cmd_def.get('measure',
[0, 1, 2]).filter(channels=[MeasureChannel(0)]),
Acquire(duration=10)(
[AcquireChannel(0),
AcquireChannel(1),
AcquireChannel(2)],
[MemorySlot(2), MemorySlot(0),
MemorySlot(1)]),
(10, cmd_def.get('measure',
[0, 1, 2]).filter(channels=[MeasureChannel(0)])),
(10, Acquire(duration=10)(
[AcquireChannel(0),
AcquireChannel(1),
AcquireChannel(2)],
[MemorySlot(4), MemorySlot(0),
MemorySlot(1)])))
self.assertEqual(sched.instructions, expected.instructions)
def test_subset_calibrated_measurements(self):
"""Test that measurement calibrations can be added and used for some qubits, even
if the other qubits do not also have calibrated measurements."""
qc = QuantumCircuit(3, 3)
qc.measure(0, 0)
qc.measure(1, 1)
qc.measure(2, 2)
meas_scheds = []
for qubit in [0, 2]:
meas = (Play(Gaussian(1200, 0.2, 4), MeasureChannel(qubit)) +
Acquire(1200, AcquireChannel(qubit), MemorySlot(qubit)))
meas_scheds.append(meas)
qc.add_calibration('measure', [qubit], meas)
meas = macros.measure([1], FakeOpenPulse3Q())
meas = meas.exclude(channels=[AcquireChannel(0), AcquireChannel(2)])
sched = schedule(qc, FakeOpenPulse3Q())
expected = Schedule(meas_scheds[0], meas_scheds[1], meas)
self.assertEqual(sched.instructions, expected.instructions)
def test_assemble_parametric_unsupported(self):
"""Test that parametric pulses are translated to Waveform if they're not supported
by the backend during assemble time.
"""
sched = pulse.Schedule(name='test_parametric_to_sample_pulse')
sched += Play(pulse.Drag(duration=25, amp=0.2+0.3j, sigma=7.8, beta=4), DriveChannel(1))
sched += Play(pulse.Constant(duration=25, amp=1), DriveChannel(2))
backend = FakeOpenPulse3Q()
backend.configuration().parametric_pulses = ['something_extra']
qobj = assemble(sched, backend)
self.assertNotEqual(qobj.config.pulse_library, [])
qobj_insts = qobj.experiments[0].instructions
self.assertFalse(hasattr(qobj_insts[0], 'pulse_shape'))
def test_user_mapping_for_memslots_3Q(self):
"""Test measuring two of three qubits."""
backend = FakeOpenPulse3Q()
cmd_def = backend.defaults().build_cmd_def()
q = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, c)
qc.measure(q[1], c[2])
qc.measure(q[2], c[0])
sched = schedule(qc, backend)
expected = Schedule(
cmd_def.get('measure', [0, 1, 2]).filter(
channels=[MeasureChannel(1), MeasureChannel(2)]),
Acquire(duration=10)([AcquireChannel(0), AcquireChannel(1), AcquireChannel(2)],
[MemorySlot(1), MemorySlot(2), MemorySlot(0)]))
self.assertEqual(sched.instructions, expected.instructions)
def test_3q_schedule(self):
"""Test a schedule that was recommended by David McKay :D """
backend = FakeOpenPulse3Q()
cmd_def = backend.defaults().build_cmd_def()
q = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, c)
qc.cx(q[0], q[1])
qc.u2(0.778, 0.122, q[2])
qc.u3(3.14, 1.57, 0., q[0])
qc.u2(3.14, 1.57, q[1])
qc.cx(q[1], q[2])
qc.u2(0.778, 0.122, q[2])
sched = schedule(qc, backend)
expected = Schedule(cmd_def.get('cx', [0, 1]),
(22, cmd_def.get('u2', [1], 3.14, 1.57)),
(46, cmd_def.get('u2', [2], 0.778, 0.122)),
(50, cmd_def.get('cx', [1, 2])),
(72, cmd_def.get('u2', [2], 0.778, 0.122)),
(74, cmd_def.get('u3', [0], 3.14, 1.57)))
self.assertEqual(sched.instructions, expected.instructions)