def test__create_program(self): parameters = {'a': ConstantParameter(.1), 'b': ConstantParameter(.2)} measurement_mapping = {'M': 'N'} channel_mapping = {'B': 'A'} global_transformation = TransformationStub() to_single_waveform = {'voll', 'toggo'} parent_loop = Loop() template = PulseTemplateStub() with mock.patch.object( template, '_internal_create_program') as _internal_create_program: template._create_program( parameters=parameters, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=global_transformation, to_single_waveform=to_single_waveform, parent_loop=parent_loop) _internal_create_program.assert_called_once_with( parameters=parameters, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=global_transformation, to_single_waveform=to_single_waveform, parent_loop=parent_loop) self.assertEqual(parent_loop, Loop())
def test_const_value(self): output_channels = {'c', 'd', 'e'} trafo = TransformationStub() inner_wf = WaveformStub() trafo_wf = TransformingWaveform(inner_wf, trafo) self.assertFalse(trafo_wf.is_constant()) self.assertIsNone(trafo_wf.constant_value_dict()) with mock.patch.object(trafo, 'is_constant_invariant', return_value=False) as is_constant_invariant: self.assertIsNone(trafo_wf.constant_value('A')) is_constant_invariant.assert_called_once_with() with mock.patch.object(trafo, 'is_constant_invariant', return_value=True): # all inputs constant inner_const_values = {'A': 1.1, 'B': 2.2} with mock.patch.object(trafo, 'get_input_channels', return_value=inner_const_values.keys()): with mock.patch.object(inner_wf, 'constant_value', side_effect=inner_const_values.values()) as constant_value: with mock.patch.object(TransformationStub, '__call__', return_value={'C': mock.sentinel}) as call: self.assertIs(trafo_wf.constant_value('C'), call.return_value['C']) call.assert_called_once_with(0., inner_const_values) self.assertEqual([mock.call(ch) for ch in inner_const_values], constant_value.call_args_list) inner_const_values['B'] = None with mock.patch.object(inner_wf, 'constant_value', side_effect=inner_const_values.values()) as constant_value: self.assertIsNone(trafo_wf.constant_value('C'))
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_create_program(self) -> None: template = PulseTemplateStub(defined_channels={'A'}, parameter_names={'foo'}) parameters = { 'foo': 2.126, 'bar': -26.2, 'hugo': 'exp(sin(pi/2))', 'append_a_child': '1' } previous_parameters = parameters.copy() measurement_mapping = {'M': 'N'} previos_measurement_mapping = measurement_mapping.copy() channel_mapping = {'A': 'B'} previous_channel_mapping = channel_mapping.copy() volatile = {'foo'} expected_scope = DictScope.from_kwargs(foo=2.126, bar=-26.2, hugo=math.exp( math.sin(math.pi / 2)), volatile=volatile, append_a_child=1) to_single_waveform = {'voll', 'toggo'} global_transformation = TransformationStub() expected_internal_kwargs = dict( scope=expected_scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=global_transformation, to_single_waveform=to_single_waveform) dummy_waveform = DummyWaveform() expected_program = Loop(children=[Loop(waveform=dummy_waveform)]) with mock.patch.object(template, '_create_program', wraps=get_appending_internal_create_program( dummy_waveform)) as _create_program: program = template.create_program( parameters=parameters, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, to_single_waveform=to_single_waveform, global_transformation=global_transformation, volatile=volatile) _create_program.assert_called_once_with(**expected_internal_kwargs, parent_loop=program) self.assertEqual(expected_program, program) self.assertEqual(previos_measurement_mapping, measurement_mapping) self.assertEqual(previous_channel_mapping, channel_mapping) self.assertEqual(previous_parameters, parameters)
def test_internal_create_program(self): sub_templates = PulseTemplateStub(defined_channels={'a'}, duration=ExpressionScalar('t1')),\ PulseTemplateStub(defined_channels={'a'}, duration=ExpressionScalar('t2')) wfs = DummyWaveform(duration=1), DummyWaveform(duration=2) spt = SequencePulseTemplate(*sub_templates, measurements=[('m', 'a', 'b')]) kwargs = dict(scope=DictScope.from_kwargs(t1=.4, t2=.5, a=.1, b=.2, irrelevant=42), measurement_mapping={'m': 'l'}, channel_mapping={'g': 'h'}, global_transformation=TransformationStub(), to_single_waveform={'to', 'single', 'waveform'}) program = Loop() expected_program = Loop( children=[Loop(waveform=wfs[0]), Loop(waveform=wfs[1])], measurements=[('l', .1, .2)]) with mock.patch.object(spt, 'validate_scope') as validate_scope: with mock.patch.object(spt, 'get_measurement_windows', return_value=[('l', .1, .2) ]) as get_measurement_windows: with mock.patch.object(sub_templates[0], '_create_program', wraps=get_appending_internal_create_program(wfs[0], True)) as create_0,\ mock.patch.object(sub_templates[1], '_create_program', wraps=get_appending_internal_create_program(wfs[1], True)) as create_1: spt._internal_create_program(**kwargs, parent_loop=program) self.assertEqual(expected_program, program) validate_scope.assert_called_once_with(kwargs['scope']) get_measurement_windows.assert_called_once_with( kwargs['scope'], kwargs['measurement_mapping']) create_0.assert_called_once_with(**kwargs, parent_loop=program) create_1.assert_called_once_with(**kwargs, parent_loop=program)
def test_create_program(self) -> None: measurement_mapping = {'meas1': 'meas2'} parameter_mapping = {'t': 'k'} channel_mapping = {'B': 'default'} global_transformation = TransformationStub() to_single_waveform = {'tom', 'jerry'} 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) pre_parameters = {'k': ConstantParameter(5)} pre_measurement_mapping = {'meas2': 'meas3'} pre_channel_mapping = {'default': 'A'} program = Loop() expected_inner_args = dict( parameters=st.map_parameters(pre_parameters), measurement_mapping=st.get_updated_measurement_mapping( pre_measurement_mapping), channel_mapping=st.get_updated_channel_mapping( pre_channel_mapping), to_single_waveform=to_single_waveform, global_transformation=global_transformation, parent_loop=program) with mock.patch.object(template, '_create_program') as inner_create_program: st._internal_create_program( parameters=pre_parameters, measurement_mapping=pre_measurement_mapping, channel_mapping=pre_channel_mapping, to_single_waveform=to_single_waveform, global_transformation=global_transformation, parent_loop=program) inner_create_program.assert_called_once_with(**expected_inner_args) # as we mock the inner function there shouldnt be any changes self.assertEqual(program, Loop())
def test_create_program(self) -> None: dt = DummyPulseTemplate(parameter_names={'i'}, waveform=DummyWaveform(duration=4.0, defined_channels={'A'}), duration=4, measurements=[('b', .2, .3)]) flt = ForLoopPulseTemplate(body=dt, loop_index='i', loop_range=('a', 'b', 'c'), measurements=[('A', 'meas_param', 1)], parameter_constraints=['c > 1']) scope = DictScope.from_kwargs(a=1, b=4, c=2, meas_param=.1, volatile={'inner'}) measurement_mapping = dict(A='B', b='b') channel_mapping = dict(C='D') to_single_waveform = {'tom', 'jerry'} global_transformation = TransformationStub() program = Loop() # inner _create_program does nothing expected_program = Loop(measurements=[('B', .1, 1)]) expected_create_program_kwargs = dict(measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=global_transformation, to_single_waveform=to_single_waveform, parent_loop=program) expected_create_program_calls = [mock.call(**expected_create_program_kwargs, scope=scope.overwrite(dict(i=i))) for i in (1, 3)] with mock.patch.object(flt, 'validate_scope') as validate_scope: with mock.patch.object(dt, '_create_program') as body_create_program: with mock.patch.object(flt, 'get_measurement_windows', wraps=flt.get_measurement_windows) as get_measurement_windows: flt._internal_create_program(scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, parent_loop=program, to_single_waveform=to_single_waveform, global_transformation=global_transformation) validate_scope.assert_called_once_with(scope=scope) get_measurement_windows.assert_called_once_with(scope, measurement_mapping) self.assertEqual(body_create_program.call_args_list, expected_create_program_calls) self.assertEqual(expected_program, program)
def test_create_program(self) -> None: template = PulseTemplateStub(defined_channels={'A'}, parameter_names={'foo'}) parameters = { 'foo': ConstantParameter(2.126), 'bar': -26.2, 'hugo': 'exp(sin(pi/2))', 'append_a_child': '1' } measurement_mapping = {'M': 'N'} channel_mapping = {'A': 'B'} expected_parameters = { 'foo': ConstantParameter(2.126), 'bar': ConstantParameter(-26.2), 'hugo': ConstantParameter('exp(sin(pi/2))'), 'append_a_child': ConstantParameter('1') } to_single_waveform = {'voll', 'toggo'} global_transformation = TransformationStub() expected_internal_kwargs = dict( parameters=expected_parameters, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=global_transformation, to_single_waveform=to_single_waveform) dummy_waveform = DummyWaveform() expected_program = Loop(children=[Loop(waveform=dummy_waveform)]) with mock.patch.object(template, '_create_program', wraps=get_appending_internal_create_program( dummy_waveform)) as _create_program: program = template.create_program( parameters=parameters, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, to_single_waveform=to_single_waveform, global_transformation=global_transformation) _create_program.assert_called_once_with(**expected_internal_kwargs, parent_loop=program) self.assertEqual(expected_program, program)
def test__create_program(self): scope = DictScope.from_kwargs(a=1., b=2., volatile={'c'}) measurement_mapping = {'M': 'N'} channel_mapping = {'B': 'A'} global_transformation = TransformationStub() to_single_waveform = {'voll', 'toggo'} parent_loop = Loop() template = PulseTemplateStub() with mock.patch.object( template, '_internal_create_program') as _internal_create_program: template._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) _internal_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=parent_loop) self.assertEqual(parent_loop, Loop()) with self.assertRaisesRegex(NotImplementedError, "volatile"): template._parameter_names = {'c'} template._create_program( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=global_transformation, to_single_waveform={template}, parent_loop=parent_loop)
def test_internal_create_program_transformation(self): inner_wf = DummyWaveform() template = AtomicPulseTemplateStub(parameter_names=set()) program = Loop() global_transformation = TransformationStub() scope = DictScope.from_kwargs() expected_program = Loop(children=[ Loop( waveform=TransformingWaveform(inner_wf, global_transformation)) ]) with mock.patch.object(template, 'build_waveform', return_value=inner_wf): template._internal_create_program( scope=scope, measurement_mapping={}, channel_mapping={}, parent_loop=program, to_single_waveform=set(), global_transformation=global_transformation) self.assertEqual(expected_program, program)
def test__create_program_single_waveform(self): template = PulseTemplateStub(identifier='pt_identifier', parameter_names={'alpha'}) for to_single_waveform in ({template}, {template.identifier}): for global_transformation in (None, TransformationStub()): scope = DictScope.from_kwargs(a=1., b=2., volatile={'a'}) measurement_mapping = {'M': 'N'} channel_mapping = {'B': 'A'} parent_loop = Loop() wf = DummyWaveform() single_waveform = DummyWaveform() measurements = [('m', 0, 1), ('n', 0.1, .9)] expected_inner_program = Loop(children=[Loop(waveform=wf)], measurements=measurements) appending_create_program = get_appending_internal_create_program( wf, measurements=measurements, always_append=True) if global_transformation: final_waveform = TransformingWaveform( single_waveform, global_transformation) else: final_waveform = single_waveform expected_program = Loop( children=[Loop(waveform=final_waveform)], measurements=measurements) with mock.patch.object(template, '_internal_create_program', wraps=appending_create_program ) as _internal_create_program: with mock.patch( 'qupulse.pulses.pulse_template.to_waveform', return_value=single_waveform) as to_waveform: template._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) _internal_create_program.assert_called_once_with( scope=scope, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=None, to_single_waveform=to_single_waveform, parent_loop=expected_inner_program) to_waveform.assert_called_once_with( expected_inner_program) expected_program._measurements = set( expected_program._measurements) parent_loop._measurements = set( parent_loop._measurements) self.assertEqual(expected_program, parent_loop)
def test_create_program(self) -> None: dt = DummyPulseTemplate(parameter_names={'i'}, waveform=DummyWaveform(duration=4.0, defined_channels={'A'}), duration=4, measurements=[('b', .2, .3)]) flt = ForLoopPulseTemplate(body=dt, loop_index='i', loop_range=('a', 'b', 'c'), measurements=[('A', 'meas_param', 1)], parameter_constraints=['c > 1']) parameters = { 'a': ConstantParameter(1), 'b': ConstantParameter(4), 'c': ConstantParameter(2), 'meas_param': ConstantParameter(.1) } measurement_mapping = dict(A='B', b='b') channel_mapping = dict(C='D') to_single_waveform = {'tom', 'jerry'} global_transformation = TransformationStub() expected_meas_params = {'meas_param': .1} program = Loop() # inner _create_program does nothing expected_program = Loop(measurements=[('B', .1, 1)]) expected_create_program_kwargs = dict( measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, global_transformation=global_transformation, to_single_waveform=to_single_waveform, parent_loop=program) expected_create_program_calls = [ mock.call(**expected_create_program_kwargs, parameters=dict(i=ConstantParameter(i))) for i in (1, 3) ] with mock.patch.object(flt, 'validate_parameter_constraints' ) as validate_parameter_constraints: with mock.patch.object(dt, '_create_program') as body_create_program: with mock.patch.object(flt, 'get_measurement_windows', wraps=flt.get_measurement_windows ) as get_measurement_windows: flt._internal_create_program( parameters=parameters, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, parent_loop=program, to_single_waveform=to_single_waveform, global_transformation=global_transformation) validate_parameter_constraints.assert_called_once_with( parameters=parameters) get_measurement_windows.assert_called_once_with( expected_meas_params, measurement_mapping) self.assertEqual(body_create_program.call_args_list, expected_create_program_calls) self.assertEqual(expected_program, program)