def measure(self):
from scripts.single_qubit import spectroscopy
spec = lambda yv: \
spectroscopy.Spectroscopy(
self.qubit_info,
self.freqs,
[self.qubit_rfsource, self.spec_power],
# self.ro_powers,
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='Pulsed spectroscopy: (ro, spec) = (%0.2f, %0.2f) dBm; yoko %0.3f V\n' % (self.instruments['ag_ro'].get_power(), self.spec_power, yv),
analyze_data=True,
keep_data=True,
use_weight=self.use_weight,
use_IQge=self.use_IQge,
subtraction=self.subtraction
)
# initialize yoko to a known voltage
self.qubit_yoko.set_voltage(0)
self.qubit_yoko.set_output_state(1)
time.sleep(1)
for idx, voltage in enumerate(self.yoko_voltages):
self.qubit_yoko.set_voltage(voltage)
# run spec at this voltage
spec_exp = spec(voltage)
spec_exp.measure()
# spec_exp.started = False #trying to fix syncing. Something is wrong atm.
#save daata
self.IQs[idx, :] = spec_exp.IQs[:]
self.reals[idx, :] = spec_exp.reals[:]
self.qubit_yoko.set_voltage(0)
self.analyze()
if self.savefig:
self.save_fig()
return self.yoko_voltages, self.freqs, self.reals
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[:]
seq=None)
ro.measure()
bla
#Find qubit
if 0:
from scripts.single_qubit import spectroscopy
# from scripts.single_qubit import spectroscopy_IQ
qubit_freq = 5002.704e6
freq_range = 5e6
# seq = sequencer.Sequence([sequencer.Trigger(250), ef_info.rotate(np.pi, 0)])
spec = spectroscopy.Spectroscopy(mclient.instruments['brick2'],
qubit_info,
np.linspace(qubit_freq - freq_range,
qubit_freq + freq_range, 121),
[0],
plen=20000,
amp=0.10,
seq=None,
plot_seqs=False) #1=1ns5
# spec = spectroscopy_IQ.Spectroscopy_IQ(client.instruments['gen'], qubit_info,
# np.linspace(702e6, 710e6, 81), [-30],
# plen=250*100, amp=0.1, ssb=False, plot_seqs=False)
spec.measure()
bla
if 0: #SSB spec
from scripts.single_qubit import ssbspec
# seq = sequencer.Sequence([sequencer.Trigger(250), cavity_info1B.rotate(1, 0)])
spec = ssbspec.SSBSpec(qubit_info,
np.linspace(-10e6, 1e6, 101),
def measure(self):
from scripts.single_qubit import spectroscopy
from scripts.single_qubit import ropower_calibration
from scripts.calibration import ro_power_cal
spec = lambda q_freqs, ro_power, spec_power, yoko_voltage: \
spectroscopy.Spectroscopy(
self.qubit_info,
q_freqs,
[self.qubit_rfsource, 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='Pulsed spectroscopy: (ro, spec) = (%0.2f, %0.2f) dBm; yoko %0.3f V\n' % (ro_power, spec_power, yoko_voltage),
analyze_data=True,
keep_data=True,
use_IQge=self.use_IQge,
use_weight=self.use_weight,
subtraction=self.subtraction)
ropcal = lambda powers: ropower_calibration.ROPower_Calibration(
self.qubit_info, powers, qubit_pulse=ropower_calibration.SAT_PULSE)
orcpcal = lambda powers: ro_power_cal.Optimal_Readout_Power(
self.qubit_info,
powers,
plen=50e3,
update_readout=True,
verbose_plots=False,
plot_best=False,
shots=self.ro_shots)
# initialize yoko to a known voltage
self.qubit_yoko.set_voltage(0)
self.qubit_yoko.set_output_state(1)
time.sleep(1)
self.last_center = np.average(self.freqs) # middle point
for idx, voltage in enumerate(self.voltages):
self.qubit_yoko.set_voltage(voltage)
# run spec at this voltage
spec_exp = spec(self.freqs, self.ro_power, self.spec_power,
voltage)
spec_exp.measure()
center = spec_exp.fit_params['x0'].value * 1e6
width = spec_exp.fit_params['w'].value * 1e6
#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
# 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
#save RO power, spec power, freqs, center, width, raw data..
self.IQs[idx, :] = spec_exp.IQs[0, :]
self.amps[idx, :] = spec_exp.amps[0, :]
# save spec fit and experiment parameter data
self.center_freqs[idx] = center
self.widths[idx] = width
self.yoko_voltages[idx] = voltage
self.ro_log[idx] = self.ro_power
self.spec_log[idx] = self.spec_power
self.freqs_log[idx, :] = self.freqs
# see if we should adjust spec power
if width < self.width_min:
self.spec_power += 1
elif width > self.width_max:
self.spec_power -= 1
#evaluate if it's time to adjust the RO power
if self.ro_tune != -1 and (idx % self.ro_tune) == 0:
self.qubit_rfsource.set_frequency(self.last_center)
powers = np.arange(self.ro_power - self.ro_range,
self.ro_power + self.ro_range + 1,
self.ro_step)
# r = ropcal(powers)
r = orcpcal(powers)
r.measure()
# # update power
# self.ro_power = r.get_best_power()
self.ro_power = r.best_power
self.qubit_yoko.set_voltage(0)
self.analyze()
if self.savefig:
self.save_fig()
return self.voltages, self.freqs, self.IQs[:]
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
spec = lambda q_freqs, ro_power, spec_power, yoko_set_val: \
spectroscopy.Spectroscopy(
self.qubit_info,
q_freqs,
[self.qubit_rfsource, 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='Pulsed spectroscopy: (ro, spec) = (%0.2f, %0.2f) dBm; yoko %0.3e V\n' % (ro_power, spec_power, yoko_set_val),
analyze_data=True,
keep_data=True,
use_IQge=self.use_IQge,
use_weight=self.use_weight,
subtraction=self.subtraction)
ropcal = lambda powers: ropower_calibration.ROPower_Calibration(
self.qubit_info,
powers,
qubit_pulse=ropower_calibration.SAT_PULSE)
orcpcal = lambda powers, curAmp: ro_power_cal.Optimal_Readout_Power(
self.qubit_info,
powers,
plen=self.plen, 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)
# initialize yoko to a known set_val
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)
time.sleep(1)
self.last_center = np.average(self.freqs) # middle point
self.last_tune_center = np.average(self.freqs)
self.ro_source.set_frequency(self.ro_freq)
for idx, set_val in enumerate(self.set_vals):
if self.source_type == 'VOLT':
self.qubit_yoko.do_set_voltage(set_val)
if self.source_type == 'CURR':
self.qubit_yoko.do_set_current(set_val)
time.sleep(1)
# run spec at this voltage
# print [self.ro_power, self.spec_power, self.plen]
# tune ro frequency
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_tune_center) > self.ro_freq_tune_interval))\
and (self.ro_spec_range !=0):
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.ro_freq = ro.fit_params[0][2]
self.ro_source.set_frequency(self.ro_freq)
self.ro_LO.set_frequency(self.ro_freq+50e6)
# # update power
# self.ro_power = r.get_best_power()
# self.ro_power = r.best_power
self.last_tune_center = self.last_center
spec_exp = spec(self.freqs, self.ro_power, self.spec_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.center_freqs[idx] = center
self.widths[idx] = width
self.yoko_set_vals[idx] = set_val
self.ro_pwr_log[idx] = self.ro_power
self.ro_freq_log[idx] = self.ro_freq
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
#evaluate if it's time to adjust the RO power
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_tune_center) > self.ro_pwr_tune_interval))\
and (self.ro_range != 0):
self.qubit_rfsource.set_frequency(self.last_center)
powers = np.arange(self.ro_power - self.ro_range,
self.ro_power + self.ro_range + self.ro_step,
self.ro_step)
# r = ropcal(powers)
r = orcpcal(powers, self.amp)
r.measure()
plt.close()
# # update power
# self.ro_power = r.get_best_power()
self.ro_power = r.best_power
self.analyze(idx)
if self.source_type == 'VOLT':
self.qubit_yoko.do_set_voltage(0)
if self.source_type == 'CURR':
self.qubit_yoko.do_set_current(0)
self.qubit_yoko.set_output_state(0)
# self.analyze()
if self.savefig:
self.save_fig()
return self.set_vals, self.freqs, self.IQs[:]
from scripts.single_qubit import EFT2measurement
eft2 = EFT2measurement.EFT2Measurement(qubit_info, ef_info, np.linspace(0.5e3, 15e3, 101), detune=800e3, double_freq=False)#, echotype = EFT2measurement.ECHO_HAHN)
eft2.measure()
if 1: # GFT2
from scripts.single_qubit import GFT2measurement
gft2 = GFT2measurement.GFT2Measurement(qubit_info, ef_info, np.linspace(0.5e3, 15e3, 101), detune=800e3, double_freq=False)#, echotype = GFT2measurement.ECHO_HAHN)
gft2.measure()
bla
if 0: #number splitting:
from scripts.single_qubit import spectroscopy
seq = sequencer.Join([sequencer.Trigger(250), cavity_info.rotate(np.pi, 0)])
# postseq = sequencer.Sequence([sequencer.Trigger(250), cavity_info.rotate(np.pi, 0)])
qubit_freq = 6306.770e6
spec = spectroscopy.Spectroscopy(mclient.instruments['brick2'], qubit_info, np.linspace(qubit_freq-8e6, qubit_freq+2e6, 101), [11.5],
plen=6000, seq = seq, amp=0.09, extra_info=cavity_info, plot_seqs=True)
spec.measure()
if 0: #Sideband modulated number splitting:
from scripts.single_qubit import ssbspec
seq = sequencer.Join([sequencer.Trigger(250), cavity_info2.rotate(np.pi*2, 0)])
spec = ssbspec.SSBSpec(qubit_info, np.linspace(-15e6, 1e6, 151),
extra_info= cavity_info2,
seq =seq, plot_seqs=False)
spec.measure()
bla
if 0: #EF Sideband modulated number splitting:
from scripts.single_qubit import ssbspec
seq = sequencer.Join([sequencer.Trigger(250), qubit_info.rotate(np.pi,0), cavity_info2.rotate(np.pi*1.0, 0)])
drive_powers = [-10]
qubit_brick.set_rf_on(0)
spec_brick.set_rf_on(1)
spec_brick.set_pulse_on(1)
for ro_pow in ro_powers:
# ag1.set_power(ro_pow)
for drive_power in drive_powers:
spec_params = (spec_brick, drive_power)
s = spectroscopy.Spectroscopy(
spec_info,
freqs,
spec_params,
plen=100e3,
freq_delay=0.25,
seq=None,
postseq=None,
use_weight=False,
use_IQge=False,
use_marker=True,
subtraction=False,
)
s.measure()
spec_brick.set_rf_on(0)
bla
if 0: # sideband modulated spectroscopy
qubit_brick.set_rf_on(1)
spec_brick.set_rf_on(0)
qubit_freq = 5735.6e6 # 50 MHz above qubit mode
freq_range = 2e6