def test_can_create_valid_schedule(self):
"""Test valid schedule creation without error.
"""
device = self.two_qubit_device
@functional_pulse
def gaussian(duration, amp, t0, sig):
x = np.linspace(0, duration - 1, duration)
return amp * np.exp(-(x - t0)**2 / sig**2)
gp0 = gaussian(duration=20, name='pulse0', amp=0.7, t0=9.5, sig=3)
gp1 = gaussian(duration=20, name='pulse1', amp=0.5, t0=9.5, sig=3)
fc_pi_2 = FrameChange(phase=1.57)
acquire = Acquire(10)
sched = Schedule()
sched = sched.append(gp0(device.q[0].drive))
sched = sched.insert(
0,
PersistentValue(value=0.2 + 0.4j)(device.q[0].control))
sched = sched.insert(30, gp1(device.q[1].drive))
sched = sched.insert(60, FrameChange(phase=-1.57)(device.q[0].drive))
sched = sched.insert(60, gp0(device.q[0].control))
sched = sched.insert(80, Snapshot("label", "snap_type"))
sched = sched.insert(90, fc_pi_2(device.q[0].drive))
sched = sched.insert(90,
acquire(device.q[1], device.mem[1], device.c[1]))
# print(sched)
new_sched = Schedule()
new_sched = new_sched.append(sched)
new_sched = new_sched.append(sched)
_ = new_sched.flat_instruction_sequence()
def sample_schedule(self):
"""Generate a sample schedule that includes the most common elements of
pulse schedules."""
gp0 = pulse_lib.gaussian(duration=20, amp=1.0, sigma=1.0)
gp1 = pulse_lib.gaussian(duration=20, amp=-1.0, sigma=2.0)
gs0 = pulse_lib.gaussian_square(duration=20,
amp=-1.0,
sigma=2.0,
risefall=3)
fc_pi_2 = FrameChange(phase=1.57)
acquire = Acquire(10)
delay = Delay(100)
sched = Schedule()
sched = sched.append(gp0(DriveChannel(0)))
sched = sched.insert(
0,
pulse_lib.ConstantPulse(duration=60,
amp=0.2 + 0.4j)(ControlChannel(0)))
sched = sched.insert(60, FrameChange(phase=-1.57)(DriveChannel(0)))
sched = sched.insert(60, SetFrequency(8.0, DriveChannel(0)))
sched = sched.insert(30, gp1(DriveChannel(1)))
sched = sched.insert(60, gp0(ControlChannel(0)))
sched = sched.insert(60, gs0(MeasureChannel(0)))
sched = sched.insert(90, fc_pi_2(DriveChannel(0)))
sched = sched.insert(
90, acquire(AcquireChannel(1), MemorySlot(1), RegisterSlot(1)))
sched = sched.append(delay(DriveChannel(0)))
sched = sched + sched
sched |= Snapshot("snapshot_1", "snap_type") << 60
sched |= Snapshot("snapshot_2", "snap_type") << 120
return sched
def test_can_create_valid_schedule(self):
"""Test valid schedule creation without error."""
gp0 = pulse_lib.gaussian(duration=20, amp=0.7, sigma=3)
gp1 = pulse_lib.gaussian(duration=20, amp=0.7, sigma=3)
fc_pi_2 = FrameChange(phase=1.57)
acquire = Acquire(10)
sched = Schedule()
sched = sched.append(gp0(self.config.drive(0)))
sched = sched.insert(
0,
PersistentValue(value=0.2 + 0.4j)(self.config.control(0)))
sched = sched.insert(60,
FrameChange(phase=-1.57)(self.config.drive(0)))
sched = sched.insert(30, gp1(self.config.drive(0)))
sched = sched.insert(60, gp0(self.config.control(0)))
sched = sched.insert(80, Snapshot("label", "snap_type"))
sched = sched.insert(90, fc_pi_2(self.config.drive(0)))
sched = sched.insert(
90, acquire(self.config.acquire(0), MemorySlot(0),
RegisterSlot(0)))
self.assertEqual(0, sched.start_time)
self.assertEqual(100, sched.stop_time)
self.assertEqual(100, sched.duration)
new_sched = Schedule()
new_sched = new_sched.append(sched)
new_sched = new_sched.append(sched)
self.assertEqual(0, new_sched.start_time)
self.assertEqual(200, new_sched.stop_time)
self.assertEqual(200, new_sched.duration)
def test_can_create_valid_schedule(self):
"""Test valid schedule creation without error."""
device = self.two_qubit_device
gp0 = pulse_lib.gaussian(duration=20, amp=0.7, sigma=3)
gp1 = pulse_lib.gaussian(duration=20, amp=0.7, sigma=3)
fc_pi_2 = FrameChange(phase=1.57)
acquire = Acquire(10)
sched = Schedule()
sched = sched.append(gp0(device.q[0].drive))
sched = sched.insert(
0,
PersistentValue(value=0.2 + 0.4j)(device.q[0].controls[0]))
sched = sched.insert(60, FrameChange(phase=-1.57)(device.q[0].drive))
sched = sched.insert(30, gp1(device.q[1].drive))
sched = sched.insert(60, gp0(device.q[0].controls[0]))
sched = sched.insert(80, Snapshot("label", "snap_type"))
sched = sched.insert(90, fc_pi_2(device.q[0].drive))
sched = sched.insert(90,
acquire(device.q[1], device.mem[1], device.c[1]))
self.assertEqual(0, sched.start_time)
self.assertEqual(100, sched.stop_time)
self.assertEqual(100, sched.duration)
new_sched = Schedule()
new_sched = new_sched.append(sched)
new_sched = new_sched.append(sched)
self.assertEqual(0, new_sched.start_time)
self.assertEqual(200, new_sched.stop_time)
self.assertEqual(200, new_sched.duration)
def test_can_create_valid_schedule_with_syntax_sugar(self):
"""Test valid schedule creation using syntax sugar without error."""
device = self.two_qubit_device
# pylint: disable=invalid-name
@functional_pulse
def gaussian(duration, amp, t0, sig):
x = np.linspace(0, duration - 1, duration)
return amp * np.exp(-(x - t0)**2 / sig**2)
gp0 = gaussian(duration=20, amp=0.7, t0=9.5, sig=3)
gp1 = gaussian(duration=20, amp=0.5, t0=9.5, sig=3)
fc_pi_2 = FrameChange(phase=1.57)
acquire = Acquire(10)
sched = Schedule()
sched += gp0(device.q[0].drive)
sched |= PersistentValue(value=0.2 + 0.4j)(
device.q[0].control).shifted(0)
sched |= FrameChange(phase=-1.57)(device.q[0].drive).shifted(60)
sched |= gp1(device.q[1].drive).shifted(30)
sched |= gp0(device.q[0].control).shifted(60)
sched |= Snapshot("label", "snap_type").shifted(80)
sched |= fc_pi_2(device.q[0].drive).shifted(90)
sched |= acquire(device.q[1], device.mem[1], device.c[1]).shifted(90)
_ = Schedule() + sched + sched
def sample_schedule(self):
"""Generate a sample schedule that includes the most common elements of
pulse schedules."""
gp0 = pulse_lib.gaussian(duration=20, amp=1.0, sigma=1.0)
gp1 = pulse_lib.gaussian(duration=20, amp=-1.0, sigma=2.0)
gs0 = pulse_lib.gaussian_square(duration=20,
amp=-1.0,
sigma=2.0,
risefall=3)
fc_pi_2 = FrameChange(phase=1.57)
acquire = Acquire(10)
sched = Schedule()
sched = sched.append(gp0(self.device.q[0].drive))
sched = sched.insert(
0,
PersistentValue(value=0.2 + 0.4j)(self.device.q[0].controls[0]))
sched = sched.insert(60,
FrameChange(phase=-1.57)(self.device.q[0].drive))
sched = sched.insert(30, gp1(self.device.q[1].drive))
sched = sched.insert(60, gp0(self.device.q[0].controls[0]))
sched = sched.insert(60, gs0(self.device.q[0].measure))
sched = sched.insert(90, fc_pi_2(self.device.q[0].drive))
sched = sched.insert(
90, acquire(self.device.q[1], self.device.mem[1],
self.device.c[1]))
sched = sched + sched
sched |= Snapshot("snapshot_1", "snap_type") << 60
sched |= Snapshot("snapshot_2", "snap_type") << 120
return sched
def test_different_name_equal(self):
"""Test that names are ignored when checking equality."""
self.assertEqual(
Schedule((0, FrameChange(0, name='fc1')(DriveChannel(1))),
name='s1'),
Schedule((0, FrameChange(0, name='fc2')(DriveChannel(1))),
name='s2'))
def test_schedule_drawer_show_framechange(self):
filename = self._get_resource_path('current_show_framechange_ref.png')
gp0 = pulse_lib.gaussian(duration=20, amp=1.0, sigma=1.0)
sched = Schedule()
sched = sched.append(gp0(DriveChannel(0)))
sched = sched.insert(60, FrameChange(phase=-1.57)(DriveChannel(0)))
sched = sched.insert(30, FrameChange(phase=-1.50)(DriveChannel(1)))
sched = sched.insert(70, FrameChange(phase=1.50)(DriveChannel(1)))
pulse_drawer(sched, filename=filename, show_framechange_channels=False)
self.assertImagesAreEqual(filename, self.schedule_show_framechange_ref)
os.remove(filename)
def test_single_channel_out_of_order(self):
"""Test that schedule with single channel equal when out of order."""
instructions = [(0, FrameChange(0)(DriveChannel(0))),
(15, SamplePulse(np.ones(10))(DriveChannel(0))),
(5, SamplePulse(np.ones(10))(DriveChannel(0)))]
self.assertEqual(Schedule(*instructions), Schedule(*reversed(instructions)))
def _1Q_frame_change_schedule(self, phi, fc_phi, total_samples, dur_drive1, dur_drive2):
"""Creates schedule for frame change test. Does a pulse w/ phase phi of duration dur_drive1,
then frame change of phase fc_phi, then another pulse of phase phi of duration dur_drive2.
The different durations for the pulses allow manipulation of rotation angles on Bloch sphere
Args:
phi (float): drive phase (phi in Hamiltonian)
fc_phi (float): phase for frame change
total_samples (int): length of pulses
dur_drive1 (int): duration of first pulse
dur_drive2 (int): duration of second pulse
Returns:
schedule (pulse schedule): schedule for frame change test
"""
phase = np.exp(1j * phi)
drive_pulse_1 = SamplePulse(phase * np.ones(dur_drive1),
name='drive_pulse_1')
drive_pulse_2 = SamplePulse(phase * np.ones(dur_drive2),
name='drive_pulse_2')
# frame change
fc_pulse = FrameChange(phase=fc_phi, name='fc')
# set up acquire command
acq_cmd = pulse.Acquire(duration=total_samples)
# add commands to schedule
schedule = pulse.Schedule(name='fc_schedule')
schedule |= drive_pulse_1(DriveChannel(0))
schedule += fc_pulse(DriveChannel(0))
schedule += drive_pulse_2(DriveChannel(0))
schedule |= acq_cmd(AcquireChannel(0), MemorySlot(0)) << schedule.duration
return schedule
def test_name_inherited(self):
"""Test that schedule keeps name if an instruction is added."""
device = self.two_qubit_device
acquire = Acquire(10)
gp0 = pulse_lib.gaussian(duration=100,
amp=0.7,
sigma=3,
name='pulse_name')
pv0 = PersistentValue(0.1)
fc0 = FrameChange(0.1)
snapshot = Snapshot('snapshot_label', 'state')
sched1 = Schedule(name='test_name')
sched2 = Schedule(name=None)
sched3 = sched1 | sched2
self.assertEqual(sched3.name, 'test_name')
sched_acq = acquire(device.q[1], device.mem[1],
name='acq_name') | sched1
self.assertEqual(sched_acq.name, 'acq_name')
sched_pulse = gp0(device.q[0].drive) | sched1
self.assertEqual(sched_pulse.name, 'pulse_name')
sched_pv = pv0(device.q[0].drive, name='pv_name') | sched1
self.assertEqual(sched_pv.name, 'pv_name')
sched_fc = fc0(device.q[0].drive, name='fc_name') | sched1
self.assertEqual(sched_fc.name, 'fc_name')
sched_snapshot = snapshot | sched1
self.assertEqual(sched_snapshot.name, 'snapshot_label')
def test_buffering(self):
"""Test channel buffering."""
buffer_chan = DriveChannel(0, buffer=5)
measure_chan = MeasureChannel(0, buffer=10)
acquire_chan = AcquireChannel(0, buffer=10)
memory_slot = MemorySlot(0)
gp0 = pulse_lib.gaussian(duration=10, amp=0.7, sigma=3)
fc_pi_2 = FrameChange(phase=1.57)
# no initial buffer
sched = Schedule()
sched += gp0(buffer_chan)
self.assertEqual(sched.duration, 10)
# this pulse should be buffered
sched += gp0(buffer_chan)
self.assertEqual(sched.duration, 25)
# should not be buffered as framechange
sched += fc_pi_2(buffer_chan)
self.assertEqual(sched.duration, 25)
# use buffer with insert
sched = sched.insert(sched.duration, gp0(buffer_chan), buffer=True)
self.assertEqual(sched.duration, 40)
sched = Schedule()
sched = gp0(measure_chan) + Acquire(duration=10)(acquire_chan, memory_slot)
self.assertEqual(sched.duration, 10)
def test_filter_channels(self):
"""Test filtering over channels."""
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
acquire = Acquire(5)
sched = Schedule(name='fake_experiment')
sched = sched.insert(0, lp0(self.config.drive(0)))
sched = sched.insert(10, lp0(self.config.drive(1)))
sched = sched.insert(30,
FrameChange(phase=-1.57)(self.config.drive(0)))
sched = sched.insert(
60,
acquire([AcquireChannel(0), AcquireChannel(1)],
[MemorySlot(0), MemorySlot(1)]))
sched = sched.insert(90, lp0(self.config.drive(0)))
# split instructions for those on AcquireChannel(1) and those not
filtered, excluded = self._filter_and_test_consistency(
sched, channels=[AcquireChannel(1)])
self.assertEqual(len(filtered.instructions), 1)
self.assertEqual(len(excluded.instructions), 4)
# Split schedule into the part with channels on 1 and into a part without
channels = [AcquireChannel(1), DriveChannel(1)]
filtered, excluded = self._filter_and_test_consistency(
sched, channels=channels)
for _, inst in filtered.instructions:
self.assertTrue(any([chan in channels for chan in inst.channels]))
for _, inst in excluded.instructions:
self.assertFalse(any([chan in channels for chan in inst.channels]))
def test_default(self):
"""Test default frame change.
"""
fc_comm = FrameChange(phase=1.57-0.785j)
self.assertEqual(fc_comm.phase, 1.57-0.785j)
self.assertEqual(fc_comm.duration, 0)
def test_filter_multiple(self):
"""Test filter composition."""
device = self.two_qubit_device
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
acquire = Acquire(5)
sched = Schedule(name='fake_experiment')
sched = sched.insert(0, lp0(device.drives[0]))
sched = sched.insert(10, lp0(device.drives[1]))
sched = sched.insert(30, FrameChange(phase=-1.57)(device.drives[0]))
sched = sched.insert(60, acquire(device.acquires, device.memoryslots))
sched = sched.insert(90, lp0(device.drives[0]))
filtered = sched.filter(channels={0},
instruction_types=[PulseInstruction],
time_ranges=[(25, 100)])
for time, inst in filtered.instructions:
self.assertIsInstance(inst, PulseInstruction)
self.assertTrue(any([chan.index == 0 for chan in inst.channels]))
self.assertTrue(25 <= time <= 100)
filtered_b = sched.filter(
instruction_types=[PulseInstruction, FrameChangeInstruction],
time_ranges=[(25, 100), (0, 30)])
for time, inst in filtered_b.instructions:
self.assertIsInstance(inst,
(FrameChangeInstruction, PulseInstruction))
self.assertTrue(len(filtered_b.instructions), 4)
def test_multiple_channels_out_of_order(self):
"""Test that schedule with multiple channels equal when out of order."""
instructions = [(0, FrameChange(0)(DriveChannel(1))),
(1, Acquire(10)(AcquireChannel(0), MemorySlot(1)))]
self.assertEqual(Schedule(*instructions),
Schedule(*reversed(instructions)))
def test_custom_filters(self):
"""Test custom filters."""
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
sched = Schedule(name='fake_experiment')
sched = sched.insert(0, lp0(self.config.drive(0)))
sched = sched.insert(10, lp0(self.config.drive(1)))
sched = sched.insert(30,
FrameChange(phase=-1.57)(self.config.drive(0)))
filtered, excluded = self._filter_and_test_consistency(
sched, lambda x: True)
for i in filtered.instructions:
self.assertTrue(i in sched.instructions)
for i in excluded.instructions:
self.assertFalse(i in sched.instructions)
filtered, excluded = self._filter_and_test_consistency(
sched, lambda x: False)
self.assertEqual(len(filtered.instructions), 0)
self.assertEqual(len(excluded.instructions), 3)
filtered, excluded = self._filter_and_test_consistency(
sched, lambda x: x[0] < 30)
self.assertEqual(len(filtered.instructions), 2)
self.assertEqual(len(excluded.instructions), 1)
# multiple custom filters
filtered, excluded = self._filter_and_test_consistency(
sched, lambda x: x[0] > 0, lambda x: x[0] < 30)
self.assertEqual(len(filtered.instructions), 1)
self.assertEqual(len(excluded.instructions), 2)
def test_filter_intervals(self):
"""Test filtering on intervals."""
device = self.two_qubit_device
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
acquire = Acquire(5)
sched = Schedule(name='fake_experiment')
sched = sched.insert(0, lp0(device.drives[0]))
sched = sched.insert(10, lp0(device.drives[1]))
sched = sched.insert(30, FrameChange(phase=-1.57)(device.drives[0]))
sched = sched.insert(60, acquire(device.acquires, device.memoryslots))
sched = sched.insert(90, lp0(device.drives[0]))
intervals_a = sched.filter(time_ranges=((0, 13), ))
for time, inst in intervals_a.instructions:
self.assertTrue(0 <= time <= 13)
self.assertTrue(inst.timeslots.timeslots[0].interval.stop <= 13)
self.assertEqual(len(intervals_a.instructions), 2)
intervals_b = sched.filter(time_ranges=[(59, 65)])
self.assertEqual(len(intervals_b.instructions), 1)
self.assertEqual(intervals_b.instructions[0][0], 60)
self.assertIsInstance(intervals_b.instructions[0][1],
AcquireInstruction)
non_full_intervals = sched.filter(time_ranges=[(0, 2), (8, 11), (61,
70)])
self.assertEqual(len(non_full_intervals.instructions), 0)
multi_interval = sched.filter(time_ranges=[(10, 15), (63, 93)])
self.assertEqual(len(multi_interval.instructions), 2)
multi_interval = sched.filter(
intervals=[Interval(10, 15), Interval(63, 93)])
self.assertEqual(len(multi_interval.instructions), 2)
def test_filter_intervals(self):
"""Test filtering on intervals."""
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
acquire = Acquire(5)
sched = Schedule(name='fake_experiment')
sched = sched.insert(0, lp0(self.config.drive(0)))
sched = sched.insert(10, lp0(self.config.drive(1)))
sched = sched.insert(30,
FrameChange(phase=-1.57)(self.config.drive(0)))
sched = sched.insert(
60,
acquire([self.config.acquire(i) for i in range(2)],
[MemorySlot(i) for i in range(2)]))
sched = sched.insert(90, lp0(self.config.drive(0)))
# split schedule into instructions occuring in (0,13), and those outside
filtered, excluded = self._filter_and_test_consistency(
sched, time_ranges=((0, 13), ))
for start_time, inst in filtered.instructions:
self.assertTrue((start_time >= 0)
and (start_time + inst.stop_time <= 13))
for start_time, inst in excluded.instructions:
self.assertFalse((start_time >= 0)
and (start_time + inst.stop_time <= 13))
self.assertEqual(len(filtered.instructions), 2)
self.assertEqual(len(excluded.instructions), 3)
# split into schedule occuring in and outside of interval (59,65)
filtered, excluded = self._filter_and_test_consistency(sched,
time_ranges=[
(59, 65)
])
self.assertEqual(len(filtered.instructions), 1)
self.assertEqual(filtered.instructions[0][0], 60)
self.assertIsInstance(filtered.instructions[0][1], AcquireInstruction)
self.assertEqual(len(excluded.instructions), 4)
self.assertEqual(excluded.instructions[3][0], 90)
self.assertIsInstance(excluded.instructions[3][1], PulseInstruction)
# split instructions based on the interval
# (none should be, though they have some overlap with some of the instructions)
filtered, excluded = \
self._filter_and_test_consistency(sched, time_ranges=[(0, 2), (8, 11), (61, 70)])
self.assertEqual(len(filtered.instructions), 0)
self.assertEqual(len(excluded.instructions), 5)
# split instructions from multiple non-overlapping intervals, specified
# as time ranges
filtered, excluded = \
self._filter_and_test_consistency(sched, time_ranges=[(10, 15), (63, 93)])
self.assertEqual(len(filtered.instructions), 2)
self.assertEqual(len(excluded.instructions), 3)
# split instructions from non-overlapping intervals, specified as Intervals
filtered, excluded = \
self._filter_and_test_consistency(sched, intervals=[Interval(10, 15), Interval(63, 93)])
self.assertEqual(len(filtered.instructions), 2)
self.assertEqual(len(excluded.instructions), 3)
def test_frame_change(self):
"""Test converted qobj from FrameChangeInstruction."""
converter = PulseQobjConverter(PulseQobjInstruction, meas_level=2)
command = FrameChange(phase=0.1)
instruction = command(self.device.q[0].drive)
valid_qobj = PulseQobjInstruction(name='fc', ch='d0', t0=0, phase=0.1)
self.assertEqual(converter(0, instruction), valid_qobj)
def test_can_create_valid_schedule_with_syntax_sugar(self):
"""Test that in place operations on schedule are still immutable
and return equivalent schedules."""
gp0 = pulse_lib.gaussian(duration=20, amp=0.7, sigma=3)
gp1 = pulse_lib.gaussian(duration=20, amp=0.5, sigma=3)
fc_pi_2 = FrameChange(phase=1.57)
acquire = Acquire(10)
sched = Schedule()
sched += gp0(self.config.drive(0))
sched |= PersistentValue(value=0.2 + 0.4j)(self.config.control(0))
sched |= FrameChange(phase=-1.57)(self.config.drive(0)) << 60
sched |= gp1(self.config.drive(0)) << 30
sched |= gp0(self.config.control(0)) << 60
sched |= Snapshot("label", "snap_type") << 60
sched |= fc_pi_2(self.config.drive(0)) << 90
sched |= acquire(self.config.acquire(0), MemorySlot(0),
RegisterSlot(0)) << 90
sched += sched
def test_frame_change(self):
"""Test converted qobj from FrameChangeInstruction."""
cmd = FrameChange(phase=0.1)
instruction = cmd(MeasureChannel(0))
qobj = PulseQobjInstruction(name='fc', ch='m0', t0=0, phase=0.1)
converted_instruction = self.converter(qobj)
self.assertEqual(converted_instruction.timeslots, instruction.timeslots)
self.assertEqual(converted_instruction.instructions[0][-1].command, cmd)
def test_can_create_valid_schedule_with_syntax_sugar(self):
"""Test that in place operations on schedule are still immutable
and return equivalent schedules."""
device = self.two_qubit_device
gp0 = pulse_lib.gaussian(duration=20, amp=0.7, sigma=3)
gp1 = pulse_lib.gaussian(duration=20, amp=0.5, sigma=3)
fc_pi_2 = FrameChange(phase=1.57)
acquire = Acquire(10)
sched = Schedule()
sched += gp0(device.q[0].drive)
sched |= PersistentValue(value=0.2 + 0.4j)(device.q[0].controls[0])
sched |= FrameChange(phase=-1.57)(device.q[0].drive) << 60
sched |= gp1(device.q[1].drive) << 30
sched |= gp0(device.q[0].controls[0]) << 60
sched |= Snapshot("label", "snap_type") << 60
sched |= fc_pi_2(device.q[0].drive) << 90
sched |= acquire(device.q[1], device.mem[1], device.c[1]) << 90
sched += sched
def test_filter(self):
"""Test _filter method."""
device = self.two_qubit_device
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
sched = Schedule(name='fake_experiment')
sched = sched.insert(0, lp0(device.drives[0]))
sched = sched.insert(10, lp0(device.drives[1]))
sched = sched.insert(30, FrameChange(phase=-1.57)(device.drives[0]))
for i in sched._filter([lambda x: True]).instructions:
self.assertTrue(i in sched.instructions)
self.assertEqual(len(sched._filter([lambda x: False]).instructions), 0)
self.assertEqual(len(sched._filter([lambda x: x[0] < 30]).instructions), 2)
def test_filter_multiple(self):
"""Test filter composition."""
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
acquire = Acquire(5)
sched = Schedule(name='fake_experiment')
sched = sched.insert(0, lp0(self.config.drive(0)))
sched = sched.insert(10, lp0(self.config.drive(1)))
sched = sched.insert(30,
FrameChange(phase=-1.57)(self.config.drive(0)))
for i in range(2):
sched = sched.insert(
60, acquire(self.config.acquire(i), MemorySlot(i)))
sched = sched.insert(90, lp0(self.config.drive(0)))
# split instructions with filters on channel 0, of type PulseInstruction,
# occurring in the time interval (25, 100)
filtered, excluded = self._filter_and_test_consistency(
sched,
channels={self.config.drive(0)},
instruction_types=[PulseInstruction],
time_ranges=[(25, 100)])
for time, inst in filtered.instructions:
self.assertIsInstance(inst, PulseInstruction)
self.assertTrue(all([chan.index == 0 for chan in inst.channels]))
self.assertTrue(25 <= time <= 100)
self.assertEqual(len(excluded.instructions), 5)
self.assertTrue(
excluded.instructions[0][1].channels[0] == DriveChannel(0))
self.assertTrue(excluded.instructions[2][0] == 30)
# split based on PulseInstructions in the specified intervals
filtered, excluded = self._filter_and_test_consistency(
sched,
instruction_types=[PulseInstruction],
time_ranges=[(25, 100), (0, 11)])
self.assertTrue(len(excluded.instructions), 3)
for time, inst in filtered.instructions:
self.assertIsInstance(inst,
(FrameChangeInstruction, PulseInstruction))
self.assertTrue(len(filtered.instructions), 4)
# make sure the PulseInstruction not in the intervals is maintained
self.assertIsInstance(excluded.instructions[0][1], PulseInstruction)
# split based on AcquireInstruction in the specified intervals
filtered, excluded = self._filter_and_test_consistency(
sched,
instruction_types=[AcquireInstruction],
time_ranges=[(25, 100)])
self.assertTrue(len(excluded.instructions), 4)
for _, inst in filtered.instructions:
self.assertIsInstance(inst, AcquireInstruction)
self.assertTrue(len(filtered.instructions), 2)
def test_frame_change(self):
"""Test converted qobj from FrameChangeInstruction."""
converter = InstructionToQobjConverter(PulseQobjInstruction,
meas_level=2)
command = FrameChange(phase=0.1)
instruction = command(DriveChannel(0))
valid_qobj = PulseQobjInstruction(name='fc', ch='d0', t0=0, phase=0.1)
self.assertEqual(converter(0, instruction), valid_qobj)
instruction = ShiftPhase(0.1, DriveChannel(0))
self.assertEqual(converter(0, instruction), valid_qobj)
def test_filter(self):
"""Test _filter method."""
device = self.two_qubit_device
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
sched = Schedule(name='fake_experiment')
sched = sched.insert(0, lp0(device.drives[0]))
sched = sched.insert(10, lp0(device.drives[1]))
sched = sched.insert(30, FrameChange(phase=-1.57)(device.drives[0]))
for i in sched._filter([lambda x: True]).instructions:
self.assertTrue(i in sched.instructions)
self.assertEqual(len(sched._filter([lambda x: False]).instructions), 0)
self.assertEqual(
len(sched._filter([lambda x: x[0] < 30]).instructions), 2)
def my_test_par_sched_one(x, y, z):
result = PulseInstruction(
SamplePulse(np.array([x, y, z]), name='sample'),
device.drives[0])
return 0, result
def my_test_par_sched_two(x, y, z):
result = PulseInstruction(
SamplePulse(np.array([x, y, z]), name='sample'),
device.drives[0])
return 5, result
par_sched_in_0 = ParameterizedSchedule(my_test_par_sched_one,
parameters={
'x': 0,
'y': 1,
'z': 2
})
par_sched_in_1 = ParameterizedSchedule(my_test_par_sched_two,
parameters={
'x': 0,
'y': 1,
'z': 2
})
par_sched = ParameterizedSchedule(par_sched_in_0, par_sched_in_1)
cmd_def = CmdDef()
cmd_def.add('test', 0, par_sched)
actual = cmd_def.get('test', 0, 0.01, 0.02, 0.03)
expected = par_sched_in_0.bind_parameters(0.01, 0.02, 0.03) |\
par_sched_in_1.bind_parameters(0.01, 0.02, 0.03)
self.assertEqual(actual.start_time, expected.start_time)
self.assertEqual(actual.stop_time, expected.stop_time)
self.assertEqual(cmd_def.get_parameters('test', 0), ('x', 'y', 'z'))
def test_parameterized_frame_change(self):
"""Test converted qobj from FrameChangeInstruction."""
cmd = FrameChange(phase=4.)
instruction = cmd(MeasureChannel(0)) << 10
qobj = PulseQobjInstruction(name='fc', ch='m0', t0=10, phase='P1**2')
converted_instruction = self.converter(qobj)
self.assertIsInstance(converted_instruction, ParameterizedSchedule)
evaluated_instruction = converted_instruction.bind_parameters(2.)
self.assertEqual(evaluated_instruction.timeslots, instruction.timeslots)
self.assertEqual(evaluated_instruction.instructions[0][-1].command, cmd)
def test_filter_channels(self):
"""Test filtering over channels."""
device = self.two_qubit_device
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
acquire = Acquire(5)
sched = Schedule(name='fake_experiment')
sched = sched.insert(0, lp0(device.q[0].drive))
sched = sched.insert(10, lp0(device.q[1].drive))
sched = sched.insert(30, FrameChange(phase=-1.57)(device.q[0].drive))
sched = sched.insert(60, acquire(device.q, device.mem))
sched = sched.insert(90, lp0(device.q[0].drive))
self.assertEqual(len(sched.filter(channels=[AcquireChannel(1)]).instructions), 1)
channels = [AcquireChannel(1), DriveChannel(1)]
has_chan_1 = sched.filter(channels=channels)
for _, inst in has_chan_1.instructions:
self.assertTrue(any([chan in channels for chan in inst.channels]))
def test_empty_filters(self):
"""Test behavior on empty filters."""
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
acquire = Acquire(5)
sched = Schedule(name='fake_experiment')
sched = sched.insert(0, lp0(self.config.drive(0)))
sched = sched.insert(10, lp0(self.config.drive(1)))
sched = sched.insert(30,
FrameChange(phase=-1.57)(self.config.drive(0)))
sched = sched.insert(
60,
acquire([self.config.acquire(i) for i in range(2)],
[MemorySlot(i) for i in range(2)]))
sched = sched.insert(90, lp0(self.config.drive(0)))
# empty channels
filtered, excluded = self._filter_and_test_consistency(sched,
channels=[])
self.assertTrue(len(filtered.instructions) == 0)
self.assertTrue(len(excluded.instructions) == 5)
# empty instruction_types
filtered, excluded = self._filter_and_test_consistency(
sched, instruction_types=[])
self.assertTrue(len(filtered.instructions) == 0)
self.assertTrue(len(excluded.instructions) == 5)
# empty time_ranges
filtered, excluded = self._filter_and_test_consistency(sched,
time_ranges=[])
self.assertTrue(len(filtered.instructions) == 0)
self.assertTrue(len(excluded.instructions) == 5)
# empty intervals
filtered, excluded = self._filter_and_test_consistency(sched,
intervals=[])
self.assertTrue(len(filtered.instructions) == 0)
self.assertTrue(len(excluded.instructions) == 5)
# empty channels with other non-empty filters
filtered, excluded = self._filter_and_test_consistency(
sched, channels=[], instruction_types=[PulseInstruction])
self.assertTrue(len(filtered.instructions) == 0)
self.assertTrue(len(excluded.instructions) == 5)
