def test_online_qasm_simulator_two_registers(self, qe_token, qe_url): """Test online_qasm_simulator_two_registers. If all correct should return correct counts. """ provider = IBMQProvider(qe_token, qe_url) backend = provider.get_backend('ibmq_qasm_simulator') q1 = QuantumRegister(2) c1 = ClassicalRegister(2) q2 = QuantumRegister(2) c2 = ClassicalRegister(2) qc1 = QuantumCircuit(q1, q2, c1, c2) qc2 = QuantumCircuit(q1, q2, c1, c2) qc1.x(q1[0]) qc2.x(q2[1]) qc1.measure(q1[0], c1[0]) qc1.measure(q1[1], c1[1]) qc1.measure(q2[0], c2[0]) qc1.measure(q2[1], c2[1]) qc2.measure(q1[0], c1[0]) qc2.measure(q1[1], c1[1]) qc2.measure(q2[0], c2[0]) qc2.measure(q2[1], c2[1]) shots = 1024 qobj = transpiler.compile([qc1, qc2], backend, seed=8458, shots=shots) job = backend.run(qobj) result = job.result() result1 = result.get_counts(qc1) result2 = result.get_counts(qc2) self.assertEqual(result1, {'00 01': 1024}) self.assertEqual(result2, {'10 00': 1024})
def test_run_remote_simulator_compile(self, QE_TOKEN, QE_URL): provider = IBMQProvider(QE_TOKEN, QE_URL) backend = provider.get_backend('ibmqx_qasm_simulator') quantum_job = QuantumJob(self.qc, do_compile=True, backend=backend) jobprocessor.run_backend(quantum_job)
def test_get_backend_name(self, qe_token, qe_url): provider = IBMQProvider(qe_token, qe_url) backend_name = 'ibmq_qasm_simulator' backend = provider.get_backend(backend_name) qobj = transpiler.compile(self._qc, backend) job = backend.run(qobj) self.assertTrue(job.backend_name() == backend_name)
def test_get_jobs_filter_counts(self, qe_token, qe_url): provider = IBMQProvider(qe_token, qe_url) # TODO: consider generalizing backend name # TODO: this tests depends on the previous executions of the user backend = provider.get_backend('ibmq_qasm_simulator') my_filter = { 'backend.name': 'ibmq_qasm_simulator', 'shots': 1024, 'qasms.result.data.counts.00': { 'lt': 500 } } self.log.info('searching for at most 5 jobs with 1024 shots, a count ' 'for "00" of < 500, on the ibmq_qasm_simulator backend') job_list = backend.jobs(limit=5, skip=0, db_filter=my_filter) self.log.info('found %s matching jobs', len(job_list)) for i, job in enumerate(job_list): self.log.info('match #%d', i) result = job.result() self.assertTrue( any(cresult['data']['counts']['00'] < 500 for cresult in result._result['result'])) for circuit_name in result.get_names(): self.log.info('\tcircuit_name: %s', circuit_name) if circuit_name: counts = result.get_counts(circuit_name) self.log.info('\t%s', str(counts))
def test_mix_local_remote_jobs(self, QE_TOKEN, QE_URL): """test mixing local and remote jobs Internally local jobs execute in seperate processes since they are CPU bound and remote jobs execute in seperate threads since they are I/O bound. The module gets results from potentially both kinds in one list. Test that this works. """ provider = IBMQProvider(QE_TOKEN, QE_URL) remote_backend = provider.get_backend('ibmqx_qasm_simulator') local_backend = QasmSimulator() njobs = 6 job_list = [] backend_type = [local_backend, remote_backend] i = 0 for circuit in self.rqg.get_circuits(format_='QuantumCircuit')[:njobs]: compiled_circuit = compile_circuit(circuit) backend = backend_type[i % len(backend_type)] self.log.info(backend) quantum_job = QuantumJob(compiled_circuit, backend=backend) job_list.append(quantum_job) i += 1 jp = jobprocessor.JobProcessor(job_list, max_workers=None, callback=None) jp.submit()
class TestQObjectBasedIBMQJob(JobTestCase): """Test jobs supporting QObject.""" def setUp(self): super().setUp() self._testing_device = os.getenv('IBMQ_QOBJ_DEVICE', None) self._qe_token = os.getenv('IBMQ_TOKEN', None) self._qe_url = os.getenv('IBMQ_QOBJ_URL') if not self._testing_device or not self._qe_token or not self._qe_url: self.skipTest('No credentials or testing device available for ' 'testing Qobj capabilities.') self._provider = IBMQProvider(self._qe_token, self._qe_url) self._backend = self._provider.get_backend(self._testing_device) self._qc = _bell_circuit() def test_qobject_enabled_job(self): """Job should be an instance of IBMQJob.""" qobj = transpiler.compile(self._qc, self._backend) job = self._backend.run(qobj) self.assertIsInstance(job, IBMQJob) def test_qobject_result(self): """Jobs can be retrieved.""" qobj = transpiler.compile(self._qc, self._backend) job = self._backend.run(qobj) try: job.result() except JobError as err: self.fail(err)
def test_job_id(self, qe_token, qe_url): provider = IBMQProvider(qe_token, qe_url) backend = provider.get_backend('ibmq_qasm_simulator') qobj = transpiler.compile(self._qc, backend) job = backend.run(qobj) self.log.info('job_id: %s', job.id()) self.assertTrue(job.id() is not None)
def test_double_submit_fails(self, qe_token, qe_url): provider = IBMQProvider(qe_token, qe_url) backend = provider.get_backend('ibmq_qasm_simulator') qobj = transpiler.compile(self._qc, backend) # backend.run() will automatically call job.submit() job = backend.run(qobj) with self.assertRaises(JobError): job.submit()
def test_run_remote_simulator(self, QE_TOKEN, QE_URL): provider = IBMQProvider(QE_TOKEN, QE_URL) backend = provider.get_backend('ibmqx_qasm_simulator') compiled_circuit = compile_circuit(self.qc) quantum_job = QuantumJob(compiled_circuit, do_compile=False, backend=backend) jobprocessor.run_backend(quantum_job)
def test_retrieve_job(self, qe_token, qe_url): provider = IBMQProvider(qe_token, qe_url) backend = provider.get_backend('ibmq_qasm_simulator') qobj = transpiler.compile(self._qc, backend) job = backend.run(qobj) rjob = backend.retrieve_job(job.id()) self.assertTrue(job.id() == rjob.id()) self.assertTrue( job.result().get_counts() == rjob.result().get_counts())
def test_cancel(self, qe_token, qe_url): provider = IBMQProvider(qe_token, qe_url) backend_name = ('ibmq_20_tokyo' if self.using_ibmq_credentials else 'ibmqx4') backend = provider.get_backend(backend_name) qobj = transpiler.compile(self._qc, backend) job = backend.run(qobj) self.wait_for_initialization(job, timeout=5) can_cancel = job.cancel() self.assertTrue(can_cancel) self.assertStatus(job, JobStatus.CANCELLED)
def test_run_job_processor_online(self, QE_TOKEN, QE_URL): provider = IBMQProvider(QE_TOKEN, QE_URL) backend = provider.get_backend('ibmqx_qasm_simulator') njobs = 1 job_list = [] for _ in range(njobs): compiled_circuit = compile_circuit(self.qc) quantum_job = QuantumJob(compiled_circuit, backend=backend) job_list.append(quantum_job) jp = jobprocessor.JobProcessor(job_list, callback=None) jp.submit()
def test_run_async_simulator(self, qe_token, qe_url): provider = IBMQProvider(qe_token, qe_url) IBMQJob._executor = futures.ThreadPoolExecutor(max_workers=2) backend = provider.get_backend('ibmq_qasm_simulator') self.log.info('submitting to backend %s', backend.name) num_qubits = 16 qr = QuantumRegister(num_qubits, 'qr') cr = ClassicalRegister(num_qubits, 'cr') qc = QuantumCircuit(qr, cr) for i in range(num_qubits - 1): qc.cx(qr[i], qr[i + 1]) qc.measure(qr, cr) qobj = transpiler.compile([qc] * 10, backend) num_jobs = 5 job_array = [backend.run(qobj) for _ in range(num_jobs)] found_async_jobs = False timeout = 30 start_time = time.time() while not found_async_jobs: check = sum( [job.status() is JobStatus.RUNNING for job in job_array]) if check >= 2: self.log.info('found %d simultaneous jobs', check) break if all([job.status() is JobStatus.DONE for job in job_array]): # done too soon? don't generate error self.log.warning('all jobs completed before simultaneous jobs ' 'could be detected') break for job in job_array: self.log.info('%s %s %s %s', job.status(), job.status() is JobStatus.RUNNING, check, job.id()) self.log.info('-' * 20 + ' ' + str(time.time() - start_time)) if time.time() - start_time > timeout: raise TimeoutError('failed to see multiple running jobs after ' '{0} s'.format(timeout)) time.sleep(0.2) result_array = [job.result() for job in job_array] self.log.info('got back all job results') # Ensure all jobs have finished. self.assertTrue( all([job.status() is JobStatus.DONE for job in job_array])) self.assertTrue( all([ result.get_status() == 'COMPLETED' for result in result_array ])) # Ensure job ids are unique. job_ids = [job.id() for job in job_array] self.assertEqual(sorted(job_ids), sorted(list(set(job_ids))))
def test_execute_remote(self, QE_TOKEN, QE_URL): """Test Execute remote. If all correct some should exists. """ provider = IBMQProvider(QE_TOKEN, QE_URL) my_backend = provider.get_backend('ibmqx_qasm_simulator') qubit_reg = qiskit.QuantumRegister(2) clbit_reg = qiskit.ClassicalRegister(2) qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg) qc.h(qubit_reg[0]) qc.cx(qubit_reg[0], qubit_reg[1]) qc.measure(qubit_reg, clbit_reg) results = qiskit._compiler.execute(qc, my_backend) self.assertIsInstance(results, Result)
def test_compile_run_remote(self, QE_TOKEN, QE_URL): """Test Compiler and run remote. If all correct some should exists. """ provider = IBMQProvider(QE_TOKEN, QE_URL) my_backend = provider.get_backend('ibmqx_qasm_simulator') qubit_reg = qiskit.QuantumRegister(2, name='q') clbit_reg = qiskit.ClassicalRegister(2, name='c') qc = qiskit.QuantumCircuit(qubit_reg, clbit_reg, name="bell") qc.h(qubit_reg[0]) qc.cx(qubit_reg[0], qubit_reg[1]) qc.measure(qubit_reg, clbit_reg) qobj = qiskit._compiler.compile(qc, my_backend) result = my_backend.run(qiskit.QuantumJob(qobj, preformatted=True)) self.assertIsInstance(result, Result)
def test_execute_one_circuit_simulator_online(self, qe_token, qe_url): """Test execute_one_circuit_simulator_online. If all correct should return correct counts. """ provider = IBMQProvider(qe_token, qe_url) backend = provider.get_backend('ibmq_qasm_simulator') qr = QuantumRegister(1) cr = ClassicalRegister(1) qc = QuantumCircuit(qr, cr) qc.h(qr[0]) qc.measure(qr[0], cr[0]) qobj = transpiler.compile(qc, backend, seed=73846087) shots = qobj.config.shots job = backend.run(qobj) result = job.result() counts = result.get_counts(qc) target = {'0': shots / 2, '1': shots / 2} threshold = 0.04 * shots self.assertDictAlmostEqual(counts, target, threshold)
def test_mapping_multi_qreg(self, QE_TOKEN, QE_URL, hub=None, group=None, project=None): """Test mapping works for multiple qregs. """ provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project) backend = provider.get_backend('ibmqx5') q = qiskit.QuantumRegister(3, name='qr') q2 = qiskit.QuantumRegister(1, name='qr2') q3 = qiskit.QuantumRegister(4, name='qr3') c = qiskit.ClassicalRegister(3, name='cr') qc = qiskit.QuantumCircuit(q, q2, q3, c) qc.h(q[0]) qc.cx(q[0], q2[0]) qc.cx(q[1], q3[2]) qc.measure(q, c) try: qobj = qiskit._compiler.compile(qc, backend) except QISKitError: qobj = None self.assertIsInstance(qobj, dict)
def test_run_simulator(self, qe_token, qe_url): provider = IBMQProvider(qe_token, qe_url) backend = provider.get_backend('ibmq_qasm_simulator') qr = QuantumRegister(2, 'q') cr = ClassicalRegister(2, 'c') qc = QuantumCircuit(qr, cr, name='hadamard') qc.h(qr) qc.measure(qr, cr) qobj = transpiler.compile([self._qc, qc], backend) shots = qobj.config.shots job = backend.run(qobj) result = job.result() counts_qx1 = result.get_counts(result.get_names()[0]) counts_qx2 = result.get_counts('hadamard') counts_ex1 = {'00': shots / 2, '11': shots / 2} counts_ex2 = { '00': shots / 4, '11': shots / 4, '10': shots / 4, '01': shots / 4 } states1 = counts_qx1.keys() | counts_ex1.keys() states2 = counts_qx2.keys() | counts_ex2.keys() # contingency table ctable1 = numpy.array([[counts_qx1.get(key, 0) for key in states1], [counts_ex1.get(key, 0) for key in states1]]) ctable2 = numpy.array([[counts_qx2.get(key, 0) for key in states2], [counts_ex2.get(key, 0) for key in states2]]) self.log.info('states1: %s', str(states1)) self.log.info('states2: %s', str(states2)) self.log.info('ctable1: %s', str(ctable1)) self.log.info('ctable2: %s', str(ctable2)) contingency1 = chi2_contingency(ctable1) contingency2 = chi2_contingency(ctable2) self.log.info('chi2_contingency1: %s', str(contingency1)) self.log.info('chi2_contingency2: %s', str(contingency2)) self.assertGreater(contingency1[1], 0.01) self.assertGreater(contingency2[1], 0.01)
def test_execute_several_circuits_simulator_online(self, qe_token, qe_url): """Test execute_several_circuits_simulator_online. If all correct should return correct counts. """ provider = IBMQProvider(qe_token, qe_url) backend = provider.get_backend('ibmq_qasm_simulator') qr = QuantumRegister(2) cr = ClassicalRegister(2) qc1 = QuantumCircuit(qr, cr) qc2 = QuantumCircuit(qr, cr) qc1.h(qr) qc2.h(qr[0]) qc2.cx(qr[0], qr[1]) qc1.measure(qr[0], cr[0]) qc1.measure(qr[1], cr[1]) qc2.measure(qr[0], cr[0]) qc2.measure(qr[1], cr[1]) shots = 1024 qobj = transpiler.compile([qc1, qc2], backend, seed=73846087, shots=shots) job = backend.run(qobj) result = job.result() counts1 = result.get_counts(qc1) counts2 = result.get_counts(qc2) target1 = { '00': shots / 4, '01': shots / 4, '10': shots / 4, '11': shots / 4 } target2 = {'00': shots / 2, '11': shots / 2} threshold = 0.04 * shots self.assertDictAlmostEqual(counts1, target1, threshold) self.assertDictAlmostEqual(counts2, target2, threshold)
# Copyright 2018, IBM. # # This source code is licensed under the Apache License, Version 2.0 found in # the LICENSE.txt file in the root directory of this source tree. """ Example showing how to use QISKit at level 2 (advanced). Note: if you have only cloned the QISKit repository but not used `pip install`, the examples only work from the root directory. """ # choose a remote device import Qconfig from qiskit.backends.ibmq import IBMQProvider ibmqprovider = IBMQProvider(Qconfig.APItoken, Qconfig.config['url']) backend_device = ibmqprovider.get_backend('ibmqx4') # 0. build circuit from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit q = QuantumRegister(2) c = ClassicalRegister(2) circ = QuantumCircuit(q, c) circ.cx(q[0], q[1]) circ.cx(q[0], q[1]) circ.cx(q[0], q[1]) circ.cx(q[0], q[1]) circ.measure(q, c) # draw circuit from qiskit.tools.visualization import plot_circuit plot_circuit(circ)
class TestIBMQJob(QiskitTestCase): """ Test ibmqjob module. """ @requires_qe_access def setUp(self, QE_TOKEN, QE_URL, hub=None, group=None, project=None): # pylint: disable=arguments-differ super().setUp() # create QuantumCircuit qr = QuantumRegister(2, 'q') cr = ClassicalRegister(2, 'c') qc = QuantumCircuit(qr, cr) qc.h(qr[0]) qc.cx(qr[0], qr[1]) qc.measure(qr, cr) self._qc = qc self._provider = IBMQProvider(QE_TOKEN, QE_URL, hub, group, project) def test_run_simulator(self): backend = self._provider.get_backend('ibmq_qasm_simulator') qr = QuantumRegister(2, 'q') cr = ClassicalRegister(2, 'c') qc = QuantumCircuit(qr, cr, name='hadamard') qc.h(qr) qc.measure(qr, cr) qobj = transpiler.compile([self._qc, qc], backend) shots = qobj.config.shots job = backend.run(qobj) result = job.result() counts_qx1 = result.get_counts(result.get_names()[0]) counts_qx2 = result.get_counts('hadamard') counts_ex1 = {'00': shots / 2, '11': shots / 2} counts_ex2 = { '00': shots / 4, '11': shots / 4, '10': shots / 4, '01': shots / 4 } states1 = counts_qx1.keys() | counts_ex1.keys() states2 = counts_qx2.keys() | counts_ex2.keys() # contingency table ctable1 = numpy.array([[counts_qx1.get(key, 0) for key in states1], [counts_ex1.get(key, 0) for key in states1]]) ctable2 = numpy.array([[counts_qx2.get(key, 0) for key in states2], [counts_ex2.get(key, 0) for key in states2]]) self.log.info('states1: %s', str(states1)) self.log.info('states2: %s', str(states2)) self.log.info('ctable1: %s', str(ctable1)) self.log.info('ctable2: %s', str(ctable2)) contingency1 = chi2_contingency(ctable1) contingency2 = chi2_contingency(ctable2) self.log.info('chi2_contingency1: %s', str(contingency1)) self.log.info('chi2_contingency2: %s', str(contingency2)) self.assertGreater(contingency1[1], 0.01) self.assertGreater(contingency2[1], 0.01) @slow_test def test_run_device(self): backends = [ backend for backend in self._provider.available_backends() if not backend.configuration['simulator'] ] self.log.info('devices: %s', [b.name for b in backends]) backend = _least_busy(backends) self.log.info('using backend: %s', backend.name) qobj = transpiler.compile(self._qc, backend) shots = qobj.config.shots job = backend.run(qobj) while not (job.done or job.exception): self.log.info(job.status) time.sleep(4) if job.exception: raise job.exception self.log.info(job.status) result = job.result() counts_qx = result.get_counts(result.get_names()[0]) counts_ex = {'00': shots / 2, '11': shots / 2} states = counts_qx.keys() | counts_ex.keys() # contingency table ctable = numpy.array([[counts_qx.get(key, 0) for key in states], [counts_ex.get(key, 0) for key in states]]) self.log.info('states: %s', str(states)) self.log.info('ctable: %s', str(ctable)) contingency = chi2_contingency(ctable) self.log.info('chi2_contingency: %s', str(contingency)) self.assertDictAlmostEqual(counts_qx, counts_ex, shots * 0.1) @slow_test def test_run_async_simulator(self): IBMQJob._executor = futures.ThreadPoolExecutor(max_workers=2) backend = self._provider.get_backend('ibmq_qasm_simulator') self.log.info('submitting to backend %s', backend.name) num_qubits = 16 qr = QuantumRegister(num_qubits, 'qr') cr = ClassicalRegister(num_qubits, 'cr') qc = QuantumCircuit(qr, cr) for i in range(num_qubits - 1): qc.cx(qr[i], qr[i + 1]) qc.measure(qr, cr) qobj = transpiler.compile([qc] * 10, backend) num_jobs = 5 job_array = [backend.run(qobj) for _ in range(num_jobs)] found_async_jobs = False timeout = 30 start_time = time.time() while not found_async_jobs: check = sum([job.running for job in job_array]) if check >= 2: self.log.info('found %d simultaneous jobs', check) break if all([job.done for job in job_array]): # done too soon? don't generate error self.log.warning('all jobs completed before simultaneous jobs ' 'could be detected') break for job in job_array: self.log.info('%s %s %s %s', job.status['status'], job.running, check, job.id) self.log.info('-' * 20 + ' ' + str(time.time() - start_time)) if time.time() - start_time > timeout: raise TimeoutError('failed to see multiple running jobs after ' '{0} s'.format(timeout)) time.sleep(0.2) result_array = [job.result() for job in job_array] self.log.info('got back all job results') # Ensure all jobs have finished. self.assertTrue(all([job.done for job in job_array])) self.assertTrue( all([ result.get_status() == 'COMPLETED' for result in result_array ])) # Ensure job ids are unique. job_ids = [job.id for job in job_array] self.assertEqual(sorted(job_ids), sorted(list(set(job_ids)))) @slow_test def test_run_async_device(self): backends = [ backend for backend in self._provider.available_backends() if not backend.configuration['simulator'] ] backend = _least_busy(backends) self.log.info('submitting to backend %s', backend.name) num_qubits = 5 qr = QuantumRegister(num_qubits, 'qr') cr = ClassicalRegister(num_qubits, 'cr') qc = QuantumCircuit(qr, cr) for i in range(num_qubits - 1): qc.cx(qr[i], qr[i + 1]) qc.measure(qr, cr) qobj = transpiler.compile(qc, backend) num_jobs = 3 job_array = [backend.run(qobj) for _ in range(num_jobs)] time.sleep(3) # give time for jobs to start (better way?) job_status = [job.status['status'] for job in job_array] num_init = sum( [status == JobStatus.INITIALIZING for status in job_status]) num_queued = sum([status == JobStatus.QUEUED for status in job_status]) num_running = sum( [status == JobStatus.RUNNING for status in job_status]) num_done = sum([status == JobStatus.DONE for status in job_status]) num_error = sum([status == JobStatus.ERROR for status in job_status]) self.log.info('number of currently initializing jobs: %d/%d', num_init, num_jobs) self.log.info('number of currently queued jobs: %d/%d', num_queued, num_jobs) self.log.info('number of currently running jobs: %d/%d', num_running, num_jobs) self.log.info('number of currently done jobs: %d/%d', num_done, num_jobs) self.log.info('number of errored jobs: %d/%d', num_error, num_jobs) self.assertTrue(num_jobs - num_error - num_done > 0) # Wait for all the results. result_array = [job.result() for job in job_array] # Ensure all jobs have finished. self.assertTrue(all([job.done for job in job_array])) self.assertTrue( all([ result.get_status() == 'COMPLETED' for result in result_array ])) # Ensure job ids are unique. job_ids = [job.id for job in job_array] self.assertEqual(sorted(job_ids), sorted(list(set(job_ids)))) def test_cancel(self): if not self.using_ibmq_credentials: self.skipTest('job cancellation currently only available on hubs') backends = [ backend for backend in self._provider.available_backends() if not backend.configuration['simulator'] ] self.log.info('devices: %s', [b.name for b in backends]) backend = backends[0] self.log.info('using backend: %s', backend.name) num_qubits = 5 qr = QuantumRegister(num_qubits, 'qr') cr = ClassicalRegister(num_qubits, 'cr') qc = QuantumCircuit(qr, cr) for i in range(num_qubits - 1): qc.cx(qr[i], qr[i + 1]) qc.measure(qr, cr) qobj = transpiler.compile(qc, backend) num_jobs = 3 job_array = [backend.run(qobj) for _ in range(num_jobs)] success = False self.log.info('jobs submitted: %s', num_jobs) while any([ job.status['status'] == JobStatus.INITIALIZING for job in job_array ]): self.log.info('jobs initializing') time.sleep(1) for job in job_array: job.cancel() while not success: job_status = [job.status for job in job_array] for status in job_status: self.log.info(status) if any([ status['status'] == JobStatus.CANCELLED for status in job_status ]): success = True if all( [status['status'] == JobStatus.DONE for status in job_status]): raise IBMQJobError( 'all jobs completed before any could be cancelled') self.log.info('-' * 20) time.sleep(2) self.assertTrue(success) def test_job_id(self): backend = self._provider.get_backend('ibmq_qasm_simulator') qobj = transpiler.compile(self._qc, backend) job = backend.run(qobj) self.log.info('job_id: %s', job.id) self.assertTrue(job.id is not None) def test_get_backend_name(self): backend_name = 'ibmq_qasm_simulator' backend = self._provider.get_backend(backend_name) qobj = transpiler.compile(self._qc, backend) job = backend.run(qobj) self.assertTrue(job.backend_name == backend_name) def test_get_jobs_from_backend(self): backend = _least_busy(self._provider.available_backends()) start_time = time.time() job_list = backend.jobs(limit=5, skip=0) self.log.info('time to get jobs: %0.3f s', time.time() - start_time) self.log.info('found %s jobs on backend %s', len(job_list), backend.name) for job in job_list: self.log.info('status: %s', job.status) self.assertTrue(isinstance(job.id, str)) self.log.info('time to get job statuses: %0.3f s', time.time() - start_time) def test_retrieve_job(self): backend = self._provider.get_backend('ibmq_qasm_simulator') qobj = transpiler.compile(self._qc, backend) job = backend.run(qobj) rjob = backend.retrieve_job(job.id) self.assertTrue(job.id == rjob.id) self.assertTrue( job.result().get_counts() == rjob.result().get_counts()) def test_retrieve_job_error(self): backends = [ backend for backend in self._provider.available_backends() if not backend.configuration['simulator'] ] backend = _least_busy(backends) self.assertRaises(IBMQBackendError, backend.retrieve_job, 'BAD_JOB_ID') def test_get_jobs_filter_job_status(self): backends = self._provider.available_backends() backend = _least_busy(backends) job_list = backend.jobs(limit=5, skip=0, status=JobStatus.DONE) self.log.info('found %s matching jobs', len(job_list)) for i, job in enumerate(job_list): self.log.info('match #%d: %s', i, job.result()._result['status']) self.assertTrue(job.status['status'] == JobStatus.DONE) def test_get_jobs_filter_counts(self): # TODO: consider generalizing backend name # TODO: this tests depends on the previous executions of the user backend = self._provider.get_backend('ibmq_qasm_simulator') my_filter = { 'backend.name': 'ibmq_qasm_simulator', 'shots': 1024, 'qasms.result.data.counts.00': { 'lt': 500 } } self.log.info('searching for at most 5 jobs with 1024 shots, a count ' 'for "00" of < 500, on the ibmq_qasm_simulator backend') job_list = backend.jobs(limit=5, skip=0, db_filter=my_filter) self.log.info('found %s matching jobs', len(job_list)) for i, job in enumerate(job_list): self.log.info('match #%d', i) result = job.result() self.assertTrue( any(cresult['data']['counts']['00'] < 500 for cresult in result._result['result'])) for circuit_name in result.get_names(): self.log.info('\tcircuit_name: %s', circuit_name) if circuit_name: counts = result.get_counts(circuit_name) self.log.info('\t%s', str(counts)) def test_get_jobs_filter_date(self): backends = self._provider.available_backends() backend = _least_busy(backends) past_day_30 = datetime.datetime.now() - datetime.timedelta(days=30) my_filter = {'creationDate': {'lt': past_day_30.isoformat()}} job_list = backend.jobs(limit=5, db_filter=my_filter) self.log.info('found %s matching jobs', len(job_list)) for i, job in enumerate(job_list): self.log.info('match #%d: %s', i, job.creation_date) self.assertTrue(job.creation_date < past_day_30.isoformat())
def test_mapping_correction(self, QE_TOKEN, QE_URL): """Test mapping works in previous failed case. """ provider = IBMQProvider(QE_TOKEN, QE_URL) backend = provider.get_backend('ibmqx5') q = qiskit.QuantumRegister(name='qr', size=11) c = qiskit.ClassicalRegister(name='qc', size=11) circuit = qiskit.QuantumCircuit(q, c) circuit.u3(1.564784764685993, -1.2378965763410095, 2.9746763177861713, q[3]) circuit.u3(1.2269835563676523, 1.1932982847014162, -1.5597357740824318, q[5]) circuit.cx(q[5], q[3]) circuit.u1(0.856768317675967, q[3]) circuit.u3(-3.3911273825190915, 0.0, 0.0, q[5]) circuit.cx(q[3], q[5]) circuit.u3(2.159209321625547, 0.0, 0.0, q[5]) circuit.cx(q[5], q[3]) circuit.u3(0.30949966910232335, 1.1706201763833217, 1.738408691990081, q[3]) circuit.u3(1.9630571407274755, -0.6818742967975088, 1.8336534616728195, q[5]) circuit.u3(1.330181833806101, 0.6003162754946363, -3.181264980452862, q[7]) circuit.u3(0.4885914820775024, 3.133297443244865, -2.794457469189904, q[8]) circuit.cx(q[8], q[7]) circuit.u1(2.2196187596178616, q[7]) circuit.u3(-3.152367609631023, 0.0, 0.0, q[8]) circuit.cx(q[7], q[8]) circuit.u3(1.2646005789809263, 0.0, 0.0, q[8]) circuit.cx(q[8], q[7]) circuit.u3(0.7517780502091939, 1.2828514296564781, 1.6781179605443775, q[7]) circuit.u3(0.9267400575390405, 2.0526277839695153, 2.034202361069533, q[8]) circuit.u3(2.550304293455634, 3.8250017126569698, -2.1351609599720054, q[1]) circuit.u3(0.9566260876600556, -1.1147561503064538, 2.0571590492298797, q[4]) circuit.cx(q[4], q[1]) circuit.u1(2.1899329069137394, q[1]) circuit.u3(-1.8371715243173294, 0.0, 0.0, q[4]) circuit.cx(q[1], q[4]) circuit.u3(0.4717053496327104, 0.0, 0.0, q[4]) circuit.cx(q[4], q[1]) circuit.u3(2.3167620677708145, -1.2337330260253256, -0.5671322899563955, q[1]) circuit.u3(1.0468499525240678, 0.8680750644809365, -1.4083720073192485, q[4]) circuit.u3(2.4204244021892807, -2.211701932616922, 3.8297006565735883, q[10]) circuit.u3(0.36660280497727255, 3.273119149343493, -1.8003362351299388, q[6]) circuit.cx(q[6], q[10]) circuit.u1(1.067395863586385, q[10]) circuit.u3(-0.7044917541291232, 0.0, 0.0, q[6]) circuit.cx(q[10], q[6]) circuit.u3(2.1830003849921527, 0.0, 0.0, q[6]) circuit.cx(q[6], q[10]) circuit.u3(2.1538343756723917, 2.2653381826084606, -3.550087952059485, q[10]) circuit.u3(1.307627685019188, -0.44686656993522567, -2.3238098554327418, q[6]) circuit.u3(2.2046797998462906, 0.9732961754855436, 1.8527865921467421, q[9]) circuit.u3(2.1665254613904126, -1.281337664694577, -1.2424905413631209, q[0]) circuit.cx(q[0], q[9]) circuit.u1(2.6209599970201007, q[9]) circuit.u3(0.04680566321901303, 0.0, 0.0, q[0]) circuit.cx(q[9], q[0]) circuit.u3(1.7728411151289603, 0.0, 0.0, q[0]) circuit.cx(q[0], q[9]) circuit.u3(2.4866395967434443, 0.48684511243566697, -3.0069186877854728, q[9]) circuit.u3(1.7369112924273789, -4.239660866163805, 1.0623389015296005, q[0]) circuit.barrier(q) circuit.measure(q, c) try: qobj = qiskit._compiler.compile(circuit, backend) except QISKitError: qobj = None self.assertIsInstance(qobj, dict)