def test_call_schedule(self):
"""Test calling schedule instruction."""
schedule = pulse.Schedule()
d0 = pulse.DriveChannel(0)
d1 = pulse.DriveChannel(1)
reference = pulse.Schedule()
reference = reference.insert(10, instructions.Delay(10, d0))
reference += instructions.Delay(20, d1)
with pulse.build() as schedule:
with pulse.align_right():
builder.call_schedule(reference)
self.assertEqual(schedule, reference)
with pulse.build() as schedule:
with pulse.align_right():
pulse.call(reference)
self.assertEqual(schedule, reference)
def test_play_parametric_pulse(self):
"""Test play instruction with parametric pulse."""
d0 = pulse.DriveChannel(0)
test_pulse = library.Constant(10, 1.0)
with pulse.build() as schedule:
pulse.play(test_pulse, d0)
reference = pulse.Schedule()
reference += instructions.Play(test_pulse, d0)
self.assertScheduleEqual(schedule, reference)
def test_error_post_acquire_pulse(self):
"""Test that an error is raised if a pulse occurs on a channel after an acquire."""
acquire = pulse.Acquire(5)
sched = pulse.Schedule(name='fake_experiment')
sched = sched.insert(0, self.short_pulse(self.device.drives[0]))
sched = sched.insert(4, acquire(self.device.acquires[0], self.device.memoryslots[0]))
# No error with separate channel
sched = sched.insert(10, self.short_pulse(self.device.drives[1]))
align_measures([sched], self.cmd_def)
sched = sched.insert(10, self.short_pulse(self.device.drives[0]))
with self.assertRaises(PulseError):
align_measures([sched], self.cmd_def)
def test_acquire_register_slot(self):
"""Test acquire instruction into register slot."""
acquire0 = pulse.AcquireChannel(0)
reg0 = pulse.RegisterSlot(0)
with pulse.build() as schedule:
pulse.acquire(10, acquire0, reg0)
reference = pulse.Schedule()
reference += pulse.Acquire(10, acquire0, reg_slot=reg0)
self.assertEqual(schedule, reference)
def setUp(self):
super().setUp()
self.backend = FakeOpenPulse2Q()
self.config = self.backend.configuration()
self.short_pulse = pulse.Waveform(
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 test_acquire_memory_slot(self):
"""Test acquire instruction into memory slot."""
acquire0 = pulse.AcquireChannel(0)
mem0 = pulse.MemorySlot(0)
with pulse.build() as schedule:
pulse.acquire(10, acquire0, mem0)
reference = pulse.Schedule()
reference += pulse.Acquire(10, acquire0, mem_slot=mem0)
self.assertScheduleEqual(schedule, reference)
def test_multiple_frames_at_the_same_time(self):
"""Test multiple frame instruction at the same time."""
# shift phase followed by set phase
sched = pulse.Schedule()
sched = sched.insert(0, pulse.ShiftPhase(-1.57, pulse.DriveChannel(0)))
sched = sched.insert(0, pulse.SetPhase(3.14, pulse.DriveChannel(0)))
ch_events = events.ChannelEvents.load_program(sched, pulse.DriveChannel(0))
frames = list(ch_events.get_frame_changes())
inst_data0 = frames[0]
self.assertAlmostEqual(inst_data0.frame.phase, 3.14)
# set phase followed by shift phase
sched = pulse.Schedule()
sched = sched.insert(0, pulse.SetPhase(3.14, pulse.DriveChannel(0)))
sched = sched.insert(0, pulse.ShiftPhase(-1.57, pulse.DriveChannel(0)))
ch_events = events.ChannelEvents.load_program(sched, pulse.DriveChannel(0))
frames = list(ch_events.get_frame_changes())
inst_data0 = frames[0]
self.assertAlmostEqual(inst_data0.frame.phase, 1.57)
def test_assign_parameter_to_subroutine(self):
"""Test that assign parameter objects to subroutines."""
param1 = Parameter("amp")
waveform = pulse.library.Constant(duration=100, amp=param1)
program_layer0 = pulse.Schedule()
program_layer0 += pulse.Play(waveform, pulse.DriveChannel(0))
reference = program_layer0.assign_parameters({param1: 0.1},
inplace=False)
# to call instruction
program_layer1 = pulse.Schedule()
program_layer1 += pulse.instructions.Call(program_layer0)
target = program_layer1.assign_parameters({param1: 0.1}, inplace=False)
self.assertEqual(inline_subroutines(target), reference)
# to nested call instruction
program_layer2 = pulse.Schedule()
program_layer2 += pulse.instructions.Call(program_layer1)
target = program_layer2.assign_parameters({param1: 0.1}, inplace=False)
self.assertEqual(inline_subroutines(target), reference)
def test_error_post_acquire_pulse(self):
"""Test that an error is raised if a pulse occurs on a channel after an acquire."""
sched = pulse.Schedule(name='fake_experiment')
sched = sched.insert(0, Play(self.short_pulse, self.config.drive(0)))
sched = sched.insert(4,
Acquire(5, self.config.acquire(0), MemorySlot(0)))
# No error with separate channel
sched = sched.insert(10, Play(self.short_pulse, self.config.drive(1)))
transforms.align_measures([sched], self.inst_map)
sched = sched.insert(10, Play(self.short_pulse, self.config.drive(0)))
with self.assertRaises(PulseError):
transforms.align_measures([sched], self.inst_map)
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 test_get_parameter(self):
"""Test that get parameter by name."""
param1 = Parameter('amp')
param2 = Parameter('amp')
schedule = pulse.Schedule()
waveform1 = pulse.library.Constant(duration=1280, amp=param1)
waveform2 = pulse.library.Constant(duration=1280, amp=param2)
schedule += pulse.Play(waveform1, DriveChannel(0))
schedule += pulse.Play(waveform2, DriveChannel(1))
self.assertEqual(len(schedule.get_parameters('amp')), 2)
def test_play_sample_pulse(self):
"""Test play instruction with sample pulse."""
d0 = pulse.DriveChannel(0)
test_pulse = library.Waveform([0.0, 0.0])
with pulse.build() as schedule:
pulse.play(test_pulse, d0)
reference = pulse.Schedule()
reference += instructions.Play(test_pulse, d0)
self.assertScheduleEqual(schedule, reference)
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.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.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.cmd_def = self.backend.defaults().instruction_schedule_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)))
sched = sched.insert(5, acquire(self.config.acquire(0), MemorySlot(0)))
sched = sched.insert(5, acquire(self.config.acquire(1), MemorySlot(1)))
self.sched = sched
def test_sequential_alignment(self):
"""Test sequential alignment context."""
block = pulse.ScheduleBlock(alignment_context=self.sequential_context)
block = block.append(pulse.Play(self.test_waveform0, self.d0))
block = block.append(pulse.Play(self.test_waveform1, self.d1))
ref_sched = pulse.Schedule()
ref_sched = ref_sched.insert(0, pulse.Play(self.test_waveform0,
self.d0))
ref_sched = ref_sched.insert(100,
pulse.Play(self.test_waveform1, self.d1))
self.assertScheduleEqual(block, ref_sched)
def test_play_with_parametricpulse(self):
"""Test Parametric Pulses with parameters determined by ParameterExpressions
in the Play instruction."""
waveform = pulse.library.Gaussian(duration=128, sigma=self.sigma, amp=self.amp)
schedule = pulse.Schedule()
schedule += pulse.Play(waveform, DriveChannel(10))
schedule.assign_parameters({self.amp: 0.2, self.sigma: 4})
self.backend.configuration().parametric_pulses = ['gaussian', 'drag']
insts = schedule.instructions
self.assertEqual(insts[0][1].pulse.amp, 0.2)
self.assertEqual(insts[0][1].pulse.sigma, 4.)
def test_get_parameter_from_call(self):
"""Test get parameters from instruction."""
sched = pulse.Schedule()
sched += pulse.ShiftPhase(self.phi1, self.d1)
test_obj = pulse.Call(subroutine=sched)
visitor = ParameterGetter()
visitor.visit(test_obj)
ref_params = {self.phi1, self.ch1}
self.assertSetEqual(visitor.parameters, ref_params)
def test_play_array_pulse(self):
"""Test play instruction on an array directly."""
d0 = pulse.DriveChannel(0)
test_array = np.array([0., 0.], dtype=np.complex_)
with pulse.build() as schedule:
pulse.play(test_array, d0)
reference = pulse.Schedule()
test_pulse = pulse.Waveform(test_array)
reference += instructions.Play(test_pulse, d0)
self.assertEqual(schedule, reference)
def test_align_post_u3(self):
"""Test that acquires are scheduled no sooner than the duration of the longest X gate."""
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 = transforms.align_measures([sched], self.inst_map)[0]
for time, inst in sched.instructions:
if isinstance(inst, Acquire):
self.assertEqual(time, 4)
sched = transforms.align_measures([sched], self.inst_map, max_calibration_duration=10)[0]
for time, inst in sched.instructions:
if isinstance(inst, Acquire):
self.assertEqual(time, 10)
def test_subroutine_not_transformed(self):
"""Test called schedule is not transformed."""
d0 = pulse.DriveChannel(0)
d1 = pulse.DriveChannel(1)
subprogram = pulse.Schedule()
subprogram.insert(0, pulse.Delay(30, d0), inplace=True)
subprogram.insert(10, pulse.Delay(10, d1), inplace=True)
with pulse.build() as schedule:
with pulse.align_right():
pulse.delay(10, d1)
pulse.call(subprogram)
reference = pulse.Schedule()
reference.insert(0, pulse.Delay(10, d1), inplace=True)
reference.insert(10, pulse.Delay(30, d0), inplace=True)
reference.insert(20, pulse.Delay(10, d1), inplace=True)
target = inline_subroutines(schedule)
self.assertEqual(target, reference)
def pure_cnot(self, pure_amp_times, pure_angle, pure_duration):
pure_cnot = pulse.Schedule()
new_cx = self.new_cnot(rx_angle=pure_angle)
for instruction in new_cx.instructions:
mini_pulse = instruction[1].pulse
if type(mini_pulse) == pulse_lib.GaussianSquare:
mini_pulse._width = mini_pulse._width * round(
pure_duration / self.dt / 16) * 16 / mini_pulse.duration
mini_pulse.duration = round(pure_duration / self.dt / 16) * 16
mini_pulse._amp = mini_pulse._amp * pure_amp_times
pure_cnot += instruction[1] << pure_cnot.duration
return pure_cnot
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 test_set_parameter_to_complex_schedule(self):
"""Test get parameters from complicated schedule."""
test_block = deepcopy(self.test_sched)
value_dict = {
self.amp1_1: 0.1,
self.amp1_2: 0.2,
self.amp2: 0.3,
self.amp3: 0.4,
self.dur1: 100,
self.dur2: 125,
self.dur3: 150,
self.ch1: 0,
self.ch2: 2,
self.ch3: 4,
self.phi1: 1.0,
self.phi2: 2.0,
self.phi3: 3.0,
self.meas_dur: 300,
self.mem1: 3,
self.reg1: 0,
self.context_dur: 1000,
}
visitor = ParameterSetter(param_map=value_dict)
assigned = visitor.visit(test_block)
# create ref schedule
subroutine = pulse.ScheduleBlock(alignment_context=AlignLeft())
subroutine += pulse.ShiftPhase(1.0, pulse.DriveChannel(0))
subroutine += pulse.Play(pulse.Gaussian(100, 0.3, 25),
pulse.DriveChannel(0))
sched = pulse.Schedule()
sched += pulse.ShiftPhase(3.0, pulse.DriveChannel(4))
ref_obj = pulse.ScheduleBlock(alignment_context=AlignEquispaced(1000),
name="long_schedule")
ref_obj += subroutine
ref_obj += pulse.ShiftPhase(2.0, pulse.DriveChannel(2))
ref_obj += pulse.Play(pulse.Gaussian(125, 0.3, 25),
pulse.DriveChannel(2))
ref_obj += pulse.Call(sched)
ref_obj += pulse.Play(pulse.Gaussian(150, 0.4, 25),
pulse.DriveChannel(4))
ref_obj += pulse.Acquire(300, pulse.AcquireChannel(0),
pulse.MemorySlot(3), pulse.RegisterSlot(0))
self.assertEqual(assigned, ref_obj)
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 test_frequency_offset(self):
"""Test the frequency offset context."""
d0 = pulse.DriveChannel(0)
with pulse.build() as schedule:
with pulse.frequency_offset(1e9, d0):
pulse.delay(10, d0)
reference = pulse.Schedule()
reference += instructions.ShiftFrequency(1e9, d0) # pylint: disable=no-member
reference += instructions.Delay(10, d0)
reference += instructions.ShiftFrequency(-1e9, d0) # pylint: disable=no-member
self.assertEqual(schedule, reference)
def test_phase_offset(self):
"""Test the phase offset context."""
d0 = pulse.DriveChannel(0)
with pulse.build() as schedule:
with pulse.phase_offset(3.14, d0):
pulse.delay(10, d0)
reference = pulse.Schedule()
reference += instructions.ShiftPhase(3.14, d0)
reference += instructions.Delay(10, d0)
reference += instructions.ShiftPhase(-3.14, d0)
self.assertEqual(schedule, reference)
def test_call_in_nested_schedule(self):
"""Test that subroutines in nested schedule."""
d0 = pulse.DriveChannel(0)
subroutine = pulse.Schedule()
subroutine.insert(10, pulse.Delay(10, d0), inplace=True)
nested_sched = pulse.Schedule()
nested_sched.insert(0, pulse.instructions.Call(subroutine), inplace=True)
main_sched = pulse.Schedule()
main_sched.insert(0, nested_sched, inplace=True)
target = transforms.inline_subroutines(main_sched)
# no call instruction
reference_nested = pulse.Schedule()
reference_nested.insert(0, subroutine, inplace=True)
reference = pulse.Schedule()
reference.insert(0, reference_nested, inplace=True)
self.assertEqual(target, reference)
def test_circuits(self):
"""Test that transpiling works and that we can have a y gate with a calibration."""
qubit = 1
inst_map = InstructionScheduleMap()
for inst in ["sx", "y"]:
inst_map.add(inst, (qubit,), pulse.Schedule(name=inst))
hac = HalfAngle(qubit)
hac.set_transpile_options(inst_map=inst_map)
# mimic what will happen in the experiment.
transpile_opts = copy.copy(hac.transpile_options.__dict__)
transpile_opts["initial_layout"] = list(hac._physical_qubits)
circuits = transpile(hac.circuits(), FakeAthens(), **transpile_opts)
for idx, circ in enumerate(circuits):
self.assertEqual(circ.count_ops()["sx"], idx * 2 + 2)
self.assertEqual(circ.calibrations["sx"][((qubit,), ())], pulse.Schedule(name="sx"))
if idx > 0:
self.assertEqual(circ.count_ops()["y"], idx)
self.assertEqual(circ.calibrations["y"][((qubit,), ())], pulse.Schedule(name="y"))
def test_assemble_parametric(self):
"""Test that parametric pulses can be assembled properly into a PulseQobj."""
sched = pulse.Schedule(name='test_parametric')
sched += Play(pulse.Gaussian(duration=25, sigma=4, amp=0.5j),
DriveChannel(0))
sched += Play(
pulse.Drag(duration=25, amp=0.2 + 0.3j, sigma=7.8, beta=4),
DriveChannel(1))
sched += Play(pulse.ConstantPulse(duration=25, amp=1), DriveChannel(2))
sched += Play(
pulse.GaussianSquare(duration=150, amp=0.2, sigma=8, width=140),
MeasureChannel(0)) << sched.duration
backend = FakeOpenPulse3Q()
backend.configuration().parametric_pulses = [
'gaussian', 'drag', 'gaussian_square', 'constant'
]
qobj = assemble(sched, backend)
self.assertEqual(qobj.config.pulse_library, [])
qobj_insts = qobj.experiments[0].instructions
self.assertTrue(
all(inst.name == 'parametric_pulse' for inst in qobj_insts))
self.assertEqual(qobj_insts[0].pulse_shape, 'gaussian')
self.assertEqual(qobj_insts[1].pulse_shape, 'drag')
self.assertEqual(qobj_insts[2].pulse_shape, 'constant')
self.assertEqual(qobj_insts[3].pulse_shape, 'gaussian_square')
self.assertDictEqual(qobj_insts[0].parameters, {
'duration': 25,
'sigma': 4,
'amp': 0.5j
})
self.assertDictEqual(qobj_insts[1].parameters, {
'duration': 25,
'sigma': 7.8,
'amp': 0.2 + 0.3j,
'beta': 4
})
self.assertDictEqual(qobj_insts[2].parameters, {
'duration': 25,
'amp': 1
})
self.assertDictEqual(qobj_insts[3].parameters, {
'duration': 150,
'sigma': 8,
'amp': 0.2,
'width': 140
})
self.assertEqual(
qobj.to_dict()['experiments'][0]['instructions'][0]['parameters']
['amp'], 0.5j)
