Example #1
0
    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_scope = DictScope.from_kwargs(k=5)
        pre_measurement_mapping = {'meas2': 'meas3'}
        pre_channel_mapping = {'default': 'A'}

        program = Loop()
        expected_inner_args = dict(
            scope=st.map_scope(pre_scope),
            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(
                scope=pre_scope,
                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())
Example #2
0
    def test_create_program_subtemplate_none(self) -> None:
        measurement_mapping = {'meas1': 'meas2'}
        parameter_mapping = {'t': 'k'}
        channel_mapping = {'B': 'default'}
        volatile = {'t'}

        template = DummyPulseTemplate(measurements=[('meas1', 0, 1)],
                                      measurement_names={'meas1'},
                                      defined_channels={'B'},
                                      waveform=None,
                                      duration=0,
                                      parameter_names={'t'})
        st = MappingPulseTemplate(template,
                                  parameter_mapping=parameter_mapping,
                                  measurement_mapping=measurement_mapping,
                                  channel_mapping=channel_mapping)

        pre_scope = DictScope.from_kwargs(k=5, volatile=volatile)
        pre_measurement_mapping = {'meas2': 'meas3'}
        pre_channel_mapping = {'default': 'A'}

        program = Loop()
        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)

        self.assertEqual(1, len(template.create_program_calls))
        self.assertEqual(
            (st.map_scope(pre_scope),
             st.get_updated_measurement_mapping(pre_measurement_mapping),
             st.get_updated_channel_mapping(pre_channel_mapping), program),
            template.create_program_calls[-1])

        self.assertEqual(1, program.repetition_count)
        self.assertEqual(0, len(program.children))
        self.assertIsNone(program._measurements)