def test_build_waveform_single_channel(self): table = TablePulseTemplate({0: [(0, 0), ('foo', 'v', 'linear'), ('bar', 0, 'jump')]}, parameter_constraints=['foo>1'], measurements=[('M', 'b', 'l'), ('N', 1, 2)]) parameters = {'v': 2.3, 'foo': 1, 'bar': 4, 'b': 2, 'l': 1} channel_mapping = {0: 'ch'} with self.assertRaises(ParameterConstraintViolation): table.build_waveform(parameters=parameters, channel_mapping=channel_mapping) parameters['foo'] = 1.1 waveform = table.build_waveform(parameters=parameters, channel_mapping=channel_mapping) self.assertIsInstance(waveform, TableWaveform) self.assertEqual(waveform._table, ((0, 0, HoldInterpolationStrategy()), (1.1, 2.3, LinearInterpolationStrategy()), (4, 0, JumpInterpolationStrategy()))) self.assertEqual(waveform._channel_id, 'ch')
def test_get_entries_instantiated_two_entries_float_float_declaration_float( self) -> None: table = TablePulseTemplate({0: [('foo', -2.)]}) instantiated_entries = table.get_entries_instantiated({'foo': 2})[0] self.assertEqual([(0, -2., HoldInterpolationStrategy()), (2, -2., HoldInterpolationStrategy())], instantiated_entries)
def test_build_waveform_multi_channel(self): table = TablePulseTemplate( { 0: [(0, 0), ('foo', 'v', 'linear'), ('bar', 0, 'jump')], 3: [(0, 1), ('bar+foo', 0, 'linear')] }, parameter_constraints=['foo>1'], measurements=[('M', 'b', 'l'), ('N', 1, 2)]) parameters = {'v': 2.3, 'foo': 1, 'bar': 4, 'b': 2, 'l': 1} channel_mapping = {0: 'ch', 3: 'oh'} with self.assertRaises(ParameterConstraintViolation): table.build_waveform(parameters=parameters, channel_mapping=channel_mapping) parameters['foo'] = 1.1 waveform = table.build_waveform(parameters=parameters, channel_mapping=channel_mapping) self.assertIsInstance(waveform, MultiChannelWaveform) expected_waveforms = [ TableWaveform.from_table( 'ch', ((0, 0, HoldInterpolationStrategy()), (1.1, 2.3, LinearInterpolationStrategy()), (4, 0, JumpInterpolationStrategy()), (5.1, 0, HoldInterpolationStrategy()))), TableWaveform.from_table( 'oh', ((0, 1, HoldInterpolationStrategy()), (5.1, 0, LinearInterpolationStrategy()))), ] self.assertEqual(waveform._sub_waveforms, tuple(expected_waveforms))
def test_issue_584_uninitialized_table_sample(self): """issue 584""" d = 598.3333333333334 - 480 tpt = TablePulseTemplate( entries={'P': [(0, 1.0, 'hold'), (d, 1.0, 'hold')]}) with mock.patch('qupulse._program.waveforms.PULSE_TO_WAVEFORM_ERROR', 1e-6): wf = to_waveform(tpt.create_program()) self.assertTrue(isclose(d, wf.duration, abs_tol=1e-6)) start_time = 0. end_time = wf.duration sample_rate = 3. sample_count = (end_time - start_time) * sample_rate + 1 times = np.linspace(float(start_time), float(wf.duration), num=int(sample_count), dtype=float) times[-1] = np.nextafter(times[-1], times[-2]) out = np.full_like(times, fill_value=np.nan) sampled = wf.get_sampled(channel='P', sample_times=times, output_array=out) expected = np.full_like(times, fill_value=1.) np.testing.assert_array_equal(expected, sampled)
def test_internal_constraints(self): table = TablePulseTemplate( { 0: [(1, 'v'), (2, 'w')], 1: [('t', 'x'), ('t+2', 'y')] }, parameter_constraints=['x<2', 'y<w', 't<1']) self.assertEqual(table.parameter_names, {'v', 'w', 't', 'x', 'y'}) with self.assertRaises(ParameterConstraintViolation): table.build_waveform(parameters=dict(v=1, w=2, t=0.1, x=2.2, y=1), channel_mapping={ 0: 0, 1: 1 }) with self.assertRaises(ParameterConstraintViolation): table.build_waveform(parameters=dict(v=1, w=2, t=0.1, x=1.2, y=2), channel_mapping={ 0: 0, 1: 1 }) with self.assertRaises(ParameterConstraintViolation): table.build_waveform(parameters=dict(v=1, w=2, t=3, x=1.2, y=1), channel_mapping={ 0: 0, 1: 1 }) table.build_waveform(parameters=dict(v=1, w=2, t=0.1, x=1.2, y=1), channel_mapping={ 0: 0, 1: 1 })
def test_get_instantiated_entries_multi_same_time_param(self) -> None: table = TablePulseTemplate({ 0: [(1, 3), ('foo', 'bar'), (7, 3)], 1: [(0, -5), (0.5, -2), ('foo', 0), (5, 'bar')] }) parameters = {'foo': 2.7, 'bar': -3.3} entries = table.get_entries_instantiated(parameters) expected = { 0: [ TableEntry(0, 3, HoldInterpolationStrategy()), TableEntry(1, 3, HoldInterpolationStrategy()), TableEntry(2.7, -3.3, HoldInterpolationStrategy()), TableEntry(7, 3, HoldInterpolationStrategy()), ], 1: [ TableEntry(0, -5, HoldInterpolationStrategy()), TableEntry(0.5, -2, HoldInterpolationStrategy()), TableEntry(2.7, 0, HoldInterpolationStrategy()), TableEntry(5, -3.3, HoldInterpolationStrategy()), TableEntry(7, -3.3, HoldInterpolationStrategy()) ] } self.assertEqual(expected, entries)
def test_time_is_0_on_instantiation(self): table = TablePulseTemplate({0: [('a', 1)]}) self.assertEqual(table.duration, Expression('a')) self.assertEqual(table.parameter_names, {'a'}) self.assertIsNone( table.build_waveform(parameters=dict(a=0), channel_mapping={0: 0}))
def setUp(self) -> None: # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex( DeprecationWarning, "deprecated", msg= "TablePT does not issue warning for old serialization routines." ): self.serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name']) self.entries = dict(A=[('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')], B=[(0, 5, 'hold'), (1, 7, 'jump'), ('k', 't', 'hold')]) self.measurements = [('m', 1, 1), ('foo', 'z', 'o')] self.template = TablePulseTemplate( entries=self.entries, measurements=self.measurements, identifier='foo', parameter_constraints=['ilse>2', 'k>foo'], registry=dict()) self.expected_data = dict( type=self.serializer.get_type_identifier(self.template)) self.maxDiff = None
def test_build_waveform_time_type(self): from qupulse.utils.types import TimeType table = TablePulseTemplate({0: [(0, 0), ('foo', 'v', 'linear'), ('bar', 0, 'jump')]}, parameter_constraints=['foo>1'], measurements=[('M', 'b', 'l'), ('N', 1, 2)]) parameters = {'v': 2.3, 'foo': TimeType.from_float(1.), 'bar': TimeType.from_float(4), 'b': TimeType.from_float(2), 'l': TimeType.from_float(1)} channel_mapping = {0: 'ch'} with self.assertRaises(ParameterConstraintViolation): table.build_waveform(parameters=parameters, channel_mapping=channel_mapping) parameters['foo'] = TimeType.from_float(1.1) waveform = table.build_waveform(parameters=parameters, channel_mapping=channel_mapping) self.assertIsInstance(waveform, TableWaveform) self.assertEqual(waveform._table, ((0, 0, HoldInterpolationStrategy()), (TimeType.from_float(1.1), 2.3, LinearInterpolationStrategy()), (4, 0, JumpInterpolationStrategy()))) self.assertEqual(waveform._channel_id, 'ch')
def test_triple_concatenation(self): tpt_1 = TablePulseTemplate({ 'A': [(0, 1), ('a', 5, 'linear')], 'B': [(0, 2), ('b', 7)] }) tpt_2 = TablePulseTemplate({ 'A': [('c', 9), ('a', 10, 'jump')], 'B': [(0, 6), ('b', 8)] }) tpt_3 = TablePulseTemplate({ 'A': [('fg', 19), ('ab', 110, 'jump')], 'B': [('df', 16), ('ab', 18)] }) expected = TablePulseTemplate({ 'A': [(0, 1), ('a', 5, 'linear'), ('Max(a, b)', 5), ('Max(a, b)', 9), ('Max(a, b) + c', 9), ('Max(a, b) + a', 10, 'jump'), ('2*Max(a, b)', 10), ('2*Max(a, b)', 19), ('2*Max(a, b) + fg', 19), ('2*Max(a, b) + ab', 110, 'jump')], 'B': [(0, 2), ('b', 7), ('Max(a, b)', 7, 'hold'), ('Max(a, b)', 6), ('Max(a, b) + b', 8), ('2*Max(a, b)', 8), ('2*Max(a, b)', 16), ('2*Max(a, b) + df', 16), ('2*Max(a, b) + ab', 18)] }) concatenated = concatenate(tpt_1, tpt_2, tpt_3, identifier='asdf') self.assertEqual(expected.entries, concatenated.entries) self.assertEqual(concatenated.identifier, 'asdf')
def test_wrong_channels(self): tpt_1 = TablePulseTemplate({'A': [(0, 1), ('a', 5, 'linear')], 'B': [(0, 2), ('b', 7)]}) tpt_2 = TablePulseTemplate({'A': [('c', 9), ('a', 10, 'jump')], 'C': [(0, 6), ('b', 8)]}) with self.assertRaisesRegex(ValueError, 'differing defined channels'): concatenate(tpt_1, tpt_2)
def test_time_is_0_on_construction(self) -> None: with self.assertWarns(ZeroDurationTablePulseTemplate): warnings.simplefilter('default', ZeroDurationTablePulseTemplate) table = TablePulseTemplate({0: [(0, 1.4)]}) self.assertTrue(table.duration == 0) self.assertTrue(table.duration == 0) self.assertIsNone( table.build_waveform(parameters=dict(), channel_mapping={0: 0}))
def test_get_entries_instantiated_multiple_parameters_missing( self) -> None: table = TablePulseTemplate({0: [(0, 'v1'), ('t', 'v2')]}) with self.assertRaises(ParameterNotProvidedException): table.get_entries_instantiated(dict()) with self.assertRaises(ParameterNotProvidedException): table.get_entries_instantiated(dict(v1=1)) with self.assertRaises(ParameterNotProvidedException): table.get_entries_instantiated(dict(v1=1, t=2)) table.get_entries_instantiated(dict(v1=1, t=2, v2=2))
def test_get_entries_instantiated_two_equal_entries(self) -> None: table = TablePulseTemplate({0: [(0, 0), (1, 5), (3, 5), (5, 1)]}) entries = table.get_entries_instantiated(dict()) expected = [ TableEntry(0, 0, HoldInterpolationStrategy()), TableEntry(1, 5, HoldInterpolationStrategy()), TableEntry(3, 5, HoldInterpolationStrategy()), TableEntry(5, 1, HoldInterpolationStrategy()) ] self.assertEqual({0: expected}, entries)
def test_time_is_negative(self) -> None: with self.assertRaises(ValueError): TablePulseTemplate({0: [(1, 2), (2, 3), (-1, 3)]}) with self.assertRaises(ValueError): TablePulseTemplate({0: [(-1, 2), (2, 3), (3, 3)]})
def test_get_entries_instantiated_two_entries_float_declaraton_declaration_declaration( self) -> None: table = TablePulseTemplate({0: [(0, 'v1'), ('t', 'v2')]}) instantiated_entries = table.get_entries_instantiated({ 'v1': -5, 'v2': 5, 't': 3 })[0] self.assertEqual([(0, -5, HoldInterpolationStrategy()), (3, 5, HoldInterpolationStrategy())], instantiated_entries)
def test_inconsistent_parameters(self): with self.assertRaises(ValueError): TablePulseTemplate({0: [('a', 1), (2, 0)], 1: [(3, 6), ('a', 7)]}) with self.assertRaises(ValueError): TablePulseTemplate({0: [('a', 1), (2, 0)]}, parameter_constraints=['a>3']) with self.assertRaises(ValueError): TablePulseTemplate({0: [('a', 1), (2, 0)]}, parameter_constraints=['2>3'])
def test_get_entries_auto_insert(self) -> None: table = TablePulseTemplate({0: [('foo', 'v', 'linear'), ('bar', 0, 'jump')], 1: [(0, 3, 'linear'), ('bar+foo', 2, 'linear')]}) instantiated_entries = table.get_entries_instantiated({'v': 2.3, 'foo': 1, 'bar': 4}) self.assertEqual({0: [(0, 2.3, HoldInterpolationStrategy()), (1, 2.3, LinearInterpolationStrategy()), (4, 0, JumpInterpolationStrategy()), (5, 0, HoldInterpolationStrategy())], 1: [(0, 3, LinearInterpolationStrategy()), (5, 2, LinearInterpolationStrategy())]}, instantiated_entries)
def test_duplication(self): tpt = TablePulseTemplate({'A': [(0, 1), ('a', 5)], 'B': [(0, 2), ('b', 3)]}) concatenated = concatenate(tpt, tpt) self.assertIsNot(concatenated.entries, tpt.entries) expected = TablePulseTemplate({'A': [(0, 1), ('a', 5), ('Max(a, b)', 5), ('Max(a, b)', 1), ('Max(a, b) + a', 5)], 'B': [(0, 2), ('b', 3), ('Max(a, b)', 3), ('Max(a, b)', 2), ('Max(a, b) + b', 3)]}) self.assertEqual(expected.entries, concatenated.entries)
def test_from_entry_list(self): entries = { 0: [(0, 9, HoldInterpolationStrategy()), (1, 2, HoldInterpolationStrategy()), (4, 1, LinearInterpolationStrategy())], 1: [(0, 8, HoldInterpolationStrategy()), (1, 1, HoldInterpolationStrategy()), (4, 2, LinearInterpolationStrategy())], 2: [(0, 7, HoldInterpolationStrategy()), (1, 3, HoldInterpolationStrategy()), (4, 3, LinearInterpolationStrategy())] } tpt = TablePulseTemplate.from_entry_list([(0, 9, 8, 7), (1, 2, 1, 3, 'hold'), (4, 1, 2, 3, 'linear')], identifier='tpt') self.assertEqual(tpt.entries, entries) self.assertEqual(tpt.identifier, 'tpt') tpt = TablePulseTemplate.from_entry_list([(0, 9, 8, 7, 'hold'), (1, 2, 1, 3, 'hold'), (4, 1, 2, 3, 'linear')], identifier='tpt2') self.assertEqual(tpt.entries, entries) entries = {k: entries[i] for k, i in zip('ABC', [0, 1, 2])} tpt = TablePulseTemplate.from_entry_list([(0, 9, 8, 7), (1, 2, 1, 3, 'hold'), (4, 1, 2, 3, 'linear')], identifier='tpt3', channel_names=['A', 'B', 'C']) self.assertEqual(tpt.entries, entries) self.assertEqual(tpt.identifier, 'tpt3') entries = { 0: [(0, 9, HoldInterpolationStrategy()), (1, 2, HoldInterpolationStrategy()), (4, 1, HoldInterpolationStrategy())], 1: [(0, 8, HoldInterpolationStrategy()), (1, 1, HoldInterpolationStrategy()), (4, 2, HoldInterpolationStrategy())], 2: [(0, 7, HoldInterpolationStrategy()), (1, 3, HoldInterpolationStrategy()), (4, 3, HoldInterpolationStrategy())] } tpt = TablePulseTemplate.from_entry_list([(0, 9, 8, 7), (1, 2, 1, 3), (4, 1, 2, 3)], identifier='tpt4') self.assertEqual(tpt.entries, entries)
class TablePulseTemplateOldSerializationTests(unittest.TestCase): def setUp(self) -> None: # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex(DeprecationWarning, "deprecated", msg="TablePT does not issue warning for old serialization routines."): self.serializer = DummySerializer(lambda x: dict(name=x.name), lambda x: x.name, lambda x: x['name']) self.entries = dict(A=[('foo', 2, 'hold'), ('hugo', 'ilse', 'linear')], B=[(0, 5, 'hold'), (1, 7, 'jump'), ('k', 't', 'hold')]) self.measurements = [('m', 1, 1), ('foo', 'z', 'o')] self.template = TablePulseTemplate(entries=self.entries, measurements=self.measurements, identifier='foo', parameter_constraints=['ilse>2', 'k>foo'], registry=dict()) self.expected_data = dict(type=self.serializer.get_type_identifier(self.template)) self.maxDiff = None def test_get_serialization_data_old(self) -> None: # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex(DeprecationWarning, "deprecated", msg="TablePT does not issue warning for old serialization routines."): expected_data = dict(measurements=self.measurements, entries=self.entries, parameter_constraints=[str(Expression('ilse>2')), str(Expression('k>foo'))]) data = self.template.get_serialization_data(self.serializer) self.assertEqual(expected_data, data) def test_deserialize_old(self) -> None: registry = dict() # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex(DeprecationWarning, "deprecated", msg="TablePT does not issue warning for old serialization routines."): data = dict(measurements=self.measurements, entries=self.entries, parameter_constraints=['ilse>2', 'k>foo'], identifier='foo') # deserialize template = TablePulseTemplate.deserialize(self.serializer, **data, registry=registry) self.assertEqual(template.entries, self.template.entries) self.assertEqual(template.measurement_declarations, self.template.measurement_declarations) self.assertEqual(template.parameter_constraints, self.template.parameter_constraints) def test_serializer_integration_old(self): registry = dict() # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex(DeprecationWarning, "deprecated", msg="TablePT does not issue warning for old serialization routines."): serializer = Serializer(DummyStorageBackend()) serializer.serialize(self.template) template = serializer.deserialize('foo') self.assertIsInstance(template, TablePulseTemplate) self.assertEqual(template.entries, self.template.entries) self.assertEqual(template.measurement_declarations, self.template.measurement_declarations) self.assertEqual(template.parameter_constraints, self.template.parameter_constraints)
def test_wrong_type(self): dummy = DummyPulseTemplate() tpt = TablePulseTemplate({'A': [(0, 1), ('a', 5, 'linear')], 'B': [(0, 2), ('b', 7)]}) with self.assertRaisesRegex(TypeError, 'not a TablePulseTemplate'): concatenate(dummy, tpt)
def test_bug_422_mock(self): pt = TablePulseTemplate({'X': [(0, 1), (100, 1)]}) program = pt.create_program() mock_program = mock.Mock(spec=dir(program)) for attr in dir(Loop): if not attr.endswith('_'): setattr(mock_program, attr, getattr(program, attr)) mock_program.__len__ = lambda x: 1 mock_program.__iter__ = lambda x: iter(program) mock_program.__getitem__ = lambda x, idx: program[idx] self.assertNotIsInstance(mock_program, Loop) render(mock_program, sample_rate=1)
def __init__(self, *args, **kwargs) -> None: super().__init__(*args, **kwargs) # Setup test data self.square = TablePulseTemplate( { 'default': [(0, 0), ('up', 'v', 'hold'), ('down', 0, 'hold'), ('length', 0)] }, measurements=[('mw1', 'up', 'length-up')]) self.mapping1 = { 'up': 'uptime', 'down': 'uptime + length', 'v': 'voltage', 'length': '0.5 * pulse_length' } self.window_name_mapping = {'mw1': 'test_window'} self.outer_parameters = {'uptime', 'length', 'pulse_length', 'voltage'} self.parameters = dict() self.parameters['uptime'] = ConstantParameter(5) self.parameters['length'] = ConstantParameter(10) self.parameters['pulse_length'] = ConstantParameter(100) self.parameters['voltage'] = ConstantParameter(10) self.sequence = SequencePulseTemplate( MappingPulseTemplate(self.square, parameter_mapping=self.mapping1, measurement_mapping=self.window_name_mapping))
def test_single_channel_no_parameters(self): raw_entries = [(0., 1.1), (1.1, 2.), (2.2, 2.4)] table = TablePulseTemplate({0: raw_entries}) expected = [TableEntry(*entry) for entry in raw_entries] self.assertEqual(table.entries, dict([(0, expected)])) self.assertEqual(table.duration, 2.2) self.assertEqual(table.parameter_names, set())
def test_deserialize_old(self) -> None: registry = dict() # test for deprecated version during transition period, remove after final switch with self.assertWarnsRegex( DeprecationWarning, "deprecated", msg= "TablePT does not issue warning for old serialization routines." ): data = dict(measurements=self.measurements, entries=self.entries, parameter_constraints=['ilse>2', 'k>foo'], identifier='foo') # deserialize template = TablePulseTemplate.deserialize(self.serializer, **data, registry=registry) self.assertEqual(template.entries, self.template.entries) self.assertEqual(template.measurement_declarations, self.template.measurement_declarations) self.assertEqual(template.parameter_constraints, self.template.parameter_constraints)
def test_from_array_1D(self) -> None: times = numpy.array([0, 1, 3]) voltages = numpy.array([5, 0, 5]) pulse = TablePulseTemplate.from_array(times, voltages, [0]) entries = [] for (time, voltage) in zip(times, voltages): entries.append(TableEntry(time, voltage, HoldInterpolationStrategy())) self.assertEqual({0: entries}, pulse.entries)
def test_from_array_multi_one_voltage(self) -> None: times = numpy.array([[0, 1, 3], [2, 3, 4]]) voltages = numpy.array([1, 2, 3]) pulse = TablePulseTemplate.from_array(times, voltages, [0, 1]) entries = { i: [TableEntry(time, voltage, HoldInterpolationStrategy()) for (time, voltage) in zip(times[i, :], voltages)] for i in range(2)} self.assertEqual(entries, pulse.entries)
def test_add_entry_multi_same_time_param(self) -> None: pulse = TablePulseTemplate({0: [(1, 3), ('foo', 'bar'), (7, 3)], 1: [(0, -5), (0.5, -2), ('foo', 0), (5, 'bar')]}) self.assertEqual({'foo', 'bar'}, pulse.parameter_names)
def test_integral(self) -> None: pulse = TablePulseTemplate(entries={0: [(1, 2, 'linear'), (3, 0, 'jump'), (4, 2, 'hold'), (5, 8, 'hold')], 'other_channel': [(0, 7, 'linear'), (2, 0, 'hold'), (10, 0)], 'symbolic': [(3, 'a', 'hold'), ('b', 4, 'linear'), ('c', Expression('d'), 'hold')]}) expected = {0: Expression('6'), 'other_channel': Expression(7), 'symbolic': Expression('(b-3.)*a + (c-b)*(d+4.) / 2')} self.assertEqual(expected, pulse.integral)