def test__filter(self): """Test _filter method.""" device = self.two_qubit_device lp0 = self.linear(duration=3, slope=0.2, intercept=0.1) sched = Schedule(name='fake_experiment') sched = sched.insert(0, lp0(device.q[0].drive)) sched = sched.insert(10, lp0(device.q[1].drive)) sched = sched.insert(30, FrameChange(phase=-1.57)(device.q[0].drive)) for i in sched._filter([lambda x: True]).instructions: self.assertTrue(i in sched.instructions) self.assertEqual(len(sched._filter([lambda x: False]).instructions), 0) self.assertEqual( len(sched._filter([lambda x: x[0] < 30]).instructions), 2)
def test_can_create_valid_schedule_with_syntax_sugar(self): """Test that in place operations on schedule are still immutable and return equivalent schedules.""" device = self.two_qubit_device gp0 = pulse_lib.gaussian(duration=20, amp=0.7, sigma=3) gp1 = pulse_lib.gaussian(duration=20, amp=0.5, sigma=3) fc_pi_2 = FrameChange(phase=1.57) acquire = Acquire(10) sched = Schedule() sched += gp0(device.drives[0]) sched |= PersistentValue(value=0.2 + 0.4j)(device.controls[0]) sched |= FrameChange(phase=-1.57)(device.drives[0]) << 60 sched |= gp1(device.drives[1]) << 30 sched |= gp0(device.controls[0]) << 60 sched |= Snapshot("label", "snap_type") << 60 sched |= fc_pi_2(device.drives[0]) << 90 sched |= acquire(device.acquires[1], device.memoryslots[1], device.registers[1]) << 90 sched += sched
def test_frame_change(self): """Test converted qobj from FrameChangeInstruction.""" converter = InstructionToQobjConverter(PulseQobjInstruction, meas_level=2) command = FrameChange(phase=0.1) instruction = command(self.device.q[0].drive) valid_qobj = PulseQobjInstruction( name='fc', ch='d0', t0=0, phase=0.1 ) self.assertEqual(converter(0, instruction), valid_qobj)
def test_parameterized_frame_change(self): """Test converted qobj from FrameChangeInstruction.""" cmd = FrameChange(phase=4.) instruction = cmd(MeasureChannel(0)) << 10 qobj = PulseQobjInstruction(name='fc', ch='m0', t0=10, phase='P1**2') converted_instruction = self.converter(qobj) self.assertIsInstance(converted_instruction, ParameterizedSchedule) evaluated_instruction = converted_instruction.bind_parameters(2.) self.assertEqual(evaluated_instruction.timeslots, instruction.timeslots) self.assertEqual(evaluated_instruction.instructions[0][-1].command, cmd)
def test_filter(self): """Test _filter method.""" device = self.two_qubit_device lp0 = self.linear(duration=3, slope=0.2, intercept=0.1) sched = Schedule(name='fake_experiment') sched = sched.insert(0, lp0(device.drives[0])) sched = sched.insert(10, lp0(device.drives[1])) sched = sched.insert(30, FrameChange(phase=-1.57)(device.drives[0])) for i in sched._filter([lambda x: True]).instructions: self.assertTrue(i in sched.instructions) self.assertEqual(len(sched._filter([lambda x: False]).instructions), 0) self.assertEqual( len(sched._filter([lambda x: x[0] < 30]).instructions), 2) def my_test_par_sched_one(x, y, z): result = PulseInstruction( SamplePulse(np.array([x, y, z]), name='sample'), device.drives[0]) return 0, result def my_test_par_sched_two(x, y, z): result = PulseInstruction( SamplePulse(np.array([x, y, z]), name='sample'), device.drives[0]) return 5, result par_sched_in_0 = ParameterizedSchedule(my_test_par_sched_one, parameters={ 'x': 0, 'y': 1, 'z': 2 }) par_sched_in_1 = ParameterizedSchedule(my_test_par_sched_two, parameters={ 'x': 0, 'y': 1, 'z': 2 }) par_sched = ParameterizedSchedule(par_sched_in_0, par_sched_in_1) cmd_def = CmdDef() cmd_def.add('test', 0, par_sched) actual = cmd_def.get('test', 0, 0.01, 0.02, 0.03) expected = par_sched_in_0.bind_parameters(0.01, 0.02, 0.03) |\ par_sched_in_1.bind_parameters(0.01, 0.02, 0.03) self.assertEqual(actual.start_time, expected.start_time) self.assertEqual(actual.stop_time, expected.stop_time) self.assertEqual(cmd_def.get_parameters('test', 0), ('x', 'y', 'z'))
def test_frame_change(self): """Test converted qobj from FrameChangeInstruction.""" converter = InstructionToQobjConverter(PulseQobjInstruction, meas_level=2) with self.assertWarns(DeprecationWarning): command = FrameChange(phase=0.1) with self.assertWarns(DeprecationWarning): instruction = command(DriveChannel(0)) valid_qobj = PulseQobjInstruction(name='fc', ch='d0', t0=0, phase=0.1) self.assertEqual(converter(0, instruction), valid_qobj) instruction = ShiftPhase(0.1, DriveChannel(0)) self.assertEqual(converter(0, instruction), valid_qobj)
def test_filter_intervals(self): """Test filtering on intervals.""" lp0 = self.linear(duration=3, slope=0.2, intercept=0.1) acquire = Acquire(5) sched = Schedule(name='fake_experiment') sched = sched.insert(0, lp0(self.config.drive(0))) sched = sched.insert(10, lp0(self.config.drive(1))) sched = sched.insert(30, FrameChange(phase=-1.57)(self.config.drive(0))) sched = sched.insert(60, acquire([self.config.acquire(i) for i in range(2)], [MemorySlot(i) for i in range(2)])) sched = sched.insert(90, lp0(self.config.drive(0))) # split schedule into instructions occurring in (0,13), and those outside filtered, excluded = self._filter_and_test_consistency(sched, time_ranges=((0, 13),)) for start_time, inst in filtered.instructions: self.assertTrue((start_time >= 0) and (start_time + inst.stop_time <= 13)) for start_time, inst in excluded.instructions: self.assertFalse((start_time >= 0) and (start_time + inst.stop_time <= 13)) self.assertEqual(len(filtered.instructions), 2) self.assertEqual(len(excluded.instructions), 3) # split into schedule occurring in and outside of interval (59,65) filtered, excluded = self._filter_and_test_consistency(sched, time_ranges=[(59, 65)]) self.assertEqual(len(filtered.instructions), 1) self.assertEqual(filtered.instructions[0][0], 60) self.assertIsInstance(filtered.instructions[0][1], AcquireInstruction) self.assertEqual(len(excluded.instructions), 4) self.assertEqual(excluded.instructions[3][0], 90) self.assertIsInstance(excluded.instructions[3][1], PulseInstruction) # split instructions based on the interval # (none should be, though they have some overlap with some of the instructions) filtered, excluded = \ self._filter_and_test_consistency(sched, time_ranges=[(0, 2), (8, 11), (61, 70)]) self.assertEqual(len(filtered.instructions), 0) self.assertEqual(len(excluded.instructions), 5) # split instructions from multiple non-overlapping intervals, specified # as time ranges filtered, excluded = \ self._filter_and_test_consistency(sched, time_ranges=[(10, 15), (63, 93)]) self.assertEqual(len(filtered.instructions), 2) self.assertEqual(len(excluded.instructions), 3) # split instructions from non-overlapping intervals, specified as Intervals filtered, excluded = \ self._filter_and_test_consistency(sched, intervals=[Interval(10, 15), Interval(63, 93)]) self.assertEqual(len(filtered.instructions), 2) self.assertEqual(len(excluded.instructions), 3)
def test_can_create_valid_schedule(self): """Test valid schedule creation without error.""" device = self.two_qubit_device # pylint: disable=invalid-name @functional_pulse def gaussian(duration, amp, t0, sig): x = np.linspace(0, duration - 1, duration) return amp * np.exp(-(x - t0)**2 / sig**2) gp0 = gaussian(duration=20, amp=0.7, t0=9.5, sig=3) gp1 = gaussian(duration=20, amp=0.5, t0=9.5, sig=3) fc_pi_2 = FrameChange(phase=1.57) acquire = Acquire(10) sched = Schedule() sched = sched.append(gp0(device.q[0].drive)) sched = sched.insert( 0, PersistentValue(value=0.2 + 0.4j)(device.q[0].control)) sched = sched.insert(60, FrameChange(phase=-1.57)(device.q[0].drive)) sched = sched.insert(30, gp1(device.q[1].drive)) sched = sched.insert(60, gp0(device.q[0].control)) sched = sched.insert(80, Snapshot("label", "snap_type")) sched = sched.insert(90, fc_pi_2(device.q[0].drive)) sched = sched.insert(90, acquire(device.q[1], device.mem[1], device.c[1])) self.assertEqual(0, sched.start_time) self.assertEqual(100, sched.stop_time) self.assertEqual(100, sched.duration) new_sched = Schedule() new_sched = new_sched.append(sched) new_sched = new_sched.append(sched) self.assertEqual(0, new_sched.start_time) self.assertEqual(200, new_sched.stop_time) self.assertEqual(200, new_sched.duration)
def test_filter_channels(self): """Test filtering over channels.""" device = self.two_qubit_device lp0 = self.linear(duration=3, slope=0.2, intercept=0.1) acquire = Acquire(5) sched = Schedule(name='fake_experiment') sched = sched.insert(0, lp0(device.q[0].drive)) sched = sched.insert(10, lp0(device.q[1].drive)) sched = sched.insert(30, FrameChange(phase=-1.57)(device.q[0].drive)) sched = sched.insert(60, acquire(device.q, device.mem)) sched = sched.insert(90, lp0(device.q[0].drive)) self.assertEqual(len(sched.filter(channels=[AcquireChannel(1)]).instructions), 1) channels = [AcquireChannel(1), DriveChannel(1)] has_chan_1 = sched.filter(channels=channels) for _, inst in has_chan_1.instructions: self.assertTrue(any([chan in channels for chan in inst.channels]))
def test_empty_filters(self): """Test behavior on empty filters.""" lp0 = self.linear(duration=3, slope=0.2, intercept=0.1) acquire = Acquire(5) sched = Schedule(name='fake_experiment') sched = sched.insert(0, lp0(self.config.drive(0))) sched = sched.insert(10, lp0(self.config.drive(1))) sched = sched.insert(30, FrameChange(phase=-1.57)(self.config.drive(0))) sched = sched.insert( 60, acquire([self.config.acquire(i) for i in range(2)], [MemorySlot(i) for i in range(2)])) sched = sched.insert(90, lp0(self.config.drive(0))) # empty channels filtered, excluded = self._filter_and_test_consistency(sched, channels=[]) self.assertTrue(len(filtered.instructions) == 0) self.assertTrue(len(excluded.instructions) == 5) # empty instruction_types filtered, excluded = self._filter_and_test_consistency( sched, instruction_types=[]) self.assertTrue(len(filtered.instructions) == 0) self.assertTrue(len(excluded.instructions) == 5) # empty time_ranges filtered, excluded = self._filter_and_test_consistency(sched, time_ranges=[]) self.assertTrue(len(filtered.instructions) == 0) self.assertTrue(len(excluded.instructions) == 5) # empty intervals filtered, excluded = self._filter_and_test_consistency(sched, intervals=[]) self.assertTrue(len(filtered.instructions) == 0) self.assertTrue(len(excluded.instructions) == 5) # empty channels with other non-empty filters filtered, excluded = self._filter_and_test_consistency( sched, channels=[], instruction_types=[PulseInstruction]) self.assertTrue(len(filtered.instructions) == 0) self.assertTrue(len(excluded.instructions) == 5)
def test_filter_multiple(self): """Test filter composition.""" lp0 = self.linear(duration=3, slope=0.2, intercept=0.1) acquire = Acquire(5) sched = Schedule(name='fake_experiment') sched = sched.insert(0, lp0(self.config.drive(0))) sched = sched.insert(10, lp0(self.config.drive(1))) sched = sched.insert(30, FrameChange(phase=-1.57)(self.config.drive(0))) sched = sched.insert( 60, acquire([self.config.acquire(i) for i in range(2)], [MemorySlot(i) for i in range(2)])) sched = sched.insert(90, lp0(self.config.drive(0))) # split instructions with filters on channel 0, of type PulseInstruction, # occuring in the time interval (25, 100) filtered, excluded = self._filter_and_test_consistency( sched, channels={self.config.drive(0)}, instruction_types=[PulseInstruction], time_ranges=[(25, 100)]) for time, inst in filtered.instructions: self.assertIsInstance(inst, PulseInstruction) self.assertTrue(all([chan.index == 0 for chan in inst.channels])) self.assertTrue(25 <= time <= 100) self.assertEqual(len(excluded.instructions), 4) self.assertTrue( excluded.instructions[0][1].channels[0] == DriveChannel(0)) self.assertTrue(excluded.instructions[2][0] == 30) # split based on PulseInstructions in the specified intervals filtered, excluded = self._filter_and_test_consistency( sched, instruction_types=[PulseInstruction], time_ranges=[(25, 100), (0, 11)]) self.assertTrue(len(excluded.instructions), 3) for time, inst in filtered.instructions: self.assertIsInstance(inst, (FrameChangeInstruction, PulseInstruction)) self.assertTrue(len(filtered.instructions), 4) # make sure the PulseInstruction not in the intervals is maintained self.assertIsInstance(excluded.instructions[0][1], PulseInstruction)
def test_buffering(self): """Test channel buffering.""" buffer_chan = DriveChannel(0, buffer=5) gp0 = pulse_lib.gaussian(duration=10, amp=0.7, sigma=3) fc_pi_2 = FrameChange(phase=1.57) # no initial buffer sched = Schedule() sched += gp0(buffer_chan) self.assertEqual(sched.duration, 10) # this pulse should not be buffered sched += gp0(buffer_chan) self.assertEqual(sched.duration, 20) # should not be buffered as framechange sched += fc_pi_2(buffer_chan) self.assertEqual(sched.duration, 20) # use buffer with insert sched = sched.insert(sched.duration, gp0(buffer_chan), buffer=True) self.assertEqual(sched.duration, 30)
def test_filter_inst_types(self): """Test filtering on instruction types.""" lp0 = self.linear(duration=3, slope=0.2, intercept=0.1) acquire = Acquire(5) sched = Schedule(name='fake_experiment') sched = sched.insert(0, lp0(self.config.drive(0))) sched = sched.insert(10, lp0(self.config.drive(1))) sched = sched.insert(30, FrameChange(phase=-1.57)(self.config.drive(0))) sched = sched.insert( 60, acquire([self.config.acquire(i) for i in range(2)], [MemorySlot(i) for i in range(2)])) sched = sched.insert(90, lp0(self.config.drive(0))) # test on Acquire only_acquire, no_acquire = \ self._filter_and_test_consistency(sched, instruction_types=[AcquireInstruction]) for _, inst in only_acquire.instructions: self.assertIsInstance(inst, AcquireInstruction) for _, inst in no_acquire.instructions: self.assertFalse(isinstance(inst, AcquireInstruction)) # test two instruction types only_pulse_and_fc, no_pulse_and_fc = \ self._filter_and_test_consistency(sched, instruction_types=[PulseInstruction, FrameChangeInstruction]) for _, inst in only_pulse_and_fc.instructions: self.assertIsInstance(inst, (PulseInstruction, FrameChangeInstruction)) for _, inst in no_pulse_and_fc.instructions: self.assertFalse( isinstance(inst, (PulseInstruction, FrameChangeInstruction))) self.assertEqual(len(only_pulse_and_fc.instructions), 4) self.assertEqual(len(no_pulse_and_fc.instructions), 1) # test on FrameChange only_fc, no_fc = \ self._filter_and_test_consistency(sched, instruction_types={FrameChangeInstruction}) self.assertEqual(len(only_fc.instructions), 1) self.assertEqual(len(no_fc.instructions), 4)
def test_filter_inst_types(self): """Test filtering on instruction types.""" device = self.two_qubit_device lp0 = self.linear(duration=3, slope=0.2, intercept=0.1) acquire = Acquire(5) sched = Schedule(name='fake_experiment') sched = sched.insert(0, lp0(device.q[0].drive)) sched = sched.insert(10, lp0(device.q[1].drive)) sched = sched.insert(30, FrameChange(phase=-1.57)(device.q[0].drive)) sched = sched.insert(60, acquire(device.q, device.mem)) sched = sched.insert(90, lp0(device.q[0].drive)) only_acquires = sched.filter(instruction_types=[AcquireInstruction]) for _, inst in only_acquires.instructions: self.assertIsInstance(inst, AcquireInstruction) only_pulse_and_fc = sched.filter(instruction_types=[PulseInstruction, FrameChangeInstruction]) for _, inst in only_pulse_and_fc.instructions: self.assertIsInstance(inst, (PulseInstruction, FrameChangeInstruction)) self.assertEqual(len(only_pulse_and_fc.instructions), 4) only_fc = sched.filter(instruction_types={FrameChangeInstruction}) self.assertEqual(len(only_fc.instructions), 1)
def _1Q_frame_change_schedule(self, phi, fc_phi, total_samples, dur_drive1, dur_drive2): """Creates schedule for frame change test. Does a pulse w/ phase phi of duration dur_drive1, then frame change of phase fc_phi, then another pulse of phase phi of duration dur_drive2. The different durations for the pulses allow manipulation of rotation angles on Bloch sphere Args: phi (float): drive phase (phi in Hamiltonian) fc_phi (float): phase for frame change total_samples (int): length of pulses dur_drive1 (int): duration of first pulse dur_drive2 (int): duration of second pulse Returns: schedule (pulse schedule): schedule for frame change test """ phase = np.exp(1j * phi) drive_pulse_1 = SamplePulse(phase * np.ones(dur_drive1), name='drive_pulse_1') drive_pulse_2 = SamplePulse(phase * np.ones(dur_drive2), name='drive_pulse_2') # frame change fc_pulse = FrameChange(phase=fc_phi, name='fc') # set up acquire command acq_cmd = pulse.Acquire(duration=total_samples) # add commands to schedule schedule = pulse.Schedule(name='fc_schedule') schedule |= drive_pulse_1(DriveChannel(0)) schedule += fc_pulse(DriveChannel(0)) schedule += drive_pulse_2(DriveChannel(0)) schedule |= acq_cmd(AcquireChannel(0), MemorySlot(0)) << schedule.duration return schedule
def test_filter_multiple(self): """Test filter composition.""" device = self.two_qubit_device lp0 = self.linear(duration=3, slope=0.2, intercept=0.1) acquire = Acquire(5) sched = Schedule(name='fake_experiment') sched = sched.insert(0, lp0(device.q[0].drive)) sched = sched.insert(10, lp0(device.q[1].drive)) sched = sched.insert(30, FrameChange(phase=-1.57)(device.q[0].drive)) sched = sched.insert(60, acquire(device.q, device.mem)) sched = sched.insert(90, lp0(device.q[0].drive)) filtered = sched.filter(channels={0}, instruction_types=[PulseInstruction], time_ranges=[(25, 100)]) for time, inst in filtered.instructions: self.assertIsInstance(inst, PulseInstruction) self.assertTrue(any([chan.index == 0 for chan in inst.channels])) self.assertTrue(25 <= time <= 100) filtered_b = sched.filter(instruction_types=[PulseInstruction, FrameChangeInstruction], time_ranges=[(25, 100), (0, 30)]) for time, inst in filtered_b.instructions: self.assertIsInstance(inst, (FrameChangeInstruction, PulseInstruction)) self.assertTrue(len(filtered_b.instructions), 4)
def test_buffering(self): """Test channel buffering.""" buffer_chan = DriveChannel(0, buffer=5) measure_chan = MeasureChannel(0, buffer=10) acquire_chan = AcquireChannel(0, buffer=10) memory_slot = MemorySlot(0) gp0 = pulse_lib.gaussian(duration=10, amp=0.7, sigma=3) fc_pi_2 = FrameChange(phase=1.57) # no initial buffer sched = Schedule() sched += gp0(buffer_chan) self.assertEqual(sched.duration, 10) # this pulse should be buffered sched += gp0(buffer_chan) self.assertEqual(sched.duration, 25) # should not be buffered as framechange sched += fc_pi_2(buffer_chan) self.assertEqual(sched.duration, 25) # use buffer with insert sched = sched.insert(sched.duration, gp0(buffer_chan), buffer=True) self.assertEqual(sched.duration, 40) sched = Schedule() sched = gp0(measure_chan) + Acquire(duration=10)(acquire_chan, memory_slot) self.assertEqual(sched.duration, 10)
def test_different_time_not_equal(self): """Test that not equal if instruction at different time.""" self.assertNotEqual(Schedule((0, FrameChange(0)(DriveChannel(1)))), Schedule((1, FrameChange(0)(DriveChannel(1)))))
def test_same_time_equal(self): """Test equal if instruction at same time.""" self.assertEqual(Schedule((0, FrameChange(0)(DriveChannel(1)))), Schedule((0, FrameChange(0)(DriveChannel(1)))))
def test_different_channels(self): """Test equality is False if different channels.""" self.assertNotEqual(Schedule(FrameChange(0)(DriveChannel(0))), Schedule(FrameChange(0)(DriveChannel(1))))
def test_multiple_channels_out_of_order(self): """Test that schedule with multiple channels equal when out of order.""" instructions = [(0, FrameChange(0)(DriveChannel(1))), (1, Acquire(10)(AcquireChannel(0), MemorySlot(1)))] self.assertEqual(Schedule(*instructions), Schedule(*reversed(instructions)))
def test_different_name_equal(self): """Test that names are ignored when checking equality.""" self.assertEqual(Schedule((0, FrameChange(0, name='fc1')(DriveChannel(1))), name='s1'), Schedule((0, FrameChange(0, name='fc2')(DriveChannel(1))), name='s2'))