def test_counts_no_header(self): """Test that counts are extracted properly without header.""" raw_counts = {'0x0': 4, '0x2': 10} no_header_processed_counts = { bin(int(bs[2:], 16))[2:]: counts for (bs, counts) in raw_counts.items() } data = models.ExperimentResultData(counts=base.Obj(**raw_counts)) exp_result = models.ExperimentResult(shots=14, success=True, meas_level=2, data=data) result = Result(results=[exp_result], **self.base_result_args) self.assertEqual(result.get_counts(0), no_header_processed_counts)
def test_memory_counts_no_header(self): """Test that memory bitstrings are extracted properly without header.""" raw_memory = ['0x0', '0x0', '0x2', '0x2', '0x2', '0x2', '0x2'] no_header_processed_memory = [ bin(int(bs[2:], 16))[2:] for bs in raw_memory ] data = models.ExperimentResultData(memory=raw_memory) exp_result = models.ExperimentResult(shots=14, success=True, meas_level=2, memory=True, data=data) result = Result(results=[exp_result], **self.base_result_args) self.assertEqual(result.get_memory(0), no_header_processed_memory)
def test_memory_int_out(self): """Test that memory bitstrings are extracted properly without header.""" raw_memory = ["0x0", "0x0", "0x2", "0x2", "0x2", "0x2", "0x2"] data = models.ExperimentResultData(memory=raw_memory) exp_result = models.ExperimentResult(shots=14, success=True, meas_level=2, memory=True, data=data) result = Result(results=[exp_result], **self.base_result_args) with self.assertRaises(Exception) as context: result.get_memory(99) self.assertEqual('Result for experiment "99" could not be found.', context.exception.message)
def _compute_phases( self, num_unitary_qubits: int, circuit_result: Result ) -> Union[numpy.ndarray, qiskit.result.Counts]: """Compute frequencies/counts of phases from the result of running the QPE circuit. How the frequencies are computed depends on whether the backend computes amplitude or samples outcomes. 1) If the backend is a statevector simulator, then the reduced density matrix of the phase-reading register is computed from the combined phase-reading- and input-state registers. The elements of the diagonal :math:`(i, i)` give the probability to measure the each of the states `i`. The index `i` expressed as a binary integer with the LSB rightmost gives the state of the phase-reading register with the LSB leftmost when interpreted as a phase. In order to maintain the compact representation, the phases are maintained as decimal integers. They may be converted to other forms via the results object, `PhaseEstimationResult` or `HamiltonianPhaseEstimationResult`. 2) If the backend samples bitstrings, then the counts are first retrieved as a dict. The binary strings (the keys) are then reversed so that the LSB is rightmost and the counts are converted to frequencies. Then the keys are sorted according to increasing phase, so that they can be easily understood when displaying or plotting a histogram. Args: num_unitary_qubits: The number of qubits in the unitary. circuit_result: the result object returned by the backend that ran the QPE circuit. Returns: Either a dict or numpy.ndarray representing the frequencies of the phases. """ if self._quantum_instance.is_statevector: state_vec = circuit_result.get_statevector() evaluation_density_matrix = qiskit.quantum_info.partial_trace( state_vec, range(self._num_evaluation_qubits, self._num_evaluation_qubits + num_unitary_qubits)) phases = evaluation_density_matrix.probabilities() else: # return counts with keys sorted numerically num_shots = circuit_result.results[0].shots counts = circuit_result.get_counts() phases = {k[::-1]: counts[k] / num_shots for k in counts.keys()} phases = _sort_phases(phases) phases = qiskit.result.Counts(phases, memory_slots=counts.memory_slots, creg_sizes=counts.creg_sizes) return phases
def _set_result(self, raw_data: Optional[Dict]) -> None: """Set the job result. Args: raw_data: Raw result data. Raises: IBMQJobInvalidStateError: If result is in an unsupported format. IBMQJobApiError: If an unexpected error occurred when communicating with the server. """ if raw_data is None: self._result = None return raw_data['client_version'] = self.client_version decode_result(raw_data) try: self._result = Result.from_dict(raw_data) except (KeyError, TypeError) as err: if not self._kind: raise IBMQJobInvalidStateError( 'Unable to retrieve result for job {}. Job result ' 'is in an unsupported format.'.format( self.job_id())) from err raise IBMQJobApiError('Unable to retrieve result for ' 'job {}: {}'.format(self.job_id(), str(err))) from err
def result(self, timeout: Optional[float] = None, wait: float = 0.5) -> Result: """ Args: timeout: Timeout in seconds. wait: Wait time between queries to the quantum-inspire platform. Returns: Result object containing results from the experiments. Raises: JobTimeoutError: If timeout is reached. QisKitBackendError: If an error occurs during simulation. """ start_time = time.time() while self.status() != JobStatus.DONE: elapsed_time = time.time() - start_time if timeout is not None and elapsed_time > timeout: raise JobTimeoutError( 'Failed getting result: timeout reached.') time.sleep(wait) experiment_results = self._backend.get_experiment_results(self) return Result(backend_name=self._backend.backend_name, backend_version=quantum_inspire_version, job_id=self.job_id(), qobj_id=self.job_id(), success=True, results=experiment_results)
def _run_job(self, job_id, qobj): """Run experiments in qobj. Args: job_id (str): unique id for the job. qobj (Qobj): job description Returns: Result: Result object """ self._validate(qobj) result_list = [] start = time.time() for experiment in qobj.experiments: result_list.append(self.run_experiment(experiment)) end = time.time() result = { "backend_name": self.name(), "backend_version": self._configuration.backend_version, "qobj_id": qobj.qobj_id, "job_id": job_id, "results": result_list, "status": "COMPLETED", "success": True, "time_taken": (end - start), "header": qobj.header.to_dict(), } return Result.from_dict(result)
def test_zz_fitter(self): """ Test ZZ fitter in Ignis characterization This test relies on static data stored in the file zz_data.json. To generate zz_data.json, run 'python generate_data.py zz'. """ with open(os.path.join(os.path.dirname(__file__), 'zz_data.json'), 'r') as handle: data = json.load(handle) fit = ZZFitter(Result.from_dict(data['backend_result']), data['xdata'], data['qubits'], data['spectators'], fit_p0=[0.5, data['omega'], 0, 0.5], fit_bounds=([-0.5, 0, -np.pi, -0.5], [1.5, 2 * data['omega'], np.pi, 1.5])) self.assertEqual(fit.series, ['0', '1']) self.assertEqual(sorted(list(fit.params.keys())), ['0', '1']) num_of_qubits = len(data['qubits']) self.assertEqual(len(fit.params['0']), num_of_qubits) self.assertEqual(len(fit.params_err['0']), num_of_qubits) self.assertTrue( np.isclose(fit.ZZ_rate(), data['zz'], rtol=0.3, atol=0.1))
def _run_job(self, job_id, run_input, data, qobj_id, qobj_header, **options): """Run experiments in run_input Args: job_id (str): unique id for the job. run_input (QuantumCircuit or Schedule or list): job description Returns: Result: Result object """ start = time.time() self._data = data experiments = run_input.experiments if hasattr(run_input, 'config') else run_input if isinstance(experiments, QuantumCircuit): experiments = [experiments] results = [] for experiment in experiments: results.append(self.run_experiment(experiment, **options)) return Result(backend_name=self.name(), backend_version=self._configuration.backend_version, qobj_id=qobj_id, job_id=job_id, success=True, results=results, date=datetime.now(), status='COMPLETED', header=qobj_header, time_taken=(time.time() - start))
def test_marginal_counts_result_format(self): """Test that marginal_counts with format_marginal true properly formats output.""" raw_counts_1 = {'0x0': 4, '0x1': 7, '0x2': 10, '0x6': 5, '0x9': 11, '0xD': 9, '0x12': 8} data_1 = models.ExperimentResultData(counts=dict(**raw_counts_1)) exp_result_header_1 = QobjExperimentHeader(creg_sizes=[['c0', 2], ['c1', 3]], memory_slots=5) exp_result_1 = models.ExperimentResult(shots=54, success=True, data=data_1, header=exp_result_header_1) result = Result(results=[exp_result_1], **self.base_result_args) expected_marginal_counts_1 = {'0_0 _0': 14, '0_0 _1': 18, '0_1 _0': 5, '0_1 _1': 9, '1_0 _0': 8} marginal_counts_result = marginal_counts(result.get_counts(), [0, 2, 4], format_marginal=True) self.assertEqual(marginal_counts_result, expected_marginal_counts_1)
def run_job(self, job_id, qobj): """Main dummy run loop""" del qobj # unused time.sleep(self.time_alive) return Result.from_dict( {'job_id': job_id, 'result': [], 'status': 'COMPLETED'})
def run(self, run_input, **options): """ Run the Tphi backend """ self.options.update_options(**options) shots = 1000 t1_circuits = [] t2ramsey_circuits = [] for circ in run_input: if circ.metadata["composite_metadata"][0]["experiment_type"] == "T1": t1_circuits.append(circ) elif circ.metadata["composite_metadata"][0]["experiment_type"] == "T2Ramsey": t2ramsey_circuits.append(circ) else: raise ValueError("Illegal name for circuit in Tphi") job_t1 = self._internal_backends["T1"].run(run_input=t1_circuits, shots=shots) job_t2ramsey = self._internal_backends["T2*"].run(run_input=t2ramsey_circuits, shots=shots) final_results = job_t1.result().results + job_t2ramsey.result().results result_for_fake = Result( backend_name="Tphi backend", backend_version="0", qobj_id="0", job_id="0", success=True, results=final_results, status="JobStatus.DONE", ) return FakeJob(self, result_for_fake)
def _run(self, qobj, job_id=''): """Run a job""" # Start timer start = time.time() # Run simulation output = self._execute(qobj) # Validate output if not isinstance(output, dict): logger.error("%s: simulation failed.", self.name()) if output: logger.error('Output: %s', output) raise AerError( "simulation terminated without returning valid output.") # Format results output["job_id"] = job_id output["date"] = datetime.datetime.now().isoformat() output["backend_name"] = self.name() output["backend_version"] = self.configuration().backend_version # Add execution time output["time_taken"] = time.time() - start # Display warning if simulation failed if not output.get("success", False): msg = "Simulation failed" if "status" in output: msg += f" and returned the following error message:\n{output['status']}" logger.warning(msg) return Result.from_dict(output)
def _set_result(self, raw_data: Optional[Dict]) -> None: """Set the job result. Args: raw_data: Raw result data. Raises: IBMQJobInvalidStateError: If result is in an unsupported format. IBMQJobApiError: If an unexpected error occurred when communicating with the server. """ if raw_data is None: self._result = None return raw_data['client_version'] = self.client_version # TODO Stop checking Terra version when it's released. from qiskit.version import __version__ as terra_version if terra_version >= '0.15.0': decode_result(raw_data) # if 'date' in raw_data: # raw_data['date'] = utc_to_local(raw_data['date']) try: self._result = Result.from_dict(raw_data) if hasattr(self._result, 'date'): self._result.date = utc_to_local(self._result.date) except (KeyError, TypeError) as err: if not self._kind: raise IBMQJobInvalidStateError( 'Unable to retrieve result for job {}. Job result ' 'is in an unsupported format.'.format( self.job_id())) from err raise IBMQJobApiError('Unable to retrieve result for ' 'job {}: {}'.format(self.job_id(), str(err))) from err
def test_circuit_unitary_repr_decimal(self): """Test postprocessing of unitary giving decimals arg.""" raw_unitary = np.array( [[0.70710678 + 0.00000000e+00j, 0.70710678 - 8.65956056e-17j], [0.70710678 + 0.00000000e+00j, -0.70710678 + 8.65956056e-17j]], dtype=np.complex_) processed_unitary = np.array( [[0.707 + 0.j, 0.707 - 0.j], [0.707 + 0.j, -0.707 + 0.j]], dtype=np.complex_) data = models.ExperimentResultData(unitary=raw_unitary) exp_result = models.ExperimentResult(shots=1, success=True, data=data) result = Result(results=[exp_result], **self.base_result_args) unitary = result.get_unitary(decimals=3) self.assertEqual(unitary.shape, (2, 2)) self.assertEqual(unitary.dtype, np.complex_) np.testing.assert_almost_equal(unitary, processed_unitary)
def test_meas_level_0_avg(self): """Test measurement level 0 average result.""" # 3 qubits raw_memory = [[[0., 1.], [0., 1.], [0., 1.]], [[1., 0.], [1., 0.], [1., 0.]]] processed_memory = np.array([[1.j, 1.j, 1.j], [1., 1., 1.]], dtype=np.complex_) data = models.ExperimentResultData(memory=raw_memory) exp_result = models.ExperimentResult(shots=2, success=True, meas_level=0, meas_return='avg', data=data) result = Result(results=[exp_result], **self.base_result_args) memory = result.get_memory(0) self.assertEqual(memory.shape, (2, 3)) self.assertEqual(memory.dtype, np.complex_) np.testing.assert_almost_equal(memory, processed_memory)
def _get_job_result(self, circ_count, has_metadata=False): """Return a job result with random counts.""" job_result = { "backend_name": self.backend.name(), "backend_version": "1.1.1", "qobj_id": "1234", "job_id": "some_job_id", "success": True, "results": [], } circ_result_template = {"shots": 1024, "success": True, "data": {}} for _ in range(circ_count): counts = randrange(1024) circ_result = copy.copy(circ_result_template) circ_result["data"] = { "counts": { "0x0": counts, "0x3": 1024 - counts } } if has_metadata: circ_result["header"] = {"metadata": {"meas_basis": "pauli"}} job_result["results"].append(circ_result) return Result.from_dict(job_result)
def test_circuit_statevector_repr_decimal(self): """Test postprocessing of statevector giving decimals arg.""" raw_statevector = np.array( [0.35355339 + 0.j, 0.35355339 + 0.j, 0.35355339 + 0.j, 0.35355339 + 0.j, 0.35355339 + 0.j, 0.35355339 + 0.j, 0.35355339 + 0.j, 0.35355339 + 0.j], dtype=np.complex_) processed_sv = np.array( [0.354 + 0.j, 0.354 + 0.j, 0.354 + 0.j, 0.354 + 0.j, 0.354 + 0.j, 0.354 + 0.j, 0.354 + 0.j, 0.354 + 0.j], dtype=np.complex_) data = models.ExperimentResultData(statevector=raw_statevector) exp_result = models.ExperimentResult(shots=1, success=True, data=data) result = Result(results=[exp_result], **self.base_result_args) statevector = result.get_statevector(decimals=3) self.assertEqual(statevector.shape, (8,)) self.assertEqual(statevector.dtype, np.complex_) np.testing.assert_almost_equal(statevector, processed_sv)
def _process_results(self): """Convert Honeywell job result to qiskit.Result""" results = [] self._status = JobStatus.DONE for i, res_resp in enumerate(self._experiment_results): status = res_resp.get('status', 'failed') if status == 'failed': self._status = JobStatus.ERROR res = res_resp['results'] counts = dict(Counter(hex(int("".join(r), 2)) for r in [*zip(*list(res.values()))])) experiment_result = { 'shots': self._qobj_payload.get('config', {}).get('shots', 1), 'success': ApiJobStatus(status) is ApiJobStatus.COMPLETED, 'data': {'counts': counts}, 'header': self._qobj_payload[ 'experiments'][i]['header'] if self._qobj_payload else {}, 'job_id': self._job_ids[i] } results.append(experiment_result) result = { 'success': self._status is JobStatus.DONE, 'job_id': self._job_id, 'results': results, 'backend_name': self._backend.name(), 'backend_version': self._backend.status().backend_version, 'qobj_id': self._job_id } return Result.from_dict(result)
def _qlm_to_qiskit_result(backend_name, backend_version, qobj_id, job_id, success, qlm_results, metadata, qobj_header): """ Tranform a QLM result into a Qiskit result structure. Args: backend_name: backend_version: qobj_id: job_id: success: qlm_results: List of qat.core.wrappers.Result objects metadata: List of the circuit's metadata qobj_header: user input that will be in the Result Returns: A qiskit Result structure. """ return Result( backend_name=backend_name, backend_version=backend_version, qobj_id=qobj_id, job_id=job_id, success=success, results=[ _generate_experiment_result(result, md) for result, md in zip(qlm_results, metadata) ], header=qobj_header, )
def result(self): result = self._wait_for_result() results = [{ 'success': True, 'shots': len(result['samples']), 'data': { 'counts': self._format_counts(result['samples']) }, 'header': { 'memory_slots': self.qobj.config.memory_slots, 'name': self.qobj.experiments[0].header.name } }] return Result.from_dict({ 'results': results, 'backend_name': self._backend._configuration.backend_name, 'backend_version': self._backend._configuration.backend_version, 'qobj_id': self.qobj.qobj_id, 'success': True, 'job_id': self._job_id, })
def test_t2star_fitter(self): """ Test T2* fitter in Ignis characterization This test relies on static data stored in the file t2star_data.json. To generate t2star_data.json, run 'python generate_data.py t2star'. """ with open(os.path.join(os.path.dirname(__file__), 't2star_data.json'), 'r') as handle: data = json.load(handle) fit = T2StarFitter( Result.from_dict(data['backend_result']), data['xdata'], data['qubits'], fit_p0=[0.5, data['t2'], data['omega'], 0, 0.5], fit_bounds=([-0.5, 0, data['omega'] - 0.02, -np.pi, -0.5], [ 1.5, data['t2'] * 1.2, data['omega'] + 0.02, np.pi, 1.5 ])) self.assertEqual(fit.series, ['0']) self.assertEqual(list(fit.params.keys()), ['0']) num_of_qubits = len(data['qubits']) self.assertEqual(len(fit.params['0']), num_of_qubits) self.assertEqual(len(fit.params_err['0']), num_of_qubits) for qubit in range(num_of_qubits): self.assertTrue( np.allclose(fit.params['0'][qubit], [0.5, data['t2'], data['omega'], 0, 0.5], rtol=0.3, atol=0.1))
def calibration_data( result: Result, metadata: List[Dict[str, any]]) -> Tuple[Dict[int, Dict[int, int]], int]: """Return FullMeasureErrorMitigator from result data. Args: result: Qiskit result object. metadata: mitigation generator metadata. Returns: Calibration data dictionary {label: Counts} and number of qubits. """ # Filter mitigation calibration data cal_data = {} num_qubits = None method = None for i, meta in enumerate(metadata): if meta.get('experiment') == 'meas_mit': if num_qubits is None: num_qubits = len(meta['cal']) if method is None: method = meta.get('method', None) key = int(meta['cal'], 2) counts = result.get_counts(i).int_outcomes() if key not in cal_data: cal_data[key] = counts else: cal_data[key] = combine_counts(cal_data[key], counts) return cal_data, num_qubits, method
def object_hook(self, obj: Any) -> Any: """Called to decode object.""" if '__type__' in obj: obj_type = obj['__type__'] obj_val = obj['__value__'] if obj_type == 'complex': return obj_val[0] + 1j * obj_val[1] if obj_type == 'ndarray': return _decode_and_deserialize(obj_val, np.load) if obj_type == 'set': return set(obj_val) if obj_type == 'QuantumCircuit': return _decode_and_deserialize(obj_val, qpy_serialization.load)[0] if obj_type == 'ParameterExpression': return _decode_and_deserialize( obj_val, qpy_serialization._read_parameter_expression, False) if obj_type == 'Instruction': return _decode_and_deserialize( obj_val, qpy_serialization._read_instruction, False) if obj_type == 'settings': return deserialize_from_settings(mod_name=obj['__module__'], class_name=obj['__class__'], settings=obj_val) if obj_type == 'Result': return Result.from_dict(obj_val) if obj_type == 'spmatrix': return _decode_and_deserialize(obj_val, scipy.sparse.load_npz, False) if obj_type == 'to_json': return obj_val return obj
def __init__( self, backend: 'ibmqbackend.IBMQBackend', api: AccountClient, job_id: str, creation_date: str, status: str, kind: Optional[str] = None, name: Optional[str] = None, time_per_step: Optional[dict] = None, result: Optional[dict] = None, qobj: Optional[Union[dict, QasmQobj, PulseQobj]] = None, error: Optional[dict] = None, tags: Optional[List[str]] = None, run_mode: Optional[str] = None, **kwargs: Any ) -> None: """IBMQJob constructor. Args: backend: The backend instance used to run this job. api: Object for connecting to the server. job_id: Job ID. creation_date: Job creation date. status: Job status returned by the server. kind: Job type. name: Job name. time_per_step: Time spent for each processing step. result: Job result. qobj: Qobj for this job. error: Job error. tags: Job tags. run_mode: Scheduling mode the job runs in. kwargs: Additional job attributes. """ self._backend = backend self._api = api self._job_id = job_id self._creation_date = dateutil.parser.isoparse(creation_date) self._api_status = status self._kind = ApiJobKind(kind) if kind else None self._name = name self._time_per_step = time_per_step self._result = Result.from_dict(result) if result else None if isinstance(qobj, dict): qobj = dict_to_qobj(qobj) self._qobj = qobj self._error = error self._tags = tags or [] self._run_mode = run_mode self._status, self._queue_info = \ self._get_status_position(status, kwargs.pop('info_queue', None)) self._use_object_storage = (self._kind == ApiJobKind.QOBJECT_STORAGE) SimpleNamespace.__init__(self, **kwargs) BaseJob.__init__(self, self.backend(), self.job_id()) # Properties used for caching. self._cancelled = False self._job_error_msg = None # type: Optional[str]
def test_marginal_counts_result_creg_sizes(self): """Test that marginal_counts with Result input properly changes creg_sizes.""" raw_counts = { "0x0": 4, "0x1": 7, "0x2": 10, "0x6": 5, "0x9": 11, "0xD": 9, "0xE": 8 } data = models.ExperimentResultData(counts=dict(**raw_counts)) exp_result_header = QobjExperimentHeader(creg_sizes=[["c0", 1], ["c1", 3]], memory_slots=4) exp_result = models.ExperimentResult(shots=54, success=True, data=data, header=exp_result_header) result = Result(results=[exp_result], **self.base_result_args) expected_marginal_counts = {"0 0": 14, "0 1": 18, "1 0": 13, "1 1": 9} expected_creg_sizes = [["c0", 1], ["c1", 1]] expected_memory_slots = 2 marginal_counts_result = marginal_counts(result, [0, 2]) self.assertEqual(marginal_counts_result.results[0].header.creg_sizes, expected_creg_sizes) self.assertEqual(marginal_counts_result.results[0].header.memory_slots, expected_memory_slots) self.assertEqual(marginal_counts_result.get_counts(0), expected_marginal_counts)
def test_coder(self): """Test runtime encoder and decoder.""" result = Result(backend_name='ibmqx2', backend_version='1.1', qobj_id='12345', job_id='67890', success=False, results=[]) data = { "string": "foo", "float": 1.5, "complex": 2 + 3j, "array": np.array([[1, 2, 3], [4, 5, 6]]), "result": result, "sclass": SerializableClass("foo"), } encoded = json.dumps(data, cls=RuntimeEncoder) decoded = json.loads(encoded, cls=RuntimeDecoder) decoded["sclass"] = SerializableClass.from_json(decoded['sclass']) decoded_result = decoded.pop('result') data.pop('result') decoded_array = decoded.pop('array') orig_array = data.pop('array') self.assertEqual(decoded, data) self.assertIsInstance(decoded_result, Result) self.assertTrue((decoded_array == orig_array).all())
def test_marginal_counts_no_cregs(self): """Test that marginal_counts without cregs See qiskit-terra/6430.""" raw_counts_1 = { "0x0": 4, "0x1": 7, "0x2": 10, "0x6": 5, "0x9": 11, "0xD": 9, "0x12": 8 } data_1 = models.ExperimentResultData(counts=dict(**raw_counts_1)) exp_result_header_1 = QobjExperimentHeader(memory_slots=5) exp_result_1 = models.ExperimentResult(shots=54, success=True, data=data_1, header=exp_result_header_1) result = Result(results=[exp_result_1], **self.base_result_args) _ = marginal_counts(result, indices=[0]) marginal_counts_result = marginal_counts(result, indices=[0]) self.assertEqual(marginal_counts_result.get_counts(), { "0": 27, "1": 27 })
def _run_job(self, job_id, qobj): """Run experiments in qobj. Args: job_id (str): unique id for the job. qobj (Qobj): job description Returns: Result: Result object """ self._validate(qobj) result_list = [] start = time.time() for experiment in qobj.experiments: result_list.append(self.run_experiment(experiment)) end = time.time() result = {'backend_name': self.name(), 'backend_version': self._configuration.backend_version, 'qobj_id': qobj.qobj_id, 'job_id': job_id, 'results': result_list, 'status': 'COMPLETED', 'success': True, 'time_taken': (end - start), 'header': qobj.header.to_dict()} return Result.from_dict(result)
def _qlm_to_qiskit_result( backend_name, backend_version, qobj_id, job_id, success, qlm_results, headers ): """ Tranform a QLM result into a Qiskit result structure. Args: backend_name: backend_version: qobj_id: job_id: success: qlm_results: List of qat.core.wrappers.Result objects headers: List of the experiments' headers Returns: A qiskit Result structure. """ return Result( backend_name=backend_name, backend_version=backend_version, qobj_id=qobj_id, job_id=job_id, success=success, results=[ _generate_experiment_result(result, head) for result, head in zip(qlm_results, headers) ], )