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 get_readout_pulse(self, pulse_len=None):
if pulse_len is None:
pulse_len = self.readout_info.pulse_len
if not hasattr(self.readout_info, 'flux_chan'):
return sequencer.Combined([
pulselib.Constant(pulse_len, 1, chan=self.readout_info.readout_chan),
pulselib.Constant(pulse_len, 1, chan=self.readout_info.acq_chan),
])
else:
flux_pulse = lambda duration, flux_level: pulselib.Constant(duration,
flux_level, chan=self.readout_info.flux_chan)
s = sequencer.Sequence()
s.append(flux_pulse(self.readout_info.pre_flux_len,
self.readout_info.ro_flux_amp))
s.append(sequencer.Combined([
pulselib.Constant(self.readout_info.pulse_len, 1,
chan=self.readout_info.readout_chan),
pulselib.Constant(self.readout_info.pulse_len, 1,
chan=self.readout_info.acq_chan),
flux_pulse(self.readout_info.pulse_len,
self.readout_info.ro_flux_amp)
]))
s.append(flux_pulse(self.readout_info.post_flux_len,
self.readout_info.ro_flux_amp))
#This is required so that after one expt and before the next trigger
#we chill at zero flux.
s.append(flux_pulse(2000,0)) # this is extended to
return s
def load_test_waveform(self):
self.awg.delete_all_waveforms()
self.awg.get_id() #Sometimes AWGs are slow. If it responds it's ready.
length = abs(int(1e9/self.if_freq *100))
qubit_info = mclient.get_qubit_info(self.qubit_info.get_name())
s = sequencer.Sequence()
s.append(sequencer.Combined([
sequencer.Constant(length, 0.25, chan=qubit_info.sideband_channels[0]),
sequencer.Constant(length, 0.25, chan=qubit_info.sideband_channels[1])]))
s = sequencer.Sequencer(s)
s.add_ssb(qubit_info.ssb)
seqs = s.render()
self.seqs = seqs
l = awgloader.AWGLoader(bulkload=config.awg_bulkload)
base = 1
for i in range(1, 5):
awg = instruments['AWG%d'%i]
if awg:
chanmap = {1:base, 2:base+1, 3:base+2, 4:base+3}
logging.info('Adding AWG%d, channel map: %s', i, chanmap)
l.add_awg(awg, chanmap)
base += 4
l.load(seqs)
l.run()
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 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 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
def __call__(self, alpha, amp=None, plot=False, **kwargs):
'''
Generate a rotation pulse of angle <alpha> around axis <phase>.
If <amp> is specified that amplitude is used and <alpha> is ignored.
'''
self.determine_correction()
sequencer.Pulse.RANGE_ACTION = sequencer.IGNORE
data = self.get_pulse_data()
name = self.get_pulse_name()
Ipulse = sequencer.Pulse('%s_I' % name,
np.real(data),
chan=self.chans[0]).rendered()
Qpulse = sequencer.Pulse('%s_Q' % name,
np.imag(data),
chan=self.chans[1]).rendered()
if plot:
plt.figure()
plt.plot(self.pulse.data)
plt.plot(np.real(data))
plt.plot(np.imag(data))
plt.plot(2 * np.arange(len(data) / 2), np.real(data[::2]), 'ks')
plt.plot(2 * np.arange(len(data) / 2), np.imag(data[::2]), 'ro')
pulses = []
Ipulse.set_params(mixer_amplitudes=(0xffff, 0), **kwargs)
pulses.append(Ipulse)
Qpulse.set_params(mixer_amplitudes=(0, 0xffff), **kwargs)
pulses.append(Qpulse)
if self.marker_chan is not None:
mpulse = sequencer.Constant(pulses[0].get_length(),
self.marker_val,
chan=self.marker_chan,
**kwargs)
pulses.append(mpulse)
if len(pulses) == 1:
return sequencer.Sequence(pulses, **kwargs)
else:
return sequencer.Combined(pulses, **kwargs)
def qubit_cool(m, NCONVINCE=4, label='qcool', tgtlabel=None):
'''
Qubit cooling sequence: measure |g> <NCONVINCE> times in a row.
If <tgtlabel> is None, a function return will be generated at the end,
otherwise the sequence jumps to <tgtlabel> on completion.
Uses counter0
'''
if tgtlabel:
retlabel = tgtlabel
else:
retlabel = label + '_ret'
s = sequencer.Sequence()
s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), master_integrate=m.integrate_nolog, master_counter0=NCONVINCE, label=label))
s.append(fpgapulses.LongMeasurementPulse(label=label+'_meas'))
s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), length=220, master_internal_function=ye.FPGASignals.s0, jump=(label+'_decc0', 'next')))
# We measured |e>, reset counter and jump back to measure
s.append(m.qubit.rotate(np.pi,0,jump=label+'_meas',master_counter0=NCONVINCE))
s.append(fpgapulses.RegOp(ye.RegisterInstruction.NOP(), master_counter0=-1, master_internal_function=ye.FPGASignals.c0, jump=(retlabel, label+'_meas'), label=label+'_decc0'))
if tgtlabel is None:
s.append(fpgapulses.RegOp(ye.RegisterInstruction., NCONVINCE=4NOP(), callreturn=True, label=retlabel))
return s
import time
import fpgapulses
import fpgameasurement
import YngwieEncoding as ye
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:
def __call__(self, alpha, phase, amp=None, **kwargs):
'''
Generate a rotation pulse of angle <alpha> around axis <phase>.
If <amp> is specified that amplitude is used and <alpha> is ignored.
'''
if amp is None:
amp = self.ampgen(alpha)
amp *= 65535.0
pulses = []
kwargs['chan%d_mixer_amplitudes' %
self.chans[0]] = (np.cos(phase) * amp, np.sin(phase) * amp)
kwargs['chan%d_mixer_amplitudes' %
self.chans[1]] = (-np.sin(phase) * amp, np.cos(phase) * amp)
if 'detune_period' in kwargs and kwargs['detune_period'] != 0:
period = kwargs.pop('detune_period')
ts = np.arange(len(self.Ipulse.data))
data = self.Ipulse.data * np.exp(2j * np.pi * ts / period)
if 0:
import matplotlib.pyplot as plt
plt.figure()
plt.plot(ts, np.real(data))
plt.plot(ts, np.imag(data))
plt.suptitle('period=%s' % period)
Ipulse = sequencer.Pulse('%s_re%s' % (self.Ipulse.name, period),
np.real(data),
chan=self.chans[0]).rendered()
Qpulse = sequencer.Pulse('%s_im%s' % (self.Ipulse.name, period),
np.imag(data),
chan=self.chans[1]).rendered()
Ipulse.set_params(**kwargs)
pulses.append(Ipulse)
Qpulse.set_params(**kwargs)
pulses.append(Qpulse)
else:
if self.Ipulse:
p = copy.deepcopy(self.Ipulse)
pulses.append(p)
pulses[-1].chan = self.chans[0]
pulses[-1].set_params(**kwargs)
if not self.Qpulse:
pulses.append(
sequencer.Constant(self.Ipulse.get_length(),
1e-6,
chan=self.chans[1]))
pulses[-1].set_params(
mixer_amplitudes=(-amp * np.sin(phase),
amp * np.cos(phase)),
**kwargs)
if self.Qpulse:
p = copy.deepcopy(self.Qpulse)
pulses.append(p)
pulses[-1].chan = self.chans[1]
pulses[-1].set_params(**kwargs)
sequencer.Pulse.RANGE_ACTION = sequencer.IGNORE
if self.marker_chan is not None:
mpulse = sequencer.Constant(pulses[0].get_length(),
self.marker_val,
chan=self.marker_chan,
**kwargs)
pulses.append(mpulse)
if len(pulses) == 1:
return sequencer.Sequence(pulses)
else:
return sequencer.Combined(pulses, **kwargs)
def measure(self):
from scripts.single_qubit import spectroscopy
from scripts.calibration import ropower_calibration
from scripts.calibration import ro_power_cal
from scripts.single_cavity import rocavspectroscopy
from scripts.single_qubit import rabi
from scripts.single_qubit import T1measurement
from scripts.single_qubit import T2measurement
from scripts.single_qubit import ssbspec_fit, stark_swap
spec = lambda q_freqs, ro_freq, ro_power, yoko_set_val: \
spectroscopy.Spectroscopy(
self.qubit_info,
q_freqs,
[self.qubit_rfsource, self.spec_power],
# [ro_power],
plen=self.plen,
amp=self.amp,
seq=self.seq,
postseq=self.postseq,
# pow_delay=self.pow_delay,
extra_info=self.extra_info,
freq_delay=self.freq_delay,
plot_type=self.plot_type,
title='Spec: (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n' % (ro_freq, ro_power, yoko_set_val),
analyze_data=True,
keep_data=True,
use_IQge=self.use_IQge,
use_weight=self.use_weight,
subtraction=self.subtraction)
SSBspec = lambda q_freqs, ro_freq, ro_power, yoko_set_val, b_freq, simulseq: \
ssbspec_fit.SSBSpec_fit(
self.qubit_info, q_freqs,
seq=self.seq,
simulseq = simulseq,
postseq = self.postseq,
bgcor = self.spec_bgcor,
extra_info=self.extra_info,
title='Spec: (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n brick_freq: %0.4e\n' % (ro_freq, ro_power, yoko_set_val, b_freq),
generate = self.spec_generate,
)
ropcal = lambda powers: ropower_calibration.ROPower_Calibration(
self.qubit_info,
powers,
qubit_pulse=ropower_calibration.SAT_PULSE)
orcpcal = lambda powers, curAmp, curplen: ro_power_cal.Optimal_Readout_Power(
self.qubit_info,
powers,
plen=curplen, amp=curAmp, update_readout=True, verbose_plots=False,
plot_best=False,
shots=self.ro_shots)
rospec = lambda power, ro_freqs: rocavspectroscopy.ROCavSpectroscopy(self.qubit_info, [power], ro_freqs)
rb = lambda amps, ro_freq, ro_power, yoko_set_val: rabi.Rabi(self.qubit_info, amps, r_axis = 0,
seq = None, postseq = None,
plot_seqs=False,
update=False,
title='Rabi: (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n' % (ro_freq, ro_power, yoko_set_val),
)
T1 = lambda delays, ro_freq, ro_power, yoko_set_val: T1measurement.T1Measurement(self.qubit_info, delays,
double_exp=False,
bgcor = self.T1_bgcor,
title='T1: (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n' % (ro_freq, ro_power, yoko_set_val),
)
T2 = lambda delays, detune, ro_freq, ro_power, yoko_set_val: T2measurement.T2Measurement(self.qubit_info, delays, detune,
title='T2: (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n' % (ro_freq, ro_power, yoko_set_val),
)
T2Echo = lambda delays, detune, ro_freq, ro_power, yoko_set_val: T2measurement.T2Measurement(self.qubit_info, delays, detune, echotype = T2measurement.ECHO_CPMG,
fit_type = 'gaussian_decay', necho = 1,
title='T2CPMG(N=1): (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n' % (ro_freq, ro_power, yoko_set_val),
)
PhT1 = lambda delays, ro_freq, ro_power, set_val: stark_swap.phonon_T1(self.qubit_info, delays,
phonon_pi = self.Ph_piLength, amp = self.Ph_amp-set_val, sigma = self.Ph_sigma,
title='T1: (ro freq, ro pwr)=(%0.4e, %0.2f); setpt %0.3e V\n' % (ro_freq, ro_power, set_val),
)
# initialize yoko to a known set_val
if self.qubit_yoko != None:
# if self.source_type == 'VOLT':
# self.qubit_yoko.do_set_voltage(0)
# elif self.source_type == 'CURR':
# self.qubit_yoko.do_set_current(0)
# else:
# print 'source type needs to be VOLT or CURR'
# return False
self.qubit_yoko.set_output_state(1)
# if self.stark_rfsource != None:
# self.stark_rfsource.set_power(-40)
# self.stark_rfsource.set_rf_on(1)
time.sleep(1)
if 'SPEC' in self.experiments:
self.last_center = np.average(self.freqs) # middle point
elif 'SSBSPEC' in self.experiments:
self.last_center = self.qubit_rfsource.get_frequency()+self.sideband_freq # use current setting of brick
self.next_center = self.qubit_rfsource.get_frequency()+self.sideband_freq
elif self.qubit_freq_fxn!=None:
self.last_center = self.qubit_freq_fxn(self.set_vals[0])
else:
self.last_center = 0 #Not doing spec or changing frequency, so keeping same qubit frequency. Presumably this means we're not tuning pwr either, so this case should never be used.
self.last_freq_tune_center = self.last_center
self.last_pwr_tune_center = self.last_center
self.ro_source.set_frequency(self.ro_freq)
self.ro_source.set_power(self.ro_power)
for idx, set_val in enumerate(self.set_vals):
if self.source_type == 'VOLT':
self.qubit_yoko.do_set_voltage(float(set_val))
elif self.source_type == 'CURR':
self.qubit_yoko.do_set_current(float(set_val))
elif self.source_type == 'STARK':
self.stark_rfsource.set_power(float(set_val))
elif self.source_type == 'STARK_V':
if self.stark_V_channel == 'ch3':
self.stark_rfsource.set_ch3_offset(float(set_val))
elif self.source_type == 'STARKSSB':
self.simulseq = sequencer.Sequence(pulselib.GaussSquare(self.qubit_info.w_selective*4+2*self.starkw, float(set_val), self.starkw, chan = self.starkch))
time.sleep(1)
self.yoko_set_vals[idx] = set_val
# ro frequency
if 'ROFREQ' in self.experiments:
if ((self.ro_freq_tune != -1 and (idx % self.ro_freq_tune) == 0)\
or (self.ro_freq_tune == -1 and np.absolute(self.last_center-self.last_freq_tune_center) > self.ro_freq_tune_interval))\
and (self.ro_spec_range !=0): #tune if it's been ro_freq_tune runs or, if not, the qubit has shifted by ro_freq_tune_interval
self.funcgen.set_frequency(5000) #rep rate
self.alazar.set_naverages(3000)
self.qubit_rfsource.set_rf_on(0) #in case rf source is resonant with qubit. This would mess up readout spec
ro_freqs = np.linspace(self.ro_freq - self.ro_spec_range,
self.ro_freq + self.ro_spec_range,
51)
ro = rospec(self.ro_power, ro_freqs)
ro.measure()
plt.close()
self.qubit_rfsource.set_rf_on(1)
self.ro_freq = ro.fit_params[0][2]
self.last_freq_tune_center = self.last_center
elif self.ro_freq_fxn!=None:
self.ro_freq = self.ro_freq_fxn(set_val)
self.ro_source.set_frequency(self.ro_freq)
self.ro_LO.set_frequency(self.ro_freq+50e6)
self.ro_freq_log[idx] = self.ro_freq
self.ro_pwr_log[idx] = self.ro_power
# qubit saturation spec
if 'SPEC' in self.experiments:
self.funcgen.set_frequency(self.spec_funcgen_freq) #rep rate
self.alazar.set_naverages(self.spec_avgs)
spec_exp = spec(self.freqs, self.ro_freq, self.ro_power, set_val)
spec_exp.measure()
plt.close()
center = spec_exp.fit_params['x0'].value * 1e6
width = spec_exp.fit_params['w'].value * 1e6
#save RO power, spec power, freqs, center, width, raw data..
# self.IQs[idx,:] = spec_exp.IQs[0,:]
# self.amps[idx,:] = spec_exp.amps[0,:]
self.IQs[idx,:] = spec_exp.IQs[:]
self.amps[idx,:] = spec_exp.reals[:]
# save spec fit and experiment parameter data
self.widths[idx] = width
self.spec_log[idx] = self.spec_power
self.freqs_log[idx,:] = self.freqs
#choose the next frequency range
delta = center - self.last_center
if self.freq_step == 0:
# no step, keep the same frequency range
self.freqs = self.freqs
self.last_center = center
elif idx == 0: # first point; don't try to stop
self.freqs = self.freqs + delta + self.freq_step
self.last_center = center
else:
# use 0th order estimator from last points
# we will weight the frequency step to the expected direction
# of the frequency step
if self.freq_step > 0:
# increasing freq
ll, ul = np.array([-0.25, 1.25]) * self.freq_step
else:
# decreasing freq
ll, ul = np.array([1.25, -0.25]) * self.freq_step
#Commented out 9/3/14 Jacob, not quite right.
# if not ll < delta < ul:
# print 'quitting: we seem to have lost the qubit'
# break
#if the width is off, probably a sign that we're not fitting to qubit peak
if not self.width_min*0.5 < width < self.width_max*2:
print 'quitting: we seem to have lost the qubit'
break
# pick new frequency range such that the NEXT point should be centered
q_freqs_center = np.average(self.freqs)
# current point is centered
self.freqs = self.freqs + (center - q_freqs_center)
# blah = np.average(self.freqs)
# offset to center next point
self.freqs = self.freqs + delta
# print 'debug: center: %0.3f, , last center: %0.3f, freq_step: %0.3f, , delta: %0.3f, ' %\
# (center, self.last_center, self.freq_step, delta)
# print 'debug; current center: %0.3f, current pt center: %0.3f, next pt center: %0.3f' %\
# (q_freqs_center, blah, np.average(self.freqs))
self.last_center = center
self.freq_step = delta
# see if we should adjust spec power
if width < self.width_min:
self.amp *= 2
# self.spec_power += 1
elif width > self.width_max:
self.amp /= 2
# self.spec_power -= 1
elif self.qubit_freq_fxn!=None:
self.last_center = self.qubit_freq_fxn(set_val)
self.qubit_rfsource.set_frequency(self.last_center)
self.center_freqs[idx] = self.last_center
# qubit SSB spec
if 'SSBSPEC' in self.experiments:
# self.qubit_inst.set_w(self.plen)
# self.qubit_inst.set_pi_amp(self.amp)
self.funcgen.set_frequency(self.spec_funcgen_freq) #rep rate
self.alazar.set_naverages(self.spec_avgs)
self.qubit_rfsource.set_frequency(self.next_center-self.sideband_freq)
spec_exp = SSBspec(self.freqs, self.ro_freq, self.ro_power, set_val, self.qubit_rfsource.get_frequency(), self.simulseq)
spec_exp.measure()
plt.close()
center = self.next_center + np.sign(self.sideband_freq)*spec_exp.fit_params['x0'].value
width = spec_exp.fit_params['w'].value
#save RO power, spec power, freqs, center, width, raw data..
# self.IQs[idx,:] = spec_exp.IQs[0,:]
# self.amps[idx,:] = spec_exp.amps[0,:]
# self.IQs[idx,:] = spec_exp.IQs[:]
self.amps[idx,:] = spec_exp.get_ys()
# save spec fit and experiment parameter data
self.widths[idx] = width
self.spec_log[idx] = self.spec_power
if np.sign(self.sideband_freq)<0:
self.freqs_log[idx,:] = self.next_center - np.flipud(self.freqs)
self.amps[idx,:] = np.flipud(spec_exp.get_ys())
else:
self.freqs_log[idx,:] = self.next_center + self.freqs
self.amps[idx,:] = spec_exp.get_ys()
#choose the next frequency range
delta = center - self.last_center
self.last_center = center
if self.freq_step == 0:
# no step, keep the same center frequency
self.next_center = self.next_center
elif idx == 0: # first point; don't try to stop
self.next_center = center + self.freq_step
else:
# use 0th order estimator from last points
# we will weight the frequency step to the expected direction
# of the frequency step
# if self.freq_step > 0:
# # increasing freq
# ll, ul = np.array([-0.25, 1.25]) * self.freq_step
# else:
# # decreasing freq
# ll, ul = np.array([1.25, -0.25]) * self.freq_step
#Commented out 9/3/14 Jacob, not quite right.
# if not ll < delta < ul:
# print 'quitting: we seem to have lost the qubit'
# break
#if the width is off, probably a sign that we're not fitting to qubit peak
# if not self.width_min*0.5 < width < self.width_max*2:
# print 'quitting: we seem to have lost the qubit'
# break
# pick new frequency range such that the NEXT point should be centered
self.next_center = center + delta
# print 'debug: center: %0.3f, , last center: %0.3f, freq_step: %0.3f, , delta: %0.3f, ' %\
# (center, self.last_center, self.freq_step, delta)
# print 'debug; current center: %0.3f, current pt center: %0.3f, next pt center: %0.3f' %\
# (q_freqs_center, blah, np.average(self.freqs))
self.freq_step = delta
# # see if we should adjust spec power
# if width < self.width_min:
# self.amp *= 2
# # self.spec_power += 1
# elif width > self.width_max:
# self.amp /= 2
# # self.spec_power -= 1
elif self.qubit_freq_fxn!=None:
self.last_center = self.qubit_freq_fxn(set_val)
self.qubit_rfsource.set_frequency(self.last_center-self.sideband_freq)
self.center_freqs[idx] = self.last_center
if 'RABI' in self.experiments:
# self.qubit_inst.set_w(self.rabi_pulse_len)
self.funcgen.set_frequency(self.rabi_funcgen_freq) #rep rate
self.alazar.set_naverages(self.rabi_avgs)
self.qubit_rfsource.set_power(self.rabi_rf_pwr)
rabi_exp = rb(self.init_rabi_amps, self.ro_freq, self.ro_power, set_val)
rabi_exp.measure()
plt.close()
rabi_A = rabi_exp.fit_params['A'].value
rabi_f = rabi_exp.fit_params['f'].value
rabi_ph = rabi_exp.fit_params['dphi'].value
#find pi pulse amplitude. Accounts for offsets
pi_amp = (np.pi-np.pi/2*np.sign(rabi_A)-rabi_ph%(2*np.pi))/(2*np.pi*rabi_f)
self.rabi_amps_log[idx,:] = rabi_exp.xs[:]
self.rabi_dat[idx,:] = rabi_exp.get_ys()[:]
# save spec fit and experiment parameter data
self.rabi_A[idx] = rabi_A
self.rabi_f[idx] = rabi_f
self.rabi_ph[idx] = rabi_ph
elif self.pi_amp_fxn!=None:
pi_amp = self.pi_amp_fxn(set_val)
else:
pi_amp = 0
self.pi_amp[idx] = pi_amp
if np.absolute(pi_amp)>1e-3 and np.absolute(pi_amp)<1:
self.qubit_inst.set_pi_amp(pi_amp)
if 'T1' in self.experiments:
self.funcgen.set_frequency(self.T1_funcgen_freq) #rep rate
self.alazar.set_naverages(self.T1_avgs)
self.qubit_rfsource.set_power(self.T1_rf_pwr)
T1_exp = T1(self.T1_delays, self.ro_freq, self.ro_power, set_val)
T1_exp.measure()
plt.close()
T1_A = T1_exp.fit_params['A'].value
T1_A_err = T1_exp.fit_params['A'].stderr
T1_tau = T1_exp.fit_params['tau'].value
T1_tau_err = T1_exp.fit_params['tau'].stderr
self.T1_delays_log[idx,:] = T1_exp.xs[:]
self.T1_dat[idx,:] = T1_exp.get_ys()[:]
# save spec fit and experiment parameter data
self.T1_A[idx] = T1_A
self.T1_A_err[idx] = T1_A_err
self.T1_tau[idx] = T1_tau
self.T1_tau_err[idx] = T1_tau_err
#decide next T1 delays
if self.T1_update_delays and T1_tau>0.001 and T1_tau<1000: #in case something goes wrong in the fitting
self.T1_delays = np.linspace(0, T1_tau*1e3*8, self.num_T1_pts)
if 'T2' in self.experiments:
self.funcgen.set_frequency(self.T2_funcgen_freq) #rep rate
self.alazar.set_naverages(self.T2_avgs)
self.qubit_rfsource.set_power(self.T2_rf_pwr)
T2_exp = T2(self.T2_delays, self.T2_delta, self.ro_freq, self.ro_power, set_val)
T2_exp.measure()
plt.close()
T2_tau = T2_exp.fit_params['tau'].value
T2_tau_err = T2_exp.fit_params['tau'].stderr
T2_f = T2_exp.fit_params['f'].value
T2_f_err = T2_exp.fit_params['f'].stderr
self.T2_delays_log[idx,:] = T2_exp.xs[:]
self.T2_dat[idx,:] = T2_exp.get_ys()[:]
# save spec fit and experiment parameter data
self.T2_f[idx] = T2_f
self.T2_f_err[idx] = T2_f_err
self.T2_tau[idx] = T2_tau
self.T2_tau_err[idx] = T2_tau_err
if self.T2_set_f:
freq_offset = np.absolute(T2_f*1e6-self.T2_delta)
freq_old = self.last_center
ctr = 0
while freq_offset > 2e6/(2*np.pi*T1_tau):
ctr += 1
if ctr > 3:
print 'quitting: cannot find qubit frequency from Ramsey'
break
else:
freq_cur = freq_old + freq_offset
self.qubit_rfsource.set_frequency(freq_cur)
T2_exp = T2(self.T2_delays, self.T2_delta, self.ro_freq, self.ro_power, set_val)
T2_exp.measure()
plt.close()
freq_offset_old = freq_offset
freq_offset = np.absolute(T2_exp.fit_params['f'].value*1e6-self.T2_delta)
if freq_offset <= freq_offset_old:
freq_old = freq_cur
if freq_offset > freq_offset_old:
freq_cur = freq_old - freq_offset_old
self.qubit_rfsource.set_frequency(freq_cur)
T2_exp = T2(self.T2_delays, self.T2_delta, self.ro_freq, self.ro_power, set_val)
T2_exp.measure()
plt.close()
freq_offset = np.absolute(T2_exp.fit_params['f'].value*1e6-self.T2_delta)
freq_old = freq_cur
# set zero detuning based on Ramsey frequency
# if self.T2_set_f:
# freq_offset = np.absolute(T2_f-self.T2_delta/1e6)
# if freq_offset > 1/(2*np.pi*T1_tau):
# self.qubit_rfsource.set_frequency(self.last_center + freq_offset*1e6)
# T2_exp = T2(self.T2_delays, self.T2_delta, self.ro_freq, self.ro_power, set_val)
# T2_exp.measure()
# plt.close()
# T2_f_new = T2_exp.fit_params['f'].value
# if np.absolute(T2_f_new-self.T2_delta/1e6) > 1/(2*np.pi*T1_tau):
# self.qubit_rfsource.set_frequency(self.last_center - freq_offset*1e6)
# T2_exp = T2(self.T2_delays, self.T2_delta, self.ro_freq, self.ro_power, set_val)
# T2_exp.measure()
# plt.close()
# T2_f_new = T2_exp.fit_params['f'].value
# if np.absolute(T2_f_new-self.T2_delta/1e6) > 1/(2*np.pi*T1_tau):
# print 'quitting: cannot find qubit frequency from Ramsey'
# break
#decide next T2 delays and detunings
if T2_tau>0.001 and T2_tau<1000: #in case something goes wrong in the fitting
self.T2_delays = np.linspace(0, T2_tau*1e3*3, self.num_T2_pts)
self.T2_delta = 3/T2_tau*1e6
if 'T2Echo' in self.experiments:
self.funcgen.set_frequency(self.T2E_funcgen_freq) #rep rate
self.alazar.set_naverages(self.T2E_avgs)
self.qubit_rfsource.set_power(self.T2E_rf_pwr)
T2E_exp = T2Echo(self.T2E_delays, self.T2E_delta, self.ro_freq, self.ro_power, set_val)
T2E_exp.measure()
plt.close()
T2E_tau = T2E_exp.fit_params['sigma'].value
T2E_tau_err = T2E_exp.fit_params['sigma'].stderr
T2E_A = T2E_exp.fit_params['area'].value / (2 * T2E_tau) / np.sqrt(np.pi / 2)
T2E_A_err = np.absolute(T2E_A)*np.sqrt((T2E_tau_err/T2E_tau)**2+(T2E_exp.fit_params['area'].stderr/T2E_A)**2)
self.T2E_delays_log[idx,:] = T2E_exp.xs[:]
self.T2E_dat[idx,:] = T2E_exp.get_ys()[:]
# save spec fit and experiment parameter data
self.T2E_A[idx] = T2E_A
self.T2E_A_err[idx] = T2E_A_err
self.T2E_tau[idx] = T2E_tau
self.T2E_tau_err[idx] = T2E_tau_err
if T2E_tau>0.001 and T2E_tau<1000: #in case something goes wrong in the fitting
self.T2E_delays = np.linspace(0, T2E_tau*1e3*5, self.num_T2E_pts)
if 'PhT1' in self.experiments:
self.funcgen.set_frequency(self.PhT1_funcgen_freq) #rep rate
self.alazar.set_naverages(self.PhT1_avgs)
PhT1_exp = PhT1(self.PhT1_delays, self.ro_freq, self.ro_power, set_val)
PhT1_exp.measure()
plt.close()
PhT1_A = PhT1_exp.fit_params['A'].value
PhT1_A_err = PhT1_exp.fit_params['A'].stderr
PhT1_tau = PhT1_exp.fit_params['tau'].value
PhT1_tau_err = PhT1_exp.fit_params['tau'].stderr
self.PhT1_delays_log[idx,:] = PhT1_exp.xs[:]
self.PhT1_dat[idx,:] = PhT1_exp.get_ys()[:]
# save spec fit and experiment parameter data
self.PhT1_A[idx] = PhT1_A
self.PhT1_A_err[idx] = PhT1_A_err
self.PhT1_tau[idx] = PhT1_tau
self.PhT1_tau_err[idx] = PhT1_tau_err
#RO power
if 'ROPWR' in self.experiments:
if ((self.ro_pwr_tune != -1 and (idx % self.ro_pwr_tune) == 0)\
or (self.ro_pwr_tune == -1 and np.absolute(self.last_center-self.last_pwr_tune_center) > self.ro_pwr_tune_interval)): #tune if it's been ro_pwr_tune runs or, if not, the qubit has shifted by ro_pwr_tune_interval
self.qubit_rfsource.set_frequency(self.last_center)
self.qubit_rfsource.set_power(self.ropwr_qubit_rf_pwr)
self.funcgen.set_frequency(5000) #rep rate
self.alazar.set_naverages(3000)
powers = np.arange(self.ro_power - self.ro_range,
self.ro_power + self.ro_range + self.ro_step,
self.ro_step)
# r = ropcal(powers)
if self.ro_pwr_pi == False:
r = orcpcal(powers, self.amp, self.plen)
else:
r = orcpcal(powers, self.amp, None)
r.measure()
plt.close()
# # update power
# self.ro_power = r.get_best_power()
self.ro_power = r.best_power
self.last_pwr_tune_center = self.last_center
elif self.ro_pwr_fxn!=None:
self.ro_power = self.ro_pwr_fxn(set_val)
self.ro_source.set_power(self.ro_power)
self.analyze(idx)
# if self.qubit_yoko != None:
# if self.source_type == 'VOLT':
# self.qubit_yoko.do_set_voltage(0)
# elif self.source_type == 'CURR':
# self.qubit_yoko.do_set_current(0)
# self.qubit_yoko.set_output_state(0)
if self.stark_rfsource != None:
self.stark_rfsource.set_rf_on(0)
# self.analyze()
# if self.savefig:
# self.save_fig()
return self.set_vals, self.freqs, self.IQs[:]
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])
cspec.measure()
bla
if 0: #Find qubit ef
from scripts.single_qubit import spectroscopy
ef_freq = 4959.00e6
seq = sequencer.Sequence(
[sequencer.Trigger(250),
qubit_info1.rotate(np.pi, 0)])
postseq = sequencer.Sequence(qubit_info1.rotate(np.pi, 0))
spec = spectroscopy.Spectroscopy(mclient.instruments['ag3'],
ef_info,
np.linspace(ef_freq - 5e6, ef_freq + 5e6,
101), [-32],
plen=2000,
amp=0.004,
seq=seq,
postseq=postseq,
extra_info=qubit_info,
plot_seqs=False)
spec.measure()
bla
],
real_signals=True,
histogram=True,
title='|e>')
tr.measure()
tr = rabi_IQ.Rabi(qubit_info, [
0.00,
],
real_signals=True,
histogram=True,
title='|g>')
tr.measure()
if 0:
from scripts.single_qubit import rabi
alz.set_naverages(50000)
seq = sequencer.Sequence([
sequencer.Trigger(250),
cavity_info1A.rotate(0, 0),
cavity_info1B.rotate(0, 0)
])
tr = rabi.Rabi(qubit_info, [
0.00,
],
histogram=True,
seq=seq,
title='|g>',
generate=True,
extra_info=[cavity_info1A, cavity_info1B])
tr.measure()
qubit_ef_brick = instruments['qubit_ef_brick']
#va_lo = instruments['va_lo']
va_lo_4_8 = instruments['va_lo']
funcgen = instruments['funcgen']
alazar = instruments['alazar']
spec_brick = instruments['spec_brick']
spec_info = mclient.get_qubit_info('spec_info')
LO_brick = instruments['LO_brick']
LO_info = mclient.get_qubit_info('LO_info')
cavity_info = mclient.get_qubit_info('cavity_info')
yoko1 = instruments['yoko1']
yoko2 = instruments['yoko2']
#ro = mclient.get_readout_info('readout')
precool = sequencer.Sequence(
[sequencer.Trigger(250),
pulselib.GaussSquare(0.660e3, 0.056, 10, chan=3)])
precool2 = sequencer.Sequence(
[pulselib.GaussSquare(0.660e3, 0.056, 10, chan=3)])
#r = qubit_info.rotate
#
#
#calibSeq = sequencer.Sequence([sequencer.Trigger(250)])
#calibSeq.append(sequencer.Combined([
# pulselib.Constant(ro.pulse_len, 1, chan=ro.readout_chan),
# pulselib.Constant(ro.pulse_len, 1, chan=ro.acq_chan),
# ]))
#calibSeq.append(sequencer.Trigger(250))
#calibSeq.append(r(np.pi, 0))
#calibSeq.append(sequencer.Combined([
bla
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,
