def test_pulse_name_conflicts_in_other_schedule(self):
"""Test two pulses with the same name in different schedule can be resolved."""
backend = FakeAlmaden()
schedules = []
ch_d0 = pulse.DriveChannel(0)
for amp in (0.1, 0.2):
sched = Schedule()
sched += Play(
gaussian(duration=100, amp=amp, sigma=30, name='my_pulse'),
ch_d0)
sched += measure(qubits=[0], backend=backend) << 100
schedules.append(sched)
qobj = assemble(schedules, backend)
# two user pulses and one measurement pulse should be contained
self.assertEqual(len(qobj.config.pulse_library), 3)
def _1Q_constant_sched(self, total_samples, amp=1.):
"""Creates a runnable schedule for 1Q with a constant drive pulse of a given length.
Args:
total_samples (int): length of pulse
amp (float): amplitude of constant pulse (can be complex)
Returns:
schedule (pulse schedule): schedule with a drive pulse followed by an acquire
"""
# set up constant pulse for doing a pi pulse
drive_pulse = SamplePulse(amp * np.ones(total_samples))
schedule = Schedule()
schedule |= Play(drive_pulse, DriveChannel(0))
schedule |= Acquire(total_samples, AcquireChannel(0), MemorySlot(0)) << schedule.duration
return schedule
def _1Q_schedule(self, total_samples=100, amp=1., num_acquires=1):
"""Creates a schedule for a single qubit.
Args:
total_samples (int): number of samples in the drive pulse
amp (complex): amplitude of drive pulse
num_acquires (int): number of acquire instructions to include in the schedule
Returns:
schedule (pulse schedule):
"""
schedule = Schedule()
schedule |= Play(Waveform(amp * np.ones(total_samples)), DriveChannel(0))
for _ in range(num_acquires):
schedule |= Acquire(total_samples, AcquireChannel(0),
MemorySlot(0)) << schedule.duration
return schedule
def test_parametric_pulses_with_duplicates(self):
"""Test with parametric pulses."""
schedule = Schedule()
drive_channel = DriveChannel(0)
schedule += Play(Gaussian(duration=25, sigma=4, amp=0.5j), drive_channel)
schedule += Play(Gaussian(duration=25, sigma=4, amp=0.5j), drive_channel)
schedule += Play(GaussianSquare(duration=150, amp=0.2,
sigma=8, width=140), drive_channel)
schedule += Play(GaussianSquare(duration=150, amp=0.2,
sigma=8, width=140), drive_channel)
schedule += Play(Constant(duration=150, amp=0.1 + 0.4j), drive_channel)
schedule += Play(Constant(duration=150, amp=0.1 + 0.4j), drive_channel)
schedule += Play(Drag(duration=25, amp=0.2 + 0.3j, sigma=7.8, beta=4), drive_channel)
schedule += Play(Drag(duration=25, amp=0.2 + 0.3j, sigma=7.8, beta=4), drive_channel)
compressed_schedule = transforms.compress_pulses([schedule])
original_pulse_ids = get_pulse_ids([schedule])
compressed_pulse_ids = get_pulse_ids(compressed_schedule)
self.assertEqual(len(original_pulse_ids), 8)
self.assertEqual(len(compressed_pulse_ids), 4)
def test_schedule_generator(self):
"""Test schedule generator functionalty."""
dur_val = 10
amp = 1.0
def test_func(dur: int):
sched = Schedule()
sched += Play(library.constant(int(dur), amp), DriveChannel(0))
return sched
expected_sched = Schedule()
expected_sched += Play(library.constant(dur_val, amp), DriveChannel(0))
inst_map = InstructionScheduleMap()
inst_map.add('f', (0, ), test_func)
self.assertEqual(inst_map.get('f', (0, ), dur_val), expected_sched)
self.assertEqual(inst_map.get_parameters('f', (0, )), ('dur', ))
def test_schedule_generator(self):
"""Test schedule generator functionalty."""
x_test = 10
amp_test = 1.0
def test_func(x):
sched = Schedule()
sched += Play(library.constant(int(x), amp_test), DriveChannel(0))
return sched
ref_sched = Schedule()
ref_sched += Play(library.constant(x_test, amp_test), DriveChannel(0))
inst_map = InstructionScheduleMap()
inst_map.add('f', (0,), test_func)
self.assertEqual(inst_map.get('f', (0,), x_test), ref_sched)
self.assertEqual(inst_map.get_parameters('f', (0,)), ('x',))
def test_pulse_name_conflicts(self):
"""Test that pulse name conflicts can be resolved."""
name_conflict_pulse = pulse.Waveform(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)
def test_subset_calibrated_measurements(self):
"""Test that measurement calibrations can be added and used for some qubits, even
if the other qubits do not also have calibrated measurements."""
qc = QuantumCircuit(3, 3)
qc.measure(0, 0)
qc.measure(1, 1)
qc.measure(2, 2)
meas_scheds = []
for qubit in [0, 2]:
meas = (Play(Gaussian(1200, 0.2, 4), MeasureChannel(qubit)) +
Acquire(1200, AcquireChannel(qubit), MemorySlot(qubit)))
meas_scheds.append(meas)
qc.add_calibration('measure', [qubit], meas)
meas = macros.measure([1], FakeOpenPulse3Q())
meas = meas.exclude(channels=[AcquireChannel(0), AcquireChannel(2)])
sched = schedule(qc, FakeOpenPulse3Q())
expected = Schedule(meas_scheds[0], meas_scheds[1], meas)
self.assertEqual(sched.instructions, expected.instructions)
def _2Q_constant_sched(self, total_samples, amp=1., u_idx=0):
"""Creates a runnable schedule with a single pulse on a U channel for two qubits.
Args:
total_samples (int): length of pulse
amp (float): amplitude of constant pulse (can be complex)
u_idx (int): index of U channel
Returns:
schedule (pulse schedule): schedule with a drive pulse followed by an acquire
"""
# set up constant pulse for doing a pi pulse
drive_pulse = SamplePulse(amp * np.ones(total_samples))
schedule = Schedule()
schedule |= Play(drive_pulse, ControlChannel(u_idx))
schedule |= Acquire(total_samples, AcquireChannel(0), MemorySlot(0)) << total_samples
schedule |= Acquire(total_samples, AcquireChannel(1), MemorySlot(1)) << total_samples
return schedule
def test_schedule_generator_supports_parameter_expressions(self):
"""Test expression-based schedule generator functionalty."""
t_param = Parameter('t')
amp = 1.0
def test_func(dur: ParameterExpression, t_val: int):
dur_bound = dur.bind({t_param: t_val})
sched = Schedule()
sched += Play(library.constant(int(float(dur_bound)), amp), DriveChannel(0))
return sched
expected_sched = Schedule()
expected_sched += Play(library.constant(10, amp), DriveChannel(0))
inst_map = InstructionScheduleMap()
inst_map.add('f', (0,), test_func)
self.assertEqual(inst_map.get('f', (0,), dur=2*t_param, t_val=5), expected_sched)
self.assertEqual(inst_map.get_parameters('f', (0,)), ('dur', 't_val',))
def test_schedule_block_in_instmap(self):
"""Test schedule block in instmap can be scheduled."""
duration = Parameter("duration")
with build() as pulse_prog:
play(Gaussian(duration, 0.1, 10), DriveChannel(0))
instmap = InstructionScheduleMap()
instmap.add("block_gate", (0, ), pulse_prog, ["duration"])
qc = QuantumCircuit(1)
qc.append(Gate("block_gate", 1, [duration]), [0])
qc.assign_parameters({duration: 100}, inplace=True)
sched = schedule(qc, self.backend, inst_map=instmap)
ref_sched = Schedule()
ref_sched += Play(Gaussian(100, 0.1, 10), DriveChannel(0))
self.assertEqual(sched, 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 model_and_pi_schedule():
"""Return a simple model and schedule for pulse simulation"""
# construct model
model = duffing_system_model(dim_oscillators=2,
oscillator_freqs=[5.0],
anharm_freqs=[0],
drive_strengths=[0.01],
coupling_dict={},
dt=1.0)
# note: parameters set so that area under curve is 1/4
sample_pulse = SamplePulse(np.ones(50))
# construct schedule
schedule = Schedule(name='test_sched')
schedule |= Play(sample_pulse, DriveChannel(0))
schedule += Acquire(10, AcquireChannel(0),
MemorySlot(0)) << schedule.duration
return model, schedule
def model_and_pi_schedule():
"""Return a simple model and schedule for pulse simulation"""
# construct model
model = duffing_system_model(dim_oscillators=2,
oscillator_freqs=[5.0],
anharm_freqs=[0],
drive_strengths=[1.0],
coupling_dict={},
dt=1.0)
# note: parameters set so that area under curve is 1/4
gauss_pulse = Gaussian(duration=10,
amp=(1.0 / 4) / 2.506627719963857,
sigma=1)
# construct schedule
schedule = Schedule(name='test_sched')
schedule |= Play(gauss_pulse, DriveChannel(0))
schedule += Acquire(10, AcquireChannel(0),
MemorySlot(0)) << schedule.duration
return model, schedule
def test_rzx_calibration_builder_duration(self, theta: float):
"""Test that pulse durations are computed correctly."""
width = 512.00000001
sigma = 64
n_sigmas = 4
duration = width + n_sigmas * sigma
sample_mult = 16
amp = 1.0
pulse = GaussianSquare(duration=duration,
amp=amp,
sigma=sigma,
width=width)
instruction = Play(pulse, ControlChannel(1))
scaled = RZXCalibrationBuilder.rescale_cr_inst(instruction,
theta,
sample_mult=sample_mult)
gaussian_area = abs(amp) * sigma * np.sqrt(2 * np.pi) * erf(n_sigmas)
area = gaussian_area + abs(amp) * width
target_area = abs(theta) / (np.pi / 2.0) * area
width = (target_area - gaussian_area) / abs(amp)
expected_duration = round(
(width + n_sigmas * sigma) / sample_mult) * sample_mult
self.assertEqual(scaled.duration, expected_duration)
def _3Q_constant_sched(self, total_samples, amp=1., u_idx=0, subsystem_list=[0, 2]):
"""Creates a runnable schedule for the 3Q system after the system is restricted to
2 qubits.
Args:
total_samples (int): length of pulse
amp (float): amplitude of constant pulse (can be complex)
u_idx (int): index of U channel
subsystem_list (list): list of qubits to restrict to
Returns:
schedule (pulse schedule): schedule with a drive pulse followed by an acquire
"""
# set up constant pulse for doing a pi pulse
drive_pulse = SamplePulse(amp * np.ones(total_samples))
schedule = Schedule()
schedule |= Play(drive_pulse, ControlChannel(u_idx))
for idx in subsystem_list:
schedule |= Acquire(total_samples,
AcquireChannel(idx),
MemorySlot(idx)) << total_samples
return schedule
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.insert(0,
Play(self.short_pulse, self.config.drive(0)),
inplace=True)
sched.insert(1,
Acquire(5, self.config.acquire(0), MemorySlot(0)),
inplace=True)
sched.insert(10,
Acquire(5, self.config.acquire(1), MemorySlot(1)),
inplace=True)
sched.insert(10,
Play(self.short_pulse, self.config.measure(0)),
inplace=True)
sched.insert(11,
Play(self.short_pulse, self.config.measure(0)),
inplace=True)
sched.insert(10,
Play(self.short_pulse, self.config.measure(1)),
inplace=True)
aligned = transforms.align_measures([sched])[0]
self.assertEqual(aligned.name, 'fake_experiment')
ref = pulse.Schedule(name='fake_experiment')
ref.insert(0,
Play(self.short_pulse, self.config.drive(0)),
inplace=True)
ref.insert(10,
Acquire(5, self.config.acquire(0), MemorySlot(0)),
inplace=True)
ref.insert(10,
Acquire(5, self.config.acquire(1), MemorySlot(1)),
inplace=True)
ref.insert(19,
Play(self.short_pulse, self.config.measure(0)),
inplace=True)
ref.insert(20,
Play(self.short_pulse, self.config.measure(0)),
inplace=True)
ref.insert(10,
Play(self.short_pulse, self.config.measure(1)),
inplace=True)
self.assertEqual(aligned, ref)
aligned = transforms.align_measures([sched],
self.inst_map,
align_time=20)[0]
ref = pulse.Schedule(name='fake_experiment')
ref.insert(10,
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(29,
Play(self.short_pulse, self.config.measure(0)),
inplace=True)
ref.insert(30,
Play(self.short_pulse, self.config.measure(0)),
inplace=True)
ref.insert(20,
Play(self.short_pulse, self.config.measure(1)),
inplace=True)
self.assertEqual(aligned, ref)
qubits=backend_config.meas_map[meas_map_idx])
### Collect the necessary channels
drive_chan = pulse.DriveChannel(qubit)
meas_chan = pulse.MeasureChannel(qubit)
acq_chan = pulse.AcquireChannel(qubit)
# Create two schedules
# Ground state schedule
gnd_schedule = pulse.Schedule(name="ground state")
gnd_schedule += measure
# Excited state schedule
exc_schedule = pulse.Schedule(name="excited state")
exc_schedule += Play(pi_pulse, drive_chan) # We found this in Part 2A above
exc_schedule += measure << exc_schedule.duration
# Execution settings
num_shots = 1024 * 8
gnd_exc_program = assemble([gnd_schedule, exc_schedule],
backend=backend,
meas_level=0,
meas_return='single',
shots=num_shots,
schedule_los=[{
drive_chan: rough_qubit_frequency
}] * 2)
# print(job.job_id())
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 my_test_par_sched_two(x, y, z):
result = Play(Waveform(np.array([x, y, z]), name="sample"), self.config.drive(0))
return 5, result
def test_numpy_integer_input(self):
"""Test that mixed integer duration types can build a schedule (#5754)."""
sched = Schedule()
sched += Delay(np.int32(25), DriveChannel(0))
sched += Play(Constant(duration=30, amp=0.1), DriveChannel(0))
self.assertEqual(sched.duration, 55)
def update_u_gates(drag_params, pi2_pulse_schedules=None,
qubits=None, inst_map=None, drives=None):
"""Update the cmd_def with new single qubit gate values
Will update U2, U3
Args:
drag_params (list): list of drag params
pi2_pulse_schedules (list): list of new pi/2 gate as a pulse schedule
will use the drag_params if this is None.
qubits (list): list of qubits to update
inst_map (InstructionScheduleMap): InstructionScheduleMap providing
circuit instruction to schedule definitions.
drives (list): List of drive chs
"""
# U2 is -P1.Y90p.-P0
# U3 is -P2.X90p.-P0.X90m.-P1
def parametrized_fc(kw_name, phi0, chan, t_offset):
def _parametrized_fc(**kwargs):
return ShiftPhase(phase=-kwargs[kw_name]+phi0, channel=chan).shift(t_offset)
return _parametrized_fc
for qubit in qubits:
drive_ch = drives[qubit]
if pi2_pulse_schedules is None:
x90_pulse = pulse_lib.drag(**drag_params[qubit])
x90_sched = Schedule()
x90_sched += Play(x90_pulse, drive_ch).shift(0)
else:
x90_sched = pi2_pulse_schedules[qubit]
pulse_dur = x90_sched.duration
# find channel dependency for u2
for _u2_group in _find_channel_groups('u2', qubits=qubit, inst_map=inst_map):
if drive_ch in _u2_group:
break
else:
_u2_group = (drive_ch, )
u2_fc1s = [parametrized_fc('P1', np.pi/2, ch, 0) for ch in _u2_group]
u2_fc2s = [parametrized_fc('P0', -np.pi/2, ch, pulse_dur) for ch in _u2_group]
# find channel dependency for u3
for _u3_group in _find_channel_groups('u3', qubits=qubit, inst_map=inst_map):
if drive_ch in _u3_group:
break
else:
_u3_group = (drive_ch, )
u3_fc1s = [parametrized_fc('P2', 0, ch, 0) for ch in _u3_group]
u3_fc2s = [parametrized_fc('P0', -np.pi, ch, pulse_dur) for ch in _u3_group]
u3_fc3s = [parametrized_fc('P1', np.pi, ch, 2*pulse_dur) for ch in _u3_group]
# add commands to schedule
# u2
sched_components = [*u2_fc1s, x90_sched, *u2_fc2s]
schedule1 = ParameterizedSchedule(*sched_components,
parameters=['P0', 'P1'], name='u2_%d' % qubit)
# u3
sched_components = [*u3_fc1s, x90_sched, *u3_fc2s, x90_sched.shift(pulse_dur), *u3_fc3s]
schedule2 = ParameterizedSchedule(*sched_components,
parameters=['P0', 'P1', 'P2'], name='u3_%d' % qubit)
inst_map.add('u2', qubits=qubit, schedule=schedule1)
inst_map.add('u3', qubits=qubit, schedule=schedule2)
def test_func(dur: int):
sched = Schedule()
sched += Play(library.constant(int(dur), amp), DriveChannel(0))
return sched
def update_u_gates(drag_params,
pi2_pulse_schedules=None,
qubits=None,
inst_map=None,
drives=None):
"""Update the cmd_def with new single qubit gate values
Will update U2, U3
Args:
drag_params (list): list of drag params
pi2_pulse_schedules (list): list of new pi/2 gate as a pulse schedule
will use the drag_params if this is None.
qubits (list): list of qubits to update
inst_map (InstructionScheduleMap): InstructionScheduleMap providing
circuit instruction to schedule definitions.
drives (list): List of drive chs
"""
# pylint: disable = invalid-name
# U2 is -P1.Y90p.-P0
# U3 is -P2.X90p.-P0.X90m.-P1
for qubit in qubits:
drive_ch = drives[qubit]
if pi2_pulse_schedules is None:
x90_pulse = pulse_lib.drag(**drag_params[qubit])
x90_sched = Schedule()
x90_sched += Play(x90_pulse, drive_ch).shift(0)
else:
x90_sched = pi2_pulse_schedules[qubit]
# find channel dependency for u2
for _u2_group in _find_channel_groups('u2',
qubits=qubit,
inst_map=inst_map):
if drive_ch in _u2_group:
break
else:
_u2_group = (drive_ch, )
# find channel dependency for u3
for _u3_group in _find_channel_groups('u3',
qubits=qubit,
inst_map=inst_map):
if drive_ch in _u3_group:
break
else:
_u3_group = (drive_ch, )
# add commands to schedule
# u2
with pulse.build(name=f"u2_{qubit}",
default_alignment="sequential") as u2_sched:
P0 = Parameter("P0")
P1 = Parameter("P1")
for ch in _u2_group:
pulse.shift_phase(-P1 + np.pi / 2, ch)
pulse.call(x90_sched)
for ch in _u2_group:
pulse.shift_phase(-P0 - np.pi / 2, ch)
# u3
with pulse.build(name=f"u3_{qubit}",
default_alignment="sequential") as u3_sched:
P0 = Parameter("P0")
P1 = Parameter("P1")
P2 = Parameter("P2")
for ch in _u3_group:
pulse.shift_phase(-P2, ch)
pulse.call(x90_sched)
for ch in _u3_group:
pulse.shift_phase(-P0 - np.pi, ch)
pulse.call(x90_sched)
for ch in _u3_group:
pulse.shift_phase(-P1 + np.pi, ch)
inst_map.add('u2', qubits=qubit, schedule=u2_sched)
inst_map.add('u3', qubits=qubit, schedule=u3_sched)
def _assemble_instructions(
schedule: Schedule, instruction_converter: InstructionToQobjConverter,
run_config: RunConfig,
user_pulselib: Dict[str,
Command]) -> Tuple[List[PulseQobjInstruction], int]:
"""Assembles the instructions in a schedule into a list of PulseQobjInstructions and returns
related metadata that will be assembled into the Qobj configuration. Lookup table for
pulses defined in all experiments are registered in ``user_pulselib``. This object should be
mutable python dictionary so that items are properly updated after each instruction assemble.
The dictionary is not returned to avoid redundancy.
Args:
schedule: Schedule to assemble.
instruction_converter: A converter instance which can convert PulseInstructions to
PulseQobjInstructions.
run_config: Configuration of the runtime environment.
user_pulselib: User pulse library from previous schedule.
Returns:
A list of converted instructions, the user pulse library dictionary (from pulse name to
pulse command), and the maximum number of readout memory slots used by this Schedule.
"""
max_memory_slot = 0
qobj_instructions = []
acquire_instruction_map = defaultdict(list)
for time, instruction in schedule.instructions:
if isinstance(instruction, ParametricInstruction): # deprecated
instruction = Play(instruction.command,
instruction.channels[0],
name=instruction.name)
if isinstance(instruction, Play) and isinstance(
instruction.pulse, ParametricPulse):
pulse_shape = ParametricPulseShapes(type(instruction.pulse)).name
if pulse_shape not in run_config.parametric_pulses:
instruction = Play(instruction.pulse.get_sample_pulse(),
instruction.channel,
name=instruction.name)
if isinstance(instruction, PulseInstruction): # deprecated
instruction = Play(SamplePulse(
name=name, samples=instruction.command.samples),
instruction.channels[0],
name=name)
if isinstance(instruction, Play) and isinstance(
instruction.pulse, SamplePulse):
name = hashlib.sha256(instruction.pulse.samples).hexdigest()
instruction = Play(SamplePulse(name=name,
samples=instruction.pulse.samples),
channel=instruction.channel,
name=name)
user_pulselib[name] = instruction.pulse.samples
if isinstance(instruction, (AcquireInstruction, Acquire)):
max_memory_slot = max(
max_memory_slot,
*[slot.index for slot in instruction.mem_slots])
# Acquires have a single AcquireChannel per inst, but we have to bundle them
# together into the Qobj as one instruction with many channels
acquire_instruction_map[(time,
instruction.command)].append(instruction)
continue
if isinstance(instruction, (DelayInstruction, Delay)):
# delay instructions are ignored as timing is explicit within qobj
continue
qobj_instructions.append(instruction_converter(time, instruction))
if acquire_instruction_map:
if hasattr(run_config, 'meas_map'):
_validate_meas_map(acquire_instruction_map, run_config.meas_map)
for (time, _), instructions in acquire_instruction_map.items():
qubits, mem_slots, reg_slots = _bundle_channel_indices(
instructions)
qobj_instructions.append(
instruction_converter.convert_single_acquires(
time,
instructions[0],
qubits=qubits,
memory_slot=mem_slots,
register_slot=reg_slots))
return qobj_instructions, max_memory_slot
break
assert meas_map_idx is not None, f"Couldn't find qubit {qubit} in the meas_map!"
inst_sched_map = backend_defaults.instruction_schedule_map
measure = inst_sched_map.get('measure',
qubits=backend_config.meas_map[meas_map_idx])
### Collect the necessary channels
drive_chan = pulse.DriveChannel(qubit)
meas_chan = pulse.MeasureChannel(qubit)
acq_chan = pulse.AcquireChannel(qubit)
# Create the base schedule
# Start with drive pulse acting on the drive channel
schedule = pulse.Schedule(name='Frequency sweep')
schedule += Play(drive_pulse, drive_chan)
# The left shift `<<` is special syntax meaning to shift the start time of the schedule by some duration
schedule += measure << schedule.duration
# Create the frequency settings for the sweep (MUST BE IN HZ)
frequencies_Hz = frequencies_GHz * GHz
schedule_frequencies = [{drive_chan: freq} for freq in frequencies_Hz]
from qiskit import assemble
num_shots_per_frequency = 1024
frequency_sweep_program = assemble(schedule,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots_per_frequency,
def test_func(x):
sched = Schedule()
sched += Play(library.constant(int(x), amp_test), DriveChannel(0))
return sched
break
assert meas_map_idx is not None, f"Couldn't find qubit {qubit} in the meas_map!"
inst_sched_map = backend_defaults.instruction_schedule_map
measure = inst_sched_map.get('measure',
qubits=backend_config.meas_map[meas_map_idx])
### Collect the necessary channels
drive_chan = pulse.DriveChannel(qubit)
meas_chan = pulse.MeasureChannel(qubit)
acq_chan = pulse.AcquireChannel(qubit)
# Create the base schedule
# Start with drive pulse acting on the drive channel
schedule = pulse.Schedule(name='Frequency sweep')
schedule += Play(drive_pulse, drive_chan)
# The left shift `<<` is special syntax meaning to shift the start time of the schedule by some duration
schedule += measure << schedule.duration
# Create the frequency settings for the sweep (MUST BE IN HZ)
frequencies_Hz = frequencies_GHz * GHz
schedule_frequencies = [{drive_chan: freq} for freq in frequencies_Hz]
from qiskit import assemble
num_shots_per_frequency = 1024
frequency_sweep_program = assemble(schedule,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots_per_frequency,
def test_func(dur: ParameterExpression, t_val: int):
dur_bound = dur.bind({t_param: t_val})
sched = Schedule()
sched += Play(library.constant(int(float(dur_bound)), amp),
DriveChannel(0))
return sched
def my_test_par_sched_one(x, y, z):
result = Play(Waveform(np.array([x, y, z]), name='sample'),
self.config.drive(0))
return 0, result
