Adjust code based on testing

Author: rassouly

exopy_hqc_legacy/manifest.enaml

@@ -488,3 +488,7 @@ enamldef HqcLegacyManifest(PluginManifest):
                     task = 'run_awg:RunAWGTask'
                     view = 'views.run_awg_views:RunAWGView'
                     instruments = ['exopy_hqc_legacy.Legacy.AWG']
+                Task:
+                    task = 'transfer_awg_file_task:TransferAWGFileTask'
+                    view = 'views.transfer_awg_file_task_view:TransferAWGFileView'
+                    instruments = ['exopy_hqc_legacy.Legacy.AWG']

exopy_hqc_legacy/pulses/contexts/awg_context.py

@@ -190,6 +190,263 @@ def compile_and_transfer_sequence(self, sequence, driver=None):
 
         return self._transfer_sequences(driver, to_send, infos)
 
+    def compile_loop(self, sequence, for_file=False, factor=True, **kwargs):
+        """ Transform a sequence of pulse to a dict of waveform suitable for
+        sequence mode of the AWG
+
+        Parameters
+        ----------
+        pulses : list(Pulse)
+            List of pulse generated by the compilation of a sequence.
+
+        Returns
+        -------
+        result : bool
+            Boolean indicating whether or not the compilation succeeded.
+
+        to_send or traceback : dict
+            Dict of {channel: array of (bytearrays,intarray,intarray)} to send
+            to the AWG in case of success containing waveform, position(s) and
+            repeat(s) or the traceback of the issues in case of failure.
+
+
+        """
+        items, errors = self.preprocess_sequence(sequence)
+
+        if errors:
+            return False, {}, errors
+
+        duration = max([pulse.stop for pulse in items])
+        if sequence.time_constrained:
+            # Total length of the sequence to send to the AWG
+            duration = sequence.duration
+
+        # Collect the channels used in the pulses' sequence
+        used_channels = set([pulse.channel[:3] for pulse in items])
+
+        # Coefficient to convert the start and stop of pulses in second and
+        # then in index integer for array
+        time_to_index = TIME_CONVERSION[self.time_unit]['s'] * \
+            self.sampling_frequency
+
+        # Length of the sequence
+        sequence_length = int(round(duration * time_to_index))
+
+        # make zero space a multiple repeat of 256 zero samples
+        zero_length = 256
+        azeros = np.ones(zero_length, dtype=np.uint16)*(2**13)
+        mzeros = np.zeros(zero_length, dtype=np.int8)
+        array_analog = {}
+        array_M1 = {}
+        array_M2 = {}
+        repeats = []
+        for channel in used_channels:
+            array_analog[channel] = []
+            array_M1[channel] = []
+            array_M2[channel] = []
+        intervals_to_pulses_a = {}
+        intervals_to_pulses_m1 = {}
+        intervals_to_pulses_m2 = {}
+        for channel in used_channels:
+            intervals_to_pulses_a[channel] = {}
+            intervals_to_pulses_m1[channel] = {}
+            intervals_to_pulses_m2[channel] = {}
+
+        if factor:
+            # intervals are places that have pulses on at least one  channel
+            intervals = []
+            for pulse in [i for i in items if i.duration != 0.0]:
+
+                waveform = pulse.waveform
+                start_index = int(round(pulse.start*time_to_index))
+                stop_index = start_index + len(waveform)
+                intervals.append((start_index, stop_index))
+            # sort and merge intervals
+            # XXX this is mostly duplicated and should be refactored
+            intervals.sort()
+            i = 1
+            while i < len(intervals):
+                while i < len(intervals) and intervals[i][0] < intervals[i-1][1]:
+                    newlast = intervals[i][1]
+                    del intervals[i]
+                    intervals[i-1] = (intervals[i-1][0],
+                                      max(newlast, intervals[i-1][1]))
+                i += 1
+
+            # check that the minimum length of the each pulse and space between
+            # them are > 256 samples fix if the condition is not satisfied
+            self.merge_intervals(intervals, sequence_length)
+
+            # fill up the space between start of sequence and first sample of pulse
+            #  with zero samples
+            if intervals[0][0] != 1:
+                zcount = int((intervals[0][0] - 1) / zero_length) - 1
+                zrem = zero_length + (intervals[0][0] - 1) % zero_length
+                azrem = np.ones(zrem, dtype=np.uint16)*(2**13)
+                mzrem = np.zeros(zrem, dtype=np.int8)
+                if zcount > 0:
+                    repeats.append(zcount)
+                repeats.append(1)
+                for channel in used_channels:
+                    if zcount > 0:
+                        array_analog[channel].append(azeros)
+                        array_M1[channel].append(mzeros)
+                        array_M2[channel].append(mzeros)
+                    array_analog[channel].append(azrem)
+                    array_M1[channel].append(mzrem)
+                    array_M2[channel].append(mzrem)
+
+            for idx, interval in enumerate(intervals):
+                for channel in used_channels:
+                    afill = 2**13*np.ones(interval[1] - interval[0],
+                                          dtype=np.uint16)
+                    mfill1 = np.zeros(interval[1] - interval[0], dtype=np.int8)
+                    mfill2 = np.zeros(interval[1] - interval[0], dtype=np.int8)
+                    array_analog[channel].append(afill)
+                    array_M1[channel].append(mfill1)
+                    array_M2[channel].append(mfill2)
+                    intervals_to_pulses_a[channel][interval] = afill
+                    intervals_to_pulses_m1[channel][interval] = mfill1
+                    intervals_to_pulses_m2[channel][interval] = mfill2
+
+                remaining = 0
+                if idx + 1 == len(intervals):
+                    remaining = sequence_length - interval[1] + 1
+                else:
+                    remaining = intervals[idx+1][0] - intervals[idx][1]
+                zcount = int(remaining / zero_length) - 1
+                zrem = zero_length + remaining % zero_length
+                azrem = np.ones(zrem, dtype=np.uint16)*(2**13)
+                mzrem = np.zeros(zrem, dtype=np.int8)
+                repeats.append(1)
+                if zcount > 0:
+                    repeats.append(zcount)
+                repeats.append(1)
+
+                if remaining != 0:
+                    for channel in used_channels:
+                        if zcount > 0:
+                            array_analog[channel].append(azeros)
+                            array_M1[channel].append(mzeros)
+                            array_M2[channel].append(mzeros)
+                        array_analog[channel].append(azrem)
+                        array_M1[channel].append(mzrem)
+                        array_M2[channel].append(mzrem)
+        else:
+            start_index = 0
+            stop_index = sequence_length
+            intervals = [(start_index, stop_index)]
+            for channel in used_channels:
+                a_fill = np.ones(sequence_length, dtype=np.uint16)*(2**13)
+                m1_fill = np.zeros(sequence_length, dtype=np.int8)
+                m2_fill = np.zeros(sequence_length, dtype=np.int8)
+                array_analog[channel].append(a_fill)
+                array_M1[channel].append(m1_fill)
+                array_M2[channel].append(m2_fill)
+                intervals_to_pulses_a[channel][intervals[0]]=a_fill
+                intervals_to_pulses_m1[channel][intervals[0]]=m1_fill
+                intervals_to_pulses_m2[channel][intervals[0]]=m2_fill
+            repeats = [1]
+
+        for pulse in [i for i in items if i.duration != 0.0]:
+            waveform = pulse.waveform
+            channel = pulse.channel[:3]
+            channeltype = pulse.channel[4:]
+
+            start_index = int(round(pulse.start*time_to_index))
+            stop_index = start_index + len(waveform)
+
+            interval_i = 0
+            while intervals[interval_i][1] < start_index:
+                interval_i += 1
+            interval = intervals[interval_i]
+
+            wav_slice = slice(start_index - interval[0],
+                              stop_index - interval[0])
+            if channeltype == 'A' and pulse.kind == 'Analogical':
+                intervals_to_pulses_a[channel][interval][wav_slice] +=\
+                    (np.rint(8191*waveform)).astype(np.uint16)
+            elif channeltype == 'M1' and pulse.kind == 'Logical':
+                intervals_to_pulses_m1[channel][interval][wav_slice] +=\
+                    waveform
+            elif channeltype == 'M2' and pulse.kind == 'Logical':
+                intervals_to_pulses_m2[channel][interval][wav_slice] +=\
+                    waveform
+            else:
+                msg = 'Selected channel does not match kind for pulse {} ({}).'
+                return (False, None, None, dict(),
+                        {'Kind issue': msg.format(pulse.index,
+                                                  (pulse.kind, pulse.channel))}
+                        )
+
+        # Check the overflows
+        traceback = {}
+        for channel in used_channels:
+            for i in range(len(array_analog[channel])):
+                analog = array_analog[channel][i]
+                m1 = array_M1[channel][i]
+                m2 = array_M2[channel][i]
+                if analog.max() > 16383 or analog.min() < 0:
+                    mes = 'Analogical values out of range.'
+                    traceback['{}_A'.format(channel)] = mes
+
+                elif m1.max() > 1 or m1.min() < 0:
+                    mes = 'Overflow in marker 1.'
+                    traceback['{}_M1'.format(channel)] = mes
+
+                elif m2.max() > 1 or m2.min() < 0:
+                    mes = 'Overflow in marker 2.'
+                    traceback['{}_M2'.format(channel)] = mes
+
+        if traceback:
+            return False, None, None, dict(), traceback
+
+        # Invert marked logical channels.
+        for i_ch in self.inverted_log_channels:
+            ch, m = i_ch.split('_')
+            if m == 'M1':
+                for waveform in array_M1[ch]:
+                    np.logical_not(waveform, waveform)
+            else:
+                for waveform in array_M2[ch]:
+                    np.logical_not(waveform, waveform)
+
+        # Byte arrays to send to the AWG
+        wfs = {}
+        already_added = {}
+        for channel in used_channels:
+            wfs[int(channel[-1])] = []
+            for i in range(len(array_analog[channel])):
+                addr = id(array_analog[channel][i])
+                if addr in already_added:
+                    added = already_added[addr]
+                    wfs[int(channel[-1])].append(added)
+
+                else:
+                    waveform_new = (array_analog[channel][i] +
+                                    array_M1[channel][i]*(2**14) +
+                                    array_M2[channel][i]*(2**15))
+                    aux = np.empty(2*len(waveform_new), dtype=np.uint8)
+                    if for_file:
+                        wfadded = waveform_new
+                    else:
+                        aux[::2] = waveform_new % 2**8
+                        aux[1::2] = waveform_new // 2**8
+                        wfadded = bytearray(aux)
+                    wfs[int(channel[-1])].append(wfadded)
+                    already_added[addr] = wfadded
+
+        # Build sequence infos
+        name = self._cache['sequence_name']
+        infos = dict(sampling_frequency=self.sampling_frequency,
+                     sequence_ch1='',
+                     sequence_ch2='',
+                     sequence_ch3='',
+                     sequence_ch4='')
+        for c in used_channels:
+            infos['sequence_ch%s' % c[2]] = name + '_' + c
+        return True, wfs, repeats, infos, traceback
+
     def list_sequence_infos(self):
         """List the sequence infos returned after a successful completion.