Synchronizing Multiple AWG Channels

Does your application require multiple AWG channels with precise and stable timing synchronization? In this blog post, we will show how to achieve this with the HDAWG Arbitrary Waveform Generator for setup sizes ranging from few channels up to 144. We demonstrate the following 3 methods suitable for different use cases:

1. Using HDAWG channel grouping as the easiest method for signals with low complexity
2. Using inter-core triggering offering independent sequencing for signals with high complexity
3. Using the PQSC as the best method to scale to multiple devices

Let’s look at a common example that requires four output channels: a control sequence for a spin qubit in an electrostatically defined double quantum dot (DQD). The DQD is formed in a 2-dimensional electron gas by applying static voltages to a set of metallic gates. The control sequence requires two types of pulses: RF pulses to drive the spin state, and DC pulses to move the DQD rapidly between operation points in the charge stability diagram. Figure 1 shows a typical multi-channel pulse sequence realizing a three-stage operation consisting of initialization, manipulation, and readout.

On channels 1 and 2, we play frequency-modulated RF pulses that serve as inputs to the I and Q ports of an upconversion circuit. On channels 3 and 4, we play what we call DC pulses, signals of piecewise constant voltage levels to mimic the three stages of the pulse sequence. With the pulse-level programming style in the sequencer of the HDAWG, we can readily generate the pulse sequences on the individual output channels. Now, let’s have a look at how we can synchronize the different channels.

1. Channel Grouping

By default, the HDAWG provides independent sequence editors for all AWG cores (4 cores on HDAWG8, 2 cores on HDAWG4). Each sequencer controls two Wave outputs. The channel grouping feature allows one to tie together multiple AWG cores, and thus enables synchronized playback on 4 or all 8 outputs with a single playWave() sequence instruction. The syntax for multi-channel playback is described in the HDAWG manual. The playWave() instruction in the grouped mode supports most features that are also available in non-grouped mode, for example the ability to dynamically adjust the AWG sampling rate divider as an argument in the playWave() instruction. This helps minimize waveform memory.

When working with the channel grouping mode, keep the following points in mind:

• All waveforms within a single playWave() instruction must have the same length. If this is not the case, the AWG compiler will automatically pad idle outputs with zeros until the start of the following playWave() instruction.
• Multi-channel pulse sequences in grouped mode often need to be divided into smaller segments with consistent lengths on all channels, e.g. to realize staggered pulse sequences. This might require segmenting connected pulses, in particular when using dynamic pulses as described in this blog post.

You can also use the command table feature in grouped mode. The command table allows you to combine waveform playback with real-time amplitude and phase control in one sequence instruction, which is great for realizing long, complex signals in a memory-efficient way. While there is a single sequence program for all cores in grouped mode, the command table remains separate for each AWG core. The sequence program contains then a list of executeTableEntry(<index>) instructions, which refer to entries with the given index in the command tables of the individual cores. Idle outputs or missing command table entries are not automatically padded with zeros. Instead, the cores would run out of sync as the missing waveforms will be skipped and the playback continues with the next available waveform in line.

The channel grouping mode works great for generating signals of similar character on all channels. In our example, the RF and DC signals are quite different in character. We have an interest to replace idle times in the RF signal with memory-saving playZero() instructions instead of zero padding, and we may want to vary parameters like pulse amplitudes or voltage levels while reusing waveform data of those signals that don't change. This calls for a way to program AWG cores independently, as is possible using the method shown next.

2. Inter-core triggering

In the inter-core triggering method, we program all AWG cores with individual sequences which have identical duration, so if they are started at the same time, the playback will always stay in sync given an equal sample rate divider on each AWG core.

To achieve this, we assign one of the AWG cores as the leader and use it to trigger all remaining cores, which are the followers. The trigger signal can be generated on the marker output 1 and distributed with a cable and a 1:4 splitter to the trigger inputs 1, 3, 5, and 7 on the front panel of the HDAWG. When using a single HDAWG like in our case, we can even accomplish this via internal signal paths alone by using the DIO interface. The DIO interface is normally used for inter-instrument communication, but it's state can also be set and read back by different units within the same instrument. So if it is not used for inter-instrument communication, it can serve as a trigger signal path between those units. We configure the DIO trigger in LabOne in the ‘DIO’ tab and the ‘AWG Sequencer’ tab as summarized in Table 1:

