def __init__(self,
Ipulse,
Qpulse,
pi_amp,
pi2_amp=0,
chans=(0, 1),
marker_chan='m1',
marker_val=2,
marker_pad=0):
if marker_pad != 0:
mp = np.zeros(marker_pad)
Ipulse = sequencer.Pulse(Ipulse.name + '_pad%s' % len(mp),
data=np.concatenate([mp, Ipulse.data,
mp]))
sequencer.Sequence([sequencer.Delay(marker_pad), Ipulse])
if Ipulse:
Ipulse = Ipulse.rendered()
if Qpulse:
Qpulse = Qpulse.rendered()
self.Ipulse = Ipulse
self.Qpulse = Qpulse
self.ampgen = ampgen.AmpGen()
self.set_pi_amp(pi_amp, pi2_amp)
self.chans = chans
self.marker_chan = marker_chan
self.marker_val = marker_val
self.marker_pad = marker_pad
super(FPGAAmplitudeRotation, self).__init__()
def MeasurementPulse(pulselen=200, delay=0, ro_delay=0, **kwargs):
label = kwargs.pop('label', None)
cb = sequencer.Combined([
sequencer.Constant(pulselen, 2, chan='m0'),
sequencer.Sequence([
sequencer.Delay(delay),
sequencer.Constant(40, 1, chan='master', **kwargs),
sequencer.Constant(220, 2, chan='master', **kwargs)
]),
],
label=label,
align=sequencer.ALIGN_LEFT)
if ro_delay == 0:
return cb
else:
return sequencer.Sequence([sequencer.Delay(ro_delay), cb])
def cavity_cool(m, NCONVINCE=4, label='qccool', tgtlabel=None):
'''
Qubit/cavity |gg> cooling sequence.
If <tgtlabel> is None, a function return will be generated at the end,
otherwise the sequence jumps to <tgtlabel> on completion.
Uses registers R1, R2 and counter0
'''
if tgtlabel:
retlabel = tgtlabel
else:
retlabel = label + '_ret'
s = sequencer.Sequence()
s.append(sequencer.Delay(1000, label=label, master_integrate=m.integrate_nolog, master_counter0=NCONVINCE))
s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), label='_'))
# First measurement, store result in R1, 0 = |g>, 1 = |e>
s.append(fpgapulses.LongMeasurementPulse())
s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), length=220, master_internal_function=ye.FPGASignals.s0, jump=(label+'_setR1_0', label+'_setR1_1')))
s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOVI(1, 0), label=label+'_setR1_0', jump=label+'_M2'))
s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOVI(1, 1), label=label+'_setR1_1'))
# Second measurement, store result in R2, 0 = |g>, 1 = |e>
s.append(m.qubit.rotate_selective(np.pi,0,label=label+'_M2'))
s.append(fpgapulses.LongMeasurementPulse())
s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), length=220, master_internal_function=ye.FPGASignals.s0, jump=(label+'_setR2_0', label+'_setR2_1')))
s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOVI(2, 0), label=label+'_setR2_0', jump=label+'_decide'))
s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOVI(2, 1), label=label+'_setR2_1'))
# Compare R1 and R2
s.append(fpgapulses.RegOp(ye.RegisterInstruction.CMP(1, 2), master_internal_function=ye.FPGASignals.r0, label=label+'_decide', jump=(label+'_same', label+'_diff')))
# If the same: reset counter, move last outcome to R1 and re-measure
s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOV(1, 2), master_counter0=NCONVINCE, jump=label+'_M2', label=label+'_same'))
# If different: decrease counter, move last outcome to R1 and goto remeasure if counter not zero
s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOV(1, 2), master_counter0=-1, master_internal_function=ye.FPGASignals.c0, jump=('next', label+'_M2'), label=label+'_diff'))
# We're almost good, make sure we are actually in |g>, if so jump to start
s.append(fpgapulses.RegOp(ye.RegisterInstruction.CMPI(1, 0), master_internal_function=ye.FPGASignals.r0, jump=(retlabel, 'next')))
# s.append(fpgapulses.RegOp(ye.RegisterInstruction.CMPI(1, 0), master_internal_function=ye.FPGASignals.r0, jump=(label+'_qcool', 'next')))
# Otherwise, set counter to 1 and remeasure
s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), master_counter0=1, jump=label+'_M2'))
if tgtlabel is None:
s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), callreturn=True, label=retlabel))
return s
def LongMeasurementPulse(pulselen=None,
rolen=None,
reflen=None,
ro_delay=0,
pulse_pump=False,
**kwargs):
sequencer.Pulse.RANGE_ACTION = sequencer.IGNORE
label = kwargs.pop('label', None)
if pulselen is None:
pulselen = ro_ins.get_pulse_len()
if rolen is None:
rolen = ro_ins.get_acq_len()
if reflen is None:
reflen = ro_ins.get_ref_len()
ro = sequencer.Constant(reflen, 3, chan='master', **kwargs)
kwargs.pop('master_integrate', None) # Remove integrate from kwargs
if reflen != rolen:
ro = sequencer.Sequence([
ro,
sequencer.Constant(rolen - reflen, 2, chan='master', **kwargs)
])
if pulse_pump:
cb = sequencer.Sequence([
sequencer.Constant(800, 1, chan='m1'),
sequencer.Combined([
sequencer.Constant(pulselen, 2, chan='m0'),
sequencer.Constant(rolen, 1, chan='m1'),
ro,
],
align=sequencer.ALIGN_LEFT)
],
label=label)
else:
cb = sequencer.Combined([
sequencer.Constant(pulselen, 2, chan='m0'),
ro,
],
label=label,
align=sequencer.ALIGN_LEFT)
if ro_delay == 0:
return cb
else:
return sequencer.Sequence([sequencer.Delay(ro_delay), cb])
def long_delay(length, block_size, label):
s = sequencer.Sequence()
if (length % block_size) != 0:
raise Exception('Length not an integer multiple of block size')
nblocks = length / block_size
if nblocks > 2**17:
raise Exception('Too many blocks requested!')
s.append(
RegOp(RegisterInstruction.MOVI(4, nblocks), label='init_%s' % label))
s.append(
RegOp(RegisterInstruction.ADDI(4, -1),
length=block_size,
label='loop_%s' % label))
s.append(
RegOp(RegisterInstruction.CMPI(4, 0),
master_internal_function=FPGASignals.r0,
jump=('done_%s' % label, 'loop_%s' % label)))
s.append(sequencer.Delay(256, label='done_%s' % label))
return s
N = 101 # Number of elements in sequence
REPRATE_DELAY = 1200000
CAVPULSE = True
DISP = np.sqrt(2)
dfs = np.linspace(-14e6, 2e6, N)
mask = (dfs != 0)
periods = np.zeros_like(dfs)
periods[mask] = 1e9 / dfs[mask]
m = fpgameasurement.FPGAMeasurement('SSBspec', xs=dfs/1e6, fit_func='gaussian', rrec=False)
s = sequencer.Sequence()
# Old-style
if 0:
s.append(sequencer.Delay(240, label='start'))
for period in periods:
if CAVPULSE:
# s.append(sequencer.Constant(500, 1, chan='m0'))
s.append(m.cavity.displace(DISP))
s.append(m.qubit.rotate(np.pi, 0, detune_period=period))
s.append(fpgapulses.LongMeasurementPulse())
s.append(sequencer.Delay(REPRATE_DELAY))
s.append(sequencer.Delay(240, jump='start'))
# New style, in logic a13 and up
else:
F0 = 50000 - round(dfs[0]/1000) # F0 in kHz
DF = round(-(dfs[1]-dfs[0])/1000) # DF in hHz
s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOVI(12, F0), master_counter0=N, label='reset'))
s.append(fpgapulses.RegOp(ye.RegisterInstruction.MOVI(0, F0)))
REPRATE_DELAY = 500000 # Delay to get a reasonable repetition rate
m = fpgameasurement.FPGAMeasurement('T1',
xs=delays / 1000.,
fit_func='exp_decay',
rrec=False)
s = sequencer.Sequence()
# FPGA style, using R13 as dynamic instruction length
if 1:
s.append(
fpgapulses.RegOp(ye.RegisterInstruction.MOVI(13, 0),
master_counter0=N,
label='reset'))
s.append(m.qubit.rotate(np.pi, 0, label='start'))
s.append(sequencer.Delay(100, inslength=('R13', 10))) # Length = R13 + 10
# s.append(sequencer.Constant(512, 1, value=1, chan='m0')) # For debugging purposes
s.append(fpgapulses.LongMeasurementPulse(label='measure'))
s.append(
fpgapulses.RegOp(ye.RegisterInstruction.ADDI(13, DT / 4),
master_counter0=-1,
master_internal_function=ye.FPGASignals.c0))
s.append(sequencer.Delay(REPRATE_DELAY, jump=('reset', 'start')))
# Old-school
else:
# m.qubit.rotate = fpgapulses.FPGAMarkerLenRotation(72, 'm0', 1)
s.append(sequencer.Delay(256, label='start'))
for curdelay in delays:
s.append(m.qubit.rotate(np.pi, 0))
if curdelay != 0:
efpi = ef_info.rotate(np.pi, 0)
#gfpi = gf_info.rotate(np.pi,0)
pi = np.pi
prepareA = sequencer.Join([sequencer.Trigger(250), cA(2.0, 0)])
prepareB = sequencer.Join([sequencer.Trigger(250), cB(1.65, 0)])
prepareAF = sequencer.Join([sequencer.Trigger(250), gepi, efpi, cA(2.0, 0)])
prepareBF = sequencer.Join([sequencer.Trigger(250), gepi, efpi, cB(1.65, 0)])
if 0: # Kerr revival
for delay in [150, 200, 250, 300, 350, 400]:
seq = sequencer.Join([
sequencer.Trigger(250),
cA(2.0, 0),
sequencer.Repeat(sequencer.Delay(10000), delay / 10)
])
Qfun = Qfunction.QFunction(qubit_info,
cavity_info1A,
amax=2.5,
N=15,
amaxx=None,
Nx=None,
amaxy=None,
Ny=None,
seq=seq,
delay=0,
saveas=None,
bgcor=False)
Qfun.measure()
bla
# Simple script to setup a readout sequence.
# Call m.start_exp() after running this to start FPGA
from pulseseq import sequencer, pulselib
import fpgapulses
import fpgameasurement
REPRATE_DELAY = 250000 # Delay to get a reasonable repetition rate
m = fpgameasurement.FPGAMeasurement('RO')
s = sequencer.Sequence()
s.append(sequencer.Delay(200, label='start'))
#s.append(m.qubit.rotate(np.pi,0))
s.append(fpgapulses.LongMeasurementPulse(label='measure'))
s.append(sequencer.Delay(REPRATE_DELAY, jump='start'))
m.set_seq(s, 1)
m.generate()
DI = round(2.0 * I0 / (NI - 1))
DQ = round(2.0 * Q0 / (NQ - 1))
s.append(sequencer.Constant(512, 1, value=1, chan='m0'))
s.append(fpgapulses.RegOp(RegisterInstruction.MOVI(0, +I0), label='Ireset'))
s.append(fpgapulses.RegOp(RegisterInstruction.MOVI(3, +I0), fpga_counter0=NI))
s.append(fpgapulses.RegOp(RegisterInstruction.MOVI(2, +Q0), label='Qreset'))
s.append(fpgapulses.RegOp(RegisterInstruction.MOVI(1, -Q0), fpga_counter1=NQ))
s.append(sequencer.Constant(256, 1, chan=0, label='displace'))
s.append(stateprep)
s.append(m.cavity.displace(1.0, fpga_mixer_mask=(True, True)))
s.append(wigodds(np.pi, 0))
s.append(fpgapulses.LongMeasurementPulse(label='measure'))
s.append(sequencer.Delay(REPRATE_DELAY))
if BG:
s.append(stateprep)
s.append(m.cavity.displace(1.0, fpga_mixer_mask=(True, True)))
s.append(wigevens(np.pi, 0))
s.append(fpgapulses.LongMeasurementPulse(label='measure'))
s.append(sequencer.Delay(REPRATE_DELAY))
s.append(
fpgapulses.RegOp(RegisterInstruction.ADDI(2, -DQ),
label='Qstep',
fpga_counter1=-1))
s.append(
fpgapulses.RegOp(RegisterInstruction.ADDI(1, +DQ),
fpga_internal_function=FPGASignals.c1,
jump=('next', 'displace')))
import numpy as np
from pulseseq import sequencer, pulselib
import sys
import time
import fpgapulses
import fpgameasurement
import fpga_sequences
from YngwieEncoding import *
REPRATE_DELAY = 50000 # Delay to get a reasonable repetition rate
m = fpgameasurement.FPGAMeasurement('cool', rrec=False)
s = sequencer.Sequence()
s.append(sequencer.Constant(512, 1, value=1, chan='m0'))
s.append(fpga_sequences.qubit_cool(m, label='qcool', tgtlabel='measure'))
s.append(
fpgapulses.RegOp(RegisterInstruction.NOP(),
master_integrate=m.integrate_log,
label='measure'))
s.append(fpgapulses.LongMeasurementPulse())
s.append(sequencer.Delay(REPRATE_DELAY, jump='qcool'))
m.set_seq(s, 10)
#m.generate(plot=True)
m.start_exp()
m.plot_histogram()
cav_freq = 5556.97e6
cspec = cavspectroscopy.CavSpectroscopy(mclient.instruments['brick3'],
qubit_info,
cavity_info1B, [0.01],
np.linspace(
cav_freq - 0.5e6,
cav_freq + 0.5e6, 61),
Qswitchseq=None)
cspec.measure()
bla
if 1: # pump tone spectroscopy
from scripts.single_cavity import cavspectroscopy
cav_freq = 7782.70e6
seq = sequencer.Join([
sequencer.Delay(10000),
sequencer.Combined([
Qswitch_info1A.rotate(np.pi, 0), # 250us square pulse pump
Qswitch_info1B.rotate(np.pi, 0),
sequencer.Repeat(sequencer.Constant(1000, 0.0001, chan=5),
250), # Qubit/Readout master switch
]),
sequencer.Delay(20000)
])
cspec = cavspectroscopy.CavSpectroscopy(
mclient.instruments['brick4'],
qubit_info,
cavity_info1B, [1.2],
np.linspace(cav_freq - 0.5e6, cav_freq + 0.5e6, 61),
Qswitchseq=seq,
extra_info=[Qswitch_info1A, Qswitch_info1B])
import numpy as np
from pulseseq import sequencer, pulselib
import fpgapulses
import fpgameasurement
REPRATE_DELAY = 1000000 # Delay to get a reasonable repetition rate
delays = np.round(np.linspace(0, 800, 41))
m = fpgameasurement.FPGAMeasurement('cavT1',
xs=delays,
fit_func='cohstate_decay',
fit_func_kwargs=dict(n=0))
s = sequencer.Sequence()
s.append(sequencer.Delay(256, label='start'))
for delay in delays:
# s.append(sequencer.Constant(1000, 1, chan='m0'))
s.append(m.cavity.displace(2.0)) #*np.exp(1j*np.pi/4)))
if delay != 0:
s.append(sequencer.Delay(delay * 1000))
s.append(m.qubit.rotate(np.pi, 0))
s.append(fpgapulses.LongMeasurementPulse())
s.append(sequencer.Delay(REPRATE_DELAY - delay * 1000))
s.append(sequencer.Delay(256, jump='start'))
m.set_seq(s, len(delays))
#m.generate(plot=True)
m.start_exp()
m.plot_se()
# this function will set the correct qubit_info sideband phase for use in experiments
# i.e. combines the AWG skew with the 7036.120e6current sideband phase offset
cal.set_tuning_parameters(set_sideband_phase=True)
cal.load_test_waveform()
cal.print_tuning_parameters()
bla
if 0: # test Q function
from scripts.single_cavity import Qfunction
for delay in [100, 200, 300, 400, 500]:
seq = sequencer.Join([
sequencer.Trigger(250),
c(1.0, 0),
ge(np.pi, 0),
ef(np.pi, 0),
sequencer.Delay(delay),
ef(-np.pi, 0),
ge(-np.pi, 0)
])
Qfun = Qfunction.QFunction(qubit_info1,
cavity_info1A,
amax=2.5,
N=11,
amaxx=None,
Nx=None,
amaxy=None,
Ny=None,
seq=seq,
delay=0,
saveas=None,
bgcor=False,
if 0: # spectroscopy for EF transition
from scripts.single_qubit import spectroscopy as spectroscopy
qubit_ef_freq = 5898.7e6 #5239.790e6-50e6-175e6
freq_range = 10e6
freqs = np.linspace(qubit_ef_freq - freq_range, qubit_ef_freq + freq_range,
101)
drive_power = -33
qubit_brick.set_rf_on(1)
spec_brick.set_rf_on(1)
spec_brick.set_pulse_on(1)
seq = sequencer.Sequence([
sequencer.Trigger(250), # prepend pi pulse
qubit_info.rotate(np.pi, 0),
sequencer.Delay(10)
])
postseq = sequencer.Sequence(qubit_info.rotate(np.pi,
0)) # postpend pi pulse
# for drive_power in drive_powers:
spec_params = (spec_brick, drive_power)
spec_brick.set_power(drive_power)
# spec_params = (qubit_ef_brick, None)
s = spectroscopy.Spectroscopy(
spec_info,
freqs,
spec_params,
use_marker=True,
plen=5e3,
amp=0.1,
