qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/assembler/assemble_schedules.py

@@ -0,0 +1,372 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+
+"""Assemble function for converting a list of circuits into a qobj."""
+import hashlib
+from collections import defaultdict
+from typing import Any, Dict, List, Tuple, Union
+
+from qiskit import qobj, pulse
+from qiskit.assembler.run_config import RunConfig
+from qiskit.exceptions import QiskitError
+from qiskit.pulse import instructions, transforms, library, schedule, channels
+from qiskit.qobj import utils as qobj_utils, converters
+from qiskit.qobj.converters.pulse_instruction import ParametricPulseShapes
+
+
+def assemble_schedules(
+    schedules: List[
+        Union[
+            schedule.ScheduleBlock,
+            schedule.ScheduleComponent,
+            Tuple[int, schedule.ScheduleComponent],
+        ]
+    ],
+    qobj_id: int,
+    qobj_header: qobj.QobjHeader,
+    run_config: RunConfig,
+) -> qobj.PulseQobj:
+    """Assembles a list of schedules into a qobj that can be run on the backend.
+
+    Args:
+        schedules: Schedules to assemble.
+        qobj_id: Identifier for the generated qobj.
+        qobj_header: Header to pass to the results.
+        run_config: Configuration of the runtime environment.
+
+    Returns:
+        The Qobj to be run on the backends.
+
+    Raises:
+        QiskitError: when frequency settings are not supplied.
+
+    Examples:
+
+        .. code-block:: python
+
+            from qiskit import pulse
+            from qiskit.assembler import assemble_schedules
+            from qiskit.assembler.run_config import RunConfig
+            # Construct a Qobj header for the output Qobj
+            header = {"backend_name": "FakeOpenPulse2Q", "backend_version": "0.0.0"}
+            # Build a configuration object for the output Qobj
+            config = RunConfig(shots=1024,
+                               memory=False,
+                               meas_level=1,
+                               meas_return='avg',
+                               memory_slot_size=100,
+                               parametric_pulses=[],
+                               init_qubits=True,
+                               qubit_lo_freq=[4900000000.0, 5000000000.0],
+                               meas_lo_freq=[6500000000.0, 6600000000.0],
+                               schedule_los=[])
+            # Build a Pulse schedule to assemble into a Qobj
+            schedule = pulse.Schedule()
+            schedule += pulse.Play(pulse.Waveform([0.1] * 16, name="test0"),
+                                   pulse.DriveChannel(0),
+                                   name="test1")
+            schedule += pulse.Play(pulse.Waveform([0.1] * 16, name="test1"),
+                                   pulse.DriveChannel(0),
+                                   name="test2")
+            schedule += pulse.Play(pulse.Waveform([0.5] * 16, name="test0"),
+                                   pulse.DriveChannel(0),
+                                   name="test1")
+            # Assemble a Qobj from the schedule.
+            pulseQobj = assemble_schedules(schedules=[schedule],
+                                           qobj_id="custom-id",
+                                           qobj_header=header,
+                                           run_config=config)
+    """
+    if not hasattr(run_config, "qubit_lo_freq"):
+        raise QiskitError("qubit_lo_freq must be supplied.")
+    if not hasattr(run_config, "meas_lo_freq"):
+        raise QiskitError("meas_lo_freq must be supplied.")
+
+    lo_converter = converters.LoConfigConverter(
+        qobj.PulseQobjExperimentConfig, **run_config.to_dict()
+    )
+    experiments, experiment_config = _assemble_experiments(schedules, lo_converter, run_config)
+    qobj_config = _assemble_config(lo_converter, experiment_config, run_config)
+
+    return qobj.PulseQobj(
+        experiments=experiments, qobj_id=qobj_id, header=qobj_header, config=qobj_config
+    )
+
+
+def _assemble_experiments(
+    schedules: List[Union[schedule.ScheduleComponent, Tuple[int, schedule.ScheduleComponent]]],
+    lo_converter: converters.LoConfigConverter,
+    run_config: RunConfig,
+) -> Tuple[List[qobj.PulseQobjExperiment], Dict[str, Any]]:
+    """Assembles a list of schedules into PulseQobjExperiments, and returns related metadata that
+    will be assembled into the Qobj configuration.
+
+    Args:
+        schedules: Schedules to assemble.
+        lo_converter: The configured frequency converter and validator.
+        run_config: Configuration of the runtime environment.
+
+    Returns:
+        The list of assembled experiments, and the dictionary of related experiment config.
+
+    Raises:
+        QiskitError: when frequency settings are not compatible with the experiments.
+    """
+    freq_configs = [lo_converter(lo_dict) for lo_dict in getattr(run_config, "schedule_los", [])]
+
+    if len(schedules) > 1 and len(freq_configs) not in [0, 1, len(schedules)]:
+        raise QiskitError(
+            "Invalid 'schedule_los' setting specified. If specified, it should be "
+            "either have a single entry to apply the same LOs for each schedule or "
+            "have length equal to the number of schedules."
+        )
+
+    instruction_converter = getattr(
+        run_config, "instruction_converter", converters.InstructionToQobjConverter
+    )
+    instruction_converter = instruction_converter(qobj.PulseQobjInstruction, **run_config.to_dict())
+
+    formatted_schedules = [transforms.target_qobj_transform(sched) for sched in schedules]
+    compressed_schedules = transforms.compress_pulses(formatted_schedules)
+
+    user_pulselib = {}
+    experiments = []
+    for idx, sched in enumerate(compressed_schedules):
+        qobj_instructions, max_memory_slot = _assemble_instructions(
+            sched, instruction_converter, run_config, user_pulselib
+        )
+
+        metadata = sched.metadata
+        if metadata is None:
+            metadata = {}
+        # TODO: add other experimental header items (see circuit assembler)
+        qobj_experiment_header = qobj.QobjExperimentHeader(
+            memory_slots=max_memory_slot + 1,  # Memory slots are 0 indexed
+            name=sched.name or "Experiment-%d" % idx,
+            metadata=metadata,
+        )
+
+        experiment = qobj.PulseQobjExperiment(
+            header=qobj_experiment_header, instructions=qobj_instructions
+        )
+        if freq_configs:
+            # This handles the cases where one frequency setting applies to all experiments and
+            # where each experiment has a different frequency
+            freq_idx = idx if len(freq_configs) != 1 else 0
+            experiment.config = freq_configs[freq_idx]
+
+        experiments.append(experiment)
+
+    # Frequency sweep
+    if freq_configs and len(experiments) == 1:
+        experiment = experiments[0]
+        experiments = []
+        for freq_config in freq_configs:
+            experiments.append(
+                qobj.PulseQobjExperiment(
+                    header=experiment.header,
+                    instructions=experiment.instructions,
+                    config=freq_config,
+                )
+            )
+
+    # Top level Qobj configuration
+    experiment_config = {
+        "pulse_library": [
+            qobj.PulseLibraryItem(name=name, samples=samples)
+            for name, samples in user_pulselib.items()
+        ],
+        "memory_slots": max(exp.header.memory_slots for exp in experiments),
+    }
+
+    return experiments, experiment_config
+
+
+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.from_instance(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, _), instruction_bundle in acquire_instruction_map.items():
+            qobj_instructions.append(
+                instruction_converter(time, instruction_bundle),
+            )
+
+    return qobj_instructions, max_memory_slot
+
+
+def _validate_meas_map(
+    instruction_map: Dict[Tuple[int, instructions.Acquire], List[instructions.Acquire]],
+    meas_map: List[List[int]],
+) -> None:
+    """Validate all qubits tied in ``meas_map`` are to be acquired.
+
+    Args:
+        instruction_map: A dictionary grouping Acquire instructions according to their start time
+                         and duration.
+        meas_map: List of groups of qubits that must be acquired together.
+
+    Raises:
+        QiskitError: If the instructions do not satisfy the measurement map.
+    """
+    sorted_inst_map = sorted(instruction_map.items(), key=lambda item: item[0])
+    meas_map_sets = [set(m) for m in meas_map]
+
+    # error if there is time overlap between qubits in the same meas_map
+    for idx, inst in enumerate(sorted_inst_map[:-1]):
+        inst_end_time = inst[0][0] + inst[0][1]
+        next_inst = sorted_inst_map[idx + 1]
+        next_inst_time = next_inst[0][0]
+        if next_inst_time < inst_end_time:
+            inst_qubits = {inst.channel.index for inst in inst[1]}
+            next_inst_qubits = {inst.channel.index for inst in next_inst[1]}
+            for meas_set in meas_map_sets:
+                common_instr_qubits = inst_qubits.intersection(meas_set)
+                common_next = next_inst_qubits.intersection(meas_set)
+                if common_instr_qubits and common_next:
+                    raise QiskitError(
+                        "Qubits {} and {} are in the same measurement grouping: {}. "
+                        "They must either be acquired at the same time, or disjointly"
+                        ". Instead, they were acquired at times: {}-{} and "
+                        "{}-{}".format(
+                            common_instr_qubits,
+                            common_next,
+                            meas_map,
+                            inst[0][0],
+                            inst_end_time,
+                            next_inst_time,
+                            next_inst_time + next_inst[0][1],
+                        )
+                    )
+
+
+def _assemble_config(
+    lo_converter: converters.LoConfigConverter,
+    experiment_config: Dict[str, Any],
+    run_config: RunConfig,
+) -> qobj.PulseQobjConfig:
+    """Assembles the QobjConfiguration from experimental config and runtime config.
+
+    Args:
+        lo_converter: The configured frequency converter and validator.
+        experiment_config: Schedules to assemble.
+        run_config: Configuration of the runtime environment.
+
+    Returns:
+        The assembled PulseQobjConfig.
+    """
+    qobj_config = run_config.to_dict()
+    qobj_config.update(experiment_config)
+
+    # Run config not needed in qobj config
+    qobj_config.pop("meas_map", None)
+    qobj_config.pop("qubit_lo_range", None)
+    qobj_config.pop("meas_lo_range", None)
+
+    # convert enums to serialized values
+    meas_return = qobj_config.get("meas_return", "avg")
+    if isinstance(meas_return, qobj_utils.MeasReturnType):
+        qobj_config["meas_return"] = meas_return.value
+
+    meas_level = qobj_config.get("meas_level", 2)
+    if isinstance(meas_level, qobj_utils.MeasLevel):
+        qobj_config["meas_level"] = meas_level.value
+
+    # convert LO frequencies to GHz
+    qobj_config["qubit_lo_freq"] = [freq / 1e9 for freq in qobj_config["qubit_lo_freq"]]
+    qobj_config["meas_lo_freq"] = [freq / 1e9 for freq in qobj_config["meas_lo_freq"]]
+
+    # override defaults if single entry for ``schedule_los``
+    schedule_los = qobj_config.pop("schedule_los", [])
+    if len(schedule_los) == 1:
+        lo_dict = schedule_los[0]
+        q_los = lo_converter.get_qubit_los(lo_dict)
+        # Hz -> GHz
+        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]
+
+    return qobj.PulseQobjConfig(**qobj_config)