These settings switch the Digital I/O mode to ‘AWG Sequencer’, which lets the sequencer control the 32 bits of the DIO. Furthermore, we enable driving of the first of 4 groups of 8 bits each. The other settings are done in the ‘Trigger’ sub-tab of the AWG sequencer tab and ensure that the sequencers are waiting for the correct polarity of the right bit. Figure 2 shows a screenshot of the corresponding tabs in the graphical user interface.

At the beginning of the sequence program of the leader AWG core, we insert the following lines. The first 3 lines generate a trigger signal on the DIO port. There are internal propagation delays between the AWG core and the DIO port, which is a feature we can exploit: we can have this AWG core triggered by the signal it just emitted using a waitDIOTrigger() instruction, which means we don't need to compensate explicitly for the propagation delay between leader and follower AWG cores.  

setDIO(1);  //Send trigger
wait(5);
setDIO(0);

waitDIOTrigger();   //Wait for trigger

//Waveform playback
//playWave....	

And at the beginning of the sequence programs of the follower AWG cores, we insert the following line to wait for the trigger signal:

waitDIOTrigger();   //Wait for trigger

//Waveform playback
//playWave....

Finally, we first start the follower AWG sequencers and, at last, the leader AWG sequencer. With the example script accompanying this post we can perform the described instrument configuration and generate the example pulse sequence. We verify the expected pulse sequence from the example (shown in Figure 1) with an oscilloscope (screenshot in Figure 3).

With the instrument node /dev8XXX/sigouts/n/delay we can now fine-tune the global delay between individual output channels, for instance to compensate different path lengths. In summary, the node settings and sequences described above result in synchronous playback on all outputs of a single HDAWG instrument.

3. Synchronization with PQSC

So far, we discussed how to synchronize output channels on a single instrument. For setups of multiple QCCS instruments, the PQSC Programmable Quantum System Controller offers a simple and scalable approach to synchronization. It synchronizes up to 18 instruments via the ZSync interface, which totals to 144 AWG channels. In this setup, the PQSC sends one or a burst of triggers to all connected instruments. The triggering part at the beginning of all sequence programs simplifies to a single waitZSyncTrigger() instruction:

waitZSyncTrigger();   //Wait for the trigger

//Waveform playback
//playWave....

To enable synchronization via the PQSC, the reference clock source in the 'Device' tab of the HDAWG is configured to 'ZSYNC'. Additionally, in the DIO tab the Digital I/O mode is set to 'QCCS'. An extended example for synchronization of multiple HDAWG is explained in this tutorial. The PQSC thus facilitates system-wide and sub-ns synchronization of all instruments and is the best solution for multi-instrument setups. AWG synchronization using a PQSC is also supported by the LabOne QCCS Software, the next-generation pulse-level programming language for efficient code generation and execution of qubit experiments.

The ZSync interface also provides bidirectional real-time communication. Qubit readout results can be sent to the PQSC for further processing or simple forwarding. The PQSC then acts as a central hub to initiate conditional actions on the individual AWGs for quantum feedback. An example can be found in this blog post.

Summary

Synchronized multi-channel playback is important not only for large qubit processors but is also essential for a single qubit, as seen in the example of a spin qubit. In the case of a small system based on a single HDAWG, we can use the channel grouping mode to create simple, multi-channel sequences. Alternatively, we can program the AWG cores individually and synchronize them using a trigger on the front panel or the DIO interface. For multi-channel playback on multiple instruments, the PQSC provides synchronization with minimal effort scalable to large systems. It also offers a path to realizing powerful feedback protocols.

The script accompanying this blog post can be found in our GitHub Space.

If you have any questions or would like to discuss the best approach for your experiments, please reach out to us and we will gladly help you.