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."""
gp0 = pulse_lib.gaussian(duration=20, amp=0.7, sigma=3)
gp1 = pulse_lib.gaussian(duration=20, amp=0.7, sigma=3)
sched = Schedule()
sched = sched.append(Play(gp0, self.config.drive(0)))
with self.assertWarns(DeprecationWarning):
sched = sched.insert(
0,
PersistentValue(value=0.2 + 0.4j)(self.config.control([0,
1])[0]))
sched = sched.insert(60, ShiftPhase(-1.57, self.config.drive(0)))
sched = sched.insert(30, Play(gp1, self.config.drive(0)))
sched = sched.insert(60, Play(gp0, self.config.control([0, 1])[0]))
sched = sched.insert(80, Snapshot("label", "snap_type"))
sched = sched.insert(90, ShiftPhase(1.57, self.config.drive(0)))
sched = sched.insert(
90,
Acquire(10, self.config.acquire(0), MemorySlot(0),
RegisterSlot(0))) # TODO: this shouldn't raise a warning
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)
ids = set()
for _, inst in sched.instructions:
self.assertFalse(inst.id in ids)
ids.add(inst.id)
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 sample_schedule(self):
"""Generate a sample schedule that includes the most common elements of
pulse schedules."""
gp0 = library.gaussian(duration=20, amp=1.0, sigma=1.0)
gp1 = library.gaussian(duration=20, amp=-1.0, sigma=2.0)
gs0 = library.gaussian_square(duration=20, amp=-1.0, sigma=2.0, risefall=3)
sched = Schedule(name='test_schedule')
sched = sched.append(gp0(DriveChannel(0)))
sched = sched.insert(0, Play(library.Constant(duration=60, amp=0.2 + 0.4j),
ControlChannel(0)))
sched = sched.insert(60, ShiftPhase(-1.57, DriveChannel(0)))
sched = sched.insert(60, SetFrequency(8.0, DriveChannel(0)))
sched = sched.insert(60, SetPhase(3.14, DriveChannel(0)))
sched = sched.insert(70, ShiftFrequency(4.0e6, DriveChannel(0)))
sched = sched.insert(30, Play(gp1, DriveChannel(1)))
sched = sched.insert(60, Play(gp0, ControlChannel(0)))
sched = sched.insert(60, Play(gs0, MeasureChannel(0)))
sched = sched.insert(90, ShiftPhase(1.57, DriveChannel(0)))
sched = sched.insert(90, Acquire(10,
AcquireChannel(1),
MemorySlot(1),
RegisterSlot(1)))
sched = sched.append(Delay(100, 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 = library.gaussian(duration=20, amp=0.7, sigma=3)
gp1 = library.gaussian(duration=20, amp=0.7, sigma=3)
sched = Schedule()
sched = sched.append(Play(gp0, self.config.drive(0)))
sched = sched.insert(60, ShiftPhase(-1.57, self.config.drive(0)))
sched = sched.insert(30, Play(gp1, self.config.drive(0)))
sched = sched.insert(60, Play(gp0, self.config.control([0, 1])[0]))
sched = sched.insert(80, Snapshot("label", "snap_type"))
sched = sched.insert(90, ShiftPhase(1.57, self.config.drive(0)))
sched = sched.insert(
90, Acquire(10, 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)
ids = set()
for _, inst in sched.instructions:
self.assertFalse(inst.id in ids)
ids.add(inst.id)
def block_to_schedule(block: ScheduleBlock) -> Schedule:
"""Convert ``ScheduleBlock`` to ``Schedule``.
Args:
block: A ``ScheduleBlock`` to convert.
Returns:
Scheduled pulse program.
Raises:
UnassignedDurationError: When any instruction duration is not assigned.
"""
if not block.is_schedulable():
raise UnassignedDurationError(
'All instruction durations should be assigned before creating `Schedule`.'
'Please check `.parameters` to find unassigned parameter objects.')
schedule = Schedule(name=block.name, metadata=block.metadata)
for op_data in block.instructions:
if isinstance(op_data, ScheduleBlock):
context_schedule = block_to_schedule(op_data)
schedule.append(context_schedule, inplace=True)
else:
schedule.append(op_data, inplace=True)
# transform with defined policy
return block.alignment_context.align(schedule)
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(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(self.device.drives[0]))
sched = sched.insert(
0,
PersistentValue(value=0.2 + 0.4j)(self.device.controls[0]))
sched = sched.insert(60,
FrameChange(phase=-1.57)(self.device.drives[0]))
sched = sched.insert(30, gp1(self.device.drives[1]))
sched = sched.insert(60, gp0(self.device.controls[0]))
sched = sched.insert(60, gs0(self.device.measures[0]))
sched = sched.insert(90, fc_pi_2(self.device.drives[0]))
sched = sched.insert(
90,
acquire(self.device.acquires[1], self.device.memoryslots[1],
self.device.registers[1]))
sched = sched.append(delay(self.device.drives[0]))
sched = sched + sched
sched |= Snapshot("snapshot_1", "snap_type") << 60
sched |= Snapshot("snapshot_2", "snap_type") << 120
return sched
def test_same_commands_on_two_channels_at_same_time_out_of_order(self):
"""Test that schedule with same commands on two channels at the same time equal
when out of order."""
sched1 = Schedule()
sched1 = sched1.append(Delay(100, DriveChannel(1)))
sched1 = sched1.append(Delay(100, ControlChannel(1)))
sched2 = Schedule()
sched2 = sched2.append(Delay(100, ControlChannel(1)))
sched2 = sched2.append(Delay(100, DriveChannel(1)))
self.assertEqual(sched1, sched2)
def test_absolute_start_time_of_grandchild(self):
"""Test correct calculation of start time of grandchild of a schedule."""
lp0 = self.linear(duration=10, slope=0.02, intercept=0.01)
subsched = Schedule()
subsched = subsched.insert(20, Play(lp0, self.config.drive(0))) # grand child 1
subsched = subsched.append(Play(lp0, self.config.drive(0))) # grand child 2
sched = Schedule()
sched = sched.append(Play(lp0, self.config.drive(0))) # child
sched = sched.append(subsched)
start_times = sorted([shft + instr.start_time for shft, instr in sched.instructions])
self.assertEqual([0, 30, 40], start_times)
def test_absolute_start_time_of_grandchild(self):
"""Test correct calculation of start time of grandchild of a schedule."""
device = self.two_qubit_device
lp0 = self.linear(duration=10, slope=0.02, intercept=0.01)
subsched = Schedule()
subsched = subsched.insert(20, lp0(device.q[0].drive)) # grand child 1
subsched = subsched.append(lp0(device.q[0].drive)) # grand child 2
sched = Schedule()
sched = sched.append(lp0(device.q[0].drive)) # child
sched = sched.append(subsched)
start_times = sorted(
[i.start_time for i in sched.flat_instruction_sequence()])
self.assertEqual([0, 30, 40], start_times)
def test_shift_schedule(self):
"""Test shift schedule."""
lp0 = self.linear(duration=10, slope=0.02, intercept=0.01)
subsched = Schedule()
subsched = subsched.insert(20, Play(lp0, self.config.drive(0))) # grand child 1
subsched = subsched.append(Play(lp0, self.config.drive(0))) # grand child 2
sched = Schedule()
sched = sched.append(Play(lp0, self.config.drive(0))) # child
sched = sched.append(subsched)
shift = sched.shift(100)
start_times = sorted([shft + instr.start_time for shft, instr in shift.instructions])
self.assertEqual([100, 130, 140], start_times)
def test_append_an_instruction_to_empty_schedule(self):
"""Test append instructions to an empty schedule."""
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
sched = Schedule()
sched = sched.append(Play(lp0, self.config.drive(0)))
self.assertEqual(0, sched.start_time)
self.assertEqual(3, sched.stop_time)
def test_shift_schedule(self):
"""Test shift schedule."""
device = self.two_qubit_device
lp0 = self.linear(duration=10, slope=0.02, intercept=0.01)
subsched = Schedule()
subsched = subsched.insert(20, lp0(device.q[0].drive)) # grand child 1
subsched = subsched.append(lp0(device.q[0].drive)) # grand child 2
sched = Schedule()
sched = sched.append(lp0(device.q[0].drive)) # child
sched = sched.append(subsched)
shift = sched.shift(100)
start_times = sorted([shft+instr.start_time for shft, instr in shift.instructions])
self.assertEqual([100, 130, 140], start_times)
def test_len(self):
"""Test __len__ method"""
sched = Schedule()
self.assertEqual(len(sched), 0)
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
for j in range(1, 10):
sched = sched.append(Play(lp0, self.config.drive(0)))
self.assertEqual(len(sched), j)
def test_append_an_instruction_to_empty_schedule(self):
"""Test append instructions to an empty schedule."""
device = self.two_qubit_device
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
sched = Schedule()
sched = sched.append(lp0(device.q[0].drive))
self.assertEqual(0, sched.start_time)
self.assertEqual(3, sched.stop_time)
def test_deprecated_style(self):
"""Test append instructions to an empty schedule."""
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
sched = Schedule()
with self.assertWarns(DeprecationWarning):
sched = sched.append(lp0(self.config.drive(0)))
self.assertEqual(0, sched.start_time)
self.assertEqual(3, sched.stop_time)
def test_append_instructions_applying_to_different_channels(self):
"""Test append instructions to schedule."""
device = self.two_qubit_device
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
sched = Schedule()
sched = sched.append(lp0(device.q[0].drive))
sched = sched.append(lp0(device.q[1].drive))
self.assertEqual(0, sched.start_time)
self.assertEqual(6, sched.stop_time)
def test_append_instructions_applying_to_different_channels(self):
"""Test append instructions to schedule."""
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
sched = Schedule()
sched = sched.append(Play(lp0, self.config.drive(0)))
sched = sched.append(Play(lp0, self.config.drive(1)))
self.assertEqual(0, sched.start_time)
# appending to separate channel so should be at same time.
self.assertEqual(3, sched.stop_time)
def test_flat_instruction_sequence_returns_instructions(self):
"""Test if `flat_instruction_sequence` returns `Instruction`s."""
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
# empty schedule with empty schedule
empty = Schedule().append(Schedule())
for _, instr in empty.instructions:
self.assertIsInstance(instr, Instruction)
# normal schedule
subsched = Schedule()
subsched = subsched.insert(20, Play(lp0, self.config.drive(0))) # grand child 1
subsched = subsched.append(Play(lp0, self.config.drive(0))) # grand child 2
sched = Schedule()
sched = sched.append(Play(lp0, self.config.drive(0))) # child
sched = sched.append(subsched)
for _, instr in sched.instructions:
self.assertIsInstance(instr, Instruction)
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_flat_instruction_sequence_returns_instructions(self):
"""Test if `flat_instruction_sequence` returns `Instruction`s."""
device = self.two_qubit_device
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
# empty schedule with empty schedule
empty = Schedule().append(Schedule())
for _, instr in empty.instructions:
self.assertIsInstance(instr, Instruction)
# normal schedule
subsched = Schedule()
subsched = subsched.insert(20, lp0(device.q[0].drive)) # grand child 1
subsched = subsched.append(lp0(device.q[0].drive)) # grand child 2
sched = Schedule()
sched = sched.append(lp0(device.q[0].drive)) # child
sched = sched.append(subsched)
for _, instr in sched.instructions:
self.assertIsInstance(instr, Instruction)
def test_schedule_drawer_show_framechange(self):
filename = self._get_resource_path('current_show_framechange_ref.png')
gp0 = library.gaussian(duration=20, amp=1.0, sigma=1.0)
sched = Schedule(name='test_schedule')
sched = sched.append(Play(gp0, DriveChannel(0)))
sched = sched.insert(60, ShiftPhase(-1.57, DriveChannel(0)))
sched = sched.insert(30, ShiftPhase(-1.50, DriveChannel(1)))
sched = sched.insert(70, ShiftPhase(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_absolute_start_time_of_grandchild(self):
"""Test correct calculation of start time of grandchild of a schedule.
"""
device = self.two_qubit_device
acquire = Acquire(10)
children = Schedule()
children = children.insert(20, acquire(device.q[1],
device.mem[1])) # grand child 1
children = children.append(acquire(device.q[1],
device.mem[1])) # grand child 2
sched = Schedule()
sched = sched.append(acquire(device.q[1], device.mem[1])) # child
sched = sched.append(children)
start_times = sorted(
[i.start_time for i in sched.flat_instruction_sequence()])
self.assertEqual([0, 30, 40], start_times)
def test_append_instructions_applying_to_different_channels(self):
"""Test append instructions to schedule."""
device = self.two_qubit_device
lp0 = self.linear(duration=3, slope=0.2, intercept=0.1)
sched = Schedule()
sched = sched.append(lp0(device.drives[0]))
sched = sched.append(lp0(device.drives[1]))
self.assertEqual(0, sched.start_time)
# appending to separate channel so should be at same time.
self.assertEqual(3, sched.stop_time)
def test_keep_original_schedule_after_attached_to_another_schedule(self):
"""Test if a schedule keeps its children after attached to another schedule."""
device = self.two_qubit_device
acquire = Acquire(10)
children = Schedule()\
.insert(20, acquire(device.q[1], device.mem[1]))\
.append(acquire(device.q[1], device.mem[1]))
self.assertEqual(2, len(children.flat_instruction_sequence()))
sched = Schedule()\
.append(acquire(device.q[1], device.mem[1]))\
.append(children)
self.assertEqual(3, len(sched.flat_instruction_sequence()))
# add 2 instructions to children (2 instructions -> 4 instructions)
children = children.append(acquire(device.q[1], device.mem[1]))
children = children.insert(100, acquire(device.q[1], device.mem[1]))
self.assertEqual(4, len(children.flat_instruction_sequence()))
# sched must keep 3 instructions (must not update to 5 instructions)
self.assertEqual(3, len(sched.flat_instruction_sequence()))
