def _assemble_instructions(
schedule: pulse.Schedule,
instruction_converter: converters.InstructionToQobjConverter,
run_config: RunConfig, user_pulselib: Dict[str, List[complex]]
) -> Tuple[List[qobj.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 samples), 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, instructions.Play)
and isinstance(instruction.pulse, library.ParametricPulse)):
pulse_shape = ParametricPulseShapes(type(instruction.pulse)).name
if pulse_shape not in run_config.parametric_pulses:
instruction = instructions.Play(
instruction.pulse.get_waveform(),
instruction.channel,
name=instruction.name)
if (isinstance(instruction, instructions.Play)
and isinstance(instruction.pulse, library.Waveform)):
name = hashlib.sha256(instruction.pulse.samples).hexdigest()
instruction = instructions.Play(library.Waveform(
name=name, samples=instruction.pulse.samples),
channel=instruction.channel,
name=name)
user_pulselib[name] = instruction.pulse.samples
if isinstance(instruction, instructions.Acquire):
if instruction.mem_slot:
max_memory_slot = max(max_memory_slot,
instruction.mem_slot.index)
# 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.duration)].append(instruction)
continue
if isinstance(instruction,
(instructions.Delay, instructions.Directive)):
# 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, _), instrs in acquire_instruction_map.items():
qobj_instructions.append(
instruction_converter.convert_bundled_acquires(time, instrs), )
return qobj_instructions, max_memory_slot
def _assemble_instructions(
sched: Union[pulse.Schedule, pulse.ScheduleBlock],
instruction_converter: converters.InstructionToQobjConverter,
run_config: RunConfig,
user_pulselib: Dict[str, List[complex]],
) -> Tuple[List[qobj.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:
sched: 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 samples), and the maximum number of readout memory slots used by this Schedule.
"""
sched = transforms.target_qobj_transform(sched)
max_memory_slot = 0
qobj_instructions = []
acquire_instruction_map = defaultdict(list)
for time, instruction in sched.instructions:
if isinstance(instruction, instructions.Play):
if isinstance(instruction.pulse, (library.ParametricPulse, library.SymbolicPulse)):
is_backend_supported = True
try:
pulse_shape = ParametricPulseShapes(type(instruction.pulse)).name
if pulse_shape not in run_config.parametric_pulses:
is_backend_supported = False
except ValueError:
# Custom pulse class, or bare SymbolicPulse object.
is_backend_supported = False
if not is_backend_supported:
instruction = instructions.Play(
instruction.pulse.get_waveform(), instruction.channel, name=instruction.name
)
if isinstance(instruction.pulse, library.Waveform):
name = hashlib.sha256(instruction.pulse.samples).hexdigest()
instruction = instructions.Play(
library.Waveform(name=name, samples=instruction.pulse.samples),
channel=instruction.channel,
name=name,
)
user_pulselib[name] = instruction.pulse.samples
# ignore explicit delay instrs on acq channels as they are invalid on IBMQ backends;
# timing of other instrs will still be shifted appropriately
if isinstance(instruction, instructions.Delay) and isinstance(
instruction.channel, channels.AcquireChannel
):
continue
if isinstance(instruction, instructions.Acquire):
if instruction.mem_slot:
max_memory_slot = max(max_memory_slot, instruction.mem_slot.index)
# 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.duration)].append(instruction)
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, _), instrs in acquire_instruction_map.items():
qobj_instructions.append(
instruction_converter.convert_bundled_acquires(time, instrs),
)
return qobj_instructions, max_memory_slot
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):
pulse_shape = ParametricPulseShapes(type(instruction.command)).name
if pulse_shape not in run_config.parametric_pulses:
# Convert to SamplePulse if the backend does not support it
instruction = PulseInstruction(
instruction.command.get_sample_pulse(),
instruction.channels[0],
name=instruction.name)
if isinstance(instruction, PulseInstruction):
name = instruction.command.name
if name in user_pulselib and instruction.command != user_pulselib[
name]:
name = "{0}-{1:x}".format(
name, hash(instruction.command.samples.tostring()))
instruction = PulseInstruction(command=SamplePulse(
name=name, samples=instruction.command.samples),
name=instruction.name,
channel=instruction.channels[0])
# add samples to pulse library
user_pulselib[name] = instruction.command
if isinstance(instruction, AcquireInstruction):
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
def assemble_schedules(schedules, qobj_id, qobj_header, run_config):
"""Assembles a list of schedules into a qobj that can be run on the backend.
Args:
schedules (list[Schedule]): schedules to assemble
qobj_id (int): identifier for the generated qobj
qobj_header (QobjHeader): header to pass to the results
run_config (RunConfig): configuration of the runtime environment
Returns:
PulseQobj: the Qobj to be run on the backends
Raises:
QiskitError: when invalid schedules or configs are provided
"""
if hasattr(run_config, 'instruction_converter'):
instruction_converter = run_config.instruction_converter
else:
instruction_converter = InstructionToQobjConverter
qobj_config = run_config.to_dict()
qubit_lo_freq = qobj_config.get('qubit_lo_freq', None)
if qubit_lo_freq is None:
raise QiskitError('qubit_lo_freq must be supplied.')
meas_lo_freq = qobj_config.get('meas_lo_freq', None)
if meas_lo_freq is None:
raise QiskitError('meas_lo_freq must be supplied.')
meas_map = qobj_config.pop('meas_map', None)
# convert enums to serialized values
meas_return = qobj_config.get('meas_return', 'avg')
if isinstance(meas_return, MeasReturnType):
qobj_config['meas_return'] = meas_return.value
meas_level = qobj_config.get('meas_return', 2)
if isinstance(meas_level, MeasLevel):
qobj_config['meas_level'] = meas_level.value
instruction_converter = instruction_converter(PulseQobjInstruction,
**qobj_config)
qubit_lo_range = qobj_config.pop('qubit_lo_range', None)
meas_lo_range = qobj_config.pop('meas_lo_range', None)
lo_converter = LoConfigConverter(PulseQobjExperimentConfig,
qubit_lo_range=qubit_lo_range,
meas_lo_range=meas_lo_range,
**qobj_config)
memory_slot_size = 0
# Pack everything into the Qobj
qobj_schedules = []
user_pulselib = {}
for idx, schedule in enumerate(schedules):
# instructions
max_memory_slot = 0
qobj_instructions = []
# Instructions are returned as tuple of shifted time and instruction
for shift, instruction in schedule.instructions:
# TODO: support conditional gate
if isinstance(instruction, ParametricInstruction):
pulse_shape = ParametricPulseShapes(type(
instruction.command)).name
if pulse_shape not in run_config.parametric_pulses:
# Convert to SamplePulse if the backend does not support it
instruction = PulseInstruction(
instruction.command.get_sample_pulse(),
instruction.channels[0],
name=instruction.name)
if isinstance(instruction, DelayInstruction):
# delay instructions are ignored as timing is explicit within qobj
continue
if isinstance(instruction, PulseInstruction):
name = instruction.command.name
if name in user_pulselib and instruction.command != user_pulselib[
name]:
name = "{0}-{1:x}".format(
name, hash(instruction.command.samples.tostring()))
instruction = PulseInstruction(
command=SamplePulse(
name=name, samples=instruction.command.samples),
name=instruction.name,
channel=instruction.channels[0])
# add samples to pulse library
user_pulselib[name] = instruction.command
elif isinstance(instruction, AcquireInstruction):
max_memory_slot = max(
max_memory_slot,
*[slot.index for slot in instruction.mem_slots])
if meas_map:
# verify all acquires satisfy meas_map
_validate_meas_map(instruction, meas_map)
converted_instruction = instruction_converter(shift, instruction)
qobj_instructions.append(converted_instruction)
# memory slot size is memory slot index + 1 because index starts from zero
exp_memory_slot_size = max_memory_slot + 1
memory_slot_size = max(memory_slot_size, exp_memory_slot_size)
# experiment header
# TODO: add other experimental header items (see circuit assembler)
qobj_experiment_header = QobjExperimentHeader(
memory_slots=exp_memory_slot_size,
name=schedule.name or 'Experiment-%d' % idx)
qobj_schedules.append({
'header': qobj_experiment_header,
'instructions': qobj_instructions
})
# set number of memoryslots
qobj_config['memory_slots'] = memory_slot_size
# setup pulse_library
qobj_config['pulse_library'] = [
PulseLibraryItem(name=pulse.name, samples=pulse.samples)
for pulse in user_pulselib.values()
]
# convert lo frequencies to GHz
qobj_config['qubit_lo_freq'] = [freq / 1e9 for freq in qubit_lo_freq]
qobj_config['meas_lo_freq'] = [freq / 1e9 for freq in meas_lo_freq]
# create qobj experiment field
experiments = []
schedule_los = qobj_config.pop('schedule_los', [])
if len(schedule_los) == 1:
lo_dict = schedule_los[0]
# update global config
q_los = lo_converter.get_qubit_los(lo_dict)
if q_los:
qobj_config['qubit_lo_freq'] = [freq / 1e9 for freq in q_los]
m_los = lo_converter.get_meas_los(lo_dict)
if m_los:
qobj_config['meas_lo_freq'] = [freq / 1e9 for freq in m_los]
if schedule_los:
# multiple frequency setups
if len(qobj_schedules) == 1:
# frequency sweep
for lo_dict in schedule_los:
experiments.append(
PulseQobjExperiment(
instructions=qobj_schedules[0]['instructions'],
header=qobj_schedules[0]['header'],
config=lo_converter(lo_dict)))
elif len(qobj_schedules) == len(schedule_los):
# n:n setup
for lo_dict, schedule in zip(schedule_los, qobj_schedules):
experiments.append(
PulseQobjExperiment(instructions=schedule['instructions'],
header=schedule['header'],
config=lo_converter(lo_dict)))
else:
raise QiskitError(
'Invalid LO setting is specified. '
'The LO should be configured for each schedule, or '
'single setup for all schedules (unique), or '
'multiple setups for a single schedule (frequency sweep),'
'or no LO configured at all.')
else:
# unique frequency setup
for schedule in qobj_schedules:
experiments.append(
PulseQobjExperiment(
instructions=schedule['instructions'],
header=schedule['header'],
))
qobj_config = PulseQobjConfig(**qobj_config)
return PulseQobj(qobj_id=qobj_id,
config=qobj_config,
experiments=experiments,
header=qobj_header)
