def test_update_calibrations(self): """Test that we can properly update an instance of Calibrations.""" freq01 = FakeArmonk().defaults().qubit_freq_est[0] backend = MockIQBackend( experiment_helper=SpectroscopyHelper(freq_offset=5e6, line_width=2e6), iq_cluster_centers=[((-1.0, -1.0), (1.0, 1.0))], iq_cluster_width=[0.2], ) backend._configuration.basis_gates = ["x"] backend._configuration.timing_constraints = {"granularity": 16} backend.defaults().qubit_freq_est = [freq01, freq01] library = FixedFrequencyTransmon(basis_gates=["x", "sx"]) cals = Calibrations.from_backend(FakeArmonk(), libraries=[library]) prev_freq = cals.get_parameter_value(cals.__drive_freq_parameter__, (0,)) self.assertEqual(prev_freq, freq01) frequencies = np.linspace(freq01 - 10.0e6, freq01 + 10.0e6, 21) expdata = RoughFrequencyCal(0, cals, frequencies).run(backend) self.assertExperimentDone(expdata) # Check the updated frequency which should be shifted by 5MHz. post_freq = cals.get_parameter_value(cals.__drive_freq_parameter__, (0,)) self.assertTrue(abs(post_freq - freq01 - 5e6) < 1e6)
def test_update_calibrations(self): """Test that the calibration version of the experiment updates the cals.""" tol = 1e4 # 10 kHz resolution freq_name = self.cals.__drive_freq_parameter__ # Check qubit frequency before running the cal f01 = self.cals.get_parameter_value(freq_name, 0) self.assertTrue( len(self.cals.parameters_table(parameters=[freq_name])["data"]), 1) self.assertEqual(f01, FakeArmonk().defaults().qubit_freq_est[0]) freq_shift = 4e6 osc_shift = 2e6 # oscillation with 6 MHz backend = MockIQBackend( RamseyXYHelper(freq_shift=freq_shift + osc_shift)) expdata = FrequencyCal(0, self.cals, backend, osc_freq=osc_shift).run() self.assertExperimentDone(expdata) # Check that qubit frequency after running the cal is shifted by freq_shift, i.e. 4 MHz. f01 = self.cals.get_parameter_value(freq_name, 0) self.assertTrue( len(self.cals.parameters_table(parameters=[freq_name])["data"]), 2) self.assertTrue( abs(f01 - (freq_shift + FakeArmonk().defaults().qubit_freq_est[0])) < tol)
def setUp(self): """Initialize some cals.""" super().setUp() library = FixedFrequencyTransmon() self.cals = Calibrations.from_backend(FakeArmonk(), libraries=[library])
def setUp(self): """Setup the tests.""" super().setUp() library = FixedFrequencyTransmon() self.backend = FakeArmonk() self.cals = Calibrations.from_backend(self.backend, library)
def test_qubit_lo_from_configurable_backend(self): """Test computation of qubit_lo_freq from configurable backend.""" backend = FakeArmonk() test_model = PulseSystemModel.from_backend(backend) qubit_lo_from_hamiltonian = test_model.hamiltonian.get_qubit_lo_from_drift() freqs = test_model.calculate_channel_frequencies(qubit_lo_from_hamiltonian) expected = getattr(backend.configuration(), 'hamiltonian')['vars']['wq0'] / (2 * np. pi) self.assertAlmostEqual(freqs['D0'], expected, places=4)
def test_experiment_config(self): """Test converting to and from config works""" cals = Calibrations.from_backend(FakeArmonk()) frequencies = [1, 2, 3] exp = RoughFrequencyCal(0, cals, frequencies) loaded_exp = RoughFrequencyCal.from_config(exp.config()) self.assertNotEqual(exp, loaded_exp) self.assertTrue(self.json_equiv(exp, loaded_exp))
def test_qubit_lo_from_configurable_backend(self): backend = FakeArmonk() test_model = PulseSystemModel.from_backend(backend) qubit_lo_from_hamiltonian = test_model.hamiltonian.get_qubit_lo_from_drift( ) freqs = test_model.calculate_channel_frequencies( qubit_lo_from_hamiltonian) self.assertAlmostEqual(freqs['D0'], 4.974286046328553)
def test_circuits(self): """Test the circuits of the experiment.""" drag = FineDrag(0) drag.set_experiment_options(schedule=self.schedule) for circuit in drag.circuits(FakeArmonk())[1:]: for idx, name in enumerate(["Drag", "rz", "Drag", "rz"]): self.assertEqual(circuit.data[idx][0].name, name)
def test_circuits(self): """Test the circuits of the experiment.""" drag = FineDrag(0, Gate("Drag", num_qubits=1, params=[])) drag.set_experiment_options(schedule=self.schedule) drag.backend = FakeArmonk() for circuit in drag.circuits()[1:]: for idx, name in enumerate(["Drag", "rz", "Drag", "rz"]): self.assertEqual(circuit.data[idx][0].name, name)
def test_execute_block(self): """Test executing a ScheduleBlock on a Pulse backend""" with pulse.build(name="test_block") as sched_block: pulse.play(pulse.Constant(160, 1.0), pulse.DriveChannel(0)) pulse.acquire(50, pulse.MeasureChannel(0), pulse.MemorySlot(0)) backend = FakeArmonk() test_result = backend.run(sched_block).result() self.assertDictEqual(test_result.get_counts(), {"0": 1024})
def setUp(self): """Setup for the test.""" super().setUp() self.inst_map = pulse.InstructionScheduleMap() self.sx_duration = 160 with pulse.build(name="sx") as sx_sched: pulse.play(pulse.Gaussian(self.sx_duration, 0.5, 40), pulse.DriveChannel(0)) self.inst_map.add("sx", 0, sx_sched) self.cals = Calibrations.from_backend(FakeArmonk(), libraries=[FixedFrequencyTransmon()])
def test_inst_map_transpilation(self): """Test that we can use the inst_map to inject the cals into the circuit.""" cals = BackendCalibrations( FakeArmonk(), library=FixedFrequencyTransmon(basis_gates=["x"]), ) param = Parameter("amp") cals.inst_map_add("Rabi", (0,), "x", assign_params={"amp": param}) circ = QuantumCircuit(1) circ.x(0) circ.append(Gate("Rabi", num_qubits=1, params=[param]), (0,)) circs, amps = [], [0.12, 0.25] for amp in amps: new_circ = circ.assign_parameters({param: amp}, inplace=False) circs.append(new_circ) # Check that calibrations are absent for circ in circs: self.assertEqual(len(circ.calibrations), 0) # Transpile to inject the cals. # TODO Enable this test once terra 0.19.0 is live. circs = transpile(circs) # TODO add: inst_map=cals.instruction_schedule_map # Check that we have the expected schedules. with pulse.build() as x_expected: pulse.play(pulse.Drag(160, 0.5, 40, 0), pulse.DriveChannel(0)) for idx, circ in enumerate(circs): amp = amps[idx] with pulse.build() as rabi_expected: pulse.play(pulse.Drag(160, amp, 40, 0), pulse.DriveChannel(0)) self.assertEqual(circ.calibrations["x"][((0,), ())], x_expected) circ_rabi = next(iter(circ.calibrations["Rabi"].values())) self.assertEqual(circ_rabi, rabi_expected) # Test the removal of the Rabi instruction self.assertTrue(cals.default_inst_map.has("Rabi", (0,))) cals.default_inst_map.remove("Rabi", (0,)) self.assertFalse(cals.default_inst_map.has("Rabi", (0,)))
def test_update_calibrations(self): """Test that we can properly update an instance of Calibrations.""" freq01 = FakeArmonk().defaults().qubit_freq_est[0] backend = SpectroscopyBackend(freq_offset=5e6, line_width=2e6) backend.defaults().qubit_freq_est = [freq01, freq01] library = FixedFrequencyTransmon(basis_gates=["x", "sx"]) cals = Calibrations.from_backend(FakeArmonk(), library=library) prev_freq = cals.get_parameter_value(cals.__drive_freq_parameter__, (0, )) self.assertEqual(prev_freq, freq01) frequencies = np.linspace(freq01 - 10.0e6, freq01 + 10.0e6, 21) RoughFrequencyCal(0, cals, frequencies).run(backend).block_for_results() # Check the updated frequency which should be shifted by 5MHz. post_freq = cals.get_parameter_value(cals.__drive_freq_parameter__, (0, )) self.assertTrue(abs(post_freq - freq01 - 5e6) < 1e6)
def test_init(self): """Test that initialization.""" qubit = 1 cals = Calibrations.from_backend(FakeArmonk()) frequencies = [1000, 2000, 3000] auto_update = False absolute = False freq = RoughFrequencyCal( qubit, cals, frequencies, auto_update=auto_update, absolute=absolute ) self.assertEqual(freq.physical_qubits, (qubit,)) self.assertEqual(freq._frequencies, frequencies) self.assertEqual(freq._absolute, False) self.assertEqual(freq.auto_update, False)
def get_qiskit_backend(backend_name): try: from qiskit.test.mock import FakeArmonk, FakeAlmaden, FakeAthens except ImportError: pass '''TODO: might be able to do this in a better way without having to do conditional checks for each backend name.''' if backend_name == 'Armonk': backend = FakeArmonk() elif backend_name == 'Almaden': backend = FakeAlmaden() elif backend_name == 'Athens': backend = FakeAthens() else: '''TODO: There is no FakeCasablanca, so using FakeAlmaden for it right now''' backend = FakeAlmaden() return backend
def test_init(self): """Test that initialization.""" qubit = 1 cals = BackendCalibrations(FakeArmonk()) frequencies = [1, 2, 3] unit = "kHz" auto_update = False absolute = False freq = RoughFrequencyCal(qubit, cals, frequencies, unit, auto_update, absolute) self.assertEqual(freq.physical_qubits, (qubit, )) self.assertEqual(freq._frequencies, [1000, 2000, 3000]) self.assertEqual(freq._absolute, False) self.assertEqual(freq.auto_update, False)
def test_calibration_version(self): """Test the calibration version of the experiment.""" freq_shift = 0.1e6 backend = MockFineFreq(freq_shift, sx_duration=self.sx_duration) fine_freq = FineFrequencyCal(0, self.cals, backend) armonk_freq = FakeArmonk().defaults().qubit_freq_est[0] freq_before = self.cals.get_parameter_value( self.cals.__drive_freq_parameter__, 0) self.assertAlmostEqual(freq_before, armonk_freq) fine_freq.run().block_for_results() freq_after = self.cals.get_parameter_value( self.cals.__drive_freq_parameter__, 0) # Test equality up to 10kHz on a 100 kHz shift self.assertAlmostEqual(freq_after, armonk_freq - freq_shift, delta=1e4)
def test_setup_withLibrary(self): """Test that we can setup with a library.""" cals = BackendCalibrations( FakeArmonk(), library=FixedFrequencyTransmon( basis_gates=["x", "sx"], default_values={"duration": 320} ), ) # Check the x gate with pulse.build(name="x") as expected: pulse.play(pulse.Drag(duration=320, amp=0.5, sigma=80, beta=0), pulse.DriveChannel(0)) self.assertEqual(cals.get_schedule("x", (0,)), expected) # Check the sx gate with pulse.build(name="sx") as expected: pulse.play(pulse.Drag(duration=320, amp=0.25, sigma=80, beta=0), pulse.DriveChannel(0)) self.assertEqual(cals.get_schedule("sx", (0,)), expected)
def test_calibration_version(self): """Test the calibration version of the experiment.""" exp_helper = FineFreqHelper(sx_duration=self.sx_duration, freq_shift=0.1e6) backend = MockIQBackend(exp_helper) exp_helper.dt = backend.configuration().dt fine_freq = FineFrequencyCal(0, self.cals, backend) armonk_freq = FakeArmonk().defaults().qubit_freq_est[0] freq_before = self.cals.get_parameter_value(self.cals.__drive_freq_parameter__, 0) self.assertAlmostEqual(freq_before, armonk_freq) expdata = fine_freq.run() self.assertExperimentDone(expdata) freq_after = self.cals.get_parameter_value(self.cals.__drive_freq_parameter__, 0) # Test equality up to 10kHz on a 100 kHz shift self.assertAlmostEqual(freq_after, armonk_freq + exp_helper.freq_shift, delta=1e4)
def setUp(self): """Setup the tests""" super().setUp() library = FixedFrequencyTransmon() self.backend = FakeArmonk() self.cals = Calibrations.from_backend(self.backend, library) # Add some pulses on the 1-2 transition. d0 = pulse.DriveChannel(0) with pulse.build(name="x12") as x12: with pulse.frequency_offset(-300e6, d0): pulse.play(pulse.Drag(160, Parameter("amp"), 40, 0.0), d0) with pulse.build(name="sx12") as sx12: with pulse.frequency_offset(-300e6, d0): pulse.play(pulse.Drag(160, Parameter("amp"), 40, 0.0), d0) self.cals.add_schedule(x12, 0) self.cals.add_schedule(sx12, 0) self.cals.add_parameter_value(0.4, "amp", 0, "x12") self.cals.add_parameter_value(0.2, "amp", 0, "sx12")
def test_run_options(self): """Test that we can get run options.""" cals = BackendCalibrations(FakeArmonk()) self.assertEqual(cals.get_meas_frequencies(), [6993370669.000001]) self.assertEqual(cals.get_qubit_frequencies(), [4971852852.405576])