def sequence_gates(self, gate_comb, do_upload=True):
if do_upload:
[awg.delete_waveforms() for awg in self.awgs]
for number in self.__awg_range:
sequence_channels = list()
sequence_names = list()
sequence_items = list()
vpp_amplitude = self.awgs[number].retrieve_gain()
sampling_rate = self.awgs[number].retrieve_sampling_rate()
for gate_name, sequence in gate_comb.items():
(awg_number, channel_number,
*marker_number) = self._gate_map[gate_name]
if awg_number != number:
continue
awg_to_plunger = self.__hardware.parameters['awg_to_{}'.format(
gate_name)].get()
scaling_ratio = 2 * VirtualAwg.__volt_to_millivolt / awg_to_plunger / vpp_amplitude
sample_data = Sequencer.get_data(sequence, sampling_rate)
sequence_data = sample_data if marker_number else sample_data * scaling_ratio
sequence_names.append('{}_{}'.format(gate_name,
sequence['name']))
sequence_channels.append((channel_number, *marker_number))
sequence_items.append(sequence_data)
if do_upload:
self.awgs[number].upload_waveforms(sequence_names,
sequence_channels,
sequence_items)
return {'gate_comb': gate_comb}
def sequence_gates(self, sequences, do_upload=True):
""" The base function for uploading sequences to the AWG's. The sequences must be
constructed using the qtt.instrument_drivers.virtualAwg.sequencer.Sequencer class.
Arguments:
sequences (dict): A dictionary with names as keys and sequences as values.
do_upload (bool, Optional): Does not upload the waves to the AWG's when set to False.
Example:
>> from qtt.instrument_drivers.virtualAwg.sequencer import Sequencer.
>> amplitude = 1.5
>> period_in_seconds = 1e-6
>> sawtooth_signal = Sequencer.make_sawtooth_wave(amplitude, period_in_seconds)
>> virtual_awg.sequence_gates(sawtooth_signal)
"""
upload_data = []
settings_data = {}
if do_upload:
_ = [awg.delete_waveforms() for awg in self.awgs]
for number in self.__awg_range:
sequence_channels = []
sequence_names = []
sequence_items = []
gain_factor = self.awgs[number].retrieve_gain()
vpp_amplitude = 2 * gain_factor
sampling_rate = self.awgs[number].retrieve_sampling_rate()
settings_data[number] = {'vpp_amplitude': vpp_amplitude, 'sampling_rate': sampling_rate}
for gate_name, sequence in sequences.items():
(awg_number, channel_number, *marker_number) = self._settings.awg_map[gate_name]
if awg_number != number:
continue
waveforms = [Sequencer.get_data(waveform, sampling_rate) for waveform in sequence]
sequence_data = np.sum(waveforms, 0)
sequence_data = sequence_data[:-1]
if not marker_number:
awg_to_gate = self._settings.parameters[f'awg_to_{gate_name}'].get()
scaling_ratio = 1 / (awg_to_gate * gain_factor)
settings_data[number][gate_name] = {'scaling_ratio': scaling_ratio}
sequence_data *= scaling_ratio
sequence_name = sequence[0]['name']
sequence_names.append(f'{gate_name}_{sequence_name}')
sequence_channels.append((channel_number, *marker_number))
sequence_items.append(sequence_data)
upload_data.append((sequence_names, sequence_channels, sequence_items))
if do_upload and sequence_items:
self.awgs[number].upload_waveforms(sequence_names, sequence_channels, sequence_items)
sequence_data = {'gate_comb': sequences, 'upload_data': upload_data, 'settings': settings_data}
if self.enable_debug:
self._latest_sequence_data = sequence_data
return sequence_data
def test_make_pulse_table(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=UserWarning, message="qupulse")
amplitudes = [1, 2, 3]
waiting_times = [1e-4, 2e-5, 3e-3]
sampling_rate = 1e9
pulse_data = Sequencer.make_pulse_table(amplitudes, waiting_times)
raw_data = Sequencer.get_data(pulse_data, sampling_rate)
self.assertTrue(raw_data[0] == amplitudes[0])
self.assertTrue(raw_data[-1] == amplitudes[-1])
def test_raw_wave_HasCorrectProperties(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=UserWarning, message="qupulse")
period = 1e-3
sampling_rate = 1e9
name = 'test_raw_data'
sequence = {'name': name, 'wave': [0] * int(period * sampling_rate + 1),
'type': DataTypes.RAW_DATA}
raw_data = Sequencer.get_data(sequence, sampling_rate)
self.assertTrue(len(raw_data) == sampling_rate * period + 1)
self.assertTrue(np.min(raw_data) == 0)
def test_qupulse_sawtooth_HasCorrectProperties(self):
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=UserWarning, message="qupulse")
epsilon = 1e-14
period = 1e-3
amplitude = 1.5
sampling_rate = 1e9
sequence = Sequencer.make_sawtooth_wave(amplitude, period)
raw_data = Sequencer.get_data(sequence, sampling_rate)
self.assertTrue(len(raw_data) == sampling_rate * period + 1)
self.assertTrue(np.abs(np.min(raw_data) + amplitude / 2) <= epsilon)
self.assertTrue(np.abs(np.max(raw_data) - amplitude / 2) <= epsilon)