def __qupulse_template_to_array(sequence, sampling_rate): """ Renders a qupulse sequence as array with voltages. Args: sequence (dict): a waveform is a dictionary with "type" value given the used pulse library. The "wave" value should contain the actual wave-object. sampling_rate (float): The number of samples per second. Returns: voltages (np.array): The array with voltages generated from the template. """ sequencer = Sequencing() template = sequence['wave'] channels = template.defined_channels sequencer.push( template, dict(), channel_mapping={ch: ch for ch in channels}, window_mapping={w: w for w in template.measurement_names}) instructions = sequencer.build() if not sequencer.has_finished(): raise PlottingNotPossibleException(template) (_, voltages, _) = render(instructions, sampling_rate / Sequencer.__sec_to_ns) return np.array(voltages[next(iter(voltages))])
def test_build_path_o2_m2_i1_t_i1_t_m2_i0_i0_one_element_custom_block_one_element_main_block(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} elem_main = DummySequencingElement(False) sequencer.push(elem_main, ps, cs) target_block = InstructionBlock() elem_cstm = DummySequencingElement(False) sequencer.push(elem_cstm, ps, cs, target_block=target_block) sequence = sequencer.build() self.assertTrue(sequencer.has_finished()) self.assertIs(elem_main, sequence[0].elem) self.assertEqual(ps, elem_main.parameters) self.assertEqual(cs, elem_main.conditions) self.assertEqual(1, elem_main.requires_stop_call_counter) self.assertEqual(1, elem_main.build_call_counter) self.assertIs(target_block, elem_cstm.target_block) self.assertEqual(ps, elem_cstm.parameters) self.assertEqual(cs, elem_cstm.conditions) self.assertEqual(1, elem_cstm.requires_stop_call_counter) self.assertEqual(1, elem_cstm.build_call_counter) self.assertEqual(STOPInstruction(), sequence[1]) self.assertEqual(2, len(sequence))
def test_build_path_o1_m2_i1_f_i1_f_one_element_custom_and_main_block_requires_stop(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} wm = {} cm = {} elem_main = DummySequencingElement(True) sequencer.push(elem_main, ps, cs, channel_mapping=cm) elem_cstm = DummySequencingElement(True) target_block = InstructionBlock() sequencer.push(elem_cstm, ps, cs, window_mapping=wm, channel_mapping=cm, target_block=target_block) sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertEqual(ps, elem_main.parameters) self.assertEqual(cs, elem_main.conditions) self.assertEqual(1, elem_main.requires_stop_call_counter) self.assertEqual(0, elem_main.build_call_counter) self.assertEqual(ps, elem_cstm.parameters) self.assertEqual(cs, elem_cstm.conditions) self.assertEqual(1, elem_cstm.requires_stop_call_counter) self.assertEqual(0, elem_cstm.build_call_counter)
def test_build_path_o2_m2_i1_f_i2_tf_m2_i1_f_i1_f_two_elements_custom_block_last_requires_stop_one_element_requires_stop_main_block(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} wm = {'foo': 'bar'} target_block = InstructionBlock() elem2 = DummySequencingElement(True) sequencer.push(elem2, ps, cs, window_mapping=wm, target_block=target_block) elem1 = DummySequencingElement(False) sequencer.push(elem1, ps, cs, window_mapping=wm, target_block=target_block) elem_main = DummySequencingElement(True) sequencer.push(elem_main, ps, cs) sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertIs(target_block, elem1.target_block) self.assertEqual(ps, elem1.parameters) self.assertEqual(cs, elem1.conditions) self.assertEqual(1, elem1.requires_stop_call_counter) self.assertEqual(1, elem1.build_call_counter) self.assertEqual(ps, elem2.parameters) self.assertEqual(cs, elem2.conditions) self.assertEqual(2, elem2.requires_stop_call_counter) self.assertEqual(0, elem2.build_call_counter) self.assertEqual(ps, elem_main.parameters) self.assertEqual(cs, elem_main.conditions) self.assertEqual(2, elem_main.requires_stop_call_counter) self.assertEqual(0, elem_main.build_call_counter)
def test_build_path_o2_m1_i2_tf_m2_i1_f_i1_f_two_elements_main_block_last_requires_stop_add_one_element_requires_stop_new_block(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} new_block = InstructionBlock() new_elem = DummySequencingElement(True) elem1 = DummySequencingElement(False, (new_block, [new_elem])) elem2 = DummySequencingElement(True) sequencer.push(elem2, ps, cs) sequencer.push(elem1, ps, cs) instr, stop = sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertIs(elem1, instr.elem) self.assertEqual(ps, elem1.parameters) self.assertEqual(cs, elem1.conditions) self.assertEqual(1, elem1.requires_stop_call_counter) self.assertEqual(1, elem1.build_call_counter) self.assertEqual(ps, elem2.parameters) self.assertEqual(cs, elem2.conditions) self.assertEqual(2, elem2.requires_stop_call_counter) self.assertEqual(0, elem2.build_call_counter) self.assertEqual(ps, new_elem.parameters) self.assertEqual(cs, new_elem.conditions) self.assertEqual(1, new_elem.requires_stop_call_counter) self.assertEqual(0, new_elem.build_call_counter) self.assertEqual(STOPInstruction(), stop)
def test_build_path_o2_m1_i1_t_m2_i0_i1_f_one_element_main_block_adds_one_element_requires_stop_new_block(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} new_block = InstructionBlock() new_elem = DummySequencingElement(True) elem = DummySequencingElement(False, (new_block, [new_elem])) sequencer.push(elem, ps, cs) sequence = sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertIs(elem, sequence[0].elem) self.assertEqual(ps, elem.parameters) self.assertEqual(cs, elem.conditions) self.assertEqual(1, elem.requires_stop_call_counter) self.assertEqual(1, elem.build_call_counter) self.assertEqual(ps, new_elem.parameters) self.assertEqual(cs, new_elem.conditions) self.assertEqual(1, new_elem.requires_stop_call_counter) self.assertEqual(0, new_elem.build_call_counter) self.assertEqual(STOPInstruction(), sequence[1]) self.assertEqual(2, len(sequence))
def test_build_path_o2_m1_i2_tt_m1_i0_two_elements_main_block(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} elem1 = DummySequencingElement(False) elem2 = DummySequencingElement(False) sequencer.push(elem2, ps, cs) sequencer.push(elem1, ps, cs) sequence = sequencer.build() self.assertTrue(sequencer.has_finished()) self.assertIs(elem1, sequence[0].elem) self.assertEqual(ps, elem1.parameters) self.assertEqual(cs, elem1.conditions) self.assertEqual(1, elem1.requires_stop_call_counter) self.assertEqual(1, elem1.build_call_counter) self.assertIs(elem2, sequence[1].elem) self.assertEqual(ps, elem2.parameters) self.assertEqual(cs, elem2.conditions) self.assertEqual(1, elem2.requires_stop_call_counter) self.assertEqual(1, elem2.build_call_counter) self.assertEqual(STOPInstruction(), sequence[2]) self.assertEqual(3, len(sequence))
def test_push_float_params(self) -> None: sequencer = Sequencer() ps = {'foo': 1, 'bar': 7.3} cs = {'foo': DummyCondition()} elem = DummySequencingElement() sequencer.push(elem, ps, cs) self.assertFalse(sequencer.has_finished()) sequencer.build() self.assertIsInstance(elem.parameters['foo'], ConstantParameter) self.assertIsInstance(elem.parameters['bar'], ConstantParameter) self.assertEqual(cs, elem.conditions)
def test_push(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} wm = {'foo' : 'bar'} elem = DummySequencingElement() sequencer.push(elem, ps, cs, window_mapping=wm) self.assertFalse(sequencer.has_finished()) sequencer.build() self.assertEqual(ps, elem.parameters)
def test_build_path_o1_m1_i1_f_single_element_requires_stop_main_block(self) -> None: sequencer = Sequencer() elem = DummySequencingElement(True) ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} sequencer.push(elem, ps, cs) sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertEqual(ps, elem.parameters) self.assertEqual(cs, elem.conditions) self.assertEqual(1, elem.requires_stop_call_counter) self.assertEqual(0, elem.build_call_counter)
def test_build_path_o2_m2_i2_tt_t_i2_tt_m2_i0_i0_two_elements_custom_block_two_element_main_block(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} wm = {'foo': 'bar'} target_block = InstructionBlock() elem2 = DummySequencingElement(False) sequencer.push(elem2, ps, cs, window_mapping=wm, target_block=target_block) elem1 = DummySequencingElement(False) sequencer.push(elem1, ps, cs, window_mapping=wm, target_block=target_block) elem_main2 = DummySequencingElement(False) sequencer.push(elem_main2, ps, cs) elem_main1 = DummySequencingElement(False) sequencer.push(elem_main1, ps, cs) sequence = sequencer.build() self.assertTrue(sequencer.has_finished()) self.assertIs(target_block, elem1.target_block) self.assertEqual(ps, elem1.parameters) self.assertEqual(cs, elem1.conditions) self.assertEqual(1, elem1.requires_stop_call_counter) self.assertEqual(1, elem1.build_call_counter) self.assertIs(target_block, elem2.target_block) self.assertEqual(ps, elem2.parameters) self.assertEqual(cs, elem2.conditions) self.assertEqual(1, elem2.requires_stop_call_counter) self.assertEqual(1, elem2.build_call_counter) self.assertIs(elem_main1, sequence[0].elem) self.assertEqual(ps, elem_main1.parameters) self.assertEqual(cs, elem_main1.conditions) self.assertEqual(1, elem_main1.requires_stop_call_counter) self.assertEqual(1, elem_main1.build_call_counter) self.assertIs(elem_main2, sequence[1].elem) self.assertEqual(ps, elem_main2.parameters) self.assertEqual(cs, elem_main2.conditions) self.assertEqual(1, elem_main2.requires_stop_call_counter) self.assertEqual(1, elem_main2.build_call_counter) self.assertEqual(STOPInstruction(), sequence[2]) self.assertEqual(3, len(sequence))
def test_qupulse_template_to_array_new_style_vs_old_style(self): with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=UserWarning, message="qupulse") warnings.filterwarnings( "ignore", category=DeprecationWarning, message="InstructionBlock API is deprecated") period = 1e-3 amplitude = 1.5 sampling_rate = 1e9 sequence = Sequencer.make_sawtooth_wave(amplitude, period) template = sequence['wave'] channels = template.defined_channels sequencer = Sequencing() sequencer.push( template, dict(), channel_mapping={ch: ch for ch in channels}, window_mapping={w: w for w in template.measurement_names}) instructions = sequencer.build() if not sequencer.has_finished(): raise PlottingNotPossibleException(template) (_, voltages_old, _) = render(instructions, sampling_rate / 1e9) loop = template.create_program( parameters=dict(), measurement_mapping={w: w for w in template.measurement_names}, channel_mapping={ch: ch for ch in channels}, global_transformation=None, to_single_waveform=set()) (_, voltages_new, _) = render(loop, sampling_rate / 1e9) self.assertTrue(len(voltages_old) == len(voltages_new)) self.assertTrue(np.min(voltages_old) == np.min(voltages_old)) self.assertTrue(np.max(voltages_old) == np.max(voltages_old))
def test_build_path_o2_m2_i0_i1_t_m2_i0_i0_one_element_custom_block(self) -> None: sequencer = Sequencer() ps = {'foo': ConstantParameter(1), 'bar': ConstantParameter(7.3)} cs = {'foo': DummyCondition()} wm = {'foo': 'bar'} cm = {'A': 'B'} target_block = InstructionBlock() elem = DummySequencingElement(False) sequencer.push(elem, ps, cs, window_mapping=wm, channel_mapping=cm, target_block=target_block) sequencer.build() self.assertTrue(sequencer.has_finished()) self.assertIs(target_block, elem.target_block) self.assertEqual(ps, elem.parameters) self.assertEqual(cs, elem.conditions) self.assertEqual(wm, elem.window_mapping) self.assertEqual(cm, elem.channel_mapping) self.assertEqual(1, elem.requires_stop_call_counter) self.assertEqual(1, elem.build_call_counter)
def test_table_sequence_sequencer_integration(self) -> None: t1 = TablePulseTemplate(entries={'default': [(2, 'foo'), (5, 0)]}, measurements=[('foo', 2, 2)]) t2 = TablePulseTemplate( entries={'default': [(4, 0), (4.5, 'bar', 'linear'), (5, 0)]}, measurements=[('foo', 4, 1)]) seqt = SequencePulseTemplate( MappingPulseTemplate(t1, measurement_mapping={'foo': 'bar'}), MappingPulseTemplate(t2, parameter_mapping={'bar': '2 * hugo'})) with self.assertRaises(ParameterNotProvidedException): t1.requires_stop(dict(), dict()) with self.assertRaises(ParameterNotProvidedException): t2.requires_stop(dict(), dict()) self.assertFalse( seqt.requires_stop( { 'foo': DummyParameter(), 'hugo': DummyParameter() }, {})) foo = DummyNoValueParameter() bar = DummyNoValueParameter() sequencer = Sequencer() sequencer.push(seqt, { 'foo': foo, 'hugo': bar }, window_mapping=dict(bar='my', foo='thy'), channel_mapping={'default': 'A'}) instructions = sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertEqual(1, len(instructions)) # stop after first TablePT foo = DummyParameter(value=1.1) bar = DummyNoValueParameter() sequencer = Sequencer() sequencer.push(seqt, { 'foo': foo, 'hugo': bar }, window_mapping=dict(bar='my', foo='thy'), channel_mapping={'default': 'A'}) block = sequencer.build() instructions = block.instructions self.assertFalse(sequencer.has_finished()) self.assertIsInstance(block, AbstractInstructionBlock) self.assertEqual(2, len(instructions)) self.assertEqual(instructions[0], MEASInstruction([('my', 2, 2)])) self.assertIsInstance(instructions[1], EXECInstruction) # stop before first TablePT foo = DummyParameter(value=1.1) bar = DummyNoValueParameter() sequencer = Sequencer() sequencer.push(seqt, { 'foo': bar, 'hugo': foo }, window_mapping=dict(bar='my', foo='thy'), channel_mapping={'default': 'A'}) instructions = sequencer.build() self.assertFalse(sequencer.has_finished()) self.assertEqual(1, len(instructions)) foo = DummyParameter(value=1.1) bar = DummyParameter(value=-0.2) sequencer = Sequencer() sequencer.push(seqt, { 'foo': foo, 'hugo': bar }, window_mapping=dict(bar='my', foo='thy'), channel_mapping={'default': 'A'}) instructions = sequencer.build() self.assertTrue(sequencer.has_finished()) self.assertEqual(4, len(instructions.instructions)) self.assertEqual(instructions[0], MEASInstruction([('my', 2, 2)])) self.assertIsInstance(instructions[1], EXECInstruction) self.assertEqual(instructions[2], MEASInstruction([('thy', 4, 1)])) self.assertIsInstance(instructions[3], EXECInstruction)
def test_build_path_no_loop_nothing_to_do(self) -> None: sequencer = Sequencer() sequencer.build() self.assertTrue(sequencer.has_finished())
def test_initialization(self) -> None: sequencer = Sequencer() self.assertTrue(sequencer.has_finished())