def test_filter_inst_types(self):
"""Test filtering on instruction types."""
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(40, SetFrequency(8.0, self.config.drive(0)))
sched = sched.insert(50, ShiftFrequency(4.0e6, self.config.drive(0)))
sched = sched.insert(55, SetPhase(3.14, 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)))
# 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), 5)
# 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), 8)
# test on SetPhase
only_setp, no_setp = self._filter_and_test_consistency(
sched, instruction_types={SetPhase})
self.assertEqual(len(only_setp.instructions), 1)
self.assertEqual(len(no_setp.instructions), 8)
# test on SetFrequency
only_setf, no_setf = self._filter_and_test_consistency(
sched, instruction_types=[SetFrequency])
for _, inst in only_setf.instructions:
self.assertTrue(isinstance(inst, SetFrequency))
self.assertEqual(len(only_setf.instructions), 1)
self.assertEqual(len(no_setf.instructions), 8)
# test on ShiftFrequency
only_shiftf, no_shiftf = self._filter_and_test_consistency(
sched, instruction_types=[ShiftFrequency])
for _, inst in only_shiftf.instructions:
self.assertTrue(isinstance(inst, ShiftFrequency))
self.assertEqual(len(only_shiftf.instructions), 1)
self.assertEqual(len(no_shiftf.instructions), 8)
def test_bell_schedule(self):
"""Test complex schedule to create a Bell state."""
with builder.build() as test_sched:
with builder.align_sequential():
# H
builder.shift_phase(-1.57, DriveChannel(0))
builder.play(Drag(160, 0.05, 40, 1.3), DriveChannel(0))
builder.shift_phase(-1.57, DriveChannel(0))
# ECR
with builder.align_left():
builder.play(GaussianSquare(800, 0.05, 64, 544),
DriveChannel(1))
builder.play(GaussianSquare(800, 0.1 - 0.2j, 64, 544),
ControlChannel(0))
builder.play(Drag(160, 0.1, 40, 1.5), DriveChannel(0))
with builder.align_left():
builder.play(GaussianSquare(800, -0.05, 64, 544),
DriveChannel(1))
builder.play(GaussianSquare(800, -0.1 + 0.2j, 64, 544),
ControlChannel(0))
builder.play(Drag(160, 0.1, 40, 1.5), DriveChannel(0))
# Measure
with builder.align_left():
builder.play(GaussianSquare(8000, 0.2, 64, 7744),
MeasureChannel(0))
builder.acquire(8000, AcquireChannel(0), MemorySlot(0))
self.assert_roundtrip_equal(test_sched)
def test_default(self):
"""Test default memory slot."""
memory_slot = MemorySlot(123)
self.assertEqual(memory_slot.index, 123)
self.assertEqual(memory_slot.name, "m123")
self.assertTrue(isinstance(memory_slot, ClassicalIOChannel))
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 = 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_default(self):
"""Test default memory slot.
"""
memory_slot = MemorySlot(123)
self.assertEqual(memory_slot.index, 123)
self.assertEqual(memory_slot.name, 'm123')
def test_assemble_meas_map(self):
"""Test assembling a single schedule, no lo config."""
acquire = pulse.Acquire(5)
schedule = acquire([AcquireChannel(0), AcquireChannel(1)],
[MemorySlot(0), 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)
with self.assertRaises(QiskitError):
assemble(schedule,
qubit_lo_freq=self.default_qubit_lo_freq,
meas_lo_freq=self.default_meas_lo_freq,
meas_map=[[0, 1, 2]])
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_pad_no_delay_on_classical_io_channels(self):
"""Test padding does not apply to classical IO channels."""
delay = 10
sched = (
Delay(delay, MemorySlot(0)).shift(20)
+ Delay(delay, RegisterSlot(0)).shift(10)
+ Delay(delay, SnapshotChannel())
)
ref_sched = (
Delay(delay, MemorySlot(0)).shift(20)
+ Delay(delay, RegisterSlot(0)).shift(10)
+ Delay(delay, SnapshotChannel())
)
self.assertEqual(transforms.pad(sched, until=15), ref_sched)
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 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 setUp(self):
self.backend_config = FakeOpenPulse2Q().configuration()
test_pulse = pulse.SamplePulse(samples=np.array(
[0.02739068, 0.05, 0.05, 0.05, 0.02739068], dtype=np.complex128),
name='pulse0')
self.schedule = pulse.Schedule(name='fake_experiment')
self.schedule = self.schedule.insert(
0, Play(test_pulse, self.backend_config.drive(0)))
for i in range(self.backend_config.n_qubits):
self.schedule = self.schedule.insert(
5, Acquire(5, self.backend_config.acquire(i), MemorySlot(i)))
self.user_lo_config_dict = {self.backend_config.drive(0): 4.91e9}
self.user_lo_config = pulse.LoConfig(self.user_lo_config_dict)
self.default_qubit_lo_freq = [4.9e9, 5.0e9]
self.default_meas_lo_freq = [6.5e9, 6.6e9]
self.config = {
'meas_level': 1,
'memory_slot_size': 100,
'meas_return': 'avg',
'rep_time': 0.0001,
}
self.header = {
'backend_name': 'FakeOpenPulse2Q',
'backend_version': '0.0.0'
}
def test_align_across_schedules(self):
"""Test that acquires are aligned together across multiple schedules."""
acquire = pulse.Acquire(5)
sched1 = pulse.Schedule(name='fake_experiment')
sched1 = sched1.insert(0, self.short_pulse(self.config.drive(0)))
sched1 = sched1.insert(10, acquire(self.config.acquire(0), MemorySlot(0)))
sched2 = pulse.Schedule(name='fake_experiment')
sched2 = sched2.insert(3, self.short_pulse(self.config.drive(0)))
sched2 = sched2.insert(25, acquire(self.config.acquire(0), MemorySlot(0)))
schedules = align_measures([sched1, sched2], self.cmd_def)
for time, inst in schedules[0].instructions:
if isinstance(inst, AcquireInstruction):
self.assertEqual(time, 25)
for time, inst in schedules[0].instructions:
if isinstance(inst, AcquireInstruction):
self.assertEqual(time, 25)
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 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 test_keep_original_schedule_after_attached_to_another_schedule(self):
"""Test if a schedule keeps its children after attached to another schedule."""
children = Acquire(10, self.config.acquire(0), MemorySlot(0)).shift(20) + Acquire(
10, self.config.acquire(0), MemorySlot(0)
)
self.assertEqual(2, len(list(children.instructions)))
sched = Acquire(10, 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(10, self.config.acquire(0), MemorySlot(0)))
children = children.insert(100, Acquire(10, 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_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_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_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."""
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(
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 = fc0(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 _simple_1Q_schedule(self, phi, total_samples, shape="square", gauss_sigma=0):
"""Creates schedule for single pulse test
Args:
phi (float): drive phase (phi in Hamiltonian)
total_samples (int): length of pulses
shape (str): shape of the pulse; defaults to square pulse
gauss_sigma (float): std dev for gaussian pulse if shape=="gaussian"
Returns:
schedule (pulse schedule): schedule for this test
"""
# set up pulse command
phase = np.exp(1j * phi)
drive_pulse = None
if shape == "square":
const_pulse = np.ones(total_samples)
drive_pulse = SamplePulse(phase * const_pulse, name='drive_pulse')
if shape == "gaussian":
times = 1.0 * np.arange(total_samples)
gaussian = np.exp(-times**2 / 2 / gauss_sigma**2)
drive_pulse = SamplePulse(phase * gaussian, name='drive_pulse')
# set up acquire command
acq_cmd = pulse.Acquire(duration=total_samples)
# add commands into a schedule for first qubit
schedule = pulse.Schedule(name='drive_pulse')
schedule |= drive_pulse(DriveChannel(0))
schedule |= acq_cmd(AcquireChannel(0), MemorySlot(0)) << schedule.duration
return schedule
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([AcquireChannel(i) for i in range(self.n_qubits)],
[MemorySlot(i) for i in range(self.n_qubits)],
[RegisterSlot(i) for i in range(self.n_qubits)])
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,
instruction.timeslots)
self.assertEqual(converted_instruction.instructions[0][-1].command,
cmd)
def test_name_inherited(self):
"""Test that schedule keeps name if an instruction is added."""
gp0 = pulse_lib.gaussian(duration=100,
amp=0.7,
sigma=3,
name='pulse_name')
with self.assertWarns(DeprecationWarning):
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(
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')
with self.assertWarns(DeprecationWarning):
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_assemble_with_unequal_kernels(self):
"""Test that assembly works with incorrect number of discriminators for
number of qubits."""
disc_one = Kernel('disc_one', test_params=True)
disc_two = Kernel('disc_two', test_params=False)
schedule = Schedule()
schedule += Acquire(5, AcquireChannel(0), MemorySlot(0), kernel=disc_one)
schedule += Acquire(5, AcquireChannel(1), MemorySlot(1), kernel=disc_two)
schedule += Acquire(5, AcquireChannel(2), MemorySlot(2))
with self.assertRaises(QiskitError):
assemble(schedule,
qubit_lo_freq=self.default_qubit_lo_freq,
meas_lo_freq=self.default_meas_lo_freq,
meas_map=[[0, 1, 2]])
def test_multiple_acquires(self):
"""Test for multiple acquires."""
sched = pulse.Schedule()
acq_q0 = pulse.Acquire(1200, AcquireChannel(0), MemorySlot(0))
sched += acq_q0
sched += acq_q0 << sched.duration
sched = transforms.add_implicit_acquires(sched, meas_map=[[0]])
self.assertEqual(sched.instructions, ((0, acq_q0), (2400, acq_q0)))
def test_assemble_meas_map(self):
"""Test assembling a single schedule, no lo config."""
schedule = Schedule(name='fake_experiment')
schedule = schedule.insert(5, Acquire(5, AcquireChannel(0), MemorySlot(0)))
schedule = schedule.insert(5, 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)
with self.assertRaises(QiskitError):
assemble(schedule,
qubit_lo_freq=self.default_qubit_lo_freq,
meas_lo_freq=self.default_meas_lo_freq,
meas_map=[[0, 1, 2]])
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 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 device specification.
"""
spec = PulseChannelSpec(n_qubits=2, n_control=0, n_registers=2)
self.assertEqual(spec.drives[0], DriveChannel(0))
self.assertEqual(spec.acquires[1], AcquireChannel(1))
self.assertEqual(spec.memoryslots[0], MemorySlot(0))
self.assertEqual(spec.registers[1], RegisterSlot(1))
def test_measurement_at_zero(self):
"""Test that acquire at t=0 works."""
sched1 = pulse.Schedule(name='fake_experiment')
sched1 = sched1.insert(0, Play(self.short_pulse, self.config.drive(0)))
sched1 = sched1.insert(
0, Acquire(5, self.config.acquire(0), MemorySlot(0)))
sched2 = pulse.Schedule(name='fake_experiment')
sched2 = sched2.insert(0, Play(self.short_pulse, self.config.drive(0)))
sched2 = sched2.insert(
0, Acquire(5, self.config.acquire(0), MemorySlot(0)))
schedules = transforms.align_measures([sched1, sched2],
max_calibration_duration=0)
for time, inst in schedules[0].instructions:
if isinstance(inst, Acquire):
self.assertEqual(time, 0)
for time, inst in schedules[0].instructions:
if isinstance(inst, Acquire):
self.assertEqual(time, 0)
