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 test_acquire(self):
"""Test converted qobj from AcquireInstruction."""
cmd = Acquire(10,
kernel=Kernel(name='test_kern',
params={'test_params': 'test'}),
discriminator=Discriminator(name='test_disc',
params={'test_params': 1.0}))
schedule = Schedule()
for i in range(self.n_qubits):
schedule |= cmd(AcquireChannel(i), MemorySlot(i), RegisterSlot(i))
qobj = PulseQobjInstruction(
name='acquire',
t0=0,
duration=10,
qubits=[0, 1],
memory_slot=[0, 1],
register_slot=[0, 1],
kernels=[
QobjMeasurementOption(name='test_kern',
params={'test_params': 'test'})
],
discriminators=[
QobjMeasurementOption(name='test_disc',
params={'test_params': 1.0})
])
converted_instruction = self.converter(qobj)
self.assertEqual(converted_instruction.timeslots, schedule.timeslots)
self.assertEqual(converted_instruction.instructions[0][-1].command,
cmd)
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 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_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 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_name_inherited(self):
"""Test that schedule keeps name if an instruction is added."""
acquire = Acquire(10)
gp0 = pulse_lib.gaussian(duration=100,
amp=0.7,
sigma=3,
name='pulse_name')
pv0 = PersistentValue(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(
self.config.acquire(1), MemorySlot(1), name='acq_name') | sched1
self.assertEqual(sched_acq.name, 'acq_name')
sched_pulse = gp0(self.config.drive(0)) | sched1
self.assertEqual(sched_pulse.name, 'pulse_name')
sched_pv = pv0(self.config.drive(0), name='pv_name') | sched1
self.assertEqual(sched_pv.name, 'pv_name')
sched_fc = ShiftPhase(0.1, self.config.drive(0),
name='fc_name') | sched1
self.assertEqual(sched_fc.name, 'fc_name')
sched_snapshot = snapshot | sched1
self.assertEqual(sched_snapshot.name, 'snapshot_label')
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_deprecated_acquire(self):
"""Test converted qobj from AcquireInstruction."""
converter = InstructionToQobjConverter(PulseQobjInstruction, meas_level=2)
with self.assertWarns(DeprecationWarning):
command = Acquire(duration=10)
with self.assertWarns(DeprecationWarning):
instruction = command(AcquireChannel(0),
MemorySlot(0),
RegisterSlot(0))
valid_qobj = PulseQobjInstruction(
name='acquire',
t0=0,
duration=10,
qubits=[0],
memory_slot=[0],
register_slot=[0]
)
self.assertEqual(converter(0, instruction), valid_qobj)
# test without register
with self.assertWarns(DeprecationWarning):
instruction = command(AcquireChannel(0), MemorySlot(0))
valid_qobj = PulseQobjInstruction(
name='acquire',
t0=0,
duration=10,
qubits=[0],
memory_slot=[0]
)
self.assertEqual(converter(0, instruction), valid_qobj)
def test_truncate_acquisition(self):
sched = Schedule()
acquire = Acquire(30)
sched = sched.insert(
0, acquire(AcquireChannel(1), MemorySlot(1), RegisterSlot(1)))
# Check ValueError is not thrown
sched.draw(plot_range=(0, 15))
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,
ConstantPulse(duration=60, amp=0.2 + 0.4j)(ControlChannel(0)))
sched = sched.insert(60, FrameChange(phase=-1.57)(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_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_acquire(self):
"""Test converted qobj from AcquireInstruction."""
cmd = Acquire(
10, Discriminator(name='test_disc', params={'test_params': 1.0}),
Kernel(name='test_kern', params={'test_params': 'test'}))
instruction = cmd(self.device.q, self.device.mem, self.device.c)
qobj = PulseQobjInstruction(
name='acquire',
t0=0,
duration=10,
qubits=[0],
memory_slot=[0],
register_slot=[0],
kernels=[
QobjMeasurementOption(name='test_kern',
params={'test_params': 'test'})
],
discriminators=[
QobjMeasurementOption(name='test_disc',
params={'test_params': 1.0})
])
converted_instruction = self.converter(qobj)
self.assertEqual(converted_instruction.timeslots,
instruction.timeslots)
self.assertEqual(converted_instruction.instructions[0][-1].command,
cmd)
def test_acquire(self):
"""Test converted qobj from AcquireInstruction."""
converter = InstructionToQobjConverter(PulseQobjInstruction,
meas_level=2)
command = Acquire(duration=10)
instruction = command(self.device.q, self.device.mem, self.device.c)
valid_qobj = PulseQobjInstruction(name='acquire',
t0=0,
duration=10,
qubits=[0],
memory_slot=[0],
register_slot=[0])
self.assertEqual(converter(0, instruction), valid_qobj)
# test without register
instruction = command(self.device.q, self.device.mem)
valid_qobj = PulseQobjInstruction(name='acquire',
t0=0,
duration=10,
qubits=[0],
memory_slot=[0])
self.assertEqual(converter(0, instruction), valid_qobj)
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_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_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_truncate_acquisition(self):
sched = Schedule()
acquire = Acquire(30)
sched = sched.insert(0, acquire(self.device.acquires[1],
self.device.memoryslots[1],
self.device.registers[1]))
# Check ValueError is not thrown
sched.draw(plot_range=(0, 15))
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_default(self):
"""Test default discriminator and kernel.
"""
acq_comm = Acquire(duration=10)
self.assertEqual(acq_comm.duration, 10)
self.assertEqual(acq_comm.discriminator.name, None)
self.assertEqual(acq_comm.discriminator.params, {})
self.assertEqual(acq_comm.kernel.name, None)
self.assertEqual(acq_comm.kernel.params, {})
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_schedule_with_acquire_on_single_qubit(self):
"""Test schedule with acquire on single qubit."""
acquire = Acquire(10)
sched_single = Schedule()
for i in range(self.config.n_qubits):
sched_single = sched_single.insert(
10,
acquire(self.config.acquire(i), MemorySlot(i),
RegisterSlot(i)))
self.assertEqual(len(sched_single.instructions), 2)
self.assertEqual(len(sched_single.channels), 6)
def test_schedule_with_acquire_on_multiple_qubits(self):
"""Test schedule with acquire on multiple qubits."""
acquire = Acquire(10)
sched_multiple = Schedule()
qubits = [self.config.acquire(i) for i in range(self.config.n_qubits)]
mem_slots = [MemorySlot(i) for i in range(self.config.n_qubits)]
reg_slots = [RegisterSlot(i) for i in range(self.config.n_qubits)]
sched_multiple = sched_multiple.insert(
10, acquire(qubits, mem_slots, reg_slots))
self.assertEqual(len(sched_multiple.instructions), 1)
self.assertEqual(len(sched_multiple.channels), 6)
def test_delay_acquire_channel(self):
"""Test Delay on DriveChannel"""
acquire_ch = self.config.acquire(0)
acquire = Acquire(10)
# should pass as is an append
sched = self.delay(acquire_ch) + acquire(acquire_ch, MemorySlot(0))
self.assertIsInstance(sched, Schedule)
# should fail due to overlap
with self.assertRaises(PulseError):
sched = self.delay(acquire_ch) | acquire(acquire_ch)
self.assertIsInstance(sched, Schedule)
def test_parametric_commands_in_sched(self):
"""Test that schedules can be built with parametric commands."""
sched = Schedule(name='test_parametric')
sched += Gaussian(duration=25, sigma=4, amp=0.5j)(DriveChannel(0))
sched += Drag(duration=25, amp=0.2+0.3j, sigma=7.8, beta=4)(DriveChannel(1))
sched += ConstantPulse(duration=25, amp=1)(DriveChannel(2))
sched_duration = sched.duration
sched += GaussianSquare(duration=1500, amp=0.2,
sigma=8, width=140)(MeasureChannel(0)) << sched_duration
sched += Acquire(duration=1500)(AcquireChannel(0),
mem_slots=[MemorySlot(0)]) << sched_duration
self.assertEqual(sched.duration, 1525)
self.assertTrue('sigma' in sched.instructions[0][1].command.parameters)
def test_acquire(self):
"""Test converted qobj from AcquireInstruction."""
converter = InstructionToQobjConverter(PulseQobjInstruction, meas_level=2)
instruction = Acquire(10, AcquireChannel(0), MemorySlot(0), RegisterSlot(0))
valid_qobj = PulseQobjInstruction(
name='acquire',
t0=0,
duration=10,
qubits=[0],
memory_slot=[0],
register_slot=[0])
self.assertEqual(converter(0, instruction), valid_qobj)
# without register
instruction = Acquire(10, AcquireChannel(0), MemorySlot(0))
valid_qobj = PulseQobjInstruction(
name='acquire',
t0=0,
duration=10,
qubits=[0],
memory_slot=[0])
self.assertEqual(converter(0, instruction), valid_qobj)
def test_filter_inst_types(self):
"""Test filtering on instruction types."""
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, ShiftPhase(-1.57, self.config.drive(0)))
sched = sched.insert(40, SetFrequency(8.0, 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)))
# test on Acquire
only_acquire, no_acquire = \
self._filter_and_test_consistency(sched, instruction_types=[Acquire])
for _, inst in only_acquire.instructions:
self.assertIsInstance(inst, Acquire)
for _, inst in no_acquire.instructions:
self.assertFalse(isinstance(inst, Acquire))
# test two instruction types
only_pulse_and_fc, no_pulse_and_fc = \
self._filter_and_test_consistency(sched, instruction_types=[Play,
ShiftPhase])
for _, inst in only_pulse_and_fc.instructions:
self.assertIsInstance(inst, (Play, ShiftPhase))
for _, inst in no_pulse_and_fc.instructions:
self.assertFalse(isinstance(inst, (Play, ShiftPhase)))
self.assertEqual(len(only_pulse_and_fc.instructions), 4)
self.assertEqual(len(no_pulse_and_fc.instructions), 3)
# test on ShiftPhase
only_fc, no_fc = \
self._filter_and_test_consistency(sched, instruction_types={ShiftPhase})
self.assertEqual(len(only_fc.instructions), 1)
self.assertEqual(len(no_fc.instructions), 6)
# test on SetFrequency
only_sf, no_sf = \
self._filter_and_test_consistency(sched,
instruction_types=[SetFrequency])
for _, inst in only_sf.instructions:
self.assertTrue(isinstance(inst, SetFrequency))
self.assertEqual(len(only_sf.instructions), 1)
self.assertEqual(len(no_sf.instructions), 6)
def test_keep_original_schedule_after_attached_to_another_schedule(self):
"""Test if a schedule keeps its _children after attached to another schedule."""
acquire = Acquire(10)
_children = (acquire(self.config.acquire(0), MemorySlot(0)).shift(20) +
acquire(self.config.acquire(0), MemorySlot(0)))
self.assertEqual(2, len(list(_children.instructions)))
sched = acquire(self.config.acquire(0), MemorySlot(0)).append(_children)
self.assertEqual(3, len(list(sched.instructions)))
# add 2 instructions to _children (2 instructions -> 4 instructions)
_children = _children.append(acquire(self.config.acquire(0), MemorySlot(0)))
_children = _children.insert(100, acquire(self.config.acquire(0),
MemorySlot(0)))
self.assertEqual(4, len(list(_children.instructions)))
# sched must keep 3 instructions (must not update to 5 instructions)
self.assertEqual(3, len(list(sched.instructions)))
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]))
