def test_schedule_with_acquire_on_single_qubit(self): """Test schedule with acquire on single qubit.""" sched_single = Schedule() for i in range(self.config.n_qubits): sched_single = sched_single.insert( 10, Acquire( 10, self.config.acquire(i), mem_slot=MemorySlot(i), reg_slot=RegisterSlot(i) ), ) self.assertEqual(len(sched_single.instructions), 2) self.assertEqual(len(sched_single.channels), 6)
def test_acquire(self): """Test converted qobj from AcquireInstruction.""" converter = InstructionToQobjConverter(PulseQobjInstruction, meas_level=2) instruction = Acquire(10, AcquireChannel(0), MemorySlot(0), RegisterSlot(0)) valid_qobj = PulseQobjInstruction(name='acquire', t0=0, duration=10, qubits=[0], memory_slot=[0], register_slot=[0]) self.assertEqual(converter(0, instruction), valid_qobj) # without register instruction = Acquire(10, AcquireChannel(0), MemorySlot(0)) valid_qobj = PulseQobjInstruction(name='acquire', t0=0, duration=10, qubits=[0], memory_slot=[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) sched = Schedule(name="fake_experiment") sched = sched.insert(0, Play(lp0, self.config.drive(0))) sched = sched.insert(10, Play(lp0, self.config.drive(1))) sched = sched.insert(30, ShiftPhase(-1.57, self.config.drive(0))) for i in range(2): sched = sched.insert(60, Acquire(5, self.config.acquire(i), MemorySlot(i))) sched = sched.insert(90, Play(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), 4) # 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), 2) self.assertEqual(filtered.instructions[0][0], 60) self.assertIsInstance(filtered.instructions[0][1], Acquire) self.assertEqual(len(excluded.instructions), 4) self.assertEqual(excluded.instructions[3][0], 90) self.assertIsInstance(excluded.instructions[3][1], Play) # 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), 6) # 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), 4) # split instructions from non-overlapping intervals, specified as Intervals filtered, excluded = self._filter_and_test_consistency( sched, intervals=[(10, 15), (63, 93)] ) self.assertEqual(len(filtered.instructions), 2) self.assertEqual(len(excluded.instructions), 4)
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, ShiftPhase(-1.57, self.config.drive(0))) for i in range(2): sched = sched.insert( 60, acquire(self.config.acquire(i), MemorySlot(i))) sched = sched.insert(90, lp0(self.config.drive(0))) # split instructions with filters on channel 0, of type PulseInstruction, # occurring 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), 5) 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, (ShiftPhase, PulseInstruction)) self.assertTrue(len(filtered.instructions), 4) # make sure the PulseInstruction not in the intervals is maintained self.assertIsInstance(excluded.instructions[0][1], PulseInstruction) # split based on AcquireInstruction in the specified intervals filtered, excluded = self._filter_and_test_consistency( sched, instruction_types=[AcquireInstruction], time_ranges=[(25, 100)]) self.assertTrue(len(excluded.instructions), 4) for _, inst in filtered.instructions: self.assertIsInstance(inst, AcquireInstruction) self.assertTrue(len(filtered.instructions), 2)
def test_assemble_with_individual_kernels(self): """Test that assembly works with individual kernels.""" disc_one = Kernel('disc_one', test_params=True) disc_two = Kernel('disc_two', test_params=False) schedule = Schedule() schedule = schedule.append( Acquire(5, AcquireChannel(0), MemorySlot(0), kernel=disc_one), ) schedule = schedule.append( Acquire(5, AcquireChannel(1), MemorySlot(1), kernel=disc_two), ) qobj = assemble(schedule, qubit_lo_freq=self.default_qubit_lo_freq, meas_lo_freq=self.default_meas_lo_freq, meas_map=[[0, 1]]) validate_qobj_against_schema(qobj) qobj_kernels = qobj.experiments[0].instructions[0].kernels self.assertEqual(len(qobj_kernels), 2) self.assertEqual(qobj_kernels[0].name, 'disc_one') self.assertEqual(qobj_kernels[0].params['test_params'], True) self.assertEqual(qobj_kernels[1].name, 'disc_two') self.assertEqual(qobj_kernels[1].params['test_params'], False)
def setUp(self): self.device = DeviceSpecification( qubits=[ Qubit(0, drive_channels=[DriveChannel(0, 1.2)], acquire_channels=[AcquireChannel(0)]) ], registers=[ RegisterSlot(0) ], mem_slots=[ MemorySlot(0) ] )
def setUp(self): @functional_pulse def linear(duration, slope, intercept): x = np.linspace(0, duration - 1, duration) return slope * x + intercept self.linear = linear qubits = [Qubit(0, DriveChannel(0), AcquireChannel(0), MeasureChannel(0), control_channels=[ControlChannel(0)]), Qubit(1, DriveChannel(1), MeasureChannel(0), AcquireChannel(1))] registers = [RegisterSlot(i) for i in range(2)] mem_slots = [MemorySlot(i) for i in range(2)] self.two_qubit_device = DeviceSpecification(qubits, registers, mem_slots)
def test_parametric_commands_in_sched(self): """Test that schedules can be built with parametric commands.""" sched = Schedule(name='test_parametric') sched += Gaussian(duration=25, sigma=4, amp=0.5j)(DriveChannel(0)) sched += Drag(duration=25, amp=0.2 + 0.3j, sigma=7.8, beta=4)(DriveChannel(1)) sched += ConstantPulse(duration=25, amp=1)(DriveChannel(2)) sched_duration = sched.duration sched += GaussianSquare(duration=1500, amp=0.2, sigma=8, width=140)( MeasureChannel(0)) << sched_duration sched += Acquire(duration=1500)(AcquireChannel(0), [MemorySlot(0)]) << sched_duration self.assertEqual(sched.duration, 1525) self.assertTrue('sigma' in sched.instructions[0][1].pulse.parameters)
def test_align_measures(self): """Test that one acquire is delayed to match the time of the later acquire.""" sched = pulse.Schedule(name='fake_experiment') sched = sched.insert(0, Play(self.short_pulse, self.config.drive(0))) sched = sched.insert(1, Acquire(5, self.config.acquire(0), MemorySlot(0))) sched = sched.insert(10, Acquire(5, self.config.acquire(1), MemorySlot(1))) sched = sched.insert(10, Play(self.short_pulse, self.config.measure(0))) sched = sched.insert(10, Play(self.short_pulse, self.config.measure(1))) sched = align_measures([sched], self.inst_map)[0] self.assertEqual(sched.name, 'fake_experiment') for time, inst in sched.instructions: if isinstance(inst, Acquire): self.assertEqual(time, 10) sched = align_measures([sched], self.inst_map, align_time=20)[0] for time, inst in sched.instructions: if isinstance(inst, Acquire): self.assertEqual(time, 20) if isinstance(inst.channels[0], MeasureChannel): self.assertEqual(time, 20)
def test_filter_channels(self): """Test filtering over channels.""" lp0 = self.linear(duration=3, slope=0.2, intercept=0.1) sched = Schedule(name="fake_experiment") sched = sched.insert(0, Play(lp0, self.config.drive(0))) sched = sched.insert(10, Play(lp0, self.config.drive(1))) sched = sched.insert(30, ShiftPhase(-1.57, self.config.drive(0))) sched = sched.insert(60, Acquire(5, AcquireChannel(0), MemorySlot(0))) sched = sched.insert(60, Acquire(5, AcquireChannel(1), MemorySlot(1))) sched = sched.insert(90, Play(lp0, self.config.drive(0))) # split instructions for those on AcquireChannel(1) and those not filtered, excluded = self._filter_and_test_consistency(sched, channels=[AcquireChannel(1)]) self.assertEqual(len(filtered.instructions), 1) self.assertEqual(len(excluded.instructions), 5) # Split schedule into the part with channels on 1 and into a part without channels = [AcquireChannel(1), DriveChannel(1)] filtered, excluded = self._filter_and_test_consistency(sched, channels=channels) for _, inst in filtered.instructions: self.assertTrue(any(chan in channels for chan in inst.channels)) for _, inst in excluded.instructions: self.assertFalse(any(chan in channels for chan in inst.channels))
def setUp(self): self.linear = SamplePulse(np.arange(0, 0.01), name='linear') self.pulse_library = [ PulseLibraryItem(name=self.linear.name, samples=self.linear.samples.tolist()) ] self.converter = QobjToInstructionConverter(self.pulse_library, buffer=0) self.device = DeviceSpecification(qubits=[ Qubit(0, DriveChannel(0), MeasureChannel(0), AcquireChannel(0)) ], registers=[RegisterSlot(0)], mem_slots=[MemorySlot(0)])
def test_parametric_commands_in_sched(self): """Test that schedules can be built with parametric commands.""" sched = Schedule(name='test_parametric') sched += Play(Gaussian(duration=25, sigma=4, amp=0.5j), DriveChannel(0)) sched += Play(Drag(duration=25, amp=0.2+0.3j, sigma=7.8, beta=4), DriveChannel(1)) sched += Play(Constant(duration=25, amp=1), DriveChannel(2)) sched_duration = sched.duration sched += Play(GaussianSquare(duration=1500, amp=0.2, sigma=8, width=140), MeasureChannel(0)) << sched_duration with self.assertWarns(DeprecationWarning): # MemorySlots as list is deprecated sched += Acquire(1500, AcquireChannel(0), [MemorySlot(0)]) << sched_duration self.assertEqual(sched.duration, 1525) self.assertTrue('sigma' in sched.instructions[0][1].pulse.parameters)
def test_multi_acquire(self): """Test that an error is raised if multiple acquires occur on the same channel.""" acquire = pulse.Acquire(5) sched = pulse.Schedule(name='fake_experiment') sched = sched.insert(0, self.short_pulse(self.config.drive(0))) sched = sched.insert(4, acquire(self.config.acquire(0), MemorySlot(0))) sched = sched.insert(10, acquire(self.config.acquire(0), MemorySlot(0))) with self.assertRaises(PulseError): align_measures([sched], self.cmd_def) # Test for measure channel sched = pulse.Schedule(name='fake_experiment') sched = sched.insert(10, self.short_pulse(self.config.measure(0))) sched = sched.insert(30, self.short_pulse(self.config.measure(0))) with self.assertRaises(PulseError): align_measures([sched], self.cmd_def) # Test both using cmd_def sched = pulse.Schedule() sched += self.cmd_def.get('measure', (0, 1)) align_measures([sched], align_time=50) sched += self.cmd_def.get('measure', (0, 1)) with self.assertRaises(PulseError): align_measures([sched], align_time=50)
def test_assemble_with_single_discriminators(self): """Test that assembly works with both a single discriminator.""" disc_one = Discriminator('disc_one', test_params=True) schedule = Schedule() schedule = schedule.append( Acquire(5, AcquireChannel(0), MemorySlot(0), discriminator=disc_one), ) schedule = schedule.append( Acquire(5, AcquireChannel(1), MemorySlot(1)), ) qobj = assemble(schedule, qubit_lo_freq=self.default_qubit_lo_freq, meas_lo_freq=self.default_meas_lo_freq, meas_map=[[0, 1]]) validate_qobj_against_schema(qobj) qobj_discriminators = qobj.experiments[0].instructions[ 0].discriminators self.assertEqual(len(qobj_discriminators), 1) self.assertEqual(qobj_discriminators[0].name, 'disc_one') self.assertEqual(qobj_discriminators[0].params['test_params'], True)
def test_can_create_valid_schedule_with_syntax_sugar(self): """Test that in place operations on schedule are still immutable and return equivalent schedules.""" gp0 = library.gaussian(duration=20, amp=0.7, sigma=3) gp1 = library.gaussian(duration=20, amp=0.5, sigma=3) sched = Schedule() sched += Play(gp0, self.config.drive(0)) sched |= ShiftPhase(-1.57, self.config.drive(0)) << 60 sched |= Play(gp1, self.config.drive(0)) << 30 sched |= Play(gp0, self.config.control(qubits=[0, 1])[0]) << 60 sched |= Snapshot("label", "snap_type") << 60 sched |= ShiftPhase(1.57, self.config.drive(0)) << 90 sched |= Acquire(10, self.config.acquire(0), MemorySlot(0)) << 90 sched += sched
def setUp(self): super().setUp() qubits = [ Qubit(0, DriveChannel(0), AcquireChannel(0), MeasureChannel(0), control_channels=[ControlChannel(0)]), Qubit(1, DriveChannel(1), MeasureChannel(0), AcquireChannel(1)) ] registers = [RegisterSlot(i) for i in range(2)] mem_slots = [MemorySlot(i) for i in range(2)] self.two_qubit_device = DeviceSpecification(qubits, registers, mem_slots)
def test_single_and_deprecated_acquire_styles(self): """Test that acquires are identically combined with Acquires that take a single channel.""" backend = FakeOpenPulse2Q() new_style_schedule = Schedule() acq_dur = 1200 for i in range(5): new_style_schedule += Acquire(acq_dur, AcquireChannel(i), MemorySlot(i)) deprecated_style_schedule = Schedule() for i in range(5): deprecated_style_schedule += Acquire(1200, AcquireChannel(i), MemorySlot(i)) # The Qobj IDs will be different n_qobj = assemble(new_style_schedule, backend) n_qobj.qobj_id = None n_qobj.experiments[0].header.name = None d_qobj = assemble(deprecated_style_schedule, backend) d_qobj.qobj_id = None d_qobj.experiments[0].header.name = None self.assertEqual(n_qobj, d_qobj) assembled_acquire = n_qobj.experiments[0].instructions[0] self.assertEqual(assembled_acquire.qubits, [0, 1, 2, 3, 4]) self.assertEqual(assembled_acquire.memory_slot, [0, 1, 2, 3, 4])
def test_align_post_u3(self): """Test that acquires are scheduled no sooner than the duration of the longest X gate. """ acquire = pulse.Acquire(5) sched = pulse.Schedule(name='fake_experiment') sched = sched.insert(0, self.short_pulse(self.config.drive(0))) sched = sched.insert(1, acquire(self.config.acquire(0), MemorySlot(0))) sched = align_measures([sched], self.cmd_def)[0] for time, inst in sched.instructions: if isinstance(inst, AcquireInstruction): self.assertEqual(time, 4) sched = align_measures([sched], self.cmd_def, max_calibration_duration=10)[0] for time, inst in sched.instructions: if isinstance(inst, AcquireInstruction): self.assertEqual(time, 10)
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, ShiftPhase(-1.57, self.config.drive(0))) sched = sched.insert(40, SetFrequency(8.0, self.config.drive(0))) for i in range(2): sched = sched.insert( 60, acquire(self.config.acquire(i), MemorySlot(i))) sched = sched.insert(90, lp0(self.config.drive(0))) # test on Acquire only_acquire, no_acquire = \ self._filter_and_test_consistency(sched, instruction_types=[Acquire]) for _, inst in only_acquire.instructions: self.assertIsInstance(inst, Acquire) for _, inst in no_acquire.instructions: self.assertFalse(isinstance(inst, Acquire)) # test two instruction types only_pulse_and_fc, no_pulse_and_fc = \ self._filter_and_test_consistency(sched, instruction_types=[Play, ShiftPhase]) for _, inst in only_pulse_and_fc.instructions: self.assertIsInstance(inst, (Play, ShiftPhase)) for _, inst in no_pulse_and_fc.instructions: self.assertFalse(isinstance(inst, (Play, ShiftPhase))) self.assertEqual(len(only_pulse_and_fc.instructions), 4) self.assertEqual(len(no_pulse_and_fc.instructions), 3) # test on ShiftPhase only_fc, no_fc = \ self._filter_and_test_consistency(sched, instruction_types={ShiftPhase}) self.assertEqual(len(only_fc.instructions), 1) self.assertEqual(len(no_fc.instructions), 6) # test on SetFrequency only_sf, no_sf = \ self._filter_and_test_consistency(sched, instruction_types=[SetFrequency]) for _, inst in only_sf.instructions: self.assertTrue(isinstance(inst, SetFrequency)) self.assertEqual(len(only_sf.instructions), 1) self.assertEqual(len(no_sf.instructions), 6)
def setUp(self): self.schedule = Schedule() self.qubits = [ Qubit(0, drive_channel=DriveChannel(0), control_channels=[ControlChannel(0)], measure_channel=MeasureChannel(0), acquire_channel=AcquireChannel(0)), Qubit(1, drive_channel=DriveChannel(1), acquire_channel=AcquireChannel(1), measure_channel=MeasureChannel(1)) ] self.registers = [RegisterSlot(i) for i in range(2)] self.mem_slots = [MemorySlot(i) for i in range(2)] self.device = DeviceSpecification(self.qubits, self.registers, self.mem_slots)
def test_can_create_valid_schedule_with_syntax_sugar(self): """Test that in place operations on schedule are still immutable and return equivalent schedules.""" gp0 = pulse_lib.gaussian(duration=20, amp=0.7, sigma=3) gp1 = pulse_lib.gaussian(duration=20, amp=0.5, sigma=3) acquire = Acquire(10) sched = Schedule() sched += gp0(self.config.drive(0)) sched |= PersistentValue(value=0.2 + 0.4j)(self.config.control(0)) sched |= ShiftPhase(-1.57, self.config.drive(0)) << 60 sched |= gp1(self.config.drive(0)) << 30 sched |= gp0(self.config.control(0)) << 60 sched |= Snapshot("label", "snap_type") << 60 sched |= ShiftPhase(1.57, self.config.drive(0)) << 90 sched |= acquire(self.config.acquire(0), MemorySlot(0), RegisterSlot(0)) << 90 sched += sched
def test_can_create_valid_schedule_with_syntax_sugar(self): """Test that in place operations on schedule are still immutable and return equivalent schedules.""" gp0 = pulse_lib.gaussian(duration=20, amp=0.7, sigma=3) gp1 = pulse_lib.gaussian(duration=20, amp=0.5, sigma=3) sched = Schedule() sched += Play(gp0, self.config.drive(0)) with self.assertWarns(DeprecationWarning): sched |= PersistentValue(value=0.2 + 0.4j)(self.config.control( [0, 1])[0]) sched |= ShiftPhase(-1.57, self.config.drive(0)) << 60 sched |= Play(gp1, self.config.drive(0)) << 30 sched |= Play(gp0, self.config.control(qubits=[0, 1])[0]) << 60 sched |= Snapshot("label", "snap_type") << 60 sched |= ShiftPhase(1.57, self.config.drive(0)) << 90 sched |= Acquire(10, self.config.acquire(0), MemorySlot(0)) << 90 sched += sched
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_schedule_with_acquire_for_back_and_forward_compatibility(self): """Test schedule with acquire for back and forward compatibility.""" acquire = Acquire(10) cmds = [ acquire(AcquireChannel(0), MemorySlot(0)), acquire([AcquireChannel(0)], MemorySlot(0)), acquire(AcquireChannel(0), [MemorySlot(0)]), acquire([AcquireChannel(0)], mem_slots=[MemorySlot(0)]), acquire(AcquireChannel(0), MemorySlot(0), [RegisterSlot(0)]), acquire(AcquireChannel(0), MemorySlot(0), reg_slot=RegisterSlot(0)) ] for cmd in cmds: mixed_schedule = Schedule() mixed_schedule = mixed_schedule.insert(10, cmd) self.assertEqual(len(mixed_schedule.instructions), 1) self.assertTrue(MemorySlot(0) in mixed_schedule.channels)
def test_empty_filters(self): """Test behavior on empty filters.""" lp0 = self.linear(duration=3, slope=0.2, intercept=0.1) sched = Schedule(name='fake_experiment') sched = sched.insert(0, Play(lp0, self.config.drive(0))) sched = sched.insert(10, Play(lp0, self.config.drive(1))) sched = sched.insert(30, ShiftPhase(-1.57, self.config.drive(0))) for i in range(2): sched = sched.insert( 60, Acquire(5, self.config.acquire(i), MemorySlot(i))) sched = sched.insert(90, Play(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) == 6) # empty instruction_types filtered, excluded = self._filter_and_test_consistency( sched, instruction_types=[]) self.assertTrue(len(filtered.instructions) == 0) self.assertTrue(len(excluded.instructions) == 6) # empty time_ranges filtered, excluded = self._filter_and_test_consistency(sched, time_ranges=[]) self.assertTrue(len(filtered.instructions) == 0) self.assertTrue(len(excluded.instructions) == 6) # empty intervals filtered, excluded = self._filter_and_test_consistency(sched, intervals=[]) self.assertTrue(len(filtered.instructions) == 0) self.assertTrue(len(excluded.instructions) == 6) # empty channels with other non-empty filters filtered, excluded = self._filter_and_test_consistency( sched, channels=[], instruction_types=[Play]) self.assertTrue(len(filtered.instructions) == 0) self.assertTrue(len(excluded.instructions) == 6)
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_multiple_acquires(self): """Test that multiple acquires are also aligned.""" sched = pulse.Schedule(name="fake_experiment") sched.insert(0, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True) sched.insert(5, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True) sched.insert(10, Acquire(5, self.config.acquire(1), MemorySlot(1)), inplace=True) ref = pulse.Schedule() ref.insert(10, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True) ref.insert(15, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True) ref.insert(10, Acquire(5, self.config.acquire(1), MemorySlot(1)), inplace=True) aligned = transforms.align_measures([sched], self.inst_map)[0] self.assertEqual(aligned, ref)
def test_schedule_with_acquire_for_back_and_forward_compatibility(self): """Test schedule with acquire for back and forward compatibility.""" dur = 10 with self.assertWarns(DeprecationWarning): # mem_slots and reg_slots are deprecated kwargs cmds = [ Acquire(dur, AcquireChannel(0), MemorySlot(0)), Acquire(dur, [AcquireChannel(0)], MemorySlot(0)), Acquire(dur, AcquireChannel(0), [MemorySlot(0)]), Acquire(dur, [AcquireChannel(0)], mem_slots=[MemorySlot(0)]), Acquire(dur, AcquireChannel(0), MemorySlot(0), [RegisterSlot(0)]), Acquire(dur, AcquireChannel(0), MemorySlot(0), reg_slot=RegisterSlot(0)) ] for cmd in cmds: mixed_schedule = Schedule() mixed_schedule = mixed_schedule.insert(dur, cmd) self.assertEqual(len(mixed_schedule.instructions), 1) self.assertTrue(MemorySlot(0) in mixed_schedule.channels)
def test_name_inherited(self): """Test that schedule keeps name if an instruction is added.""" gp0 = library.gaussian(duration=100, amp=0.7, sigma=3, name="pulse_name") snapshot = Snapshot("snapshot_label", "state") sched1 = Schedule(name="test_name") sched2 = Schedule(name=None) sched3 = sched1 | sched2 self.assertEqual(sched3.name, "test_name") sched_acq = Acquire(10, self.config.acquire(1), MemorySlot(1), name="acq_name") | sched1 self.assertEqual(sched_acq.name, "acq_name") sched_pulse = Play(gp0, self.config.drive(0)) | sched1 self.assertEqual(sched_pulse.name, "pulse_name") sched_fc = ShiftPhase(0.1, self.config.drive(0), name="fc_name") | sched1 self.assertEqual(sched_fc.name, "fc_name") sched_snapshot = snapshot | sched1 self.assertEqual(sched_snapshot.name, "snapshot_label")
def test_multi_acquire(self): """Test that the last acquire is aligned to if multiple acquires occur on the same channel.""" sched = pulse.Schedule() sched.insert(0, Play(self.short_pulse, self.config.drive(0)), inplace=True) sched.insert(4, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True) sched.insert(20, Acquire(5, self.config.acquire(1), MemorySlot(1)), inplace=True) sched.insert(10, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True) aligned = transforms.align_measures([sched], self.inst_map) ref = pulse.Schedule() ref.insert(0, Play(self.short_pulse, self.config.drive(0)), inplace=True) ref.insert(20, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True) ref.insert(20, Acquire(5, self.config.acquire(1), MemorySlot(1)), inplace=True) ref.insert(26, Acquire(5, self.config.acquire(0), MemorySlot(0)), inplace=True) self.assertEqual(aligned[0], ref)