qiskit/assembler/disassemble.py

@@ -0,0 +1,318 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Disassemble function for a qobj into a list of circuits and its config"""
+from typing import Any, Dict, List, NewType, Tuple, Union
+import collections
+import math
+
+from qiskit import pulse
+from qiskit.circuit.classicalregister import ClassicalRegister
+from qiskit.circuit.instruction import Instruction
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.quantumregister import QuantumRegister
+
+from qiskit.qobj import PulseQobjInstruction
+from qiskit.qobj.converters import QobjToInstructionConverter
+
+# A ``CircuitModule`` is a representation of a circuit execution on the backend.
+# It is currently a list of quantum circuits to execute, a run Qobj dictionary
+# and a header dictionary.
+CircuitModule = NewType(
+    "CircuitModule", Tuple[List[QuantumCircuit], Dict[str, Any], Dict[str, Any]]
+)
+
+# A ``PulseModule`` is a representation of a pulse execution on the backend.
+# It is currently a list of pulse schedules to execute, a run Qobj dictionary
+# and a header dictionary.
+PulseModule = NewType("PulseModule", Tuple[List[pulse.Schedule], Dict[str, Any], Dict[str, Any]])
+
+# Prevent the disassembler from accessing deprecated circuit methods. This can happen for
+# gates where the name of the gate matches a circuit method (e.g. Isometry.name is "isometry")
+# and the circuit attribute is also QuantumCircuit.isometry
+_DEPRECATED_CIRCUIT_METHODS = {
+    "isometry",
+    "snapshot",
+    "ucrx",
+    "ucry",
+    "ucrz",
+    "squ",
+    "diagonal",
+    "hamiltonian",
+}
+
+
+def disassemble(qobj) -> Union[CircuitModule, PulseModule]:
+    """Disassemble a qobj and return the circuits or pulse schedules, run_config, and user header.
+
+    .. note::
+
+        ``disassemble(assemble(qc))`` is not guaranteed to produce an exactly equal circuit to the
+        input, due to limitations in the :obj:`.QasmQobj` format that need to be maintained for
+        backend system compatibility.  This is most likely to be the case when using newer features
+        of :obj:`.QuantumCircuit`.  In most cases, the output should be equivalent, if not quite
+        equal.
+
+    Args:
+        qobj (Qobj): The input qobj object to disassemble
+
+    Returns:
+        Union[CircuitModule, PulseModule]: The disassembled program which consists of:
+
+            * programs: A list of quantum circuits or pulse schedules
+            * run_config: The dict of the run config
+            * user_qobj_header: The dict of any user headers in the qobj
+
+    Examples:
+
+        .. code-block:: python
+
+            from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
+            from qiskit.compiler.assembler import assemble
+            from qiskit.assembler.disassemble import disassemble
+            # Create a circuit to assemble into a qobj
+            q = QuantumRegister(2)
+            c = ClassicalRegister(2)
+            qc = QuantumCircuit(q, c)
+            qc.h(q[0])
+            qc.cx(q[0], q[1])
+            qc.measure(q, c)
+            # Assemble the circuit into a Qobj
+            qobj = assemble(qc, shots=2000, memory=True)
+            # Disassemble the qobj back into a circuit
+            circuits, run_config_out, headers = disassemble(qobj)
+    """
+    if qobj.type == "PULSE":
+        return _disassemble_pulse_schedule(qobj)
+    else:
+        return _disassemble_circuit(qobj)
+
+
+def _disassemble_circuit(qobj) -> CircuitModule:
+    run_config = qobj.config.to_dict()
+
+    # convert lo freq back to Hz
+    qubit_lo_freq = run_config.get("qubit_lo_freq", [])
+    if qubit_lo_freq:
+        run_config["qubit_lo_freq"] = [freq * 1e9 for freq in qubit_lo_freq]
+
+    meas_lo_freq = run_config.get("meas_lo_freq", [])
+    if meas_lo_freq:
+        run_config["meas_lo_freq"] = [freq * 1e9 for freq in meas_lo_freq]
+
+    user_qobj_header = qobj.header.to_dict()
+    return CircuitModule((_experiments_to_circuits(qobj), run_config, user_qobj_header))
+
+
+def _qobj_to_circuit_cals(qobj, pulse_lib):
+    """Return circuit calibrations dictionary from qobj/exp config calibrations."""
+    qobj_cals = qobj.config.calibrations.to_dict()["gates"]
+    converter = QobjToInstructionConverter(pulse_lib)
+
+    qc_cals = {}
+    for gate in qobj_cals:
+        config = (tuple(gate["qubits"]), tuple(gate["params"]))
+        cal = {
+            config: pulse.Schedule(
+                name="{} {} {}".format(gate["name"], str(gate["params"]), str(gate["qubits"]))
+            )
+        }
+        for instruction in gate["instructions"]:
+            qobj_instruction = PulseQobjInstruction.from_dict(instruction)
+            schedule = converter(qobj_instruction)
+            cal[config] = cal[config].insert(schedule.ch_start_time(), schedule)
+        if gate["name"] in qc_cals:
+            qc_cals[gate["name"]].update(cal)
+        else:
+            qc_cals[gate["name"]] = cal
+
+    return qc_cals
+
+
+def _experiments_to_circuits(qobj):
+    """Return a list of QuantumCircuit object(s) from a qobj.
+
+    Args:
+        qobj (Qobj): The Qobj object to convert to QuantumCircuits
+
+    Returns:
+        list: A list of QuantumCircuit objects from the qobj
+    """
+    if not qobj.experiments:
+        return None
+
+    circuits = []
+    for exp in qobj.experiments:
+        quantum_registers = [QuantumRegister(i[1], name=i[0]) for i in exp.header.qreg_sizes]
+        classical_registers = [ClassicalRegister(i[1], name=i[0]) for i in exp.header.creg_sizes]
+        circuit = QuantumCircuit(*quantum_registers, *classical_registers, name=exp.header.name)
+        qreg_dict = collections.OrderedDict()
+        creg_dict = collections.OrderedDict()
+        for reg in quantum_registers:
+            qreg_dict[reg.name] = reg
+        for reg in classical_registers:
+            creg_dict[reg.name] = reg
+        conditional = {}
+        for i in exp.instructions:
+            name = i.name
+            qubits = []
+            params = getattr(i, "params", [])
+            try:
+                for qubit in i.qubits:
+                    qubit_label = exp.header.qubit_labels[qubit]
+                    qubits.append(qreg_dict[qubit_label[0]][qubit_label[1]])
+            except Exception:  # pylint: disable=broad-except
+                pass
+            clbits = []
+            try:
+                for clbit in i.memory:
+                    clbit_label = exp.header.clbit_labels[clbit]
+                    clbits.append(creg_dict[clbit_label[0]][clbit_label[1]])
+            except Exception:  # pylint: disable=broad-except
+                pass
+            # TODO remove the check that name is not in the deprecated circuit methods
+            # once the methods have been removed
+            if hasattr(circuit, name) and name not in _DEPRECATED_CIRCUIT_METHODS:
+                instr_method = getattr(circuit, name)
+                if i.name == "initialize":
+                    _inst = instr_method(params, qubits)
+                elif i.name in ["mcx", "mcu1", "mcp"]:
+                    _inst = instr_method(*params, qubits[:-1], qubits[-1], *clbits)
+                else:
+                    _inst = instr_method(*params, *qubits, *clbits)
+            elif name == "bfunc":
+                conditional["value"] = int(i.val, 16)
+                full_bit_size = sum(creg_dict[x].size for x in creg_dict)
+                mask_map = {}
+                raw_map = {}
+                raw = []
+
+                for creg in creg_dict:
+                    size = creg_dict[creg].size
+                    reg_raw = [1] * size
+                    if not raw:
+                        raw = reg_raw
+                    else:
+                        for pos, val in enumerate(raw):
+                            if val == 1:
+                                raw[pos] = 0
+                        raw = reg_raw + raw
+                    mask = [0] * (full_bit_size - len(raw)) + raw
+                    raw_map[creg] = mask
+                    mask_map[int("".join(str(x) for x in mask), 2)] = creg
+                if bin(int(i.mask, 16)).count("1") == 1:
+                    # The condition is on a single bit.  This might be a single-bit condition, or it
+                    # might be a register of length one.  The case that it's a single-bit condition
+                    # in a register of length one is ambiguous, and we choose to return a condition
+                    # on the register.  This may not match the input circuit exactly, but is at
+                    # least equivalent.
+                    cbit = int(math.log2(int(i.mask, 16)))
+                    for reg in creg_dict.values():
+                        size = reg.size
+                        if cbit >= size:
+                            cbit -= size
+                        else:
+                            conditional["register"] = reg if reg.size == 1 else reg[cbit]
+                            break
+                    mask_str = bin(int(i.mask, 16))[2:].zfill(full_bit_size)
+                    mask = [int(item) for item in list(mask_str)]
+                else:
+                    creg = mask_map[int(i.mask, 16)]
+                    conditional["register"] = creg_dict[creg]
+                    mask = raw_map[creg]
+                val = int(i.val, 16)
+                for j in reversed(mask):
+                    if j == 0:
+                        val = val >> 1
+                    else:
+                        conditional["value"] = val
+                        break
+            else:
+                _inst = temp_opaque_instruction = Instruction(
+                    name=name, num_qubits=len(qubits), num_clbits=len(clbits), params=params
+                )
+                circuit.append(temp_opaque_instruction, qubits, clbits)
+            if conditional and name != "bfunc":
+                _inst.c_if(conditional["register"], conditional["value"])
+                conditional = {}
+        pulse_lib = qobj.config.pulse_library if hasattr(qobj.config, "pulse_library") else []
+        # The dict update method did not work here; could investigate in the future
+        if hasattr(qobj.config, "calibrations"):
+            circuit.calibrations = dict(
+                **circuit.calibrations, **_qobj_to_circuit_cals(qobj, pulse_lib)
+            )
+        if hasattr(exp.config, "calibrations"):
+            circuit.calibrations = dict(
+                **circuit.calibrations, **_qobj_to_circuit_cals(exp, pulse_lib)
+            )
+        circuits.append(circuit)
+    return circuits
+
+
+def _disassemble_pulse_schedule(qobj) -> PulseModule:
+    run_config = qobj.config.to_dict()
+    run_config.pop("pulse_library")
+
+    qubit_lo_freq = run_config.get("qubit_lo_freq")
+    if qubit_lo_freq:
+        run_config["qubit_lo_freq"] = [freq * 1e9 for freq in qubit_lo_freq]
+
+    meas_lo_freq = run_config.get("meas_lo_freq")
+    if meas_lo_freq:
+        run_config["meas_lo_freq"] = [freq * 1e9 for freq in meas_lo_freq]
+
+    user_qobj_header = qobj.header.to_dict()
+
+    # extract schedule lo settings
+    schedule_los = []
+    for program in qobj.experiments:
+        program_los = {}
+        if hasattr(program, "config"):
+            if hasattr(program.config, "qubit_lo_freq"):
+                for i, lo in enumerate(program.config.qubit_lo_freq):
+                    program_los[pulse.DriveChannel(i)] = lo * 1e9
+
+            if hasattr(program.config, "meas_lo_freq"):
+                for i, lo in enumerate(program.config.meas_lo_freq):
+                    program_los[pulse.MeasureChannel(i)] = lo * 1e9
+
+        schedule_los.append(program_los)
+
+    if any(schedule_los):
+        run_config["schedule_los"] = schedule_los
+
+    return PulseModule((_experiments_to_schedules(qobj), run_config, user_qobj_header))
+
+
+def _experiments_to_schedules(qobj) -> List[pulse.Schedule]:
+    """Return a list of :class:`qiskit.pulse.Schedule` object(s) from a qobj.
+
+    Args:
+        qobj (Qobj): The Qobj object to convert to pulse schedules.
+
+    Returns:
+        A list of :class:`qiskit.pulse.Schedule` objects from the qobj
+
+    Raises:
+        pulse.PulseError: If a parameterized instruction is supplied.
+    """
+    converter = QobjToInstructionConverter(qobj.config.pulse_library)
+
+    schedules = []
+    for program in qobj.experiments:
+        insts = []
+        for inst in program.instructions:
+            insts.append(converter(inst))
+
+        schedule = pulse.Schedule(*insts)
+        schedules.append(schedule)
+    return schedules