def get_two_chan_test_block(wfg=WaveformGenerator(2)): generate_waveform = wfg.generate_single_channel_waveform generate_multi_channel_waveform = wfg.generate_multi_channel_waveform loop_block11 = InstructionBlock() loop_block11.add_instruction_exec(generate_multi_channel_waveform()) loop_block1 = InstructionBlock() loop_block1.add_instruction_repj(5, ImmutableInstructionBlock(loop_block11)) loop_block21 = InstructionBlock() loop_block21.add_instruction_exec(generate_multi_channel_waveform()) loop_block21.add_instruction_exec(generate_multi_channel_waveform()) loop_block2 = InstructionBlock() loop_block2.add_instruction_repj(2, ImmutableInstructionBlock(loop_block21)) loop_block2.add_instruction_exec(generate_multi_channel_waveform()) loop_block3 = InstructionBlock() loop_block3.add_instruction_exec(generate_multi_channel_waveform()) loop_block3.add_instruction_exec(generate_multi_channel_waveform()) loop_block411 = InstructionBlock() loop_block411.add_instruction_exec(MultiChannelWaveform([generate_waveform('A')])) loop_block412 = InstructionBlock() loop_block412.add_instruction_exec(MultiChannelWaveform([generate_waveform('A')])) loop_block41 = InstructionBlock() loop_block41.add_instruction_repj(7, ImmutableInstructionBlock(loop_block411)) loop_block41.add_instruction_repj(8, ImmutableInstructionBlock(loop_block412)) loop_block421 = InstructionBlock() loop_block421.add_instruction_exec(MultiChannelWaveform([generate_waveform('B')])) loop_block422 = InstructionBlock() loop_block422.add_instruction_exec(MultiChannelWaveform([generate_waveform('B')])) loop_block42 = InstructionBlock() loop_block42.add_instruction_repj(10, ImmutableInstructionBlock(loop_block421)) loop_block42.add_instruction_repj(11, ImmutableInstructionBlock(loop_block422)) chan_block4A = InstructionBlock() chan_block4A.add_instruction_repj(6, ImmutableInstructionBlock(loop_block41)) chan_block4B = InstructionBlock() chan_block4B.add_instruction_repj(9, ImmutableInstructionBlock(loop_block42)) loop_block4 = InstructionBlock() loop_block4.add_instruction_chan({frozenset('A'): ImmutableInstructionBlock(chan_block4A), frozenset('B'): ImmutableInstructionBlock(chan_block4B)}) root_block = InstructionBlock() root_block.add_instruction_exec(generate_multi_channel_waveform()) root_block.add_instruction_repj(10, ImmutableInstructionBlock(loop_block1)) root_block.add_instruction_repj(17, ImmutableInstructionBlock(loop_block2)) root_block.add_instruction_repj(3, ImmutableInstructionBlock(loop_block3)) root_block.add_instruction_repj(4, ImmutableInstructionBlock(loop_block4)) return root_block
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 build_waveform( self, parameters: Dict[str, numbers.Real], channel_mapping: Dict[ChannelID, Optional[ChannelID]] ) -> Optional[Union[TableWaveform, MultiChannelWaveform]]: self.validate_parameter_constraints(parameters, volatile=set()) if all(channel_mapping[channel] is None for channel in self.defined_channels): return None instantiated = [(channel_mapping[channel], instantiated_channel) for channel, instantiated_channel in self.get_entries_instantiated(parameters).items() if channel_mapping[channel] is not None] if self.duration.evaluate_numeric(**parameters) == 0: return None waveforms = [ TableWaveform(*ch_instantiated) for ch_instantiated in instantiated ] if len(waveforms) == 1: return waveforms.pop() else: return MultiChannelWaveform(waveforms)
def build_waveform(self, parameters: Dict[str, Real], channel_mapping: Dict[ChannelID, Optional[ChannelID]]) -> Optional[Union[TableWaveform, MultiChannelWaveform]]: self.validate_parameter_constraints(parameters=parameters, volatile=set()) if all(channel_mapping[channel] is None for channel in self.defined_channels): return None if self.duration.evaluate_numeric(**parameters) == 0: return None mapped_channels = tuple(channel_mapping[c] for c in self._channels) waveform_entries = list([] for _ in range(len(self._channels))) for entry in self._entries: instantiated_entries = entry.instantiate(parameters, len(self._channels)) for ch_entries, wf_entry in zip(waveform_entries, instantiated_entries): ch_entries.append(wf_entry) if waveform_entries[0][0].t > 0: for ch_entries in waveform_entries: ch_entries[:0] = [PointWaveformEntry(0, ch_entries[0].v, ch_entries[0].interp)] # filter mappings to None channel_entries = [(ch, ch_entries) for (ch, ch_entries) in zip(mapped_channels, waveform_entries) if ch is not None] mapped_channels, waveform_entries = zip(*channel_entries) waveforms = [PointWaveform.from_table(mapped_channel, ch_entries) for mapped_channel, ch_entries in zip(mapped_channels, waveform_entries)] return MultiChannelWaveform.from_parallel(waveforms)
def test_build_sequence(self): wfs = [ DummyWaveform(duration=1.1, defined_channels={'A'}), DummyWaveform(duration=1.1, defined_channels={'B'}) ] sts = [ DummyPulseTemplate(duration='t1', defined_channels={'A'}, waveform=wfs[0], measurements=[('m', 0, 1)]), DummyPulseTemplate(duration='t1', defined_channels={'B'}, waveform=wfs[1]), DummyPulseTemplate(duration='t1', defined_channels={'C'}, waveform=None) ] pt = AtomicMultiChannelPulseTemplate(*sts, parameter_constraints=['a < b'], measurements=[('n', .1, .2)]) params = dict(a=ConstantParameter(1.0), b=ConstantParameter(1.1)) measurement_mapping = dict(m='foo', n='bar') channel_mapping = {'A': 'A', 'B': 'B', 'C': None} block = InstructionBlock() pt.build_sequence(None, parameters=params, conditions={}, measurement_mapping=measurement_mapping, channel_mapping=channel_mapping, instruction_block=block) expected_waveform = MultiChannelWaveform(wfs) expected_block = InstructionBlock() measurements = [('bar', .1, .2), ('foo', 0, 1)] expected_block.add_instruction_meas(measurements) expected_block.add_instruction_exec(waveform=expected_waveform) self.assertEqual(len(block.instructions), len(expected_block.instructions)) self.assertEqual(block.instructions[0].compare_key, expected_block.instructions[0].compare_key) self.assertEqual(block.instructions[1].compare_key, expected_block.instructions[1].compare_key)
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'}) parameters = {'foo': ConstantParameter(7.2)} measurement_mapping = {'M': 'N'} channel_mapping = {'B': 'A'} program = Loop() expected_parameters = {k: p.get_value() for k, p in parameters.items()} 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( parameters=parameters, 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=expected_parameters, channel_mapping=channel_mapping) self.assertEqual(expected_program, program) # ensure same result as from Sequencer sequencer = Sequencer() sequencer.push(template, parameters=parameters, conditions={}, window_mapping=measurement_mapping, channel_mapping=channel_mapping) with mock.patch.object(template, 'build_waveform', return_value=wf): block = sequencer.build() old_program = MultiChannelProgram(block, channels={'A'}) self.assertEqual(old_program.programs[frozenset({'A'})], program)
def build_waveform( self, parameters: Dict[str, numbers.Real], channel_mapping: Dict[ChannelID, Optional[ChannelID]] ) -> Optional[Union[ConstantWaveform, MultiChannelWaveform]]: logging.debug( f'build_waveform of ConstantPulse: channel_mapping {channel_mapping}, defined_channels {self.defined_channels} ' ) if all( channel_mapping.get(channel, None) is None for channel in self.defined_channels): return None waveforms = [ ConstantWaveform(self.duration, amplitude, channel) for channel, amplitude in self._amplitude_dict.items() if channel_mapping[channel] is not None ] if len(waveforms) == 1: return waveforms.pop() else: return MultiChannelWaveform(waveforms)
def test_build_sequence(self) -> None: measurement_windows = [('M', 0, 5)] single_wf = DummyWaveform(duration=6, defined_channels={'A'}) wf = MultiChannelWaveform([single_wf]) sequencer = DummySequencer() block = DummyInstructionBlock() parameters = { 'a': ConstantParameter(1), 'b': ConstantParameter(2), 'c': ConstantParameter(3) } expected_parameters = {'a': 1, 'b': 2} channel_mapping = {'B': 'A'} template = AtomicPulseTemplateStub(measurements=measurement_windows, parameter_names={'a', 'b'}) with mock.patch.object(template, 'build_waveform', return_value=wf) as build_waveform: template.build_sequence(sequencer, parameters=parameters, conditions={}, measurement_mapping={'M': 'N'}, channel_mapping=channel_mapping, instruction_block=block) build_waveform.assert_called_once_with( parameters=expected_parameters, channel_mapping=channel_mapping) self.assertEqual(len(block.instructions), 2) meas, exec = block.instructions self.assertIsInstance(meas, MEASInstruction) self.assertEqual(meas.measurements, [('N', 0, 5)]) self.assertIsInstance(exec, EXECInstruction) self.assertEqual(exec.waveform.defined_channels, {'A'})
def generate_multi_channel_waveform(self): return MultiChannelWaveform([self.generate_single_channel_waveform(self.channel_names[ch_i]) for ch_i in range(self.num_channels)])
def generate_multi_channel_waveform(): return MultiChannelWaveform( [generate_waveform('A'), generate_waveform('B')])
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) wf = DummyWaveform() self.descriptionA = \ """\ LOOP 1 times: ->EXEC {} 1 times ->EXEC {} 50 times ->LOOP 17 times: ->LOOP 2 times: ->EXEC {} 1 times ->EXEC {} 1 times ->EXEC {} 1 times ->LOOP 3 times: ->EXEC {} 1 times ->EXEC {} 1 times ->LOOP 24 times: ->EXEC {} 7 times ->EXEC {} 8 times""" self.descriptionB = \ """\ LOOP 1 times: ->EXEC {} 1 times ->EXEC {} 50 times ->LOOP 17 times: ->LOOP 2 times: ->EXEC {} 1 times ->EXEC {} 1 times ->EXEC {} 1 times ->LOOP 3 times: ->EXEC {} 1 times ->EXEC {} 1 times ->LOOP 36 times: ->EXEC {} 10 times ->EXEC {} 11 times""" def generate_waveform(channel): return DummyWaveform(sample_output=None, duration=1., defined_channels={channel}) def generate_multi_channel_waveform(): return MultiChannelWaveform( [generate_waveform('A'), generate_waveform('B')]) self.loop_block11 = InstructionBlock() self.loop_block11.add_instruction_exec( generate_multi_channel_waveform()) self.loop_block1 = InstructionBlock() self.loop_block1.add_instruction_repj( 5, ImmutableInstructionBlock(self.loop_block11)) self.loop_block21 = InstructionBlock() self.loop_block21.add_instruction_exec( generate_multi_channel_waveform()) self.loop_block21.add_instruction_exec( generate_multi_channel_waveform()) self.loop_block2 = InstructionBlock() self.loop_block2.add_instruction_repj( 2, ImmutableInstructionBlock(self.loop_block21)) self.loop_block2.add_instruction_exec( generate_multi_channel_waveform()) self.loop_block3 = InstructionBlock() self.loop_block3.add_instruction_exec( generate_multi_channel_waveform()) self.loop_block3.add_instruction_exec( generate_multi_channel_waveform()) self.loop_block411 = InstructionBlock() self.loop_block411.add_instruction_exec( MultiChannelWaveform([generate_waveform('A')])) self.loop_block412 = InstructionBlock() self.loop_block412.add_instruction_exec( MultiChannelWaveform([generate_waveform('A')])) self.loop_block41 = InstructionBlock() self.loop_block41.add_instruction_repj( 7, ImmutableInstructionBlock(self.loop_block411)) self.loop_block41.add_instruction_repj( 8, ImmutableInstructionBlock(self.loop_block412)) self.loop_block421 = InstructionBlock() self.loop_block421.add_instruction_exec( MultiChannelWaveform([generate_waveform('B')])) self.loop_block422 = InstructionBlock() self.loop_block422.add_instruction_exec( MultiChannelWaveform([generate_waveform('B')])) self.loop_block42 = InstructionBlock() self.loop_block42.add_instruction_repj( 10, ImmutableInstructionBlock(self.loop_block421)) self.loop_block42.add_instruction_repj( 11, ImmutableInstructionBlock(self.loop_block422)) self.chan_block4A = InstructionBlock() self.chan_block4A.add_instruction_repj( 6, ImmutableInstructionBlock(self.loop_block41)) self.chan_block4B = InstructionBlock() self.chan_block4B.add_instruction_repj( 9, ImmutableInstructionBlock(self.loop_block42)) self.loop_block4 = InstructionBlock() self.loop_block4.add_instruction_chan({ frozenset('A'): ImmutableInstructionBlock(self.chan_block4A), frozenset('B'): ImmutableInstructionBlock(self.chan_block4B) }) self.root_block = InstructionBlock() self.root_block.add_instruction_exec(generate_multi_channel_waveform()) self.root_block.add_instruction_repj( 10, ImmutableInstructionBlock(self.loop_block1)) self.root_block.add_instruction_repj( 17, ImmutableInstructionBlock(self.loop_block2)) self.root_block.add_instruction_repj( 3, ImmutableInstructionBlock(self.loop_block3)) self.root_block.add_instruction_repj( 4, ImmutableInstructionBlock(self.loop_block4)) self.maxDiff = None