Ejemplo n.º 1
0
    def test_render(self) -> None:
        with self.assertWarnsRegex(DeprecationWarning, ".*InstructionBlock.*"):
            wf1 = DummyWaveform(duration=19)
            wf2 = DummyWaveform(duration=21)

            block = InstructionBlock()
            block.add_instruction_exec(wf1)
            block.add_instruction_meas([('asd', 0, 1)])
            block.add_instruction_exec(wf2)

            wf1_expected = ('A', [0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
            wf2_expected = ('A', [
                x - 19 for x in [20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40]
            ])
            wf1_output_array_len_expected = len(wf1_expected[1])
            wf2_output_array_len_expected = len(wf2_expected[1])

            wf1.sample_output = numpy.linspace(start=4,
                                               stop=5,
                                               num=len(wf1_expected[1]))
            wf2.sample_output = numpy.linspace(6, 7, num=len(wf2_expected[1]))

            expected_times = numpy.arange(start=0, stop=42, step=2)
            expected_result = numpy.concatenate(
                (wf1.sample_output, wf2.sample_output))

            times, voltages, _ = render(block, sample_rate=0.5)

            self.assertEqual(len(wf1.sample_calls), 1)
            self.assertEqual(len(wf2.sample_calls), 1)

            self.assertEqual(wf1_expected[0], wf1.sample_calls[0][0])
            self.assertEqual(wf2_expected[0], wf2.sample_calls[0][0])

            numpy.testing.assert_almost_equal(wf1_expected[1],
                                              wf1.sample_calls[0][1])
            numpy.testing.assert_almost_equal(wf2_expected[1],
                                              wf2.sample_calls[0][1])

            self.assertEqual(wf1_output_array_len_expected,
                             len(wf1.sample_calls[0][2]))
            self.assertEqual(wf2_output_array_len_expected,
                             len(wf2.sample_calls[0][2]))

            self.assertEqual(voltages.keys(), dict(A=0).keys())

            numpy.testing.assert_almost_equal(expected_times, times)
            numpy.testing.assert_almost_equal(expected_result, voltages['A'])
            self.assertEqual(expected_result.shape, voltages['A'].shape)

            times, voltages, measurements = render(block,
                                                   sample_rate=0.5,
                                                   render_measurements=True)
            self.assertEqual(voltages.keys(), dict(A=0).keys())

            numpy.testing.assert_almost_equal(expected_times, times)
            numpy.testing.assert_almost_equal(expected_result, voltages['A'])
            self.assertEqual(expected_result.shape, voltages['A'].shape)

            self.assertEqual(measurements, [('asd', 19, 1)])
Ejemplo n.º 2
0
    def test_render_loop_sliced(self) -> None:
        wf = DummyWaveform(duration=19)

        full_times = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
        wf.sample_output = numpy.linspace(start=4, stop=5,
                                          num=len(full_times))[3:7]

        full_measurements = [('foo', 1, 3), ('bar', 5, 2), ('foo', 7, 3),
                             ('bar', 11, 2), ('foo', 15, 3)]
        loop = Loop(waveform=wf, measurements=full_measurements)

        expected_times = full_times[3:7]
        expected_measurements = full_measurements[1:4]

        times, voltages, measurements = render(loop,
                                               sample_rate=0.5,
                                               render_measurements=True,
                                               time_slice=(6, 12))

        numpy.testing.assert_almost_equal(expected_times, times)
        numpy.testing.assert_almost_equal(wf.sample_output, voltages['A'])
        self.assertEqual(expected_measurements, measurements)