def test_schedule_with_acquire_on_single_qubit(self):
"""Test schedule with acquire on single qubit."""
sched_single = Schedule()
for i in range(self.config.n_qubits):
sched_single = sched_single.insert(
10,
Acquire(
10, self.config.acquire(i), mem_slot=MemorySlot(i), reg_slot=RegisterSlot(i)
),
)
self.assertEqual(len(sched_single.instructions), 2)
self.assertEqual(len(sched_single.channels), 6)
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_intervals(self):
"""Test filtering on intervals."""
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
sched = Schedule(name="fake_experiment")
sched = sched.insert(0, Play(lp0, self.config.drive(0)))
sched = sched.insert(10, Play(lp0, self.config.drive(1)))
sched = sched.insert(30, ShiftPhase(-1.57, self.config.drive(0)))
for i in range(2):
sched = sched.insert(60, Acquire(5, self.config.acquire(i), MemorySlot(i)))
sched = sched.insert(90, Play(lp0, self.config.drive(0)))
# split schedule into instructions occurring 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), 4)
# split into schedule occurring in and outside of interval (59,65)
filtered, excluded = self._filter_and_test_consistency(sched, time_ranges=[(59, 65)])
self.assertEqual(len(filtered.instructions), 2)
self.assertEqual(filtered.instructions[0][0], 60)
self.assertIsInstance(filtered.instructions[0][1], Acquire)
self.assertEqual(len(excluded.instructions), 4)
self.assertEqual(excluded.instructions[3][0], 90)
self.assertIsInstance(excluded.instructions[3][1], Play)
# 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), 6)
# 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), 4)
# split instructions from non-overlapping intervals, specified as Intervals
filtered, excluded = self._filter_and_test_consistency(
sched, intervals=[(10, 15), (63, 93)]
)
self.assertEqual(len(filtered.instructions), 2)
self.assertEqual(len(excluded.instructions), 4)
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, ShiftPhase(-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, (ShiftPhase, 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_assemble_with_individual_kernels(self):
"""Test that assembly works with individual kernels."""
disc_one = Kernel('disc_one', test_params=True)
disc_two = Kernel('disc_two', test_params=False)
schedule = Schedule()
schedule = schedule.append(
Acquire(5, AcquireChannel(0), MemorySlot(0), kernel=disc_one), )
schedule = schedule.append(
Acquire(5, AcquireChannel(1), MemorySlot(1), kernel=disc_two), )
qobj = assemble(schedule,
qubit_lo_freq=self.default_qubit_lo_freq,
meas_lo_freq=self.default_meas_lo_freq,
meas_map=[[0, 1]])
validate_qobj_against_schema(qobj)
qobj_kernels = qobj.experiments[0].instructions[0].kernels
self.assertEqual(len(qobj_kernels), 2)
self.assertEqual(qobj_kernels[0].name, 'disc_one')
self.assertEqual(qobj_kernels[0].params['test_params'], True)
self.assertEqual(qobj_kernels[1].name, 'disc_two')
self.assertEqual(qobj_kernels[1].params['test_params'], False)
def setUp(self):
self.device = DeviceSpecification(
qubits=[
Qubit(0,
drive_channels=[DriveChannel(0, 1.2)],
acquire_channels=[AcquireChannel(0)])
],
registers=[
RegisterSlot(0)
],
mem_slots=[
MemorySlot(0)
]
)
def setUp(self):
@functional_pulse
def linear(duration, slope, intercept):
x = np.linspace(0, duration - 1, duration)
return slope * x + intercept
self.linear = linear
qubits = [Qubit(0, DriveChannel(0), AcquireChannel(0), MeasureChannel(0),
control_channels=[ControlChannel(0)]),
Qubit(1, DriveChannel(1), MeasureChannel(0), AcquireChannel(1))]
registers = [RegisterSlot(i) for i in range(2)]
mem_slots = [MemorySlot(i) for i in range(2)]
self.two_qubit_device = DeviceSpecification(qubits, registers, mem_slots)
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),
[MemorySlot(0)]) << sched_duration
self.assertEqual(sched.duration, 1525)
self.assertTrue('sigma' in sched.instructions[0][1].pulse.parameters)
def test_align_measures(self):
"""Test that one acquire is delayed to match the time of the later acquire."""
sched = pulse.Schedule(name='fake_experiment')
sched = sched.insert(0, Play(self.short_pulse, self.config.drive(0)))
sched = sched.insert(1,
Acquire(5, self.config.acquire(0), MemorySlot(0)))
sched = sched.insert(10,
Acquire(5, self.config.acquire(1), MemorySlot(1)))
sched = sched.insert(10, Play(self.short_pulse,
self.config.measure(0)))
sched = sched.insert(10, Play(self.short_pulse,
self.config.measure(1)))
sched = align_measures([sched], self.inst_map)[0]
self.assertEqual(sched.name, 'fake_experiment')
for time, inst in sched.instructions:
if isinstance(inst, Acquire):
self.assertEqual(time, 10)
sched = align_measures([sched], self.inst_map, align_time=20)[0]
for time, inst in sched.instructions:
if isinstance(inst, Acquire):
self.assertEqual(time, 20)
if isinstance(inst.channels[0], MeasureChannel):
self.assertEqual(time, 20)
def test_filter_channels(self):
"""Test filtering over channels."""
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
sched = Schedule(name="fake_experiment")
sched = sched.insert(0, Play(lp0, self.config.drive(0)))
sched = sched.insert(10, Play(lp0, self.config.drive(1)))
sched = sched.insert(30, ShiftPhase(-1.57, self.config.drive(0)))
sched = sched.insert(60, Acquire(5, AcquireChannel(0), MemorySlot(0)))
sched = sched.insert(60, Acquire(5, AcquireChannel(1), MemorySlot(1)))
sched = sched.insert(90, Play(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), 5)
# 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 setUp(self):
self.linear = SamplePulse(np.arange(0, 0.01), name='linear')
self.pulse_library = [
PulseLibraryItem(name=self.linear.name,
samples=self.linear.samples.tolist())
]
self.converter = QobjToInstructionConverter(self.pulse_library,
buffer=0)
self.device = DeviceSpecification(qubits=[
Qubit(0, DriveChannel(0), MeasureChannel(0), AcquireChannel(0))
],
registers=[RegisterSlot(0)],
mem_slots=[MemorySlot(0)])
def test_parametric_commands_in_sched(self):
"""Test that schedules can be built with parametric commands."""
sched = Schedule(name='test_parametric')
sched += Play(Gaussian(duration=25, sigma=4, amp=0.5j), DriveChannel(0))
sched += Play(Drag(duration=25, amp=0.2+0.3j, sigma=7.8, beta=4), DriveChannel(1))
sched += Play(Constant(duration=25, amp=1), DriveChannel(2))
sched_duration = sched.duration
sched += Play(GaussianSquare(duration=1500, amp=0.2,
sigma=8, width=140),
MeasureChannel(0)) << sched_duration
with self.assertWarns(DeprecationWarning):
# MemorySlots as list is deprecated
sched += Acquire(1500, AcquireChannel(0), [MemorySlot(0)]) << sched_duration
self.assertEqual(sched.duration, 1525)
self.assertTrue('sigma' in sched.instructions[0][1].pulse.parameters)
def test_multi_acquire(self):
"""Test that an error is raised if multiple acquires occur on the same channel."""
acquire = pulse.Acquire(5)
sched = pulse.Schedule(name='fake_experiment')
sched = sched.insert(0, self.short_pulse(self.config.drive(0)))
sched = sched.insert(4, acquire(self.config.acquire(0), MemorySlot(0)))
sched = sched.insert(10, acquire(self.config.acquire(0), MemorySlot(0)))
with self.assertRaises(PulseError):
align_measures([sched], self.cmd_def)
# Test for measure channel
sched = pulse.Schedule(name='fake_experiment')
sched = sched.insert(10, self.short_pulse(self.config.measure(0)))
sched = sched.insert(30, self.short_pulse(self.config.measure(0)))
with self.assertRaises(PulseError):
align_measures([sched], self.cmd_def)
# Test both using cmd_def
sched = pulse.Schedule()
sched += self.cmd_def.get('measure', (0, 1))
align_measures([sched], align_time=50)
sched += self.cmd_def.get('measure', (0, 1))
with self.assertRaises(PulseError):
align_measures([sched], align_time=50)
def test_assemble_with_single_discriminators(self):
"""Test that assembly works with both a single discriminator."""
disc_one = Discriminator('disc_one', test_params=True)
schedule = Schedule()
schedule = schedule.append(
Acquire(5,
AcquireChannel(0),
MemorySlot(0),
discriminator=disc_one), )
schedule = schedule.append(
Acquire(5, AcquireChannel(1), MemorySlot(1)), )
qobj = assemble(schedule,
qubit_lo_freq=self.default_qubit_lo_freq,
meas_lo_freq=self.default_meas_lo_freq,
meas_map=[[0, 1]])
validate_qobj_against_schema(qobj)
qobj_discriminators = qobj.experiments[0].instructions[
0].discriminators
self.assertEqual(len(qobj_discriminators), 1)
self.assertEqual(qobj_discriminators[0].name, 'disc_one')
self.assertEqual(qobj_discriminators[0].params['test_params'], True)
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 = library.gaussian(duration=20, amp=0.7, sigma=3)
gp1 = library.gaussian(duration=20, amp=0.5, sigma=3)
sched = Schedule()
sched += Play(gp0, self.config.drive(0))
sched |= ShiftPhase(-1.57, self.config.drive(0)) << 60
sched |= Play(gp1, self.config.drive(0)) << 30
sched |= Play(gp0, self.config.control(qubits=[0, 1])[0]) << 60
sched |= Snapshot("label", "snap_type") << 60
sched |= ShiftPhase(1.57, self.config.drive(0)) << 90
sched |= Acquire(10, self.config.acquire(0), MemorySlot(0)) << 90
sched += sched
def setUp(self):
super().setUp()
qubits = [
Qubit(0,
DriveChannel(0),
AcquireChannel(0),
MeasureChannel(0),
control_channels=[ControlChannel(0)]),
Qubit(1, DriveChannel(1), MeasureChannel(0), AcquireChannel(1))
]
registers = [RegisterSlot(i) for i in range(2)]
mem_slots = [MemorySlot(i) for i in range(2)]
self.two_qubit_device = DeviceSpecification(qubits, registers,
mem_slots)
def test_single_and_deprecated_acquire_styles(self):
"""Test that acquires are identically combined with Acquires that take a single channel."""
backend = FakeOpenPulse2Q()
new_style_schedule = Schedule()
acq_dur = 1200
for i in range(5):
new_style_schedule += Acquire(acq_dur, AcquireChannel(i), MemorySlot(i))
deprecated_style_schedule = Schedule()
for i in range(5):
deprecated_style_schedule += Acquire(1200, AcquireChannel(i), MemorySlot(i))
# The Qobj IDs will be different
n_qobj = assemble(new_style_schedule, backend)
n_qobj.qobj_id = None
n_qobj.experiments[0].header.name = None
d_qobj = assemble(deprecated_style_schedule, backend)
d_qobj.qobj_id = None
d_qobj.experiments[0].header.name = None
self.assertEqual(n_qobj, d_qobj)
assembled_acquire = n_qobj.experiments[0].instructions[0]
self.assertEqual(assembled_acquire.qubits, [0, 1, 2, 3, 4])
self.assertEqual(assembled_acquire.memory_slot, [0, 1, 2, 3, 4])
def test_align_post_u3(self):
"""Test that acquires are scheduled no sooner than the duration of the longest X gate.
"""
acquire = pulse.Acquire(5)
sched = pulse.Schedule(name='fake_experiment')
sched = sched.insert(0, self.short_pulse(self.config.drive(0)))
sched = sched.insert(1, acquire(self.config.acquire(0), MemorySlot(0)))
sched = align_measures([sched], self.cmd_def)[0]
for time, inst in sched.instructions:
if isinstance(inst, AcquireInstruction):
self.assertEqual(time, 4)
sched = align_measures([sched], self.cmd_def, max_calibration_duration=10)[0]
for time, inst in sched.instructions:
if isinstance(inst, AcquireInstruction):
self.assertEqual(time, 10)
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 setUp(self):
self.schedule = Schedule()
self.qubits = [
Qubit(0,
drive_channel=DriveChannel(0),
control_channels=[ControlChannel(0)],
measure_channel=MeasureChannel(0),
acquire_channel=AcquireChannel(0)),
Qubit(1,
drive_channel=DriveChannel(1),
acquire_channel=AcquireChannel(1),
measure_channel=MeasureChannel(1))
]
self.registers = [RegisterSlot(i) for i in range(2)]
self.mem_slots = [MemorySlot(i) for i in range(2)]
self.device = DeviceSpecification(self.qubits, self.registers,
self.mem_slots)
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)
acquire = Acquire(10)
sched = Schedule()
sched += gp0(self.config.drive(0))
sched |= PersistentValue(value=0.2 + 0.4j)(self.config.control(0))
sched |= ShiftPhase(-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 |= ShiftPhase(1.57, self.config.drive(0)) << 90
sched |= acquire(self.config.acquire(0), MemorySlot(0),
RegisterSlot(0)) << 90
sched += sched
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)
sched = Schedule()
sched += Play(gp0, self.config.drive(0))
with self.assertWarns(DeprecationWarning):
sched |= PersistentValue(value=0.2 + 0.4j)(self.config.control(
[0, 1])[0])
sched |= ShiftPhase(-1.57, self.config.drive(0)) << 60
sched |= Play(gp1, self.config.drive(0)) << 30
sched |= Play(gp0, self.config.control(qubits=[0, 1])[0]) << 60
sched |= Snapshot("label", "snap_type") << 60
sched |= ShiftPhase(1.57, self.config.drive(0)) << 90
sched |= Acquire(10, self.config.acquire(0), MemorySlot(0)) << 90
sched += sched
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)
def test_schedule_with_acquire_for_back_and_forward_compatibility(self):
"""Test schedule with acquire for back and forward compatibility."""
acquire = Acquire(10)
cmds = [
acquire(AcquireChannel(0), MemorySlot(0)),
acquire([AcquireChannel(0)], MemorySlot(0)),
acquire(AcquireChannel(0), [MemorySlot(0)]),
acquire([AcquireChannel(0)], mem_slots=[MemorySlot(0)]),
acquire(AcquireChannel(0), MemorySlot(0), [RegisterSlot(0)]),
acquire(AcquireChannel(0), MemorySlot(0), reg_slot=RegisterSlot(0))
]
for cmd in cmds:
mixed_schedule = Schedule()
mixed_schedule = mixed_schedule.insert(10, cmd)
self.assertEqual(len(mixed_schedule.instructions), 1)
self.assertTrue(MemorySlot(0) in mixed_schedule.channels)
def test_empty_filters(self):
"""Test behavior on empty filters."""
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
sched = Schedule(name='fake_experiment')
sched = sched.insert(0, Play(lp0, self.config.drive(0)))
sched = sched.insert(10, Play(lp0, self.config.drive(1)))
sched = sched.insert(30, ShiftPhase(-1.57, self.config.drive(0)))
for i in range(2):
sched = sched.insert(
60, Acquire(5, self.config.acquire(i), MemorySlot(i)))
sched = sched.insert(90, Play(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) == 6)
# empty instruction_types
filtered, excluded = self._filter_and_test_consistency(
sched, instruction_types=[])
self.assertTrue(len(filtered.instructions) == 0)
self.assertTrue(len(excluded.instructions) == 6)
# empty time_ranges
filtered, excluded = self._filter_and_test_consistency(sched,
time_ranges=[])
self.assertTrue(len(filtered.instructions) == 0)
self.assertTrue(len(excluded.instructions) == 6)
# empty intervals
filtered, excluded = self._filter_and_test_consistency(sched,
intervals=[])
self.assertTrue(len(filtered.instructions) == 0)
self.assertTrue(len(excluded.instructions) == 6)
# empty channels with other non-empty filters
filtered, excluded = self._filter_and_test_consistency(
sched, channels=[], instruction_types=[Play])
self.assertTrue(len(filtered.instructions) == 0)
self.assertTrue(len(excluded.instructions) == 6)
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,
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)))
# test on Acquire
only_acquire, no_acquire = \
self._filter_and_test_consistency(sched, instruction_types=[AcquireInstruction])
for _, inst in only_acquire.instructions:
self.assertIsInstance(inst, AcquireInstruction)
for _, inst in no_acquire.instructions:
self.assertFalse(isinstance(inst, AcquireInstruction))
# test two instruction types
only_pulse_and_fc, no_pulse_and_fc = \
self._filter_and_test_consistency(sched, instruction_types=[PulseInstruction,
FrameChangeInstruction])
for _, inst in only_pulse_and_fc.instructions:
self.assertIsInstance(inst,
(PulseInstruction, FrameChangeInstruction))
for _, inst in no_pulse_and_fc.instructions:
self.assertFalse(
isinstance(inst, (PulseInstruction, FrameChangeInstruction)))
self.assertEqual(len(only_pulse_and_fc.instructions), 4)
self.assertEqual(len(no_pulse_and_fc.instructions), 1)
# test on FrameChange
only_fc, no_fc = \
self._filter_and_test_consistency(sched, instruction_types={FrameChangeInstruction})
self.assertEqual(len(only_fc.instructions), 1)
self.assertEqual(len(no_fc.instructions), 4)
def test_multiple_acquires(self):
"""Test that multiple acquires are also aligned."""
sched = pulse.Schedule(name="fake_experiment")
sched.insert(0, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True)
sched.insert(5, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True)
sched.insert(10, Acquire(5, self.config.acquire(1), MemorySlot(1)), inplace=True)
ref = pulse.Schedule()
ref.insert(10, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True)
ref.insert(15, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True)
ref.insert(10, Acquire(5, self.config.acquire(1), MemorySlot(1)), inplace=True)
aligned = transforms.align_measures([sched], self.inst_map)[0]
self.assertEqual(aligned, ref)
def test_schedule_with_acquire_for_back_and_forward_compatibility(self):
"""Test schedule with acquire for back and forward compatibility."""
dur = 10
with self.assertWarns(DeprecationWarning):
# mem_slots and reg_slots are deprecated kwargs
cmds = [
Acquire(dur, AcquireChannel(0), MemorySlot(0)),
Acquire(dur, [AcquireChannel(0)], MemorySlot(0)),
Acquire(dur, AcquireChannel(0), [MemorySlot(0)]),
Acquire(dur, [AcquireChannel(0)], mem_slots=[MemorySlot(0)]),
Acquire(dur, AcquireChannel(0), MemorySlot(0), [RegisterSlot(0)]),
Acquire(dur, AcquireChannel(0), MemorySlot(0), reg_slot=RegisterSlot(0))
]
for cmd in cmds:
mixed_schedule = Schedule()
mixed_schedule = mixed_schedule.insert(dur, cmd)
self.assertEqual(len(mixed_schedule.instructions), 1)
self.assertTrue(MemorySlot(0) in mixed_schedule.channels)
def test_name_inherited(self):
"""Test that schedule keeps name if an instruction is added."""
gp0 = library.gaussian(duration=100, amp=0.7, sigma=3, name="pulse_name")
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(10, self.config.acquire(1), MemorySlot(1), name="acq_name") | sched1
self.assertEqual(sched_acq.name, "acq_name")
sched_pulse = Play(gp0, self.config.drive(0)) | sched1
self.assertEqual(sched_pulse.name, "pulse_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_multi_acquire(self):
"""Test that the last acquire is aligned to if multiple acquires occur on the
same channel."""
sched = pulse.Schedule()
sched.insert(0, Play(self.short_pulse, self.config.drive(0)), inplace=True)
sched.insert(4, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True)
sched.insert(20, Acquire(5, self.config.acquire(1), MemorySlot(1)), inplace=True)
sched.insert(10, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True)
aligned = transforms.align_measures([sched], self.inst_map)
ref = pulse.Schedule()
ref.insert(0, Play(self.short_pulse, self.config.drive(0)), inplace=True)
ref.insert(20, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True)
ref.insert(20, Acquire(5, self.config.acquire(1), MemorySlot(1)), inplace=True)
ref.insert(26, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True)
self.assertEqual(aligned[0], ref)
