def test_overlapping_on_assignment(self):
"""Test that assignment will catch against existing instructions."""
schedule = pulse.Schedule()
schedule |= pulse.Play(pulse.SamplePulse([1, 1, 1, 1]), DriveChannel(1))
schedule |= pulse.Play(pulse.SamplePulse([1, 1, 1, 1]), DriveChannel(self.qubit))
with self.assertRaises(PulseError):
schedule.assign_parameters({self.qubit: 1})
def test_assemble_sample_pulse(self):
"""Test that the pulse lib and qobj instruction can be paired up."""
schedule = pulse.Schedule()
schedule += pulse.Play(pulse.SamplePulse([0.1] * 16, name='test0'),
pulse.DriveChannel(0),
name='test1')
schedule += pulse.Play(pulse.SamplePulse([0.1] * 16, name='test1'),
pulse.DriveChannel(0),
name='test2')
schedule += pulse.Play(pulse.SamplePulse([0.5] * 16, name='test0'),
pulse.DriveChannel(0),
name='test1')
qobj = assemble(schedule,
qobj_header=self.header,
qubit_lo_freq=self.default_qubit_lo_freq,
meas_lo_freq=self.default_meas_lo_freq,
schedule_los=[],
**self.config)
validate_qobj_against_schema(qobj)
test_dict = qobj.to_dict()
experiment = test_dict['experiments'][0]
inst0_name = experiment['instructions'][0]['name']
inst1_name = experiment['instructions'][1]['name']
inst2_name = experiment['instructions'][2]['name']
pulses = {}
for item in test_dict['config']['pulse_library']:
pulses[item['name']] = item['samples']
self.assertTrue(
all(name in pulses
for name in [inst0_name, inst1_name, inst2_name]))
# Their pulses are the same
self.assertEqual(inst0_name, inst1_name)
self.assertTrue(np.allclose(pulses[inst0_name], [0.1] * 16))
self.assertTrue(np.allclose(pulses[inst2_name], [0.5] * 16))
def test_overlapping_on_expression_assigment_to_zero(self):
"""Test constant*zero expression conflict."""
schedule = pulse.Schedule()
schedule |= pulse.Play(pulse.SamplePulse([1, 1, 1, 1]), DriveChannel(self.qubit))
schedule |= pulse.Play(pulse.SamplePulse([1, 1, 1, 1]), DriveChannel(2*self.qubit))
with self.assertRaises(PulseError):
schedule.assign_parameters({self.qubit: 0})
def test_overlapping_pulses(self):
"""Test that an error is still raised when overlapping instructions are assigned."""
schedule = pulse.Schedule()
schedule |= pulse.Play(pulse.SamplePulse([1, 1, 1, 1]), DriveChannel(self.qubit))
with self.assertRaises(PulseError):
schedule |= pulse.Play(pulse.SamplePulse([0.5, 0.5, 0.5, 0.5]),
DriveChannel(self.qubit))
def test_overlapping_on_multiple_assignment(self):
"""Test that assigning one qubit then another raises error when overlapping."""
qubit2 = Parameter('q2')
schedule = pulse.Schedule()
schedule |= pulse.Play(pulse.SamplePulse([1, 1, 1, 1]), DriveChannel(self.qubit))
schedule |= pulse.Play(pulse.SamplePulse([1, 1, 1, 1]), DriveChannel(qubit2))
schedule.assign_parameters({qubit2: 2})
with self.assertRaises(PulseError):
schedule.assign_parameters({self.qubit: 2})
def test_merging_upon_assignment(self):
"""Test that schedule can match instructions on a channel."""
schedule = pulse.Schedule()
schedule |= pulse.Play(pulse.SamplePulse([1, 1, 1, 1]), DriveChannel(1))
schedule = schedule.insert(4, pulse.Play(pulse.SamplePulse([1, 1, 1, 1]),
DriveChannel(self.qubit)))
schedule.assign_parameters({self.qubit: 1})
self.assertEqual(schedule.ch_duration(DriveChannel(1)), 8)
self.assertEqual(schedule.channels, (DriveChannel(1),))
def setUp(self):
self.device = pulse.DeviceSpecification.create_from(FakeOpenPulse2Q())
test_pulse = pulse.SamplePulse(samples=np.array(
[0.02739068, 0.05, 0.05, 0.05, 0.02739068], dtype=np.complex128),
name='pulse0')
acquire = pulse.Acquire(5)
self.schedule = pulse.Schedule(name='fake_experiment')
self.schedule = self.schedule.insert(
0, test_pulse(self.device.q[0].drive))
self.schedule = self.schedule.insert(
5, acquire(self.device.q, self.device.mem))
self.user_lo_config_dict = {self.device.q[0].drive: 4.91}
self.user_lo_config = pulse.LoConfig(self.user_lo_config_dict)
self.default_qubit_lo_freq = [4.9, 5.0]
self.default_meas_lo_freq = [6.5, 6.6]
self.config = {
'meas_level': 1,
'memory_slots': 2,
'memory_slot_size': 100,
'meas_return': 'avg',
'rep_time': 100
}
self.header = {
'backend_name': 'FakeOpenPulse2Q',
'backend_version': '0.0.0'
}
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')
acquire = pulse.Acquire(5)
self.schedule = pulse.Schedule(name='fake_experiment')
self.schedule = self.schedule.insert(
0, test_pulse(self.backend_config.drive(0)))
for i in range(self.backend_config.n_qubits):
self.schedule = self.schedule.insert(
5, acquire(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 setUp(self):
self.backend = FakeOpenPulse2Q()
self.config = self.backend.configuration()
self.inst_map = self.backend.defaults().instruction_schedule_map
self.short_pulse = pulse.SamplePulse(samples=np.array(
[0.02739068], dtype=np.complex128),
name='p0')
def setUp(self):
self.backend = FakeOpenPulse2Q()
self.device = pulse.PulseChannelSpec.from_backend(self.backend)
self.config = self.backend.configuration()
self.cmd_def = self.backend.defaults().build_cmd_def()
self.short_pulse = pulse.SamplePulse(samples=np.array(
[0.02739068], dtype=np.complex128),
name='p0')
def setUp(self):
self.backend = FakeOpenPulse2Q()
self.device = pulse.DeviceSpecification.create_from(self.backend)
self.config = self.backend.configuration()
self.defaults = self.backend.defaults()
self.cmd_def = CmdDef.from_defaults(self.defaults.cmd_def,
self.defaults.pulse_library)
self.short_pulse = pulse.SamplePulse(samples=np.array([0.02739068], dtype=np.complex128),
name='p0')
def setUp(self):
self.backend = FakeOpenPulse2Q()
self.config = self.backend.configuration()
self.cmd_def = self.backend.defaults().circuit_instruction_map
self.short_pulse = pulse.SamplePulse(samples=np.array([0.02739068], dtype=np.complex128),
name='p0')
acquire = pulse.Acquire(5)
sched = pulse.Schedule(name='fake_experiment')
sched = sched.insert(0, self.short_pulse(self.config.drive(0)))
self.sched = sched.insert(5, acquire([self.config.acquire(0), self.config.acquire(1)],
[MemorySlot(0), MemorySlot(1)]))
def setUp(self):
self.backend = FakeOpenPulse2Q()
self.config = self.backend.configuration()
self.short_pulse = pulse.SamplePulse(samples=np.array(
[0.02739068], dtype=np.complex128),
name='p0')
sched = pulse.Schedule(name='fake_experiment')
sched = sched.insert(0, Play(self.short_pulse, self.config.drive(0)))
sched = sched.insert(5,
Acquire(5, self.config.acquire(0), MemorySlot(0)))
sched = sched.insert(5,
Acquire(5, self.config.acquire(1), MemorySlot(1)))
self.sched = sched
def setUp(self):
self.backend = FakeOpenPulse2Q()
self.device = pulse.DeviceSpecification.create_from(self.backend)
self.config = self.backend.configuration()
self.defaults = self.backend.defaults()
self.cmd_def = CmdDef.from_defaults(self.defaults.cmd_def,
self.defaults.pulse_library)
self.short_pulse = pulse.SamplePulse(samples=np.array([0.02739068], dtype=np.complex128),
name='p0')
acquire = pulse.Acquire(5)
sched = pulse.Schedule(name='fake_experiment')
sched = sched.insert(0, self.short_pulse(self.device.q[0].drive))
self.sched = sched.insert(5, acquire(self.device.q, self.device.mem))
def setUp(self):
self.backend = FakeOpenPulse2Q()
self.device = pulse.PulseChannelSpec.from_backend(self.backend)
self.config = self.backend.configuration()
self.defaults = self.backend.defaults()
self.cmd_def = CmdDef.from_defaults(self.defaults.cmd_def,
self.defaults.pulse_library)
self.short_pulse = pulse.SamplePulse(samples=np.array([0.02739068], dtype=np.complex128),
name='p0')
acquire = pulse.Acquire(5)
sched = pulse.Schedule(name='fake_experiment')
sched = sched.insert(0, self.short_pulse(self.device.drives[0]))
self.sched = sched.insert(5, acquire(self.device.acquires, self.device.memoryslots))
def get(
self,
# TODO figure out type hints for gate below
instruction: Union[str, Gate],
qubits: Union[int, Iterable[int]],
*params: Union[int, float, complex],
**kwparams: Union[int, float, complex]) -> Schedule:
"""Return the defined :py:class:`~qiskit.pulse.Schedule` for the given instruction on
the given qubits.
Args:
instruction: Name of the instruction.
qubits: The qubits for the instruction.
*params: Command parameters for generating the output schedule.
**kwparams: Keyworded command parameters for generating the schedule.
Returns:
The Schedule defined for the input.
"""
# TODO: fix below
# schedule.draw()
if isinstance(instruction, Gate):
if self._map[instruction.name]:
# self.assert_has(instruction.name, qubits)
# TODO: copied to_tuple because protected but feels redundent?
schedule_generator = self._map[instruction.name].get(
_to_tuple(qubits))
else:
print('gate hit')
pulse_seq = (
self.qoc_optimizer.get_pulse_schedule(instruction))
out_schedule = pulse.Schedule()
drive_chan = pulse.DriveChannel(1)
# Figure out universal version for more drive channels
out_schedule += Play(pulse.SamplePulse(pulse_seq),
drive_chan) << out_schedule.duration
schedule_generator = out_schedule
else:
self.assert_has(instruction, qubits)
# TODO: copied to_tuple because protected but feels redundent?
schedule_generator = self._map[instruction].get(_to_tuple(qubits))
# don't forget in here to use _gate.to_matrix
if callable(schedule_generator):
return schedule_generator(*params, **kwparams)
# otherwise this is just a Schedule
return schedule_generator
def sequence_converter(
pulse_seq_dict: Mapping[str, List[complex]]) -> Schedule:
"""Convert a dictionary of pulses and channels to a pulse schedule.
Args:
pulse_seq_dict (Mapping[str, List[complex): A dictionary of pulses and corresponding channels.
Returns:
Schedule: A pulse schedule.
"""
out_schedule = Schedule()
for channel in pulse_seq_dict.keys():
channel_obj = channel_finder(channel)
out_schedule += Play(pulse.SamplePulse(pulse_seq_dict[channel]),
channel_obj)
return out_schedule
def test_pulse_name_conflicts(self):
"""Test that pulse name conflicts can be resolved."""
name_conflict_pulse = pulse.SamplePulse(samples=np.array(
[0.02, 0.05, 0.05, 0.05, 0.02], dtype=np.complex128),
name='pulse0')
self.schedule = self.schedule.insert(
1, name_conflict_pulse(self.device.q[1].drive))
qobj = assemble(self.schedule,
qobj_header=self.header,
qubit_lo_freq=self.default_qubit_lo_freq,
meas_lo_freq=self.default_meas_lo_freq,
schedule_los=[],
**self.config)
self.assertNotEqual(qobj.config.pulse_library[1], 'pulse0')
self.assertEqual(qobj.experiments[0].instructions[0].name, 'pulse0')
self.assertNotEqual(qobj.experiments[0].instructions[1].name, 'pulse0')
def test_pulse_name_conflicts(self):
"""Test that pulse name conflicts can be resolved."""
name_conflict_pulse = pulse.SamplePulse(samples=np.array(
[0.02, 0.05, 0.05, 0.05, 0.02], dtype=np.complex128),
name='pulse0')
self.schedule = self.schedule.insert(
1, Play(name_conflict_pulse, self.backend_config.drive(1)))
qobj = assemble(self.schedule,
qobj_header=self.header,
qubit_lo_freq=self.default_qubit_lo_freq,
meas_lo_freq=self.default_meas_lo_freq,
schedule_los=[],
**self.config)
validate_qobj_against_schema(qobj)
self.assertNotEqual(qobj.config.pulse_library[0].name,
qobj.config.pulse_library[1].name)
