def test_overwrite(self): inner = DictScope(FrozenDict({ 'a': 0.5, 'i': 3 }), volatile=frozenset(['a'])) fscope = _ForLoopScope(inner, 'i', 4) self.assertIn('i', fscope) self.assertIn('a', fscope) self.assertNotIn('j', fscope) equivalent = {'a': 0.5, 'i': 4} self.assertEqual(equivalent, dict(fscope)) self.assertEqual(equivalent.items(), fscope.items()) self.assertEqual(equivalent.keys(), fscope.keys()) self.assertEqual(set(equivalent.values()), set(fscope.values())) self.assertEqual(0.5, fscope['a']) self.assertEqual(4, fscope['i']) self.assertEqual(FrozenDict({'a': ExpressionScalar('a')}), fscope.get_volatile_parameters()) inner = DictScope(FrozenDict({ 'a': 0.5, 'i': 3 }), volatile=frozenset(['a', 'i'])) fscope = _ForLoopScope(inner, 'i', 4) self.assertEqual(FrozenDict({'a': ExpressionScalar('a')}), fscope.get_volatile_parameters())
def test_from_kwargs(self): m = {'a': 1, 'b': 2} volatile = {'a'} ds = DictScope.from_kwargs(a=1, b=2) self.assertEqual(DictScope(FrozenDict(m)), ds) ds = DictScope.from_kwargs(a=1, b=2, volatile=volatile.copy()) self.assertEqual(DictScope(FrozenDict(m), frozenset(volatile)), ds)
def test_get_parameter(self): ds = DictScope(FrozenDict({'a': 1, 'b': 2})) self.assertEqual(1, ds.get_parameter('a')) self.assertEqual(2, ds.get_parameter('b')) with self.assertRaises(ParameterNotProvidedException) as cm: ds.get_parameter('c') self.assertEqual('c', cm.exception.parameter_name)
def test_from_mapping(self): m = {'a': 1, 'b': 2} volatile = {'a'} ds = DictScope.from_mapping(m.copy()) self.assertEqual(m, dict(ds)) self.assertEqual(FrozenDict(), ds.get_volatile_parameters()) ds = DictScope.from_mapping(m.copy(), volatile=volatile.copy()) self.assertEqual(DictScope(FrozenDict(m), frozenset(volatile)), ds)
def test_create_program_missing_params(self) -> None: dt = DummyPulseTemplate(parameter_names={'i'}, waveform=DummyWaveform(duration=4.0), duration='t', measurements=[('b', 2, 1)]) flt = ForLoopPulseTemplate(body=dt, loop_index='i', loop_range=('a', 'b', 'c'), measurements=[('A', 'alph', 1)], parameter_constraints=['c > 1']) scope = DictScope.from_kwargs(a=1, b=4) measurement_mapping = dict(A='B') channel_mapping = dict(C='D') children = [Loop(waveform=DummyWaveform(duration=2.0))] program = Loop(children=children) # test parameter in constraints with self.assertRaises(ParameterNotProvidedException): flt._internal_create_program( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, parent_loop=program, to_single_waveform=set(), global_transformation=None) # test parameter in measurement mappings scope = DictScope.from_kwargs(a=1, b=4, c=2) with self.assertRaises(ParameterNotProvidedException): flt._internal_create_program( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, parent_loop=program, to_single_waveform=set(), global_transformation=None) # test parameter in duration scope = DictScope.from_kwargs(a=1, b=4, c=2, alph=0) with self.assertRaises(ParameterNotProvidedException): flt._internal_create_program( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, parent_loop=program, to_single_waveform=set(), global_transformation=None) self.assertEqual(children, list(program.children)) self.assertEqual(1, program.repetition_count) self.assertIsNone(program._measurements) self.assert_measurement_windows_equal( {}, program.get_measurement_windows())
def test_update_constants(self): ds = DictScope.from_kwargs(a=1, b=2, c=3, volatile={'c'}) ds2 = DictScope.from_kwargs(a=1, b=2, c=4, volatile={'c'}) ms = MappedScope(ds, FrozenDict(x=ExpressionScalar('a * b'), c=ExpressionScalar('a - b'))) ms2 = MappedScope(ds2, ms._mapping) self.assertIs(ms, ms.change_constants({'f': 1})) changes = {'c': 4} ms_result = ms.change_constants(changes) self.assertEqual(ms2, ms_result)
def test_init(self): with self.assertRaises(AssertionError): DictScope(dict()) fd = FrozenDict({'a': 2}) ds = DictScope(fd) self.assertIs(fd, ds._values) self.assertEqual(FrozenDict(), ds._volatile_parameters) vp = frozenset('a') ds = DictScope(fd, vp) self.assertIs(fd, ds._values) self.assertEqual(FrozenDict(a=ExpressionScalar('a')), ds._volatile_parameters)
def test_internal_create_program_parameter_missing(self) -> None: sub1 = DummyPulseTemplate(duration=3, waveform=DummyWaveform(duration=3), measurements=[('b', 1, 2)]) sub2 = DummyPulseTemplate(duration='d', waveform=DummyWaveform(duration=2), parameter_names={'foo'}) seq = SequencePulseTemplate(sub1, sub2, measurements=[('a', 'bar', 1)], parameter_constraints={'foo < 2'}) loop = Loop() # test parameter from constraints scope = DictScope.from_kwargs() with self.assertRaises(ParameterNotProvidedException): seq._internal_create_program(scope=scope, measurement_mapping={ 'a': 'a', 'b': 'b' }, channel_mapping=dict(), global_transformation=None, to_single_waveform=set(), parent_loop=loop) # test parameter from measurements scope = DictScope.from_mapping({'foo': 1}) with self.assertRaises(ParameterNotProvidedException): seq._internal_create_program(scope=scope, measurement_mapping={ 'a': 'a', 'b': 'b' }, channel_mapping=dict(), global_transformation=None, to_single_waveform=set(), parent_loop=loop) # test parameter from duration scope = DictScope.from_mapping({'foo': 1, 'bar': 0}) with self.assertRaises(ParameterNotProvidedException): seq._internal_create_program(scope=scope, measurement_mapping={ 'a': 'a', 'b': 'b' }, channel_mapping=dict(), global_transformation=None, to_single_waveform=set(), parent_loop=loop)
def test_internal_create_program(self): lhs = 'x + y' rhs = DummyPulseTemplate(defined_channels={'u', 'v', 'w'}) arith = ArithmeticPulseTemplate(lhs, '-', rhs) scope = DictScope.from_kwargs(x=3, y=5, z=8, volatile={'some_parameter'}) channel_mapping = dict(u='a', v='b', w=None) measurement_mapping = dict(m1='m2') global_transformation = OffsetTransformation({'unrelated': 1.}) to_single_waveform = {'something_else'} parent_loop = mock.Mock() expected_transformation = mock.Mock(spec=IdentityTransformation()) inner_trafo = mock.Mock(spec=IdentityTransformation()) inner_trafo.chain.return_value = expected_transformation with mock.patch.object(rhs, '_create_program') as inner_create_program: with mock.patch.object( arith, '_get_transformation', return_value=inner_trafo) as get_transformation: arith._internal_create_program( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=global_transformation, to_single_waveform=to_single_waveform, parent_loop=parent_loop) get_transformation.assert_called_once_with( parameters=scope, channel_mapping=channel_mapping) inner_trafo.chain.assert_called_once_with(global_transformation) inner_create_program.assert_called_once_with( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=expected_transformation, to_single_waveform=to_single_waveform, parent_loop=parent_loop) with self.assertRaisesRegex(NotImplementedError, 'volatile'): arith._internal_create_program( scope=DictScope.from_kwargs(x=3, y=5, z=8, volatile={'x'}), measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=global_transformation, to_single_waveform=to_single_waveform, parent_loop=parent_loop)
def test_create_program_constraint_on_loop_var_exception(self): """This test is to assure the status-quo behavior of ForLoopPT handling parameter constraints affecting the loop index variable. Please see https://github.com/qutech/qupulse/issues/232 .""" with self.assertWarnsRegex(UserWarning, "constraint on a variable shadowing the loop index", msg="ForLoopPT did not issue a warning when constraining the loop index"): flt = ForLoopPulseTemplate(body=DummyPulseTemplate(parameter_names={'k', 'i'}), loop_index='i', loop_range=('a', 'b', 'c',), parameter_constraints=['k<=f', 'k>i']) # loop index showing up in parameter_names because it appears in consraints self.assertEqual(flt.parameter_names, {'f', 'k', 'a', 'b', 'c', 'i'}) scope = DictScope.from_kwargs(k=1, a=0, b=2, c=1, f=2) # loop index not accessible in current build_sequence -> Exception children = [Loop(waveform=DummyWaveform(duration=2.0))] program = Loop(children=children) with self.assertRaises(ParameterNotProvidedException): flt._internal_create_program(scope=scope, measurement_mapping=dict(), channel_mapping=dict(), parent_loop=program, to_single_waveform=set(), global_transformation=None) self.assertEqual(children, list(program.children)) self.assertEqual(1, program.repetition_count) self.assertIsNone(program._measurements) self.assert_measurement_windows_equal({}, program.get_measurement_windows())
def test_internal_create_program(self): template = DummyPulseTemplate(duration='t1', defined_channels={'X', 'Y'}, parameter_names={'a', 'b'}, measurement_names={'M'}, waveform=DummyWaveform()) overwritten_channels = {'Y': 'c', 'Z': 'a'} parent_loop = object() measurement_mapping = object() channel_mapping = object() to_single_waveform = object() other_kwargs = dict(measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, to_single_waveform=to_single_waveform, parent_loop=parent_loop) pccpt = ParallelConstantChannelPulseTemplate(template, overwritten_channels) scope = DictScope.from_kwargs(c=1.2, a=3.4) kwargs = {**other_kwargs, 'scope': scope, 'global_transformation': None} expected_overwritten_channels = {'Y': 1.2, 'Z': 3.4} expected_transformation = ParallelConstantChannelTransformation(expected_overwritten_channels) expected_kwargs = {**kwargs, 'global_transformation': expected_transformation} with mock.patch.object(template, '_create_program', spec=template._create_program) as cp_mock: pccpt._internal_create_program(**kwargs) cp_mock.assert_called_once_with(**expected_kwargs) global_transformation = LinearTransformation(numpy.zeros((0, 0)), [], []) expected_transformation = chain_transformations(global_transformation, expected_transformation) kwargs = {**other_kwargs, 'scope': scope, 'global_transformation': global_transformation} expected_kwargs = {**kwargs, 'global_transformation': expected_transformation} with mock.patch.object(template, '_create_program', spec=template._create_program) as cp_mock: pccpt._internal_create_program(**kwargs) cp_mock.assert_called_once_with(**expected_kwargs)
def test_body_scope_generator(self): dt = DummyPulseTemplate(parameter_names={'i', 'k'}) flt = ForLoopPulseTemplate(body=dt, loop_index='i', loop_range=('a', 'b', 'c')) expected_range = range(2, 17, 3) outer_scope = DictScope.from_kwargs(k=5, a=expected_range.start, b=expected_range.stop, c=expected_range.step, volatile={'i', 'j'}) forward_scopes = list( flt._body_scope_generator(outer_scope, forward=True)) backward_scopes = list( flt._body_scope_generator(outer_scope, forward=False)) volatile_dict = FrozenDict(j=ExpressionScalar('j')) self.assertEqual(forward_scopes, list(reversed(backward_scopes))) for scope, i in zip(forward_scopes, expected_range): self.assertEqual(volatile_dict, scope.get_volatile_parameters()) expected_dict_equivalent = dict(k=5, i=i, a=expected_range.start, b=expected_range.stop, c=expected_range.step) self.assertEqual(expected_dict_equivalent, dict(scope.items()))
def test_create_program_invalid_measurement_mapping(self) -> None: dt = DummyPulseTemplate(parameter_names={'i'}, waveform=DummyWaveform(duration=4.0), duration=4, measurements=[('b', 2, 1)]) flt = ForLoopPulseTemplate(body=dt, loop_index='i', loop_range=('a', 'b', 'c'), measurements=[('A', 0, 1)], parameter_constraints=['c > 1']) invalid_scope = DictScope.from_kwargs(a=1, b=4, c=2) measurement_mapping = dict() channel_mapping = dict(C='D') children = [Loop(waveform=DummyWaveform(duration=2.0))] program = Loop(children=children) with self.assertRaises(KeyError): flt._internal_create_program(scope=invalid_scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, parent_loop=program, to_single_waveform=set(), global_transformation=None) self.assertEqual(children, list(program.children)) self.assertEqual(1, program.repetition_count) self.assertIsNone(program._measurements) self.assert_measurement_windows_equal({}, program.get_measurement_windows()) # test for broken mapping on child level. no guarantee that parent_loop is not changed, only check for exception measurement_mapping = dict(A='B') with self.assertRaises(KeyError): flt._internal_create_program(scope=invalid_scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, parent_loop=program, to_single_waveform=set(), global_transformation=None)
def test_create_program_append(self) -> None: dt = DummyPulseTemplate(parameter_names={'i'}, waveform=DummyWaveform(duration=4.0), duration=4, measurements=[('b', 2, 1)]) flt = ForLoopPulseTemplate(body=dt, loop_index='i', loop_range=('a', 'b', 'c'), measurements=[('A', 0, 1)], parameter_constraints=['c > 1']) scope = DictScope.from_kwargs(a=1, b=4, c=2, volatile={'inner'}) measurement_mapping = dict(A='B', b='b') channel_mapping = dict(C='D') children = [Loop(waveform=DummyWaveform(duration=2.0))] program = Loop(children=children) flt._internal_create_program(scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, parent_loop=program, to_single_waveform=set(), global_transformation=None) self.assertEqual(3, len(program.children)) self.assertIs(children[0], program.children[0]) self.assertEqual(dt.waveform, program.children[1].waveform) self.assertEqual(dt.waveform, program.children[2].waveform) self.assertEqual(1, program.children[1].repetition_count) self.assertEqual(1, program.children[2].repetition_count) self.assertEqual(1, program.repetition_count) self.assert_measurement_windows_equal({'b': ([4, 8], [1, 1]), 'B': ([2], [1])}, program.get_measurement_windows())
def test_create_program_parameter_constraint_violation(self) -> None: measurement_mapping = {'meas1': 'meas2'} parameter_mapping = {'t': 'k'} channel_mapping = {'B': 'default'} template = DummyPulseTemplate(measurements=[('meas1', 0, 1)], measurement_names={'meas1'}, defined_channels={'B'}, waveform=DummyWaveform(duration=2.0), duration=2, parameter_names={'t'}) st = MappingPulseTemplate(template, parameter_mapping=parameter_mapping, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, parameter_constraints={'k > 6'}) pre_scope = DictScope.from_kwargs(k=5) pre_measurement_mapping = {'meas2': 'meas3'} pre_channel_mapping = {'default': 'A'} program = Loop() with self.assertRaises(ParameterConstraintViolation): st._internal_create_program(scope=pre_scope, measurement_mapping=pre_measurement_mapping, channel_mapping=pre_channel_mapping, to_single_waveform=set(), global_transformation=None, parent_loop=program)
def test_create_program_declaration_success(self) -> None: repetitions = "foo" body = DummyPulseTemplate(duration=2.0, waveform=DummyWaveform( duration=2, defined_channels={'A'})) t = RepetitionPulseTemplate(body, repetitions, parameter_constraints=['foo<9']) scope = DictScope.from_kwargs(foo=3) measurement_mapping = dict(moth='fire') channel_mapping = dict(asd='f') program = Loop() t._internal_create_program(scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, to_single_waveform=set(), global_transformation=None, parent_loop=program) self.assertEqual(1, program.repetition_count) self.assertEqual(1, len(program.children)) internal_loop = program.children[0] # type: Loop self.assertEqual(scope[repetitions], internal_loop.repetition_count) self.assertEqual(1, len(internal_loop)) self.assertEqual( (scope, measurement_mapping, channel_mapping, internal_loop), body.create_program_calls[-1]) self.assertEqual(body.waveform, internal_loop[0].waveform) self.assert_measurement_windows_equal( {}, program.get_measurement_windows())
def test_create_program_declaration_parameter_value_not_whole( self) -> None: repetitions = "foo" body = DummyPulseTemplate(duration=2.0, waveform=DummyWaveform(duration=2.0)) t = RepetitionPulseTemplate(body, repetitions, parameter_constraints=['foo<9']) scope = DictScope.from_kwargs(foo=(3.3)) measurement_mapping = dict(moth='fire') channel_mapping = dict(asd='f') children = [Loop(waveform=DummyWaveform(duration=0))] program = Loop(children=children) with self.assertRaises(ParameterNotIntegerException): t._internal_create_program(scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, to_single_waveform=set(), global_transformation=None, parent_loop=program) self.assertFalse(body.create_program_calls) self.assertEqual(1, program.repetition_count) self.assertEqual(children, list(program.children)) self.assertIsNone(program.waveform) self.assert_measurement_windows_equal( {}, program.get_measurement_windows())
def test_create_program_rep_count_neg_declaration_with_measurements( self) -> None: repetitions = "foo" body_program = Loop(waveform=DummyWaveform(duration=1.0)) body = DummyPulseTemplate(duration=2.0, program=body_program) # suppress warning about 0 repetitions on construction here, we are only interested in correct behavior during sequencing (i.e., do nothing) with warnings.catch_warnings(record=True): t = RepetitionPulseTemplate(body, repetitions, measurements=[('moth', 0, 'meas_end')]) scope = DictScope.from_kwargs(foo=-1, meas_end=7.1) measurement_mapping = dict(moth='fire') channel_mapping = dict(asd='f') program = Loop() t._internal_create_program(scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, to_single_waveform=set(), global_transformation=None, parent_loop=program) self.assertFalse(body.create_program_calls) self.assertFalse(program.children) self.assertEqual(1, program.repetition_count) self.assertEqual(None, program._measurements)
def test_mapping(self): ds = DictScope.from_kwargs(a=1, b=2, c=3) ms = MappedScope(ds, FrozenDict(x=ExpressionScalar('a * b'), c=ExpressionScalar('a - b'))) self.assertEqual(4, len(ms)) self.assertEqual(set('abcx'), set(ms.keys())) self.assertEqual([-1, 1, 2, 2], sorted(ms.values())) self.assertEqual({('a', 1), ('b', 2), ('c', -1), ('x', 2)}, set(ms.items())) self.assertEqual(set(ms), set(ms.keys())) self.assertIn('a', ms) self.assertIn('c', ms) self.assertIn('x', ms) self.assertNotIn('d', ms) self.assertEqual(-1, ms['c']) self.assertEqual(1, ms['a']) self.assertEqual(2, ms['x']) with self.assertRaises(TypeError): ms['d'] = 9 with self.assertRaisesRegex(KeyError, 'd'): _ = ms['d']
def test_create_program_body_none(self) -> None: dt = DummyPulseTemplate(parameter_names={'i'}, waveform=None, duration=0, measurements=[('b', 2, 1)]) flt = ForLoopPulseTemplate(body=dt, loop_index='i', loop_range=('a', 'b', 'c'), measurements=[('A', 0, 1)], parameter_constraints=['c > 1']) scope = DictScope.from_kwargs(a=1, b=4, c=2) measurement_mapping = dict(A='B', b='b') channel_mapping = dict(C='D') program = Loop() flt._internal_create_program(scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, parent_loop=program, to_single_waveform=set(), global_transformation=None) self.assertEqual(0, len(program.children)) self.assertEqual(1, program.repetition_count) self.assertEqual([], list(program.children))
def test_eq(self): ds1 = DictScope.from_kwargs(a=1, b=2, c=3, d=4) ds2 = DictScope.from_kwargs(a=1, b=2, c=3, d=5) mapping1 = FrozenDict(x=ExpressionScalar('a * b'), c=ExpressionScalar('a - b'), y=ExpressionScalar('c - a')) mapping2 = FrozenDict(x=ExpressionScalar('a * b'), c=ExpressionScalar('a - b'), y=ExpressionScalar('d - a')) self.assertEqual(MappedScope(ds1, mapping1), MappedScope(ds1, mapping1)) self.assertNotEqual(MappedScope(ds1, mapping1), MappedScope(ds1, mapping2)) self.assertNotEqual(MappedScope(ds2, mapping1), MappedScope(ds1, mapping1)) self.assertEqual(MappedScope(ds1, mapping2), MappedScope(ds1, mapping2))
def test_internal_create_program_no_waveform(self) -> None: measurement_windows = [('M', 0, 5)] template = AtomicPulseTemplateStub(measurements=measurement_windows, parameter_names={'foo'}) scope = DictScope.from_kwargs(foo=3.5, bar=3, volatile={'bar'}) measurement_mapping = {'M': 'N'} channel_mapping = {'B': 'A'} program = Loop() expected_program = Loop() with mock.patch.object(template, 'build_waveform', return_value=None) as build_waveform: with mock.patch.object(template, 'get_measurement_windows', wraps=template.get_measurement_windows ) as get_meas_windows: template._internal_create_program( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, parent_loop=program, to_single_waveform=set(), global_transformation=None) build_waveform.assert_called_once_with( parameters=scope, channel_mapping=channel_mapping) get_meas_windows.assert_not_called() self.assertEqual(expected_program, program)
def test_create_program_defaults(self) -> None: template = PulseTemplateStub(defined_channels={'A', 'B'}, parameter_names={'foo'}, measurement_names={'hugo', 'foo'}) expected_internal_kwargs = dict(scope=DictScope.from_kwargs(), measurement_mapping={ 'hugo': 'hugo', 'foo': 'foo' }, channel_mapping={ 'A': 'A', 'B': 'B' }, global_transformation=None, to_single_waveform=set()) dummy_waveform = DummyWaveform() expected_program = Loop(children=[Loop(waveform=dummy_waveform)]) with mock.patch.object(template, '_internal_create_program', wraps=get_appending_internal_create_program( dummy_waveform, True)) as _internal_create_program: program = template.create_program() _internal_create_program.assert_called_once_with( **expected_internal_kwargs, parent_loop=program) self.assertEqual(expected_program, program)
def test_internal_create_program(self) -> None: measurement_windows = [('M', 0, 5)] single_wf = DummyWaveform(duration=6, defined_channels={'A'}) wf = MultiChannelWaveform([single_wf]) template = AtomicPulseTemplateStub(measurements=measurement_windows, parameter_names={'foo'}) scope = DictScope.from_kwargs(foo=7.2, volatile={'gutes_zeuch'}) measurement_mapping = {'M': 'N'} channel_mapping = {'B': 'A'} program = Loop() expected_program = Loop(children=[Loop(waveform=wf)], measurements=[('N', 0, 5)]) with mock.patch.object(template, 'build_waveform', return_value=wf) as build_waveform: template._internal_create_program( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, parent_loop=program, to_single_waveform=set(), global_transformation=None) build_waveform.assert_called_once_with( parameters=scope, channel_mapping=channel_mapping) self.assertEqual(expected_program, program) # MultiChannelProgram calls cleanup program.cleanup()
def test_create_program_none(self) -> None: template = PulseTemplateStub(defined_channels={'A'}, parameter_names={'foo'}) parameters = { 'foo': ConstantParameter(2.126), 'bar': -26.2, 'hugo': 'exp(sin(pi/2))' } measurement_mapping = {'M': 'N'} channel_mapping = {'A': 'B'} volatile = {'hugo'} scope = DictScope.from_kwargs(foo=2.126, bar=-26.2, hugo=math.exp(math.sin(math.pi / 2)), volatile=volatile) expected_internal_kwargs = dict( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=None, to_single_waveform=set()) with mock.patch.object( template, '_internal_create_program') as _internal_create_program: program = template.create_program( parameters=parameters, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, volatile=volatile) _internal_create_program.assert_called_once_with( **expected_internal_kwargs, parent_loop=Loop()) self.assertIsNone(program)
def test_internal_create_program_both_children_no_duration(self) -> None: sub1 = DummyPulseTemplate(duration=0, waveform=None, measurements=[('b', 1, 2)], defined_channels={'A'}) sub2 = DummyPulseTemplate(duration=0, waveform=None, parameter_names={'foo'}, defined_channels={'A'}) scope = DictScope.from_kwargs() measurement_mapping = {'a': 'a', 'b': 'b'} channel_mapping = dict() seq = SequencePulseTemplate(sub1, sub2, measurements=[('a', 0, 1)]) loop = Loop(measurements=None) seq._internal_create_program(scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=None, to_single_waveform=set(), parent_loop=loop) self.assertEqual(1, loop.repetition_count) self.assertIsNone(loop.waveform) self.assertEqual([], list(loop.children)) self.assertIsNone(loop._measurements)
def test_internal_create_program(self): wf = DummyWaveform(duration=2.) body = PulseTemplateStub() rpt = RepetitionPulseTemplate(body, 'n_rep*mul', measurements=[('m', 'a', 'b')]) scope = DictScope.from_kwargs(n_rep=3, mul=2, a=.1, b=.2, irrelevant=42) measurement_mapping = {'m': 'l'} channel_mapping = {'x': 'Y'} global_transformation = TransformationStub() to_single_waveform = {'to', 'single', 'waveform'} program = Loop() expected_program = Loop( children=[Loop(children=[Loop(waveform=wf)], repetition_count=6)], measurements=[('l', .1, .2)]) real_relevant_parameters = dict(n_rep=3, mul=2, a=0.1, b=0.2) with mock.patch.object(body, '_create_program', wraps=get_appending_internal_create_program( wf, always_append=True)) as body_create_program: with mock.patch.object(rpt, 'validate_scope') as validate_scope: with mock.patch.object( rpt, 'get_repetition_count_value', return_value=6) as get_repetition_count_value: with mock.patch.object(rpt, 'get_measurement_windows', return_value=[('l', .1, .2) ]) as get_meas: rpt._internal_create_program( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=global_transformation, to_single_waveform=to_single_waveform, parent_loop=program) self.assertEqual(program, expected_program) body_create_program.assert_called_once_with( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=global_transformation, to_single_waveform=to_single_waveform, parent_loop=program.children[0]) validate_scope.assert_called_once_with(scope) get_repetition_count_value.assert_called_once_with( scope) get_meas.assert_called_once_with( scope, measurement_mapping)
def test_volatile_parameters(self): ds = DictScope.from_kwargs(a=1, b=2, c=3, d=4, volatile={'c', 'd'}) ms = MappedScope(ds, FrozenDict(x=ExpressionScalar('a * b'), c=ExpressionScalar('a - b'), y=ExpressionScalar('c - a'))) expected_volatile = FrozenDict(d=ExpressionScalar('d'), y=ExpressionScalar('c - 1')) self.assertEqual(expected_volatile, ms.get_volatile_parameters()) self.assertIs(ms.get_volatile_parameters(), ms.get_volatile_parameters())
def test_eq(self): ds = DictScope(FrozenDict({'a': 1, 'b': 2}), volatile=frozenset('a')) ds1 = DictScope(FrozenDict({'a': 1, 'b': 2}), volatile=frozenset()) ds2 = DictScope(FrozenDict({'a': 1, 'b': 2}), volatile=frozenset('a')) ds3 = DictScope(FrozenDict({'a': 1, 'b': 2}), volatile=frozenset('ab')) ds4 = DictScope(FrozenDict({'a': 1, 'b': 2, 'c': 3}), volatile=frozenset('a')) self.assertNotEqual(ds, ds1) self.assertNotEqual(ds, ds3) self.assertNotEqual(ds, ds4) self.assertEqual(ds, ds2) self.assertEqual(hash(ds), hash(ds2)) self.assertNotEqual(ds1, ds2) self.assertNotEqual(ds2, ds3) self.assertNotEqual(ds3, ds4)
def test_mapping(self): ds = DictScope(FrozenDict({'a': 1, 'b': 2})) self.assertIn('a', ds) self.assertNotIn('c', ds) self.assertEqual(set('ab'), set(ds.keys())) self.assertEqual(set('ab'), set(ds)) self.assertEqual({1, 2}, set(ds.values())) self.assertEqual({('a', 1), ('b', 2)}, set(ds.items())) self.assertEqual({'a': 1, 'b': 2}, dict(ds)) self.assertEqual(1, ds['a']) with self.assertRaises(KeyError): ds['c'] with self.assertRaises(TypeError): ds['a'] = 3