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 make_qubit(name, chop=4):
info = mclient.get_qubit_info(name)
info.ssb_kwargs = {'chan%d_ssb_reload'%info.channels[0]: True}
info.load_ssb_kwargs = info.ssb_kwargs
info.load_mixer_kwargs = {'chan%d_mixer_fetch'%info.channels[0]: True}
info.use_mixer_kwargs = {
'chan%d_mixer_mask'%info.channels[0]: (True, True),
'chan%d_mixer_mask'%info.channels[1]: (True, True),
}
info.loaduse_mixer_kwargs = {
'chan%d_mixer_fetch'%info.channels[0]: True,
'chan%d_mixer_mask'%info.channels[0]: (True, True),
'chan%d_mixer_mask'%info.channels[1]: (True, True),
}
info.rotate = get_rotation(info, info.rotation, info.w, info.pi_amp, info.pi2_amp, info.drag)
info.rotate_selective = get_rotation(info, info.rotation_selective, info.w_selective, info.pi_amp_selective, info.pi2_amp_selective, info.drag_selective)
return info
fg = mclient.instruments['funcgen']
#laserfg = mclient.instruments['laserfg']
# Load old settings.
if 0:
toload = [
'AWG1', 'ag1', 'ag2', 'ag3'
'alazar', 'qFC14#1', 'eFC14#1', 'qubit_DO13#3', 'ef_DO13#3',
'qubit_DO13#4', 'ef_DO13#4'
]
mclient.load_settings_from_file(r'c:\_data\settings\20131214\165409.set',
toload) # Last time-Rabi callibration
bla
#qubits = mclient.get_qubits()
qubit_info = mclient.get_qubit_info('qubit_info_1')
#ef_info = mclient.get_qubit_info('qubit_ef_info')
#cavity_info = mclient.get_qubit_info('cavity0')
if 1: # T1_QP
from scripts.QPs.single_qubit import T1measurement_QP
for i in range(1):
for l in [210e3]:
for delay in [100e3]:
# delay = 0.02e6#np.array([0.1e3,2.5e3,40e3])#
# t1times = np.concatenate((np.linspace(0, 1e3,11), np.linspace(1e3,10e3, 13)))
# t1times = np.logspace(1, np.log10(10e3), 3 )
alz.set_naverages(14e3)
t1times = np.array([0, 100, 200, 500, 1e3, 10e3])
t1 = T1measurement_QP.T1Measurement_QP(qubit_info,
t1times,
def __init__(self, qubit_info, #pass in qubit info name as a string because we need both the info and the instrument to set things like pi amp
qubit_rfsource,
funcgen,
alazar,
source_type, #choices are CURR or VOLT for B field tuning, STARK for Stark shift with changing power, STARKSSB for Stark shift with changing SSB amplitude
set_vals, #current or voltage values for field tuning. Power for Stark
experiments, # which experiments to do in array of strings. Options so far are ROFREQ, ROPWR, SPEC, RABI, T1, T2, T2Echo(does CPMG with N=1)
qubit_yoko = None,
stark_rfsource = None,
stark_V_channel = 'ch3',
save_fig = True,
#readout frequency parameters (only used if doing ROFREQ experiments)
init_ro_freq = 9e9,
ro_freq_tune = -1, #tune freq every x experiments; -1 if using frequency interval only;
ro_freq_tune_interval = -1, #tune ro frequency if the qubit frequency has changed by this much since last tuning, -1 if using steps only
ro_spec_range = 10e6,
#pre-determined function for readout values (used if not doing RO calibration)
ro_freq_fxn = None,
# readout power parameters (only used if doing ROPWR experiments)
init_ro_power = 0,
ropwr_qubit_rf_pwr = 0,
ro_range = 2, #will search += xdbm, 0 if not doing power tuning
ro_step = 1, #step to take in power
ro_pwr_tune = 1, #tune ro power every this many runs. -1 if using qubit frequency to determine when to tune
ro_pwr_tune_interval = 100e6, #tune ro pwr if the qubit frequency has changed by this much since last tuning, -1 if using steps only
ro_shots = 1e4,
ro_pwr_pi = False,
#pre-determined function for readout values (used if not doing RO calibration)
ro_pwr_fxn = None,
#spec parameters (only used if doing SPEC or SSBSPEC experiments)
init_freqs = [5e5],
init_spec_power = 0,
spec_funcgen_freq = 5000,
spec_avgs = 3000,
width_min=2e6, #min and max width of qubit peak. Used to determine when to change spec power and when we've lost the qubit
width_max=6e6,
freq_step=0e6, # If 0, same frequencies will be used. Otherwise program will handle updating frequency range based on preview qubit frequencies
plen=50e3, amp=0.01, seq=None, simulseq = None, postseq=None, starkw = 100, starkch = 3, #starkw is the risetime of the gaussiansquare pulse
pow_delay=1, freq_delay=0.1, plot_type=None,
use_IQge=0, use_weight=0,
subtraction=False,
spec_bgcor = False,
spec_generate = True,
#pre-determined function for qubit frequencies (used if not doing qubit spec)
qubit_freq_fxn = None,
#Rabi parameters (only used if doing RABI experiments)
rabi_rf_pwr = 0,
init_rabi_amps = [0],
rabi_funcgen_freq = 5000,
rabi_avgs = 1000,
rabi_pulse_len = 20,
#pre-determined function for pi pulse amplitude (used if not doing rabi)
pi_amp_fxn = None,
#T1 parameters (only used if doing T1 experiments)
T1_rf_pwr = 0,
T1_funcgen_freq = 1000,
T1_avgs = 1000,
init_T1_delays = [0],
T1_update_delays = True,
T1_bgcor = False,
#T2 parameters (only used if doing T2 experiments)
T2_rf_pwr = 0,
T2_funcgen_freq = 1000,
T2_delta = 300e3,
T2_avgs = 1000,
init_T2_delays = [0],
T2_set_f = False,
#T2Echo parameters (only used if doing T2Echo experiments)
T2E_rf_pwr = 0,
T2E_funcgen_freq = 1000,
T2E_delta = 0,
T2E_avgs = 1000,
init_T2E_delays = [0],
#Phonon T1 parameters
init_PhT1_delays = [0],
PhT1_funcgen_freq = 1000,
PhT1_avgs = 1000,
Ph_amp = 0,
Ph_piLength = 0,
Ph_sigma = 10,
**kwargs):
self.qubit_info = mclient.get_qubit_info(qubit_info)
self.qubit_inst = instruments[qubit_info]
self.qubit_rfsource = qubit_rfsource
self.qubit_yoko = qubit_yoko
self.stark_rfsource = stark_rfsource
self.stark_V_channel = stark_V_channel
self.funcgen = funcgen
self.alazar = alazar
self.source_type = source_type
self.experiments = experiments
self.set_vals = set_vals
self.num_steps = len(self.set_vals)
self.save_fig = save_fig
self.ro_shots = ro_shots
self.ro_power = init_ro_power #for adjusting RO power
self.ro_freq = init_ro_freq
self.ro_range = ro_range
self.ro_step = ro_step
self.ro_pwr_tune = ro_pwr_tune
self.ro_freq_tune = ro_freq_tune
self.ro_freq_tune_interval = ro_freq_tune_interval
self.ro_pwr_tune_interval = ro_pwr_tune_interval
self.ropwr_qubit_rf_pwr = ropwr_qubit_rf_pwr
self.ro_spec_range = ro_spec_range
self.ro_freq_fxn = ro_freq_fxn
self.ro_pwr_fxn = ro_pwr_fxn
self.ro_pwr_pi = ro_pwr_pi
self.freqs = init_freqs
self.num_freq_pts = len(init_freqs)
self.freq_range = max(init_freqs)-min(init_freqs)
self.spec_power = init_spec_power
self.spec_funcgen_freq = spec_funcgen_freq
self.spec_avgs = spec_avgs
self.width_min = width_min #for adjusting spec power
self.width_max = width_max
self.freq_step = freq_step # frequency step estimator,
# Set to 0 if you want constant frequency
self.plen = plen
self.amp = amp
self.pow_delay = pow_delay
self.freq_delay = freq_delay
if seq is None:
seq = Trigger(250)
self.seq = seq
self.simulseq = simulseq
self.postseq = postseq
self.starkw = starkw
self.starkch = starkch
self.use_IQge = use_IQge
self.use_weight = use_weight
self.subtraction = subtraction
self.spec_bgcor = spec_bgcor
self.plot_type = plot_type
self.extra_info = None
self.qubit_freq_fxn = qubit_freq_fxn
self.sideband_freq = self.qubit_info.deltaf
self.spec_generate = spec_generate
self.rabi_rf_pwr = rabi_rf_pwr
self.init_rabi_amps = init_rabi_amps
self.num_rabi_pts = len(init_rabi_amps)
self.rabi_funcgen_freq = rabi_funcgen_freq
self.rabi_avgs = rabi_avgs
self.rabi_pulse_len = rabi_pulse_len
self.pi_amp_fxn = pi_amp_fxn
self.T1_rf_pwr = T1_rf_pwr
self.T1_funcgen_freq = T1_funcgen_freq
self.T1_avgs = T1_avgs
self.T1_delays = init_T1_delays
self.num_T1_pts = len(init_T1_delays)
self.T1_update_delays = T1_update_delays
self.T1_bgcor = T1_bgcor
self.T2_rf_pwr = T2_rf_pwr
self.T2_funcgen_freq = T2_funcgen_freq
self.T2_delta = T2_delta
self.T2_avgs = T2_avgs
self.T2_delays = init_T2_delays
self.T2_set_f = T2_set_f
self.num_T2_pts = len(init_T2_delays)
self.T2E_rf_pwr = T2E_rf_pwr
self.T2E_funcgen_freq = T2E_funcgen_freq
self.T2E_delta = T2E_delta
self.T2E_avgs = T2E_avgs
self.T2E_delays = init_T2E_delays
self.num_T2E_pts = len(init_T2E_delays)
self.PhT1_delays = init_PhT1_delays
self.PhT1_funcgen_freq = PhT1_funcgen_freq
self.PhT1_avgs = PhT1_avgs
self.Ph_amp = Ph_amp
self.Ph_piLength = Ph_piLength
self.Ph_sigma = Ph_sigma
self.num_PhT1_pts = len(init_PhT1_delays)
super(Tuned_Qubit, self).__init__(1, infos=qubit_info, **kwargs)
self.ro_source = self.readout_info.rfsource1
self.ro_LO = self.readout_info.rfsource2
self.yoko_set_vals = self.data.create_dataset('yoko_set_vals', shape=[self.num_steps])
self.ro_pwr_log = self.data.create_dataset('ro_powers', shape=[self.num_steps])
self.ro_freq_log = self.data.create_dataset('ro_freqs', shape=[self.num_steps])
self.spec_log = self.data.create_dataset('spec_powers', shape=[self.num_steps])
self.freqs_log = self.data.create_dataset('freqs', shape=[self.num_steps, self.num_freq_pts])
self.center_freqs = self.data.create_dataset('center_freqs', shape=[self.num_steps])
self.widths = self.data.create_dataset('widths', shape=[self.num_steps])
self.IQs = self.data.create_dataset('avg', shape=[self.num_steps, self.num_freq_pts], dtype=np.complex)
self.amps = self.data.create_dataset('avg_pp', shape=[self.num_steps, self.num_freq_pts])
self.rabi_amps_log = self.data.create_dataset('rabi_amps', shape=[self.num_steps, self.num_rabi_pts])
self.rabi_dat = self.data.create_dataset('rabi_dat', shape=[self.num_steps, self.num_rabi_pts])
self.rabi_A = self.data.create_dataset('rabi_A', shape=[self.num_steps])
self.rabi_f = self.data.create_dataset('rabi_f', shape=[self.num_steps])
self.rabi_ph = self.data.create_dataset('rabi_phase', shape=[self.num_steps])
self.pi_amp = self.data.create_dataset('pi_amp', shape=[self.num_steps])
self.T1_delays_log = self.data.create_dataset('T1_delays', shape=[self.num_steps, self.num_T1_pts])
self.T1_dat = self.data.create_dataset('T1_dat', shape=[self.num_steps, self.num_T1_pts])
self.T1_A = self.data.create_dataset('T1_A', shape=[self.num_steps])
self.T1_A_err = self.data.create_dataset('T1_A_err', shape=[self.num_steps])
self.T1_tau = self.data.create_dataset('T1_tau', shape=[self.num_steps])
self.T1_tau_err = self.data.create_dataset('T1_tau_err', shape=[self.num_steps])
self.T2_delays_log = self.data.create_dataset('T2_delays', shape=[self.num_steps, self.num_T2_pts])
self.T2_dat = self.data.create_dataset('T2_dat', shape=[self.num_steps, self.num_T2_pts])
self.T2_tau = self.data.create_dataset('T2_tau', shape=[self.num_steps])
self.T2_tau_err = self.data.create_dataset('T2_tau_err', shape=[self.num_steps])
self.T2_f = self.data.create_dataset('T2_f', shape=[self.num_steps])
self.T2_f_err = self.data.create_dataset('T2_f_err', shape=[self.num_steps])
self.T2E_delays_log = self.data.create_dataset('T2E_delays', shape=[self.num_steps, self.num_T2E_pts])
self.T2E_dat = self.data.create_dataset('T2E_dat', shape=[self.num_steps, self.num_T2E_pts])
self.T2E_tau = self.data.create_dataset('T2E_tau', shape=[self.num_steps])
self.T2E_tau_err = self.data.create_dataset('T2E_tau_err', shape=[self.num_steps])
self.T2E_A = self.data.create_dataset('T2E_A', shape=[self.num_steps])
self.T2E_A_err = self.data.create_dataset('T2E_A_err', shape=[self.num_steps])
self.PhT1_delays_log = self.data.create_dataset('Ph_T1_delays', shape=[self.num_steps, self.num_PhT1_pts])
self.PhT1_dat = self.data.create_dataset('Ph_T1_dat', shape=[self.num_steps, self.num_PhT1_pts])
self.PhT1_A = self.data.create_dataset('Ph_T1_A', shape=[self.num_steps])
self.PhT1_A_err = self.data.create_dataset('Ph_T1_A_err', shape=[self.num_steps])
self.PhT1_tau = self.data.create_dataset('Ph_T1_tau', shape=[self.num_steps])
self.PhT1_tau_err = self.data.create_dataset('Ph_T1_tau_err', shape=[self.num_steps])
import mclient
reload(mclient)
import numpy as np
from pulseseq import sequencer
alz = mclient.instruments['alazar']
fg = mclient.instruments['funcgen']
brick2 = mclient.instruments['brick2']
readout = mclient.instruments['readout']
alz = mclient.instruments['alazar']
qubits = mclient.get_qubits()
readout_info = mclient.get_readout_info('readout')
qubit_info = mclient.get_qubit_info('qubit2ge')
ef_info = mclient.get_qubit_info('qubit2ef')
qubitph_info = mclient.get_qubit_info('qubit2ge_ph')
efph_info = mclient.get_qubit_info('qubit2ef_ph')
#gf_info1 = mclient.get_qubit_info('Qubit1gf')
cavity_info1R = mclient.get_qubit_info('cavity1R')
cavity_info1A = mclient.get_qubit_info('cavity1A')
cavity_info1B = mclient.get_qubit_info('cavity1B')
Qswitch_info1A = mclient.get_qubit_info('Qswitch1A')
Qswitch_info1B = mclient.get_qubit_info('Qswitch1B')
cA = cavity_info1A.rotate
cB = cavity_info1B.rotate
ge = qubit_info.rotate
geph = qubitph_info.rotate
geqs = qubit_info.rotate_quasilective
mclient.load_settings_from_file(r'c:\_data\settings\20131119\094145.set',
toload) # Last time-Rabi callibration
awg1 = mclient.instruments['AWG1']
fg = mclient.instruments['funcgen']
#laserfg = mclient.instruments['laserfg']
alz = mclient.instruments['alazar']
ag1 = mclient.instruments['ag1']
LO = mclient.instruments['LO_brick']
ag2 = mclient.instruments['ag2']
#qubit_brick = mclient.instruments['qubit_brick']
#brick2 = mclient.instruments['brick2']
#qGap = mclient.get_qubit_info('qGap')
#eGap = mclient.get_qubit_info('eGap')
qubit_info_1 = mclient.get_qubit_info('qubit_info_1')
qubit_info_2 = mclient.get_qubit_info('qubit_info_2')
#qubit_ef_info = mclient.get_qubit_info('qubit_ef_info')
#qJ15_2 = mclient.get_qubit_info('qJ15#2')
#eJ15_2 = mclient.get_qubit_info('qJ15#2')
#qI15_7 = mclient.get_qubit_info('qI15#7')
#eI15_7 = mclient.get_qubit_info('eI15#7')
#qI15_8 = mclient.get_qubit_info('qI15#8')
#eI15_8 = mclient.get_qubit_info('eI15#8')
#qGZ14_3 = mclient.get_qubit_info('qGZ14#3')
#eGZ14_3 = mclient.get_qubit_info('qGZ14#3')
#qGZ14_4 = mclient.get_qubit_info('qGZ14#4')
#eGZ14_4 = mclient.get_qubit_info('qGZ14#4')
#qB = mclient.get_qubit_info('qB')
#eB = mclient.get_qubit_info('eB')
#qAG13_4 = mclient.get_qubit_info('qAG13#4')
import mclient
from mclient import instruments
from datetime import datetime
import time
import numpy as np
from pulseseq.sequencer import *
from pulseseq.pulselib import *
from matplotlib import gridspec
import matplotlib.pyplot as plt
import logging
import measurementOM
from measurement import *
AS_info = mclient.get_qubit_info('AS_info')
awg1 = instruments['AWG1']
funcgen = instruments['funcgen']
alazar = instruments['alazar']
#AS_r = AS_info.rotate
#AS_r1 = AS_r(np.pi, 0, amp = 1)
AS_SC0 = AS_info.sideband_channels[0]
AS_SC1 = AS_info.sideband_channels[1]
#LO_SC0 = LO_info.sideband_channels[0]
#LO_SC1 = LO_info.sideband_channels[1]
LO_SC0 = 3
#Gaussian square pulse with length (ns), amplitude (V), and risetime (ns)
AS_p0 = GaussSquare(100, 1.0, 10, chan=AS_SC0)
AS_p1 = GaussSquare(100, 0.0, 10, chan=AS_SC1)
AS_p = Combined([AS_p0, AS_p1])
import numpy as np
from pulseseq import sequencer
from pulseseq import pulselib
from matplotlib import gridspec
import matplotlib.pyplot as plt
import logging
from scripts.single_qubit import spectroscopy as spectroscopy
from scripts.jk.single_qubit import temperature as temperature
from scripts.single_qubit import ssbspec, ssbspec_fit, stark_swap
from scripts.single_qubit import rocavspectroscopyPhononSwap as rospecPS
from scripts.single_qubit import tuned_qubit_characterization as tuned_qubit
ag1 = instruments['ag1']
ag2 = instruments['ag2']
#ag3 = instruments['ag3']
qubit_info = mclient.get_qubit_info('qubit_info')
phonon1_info = mclient.get_qubit_info('phonon1_info')
qubit_ef_info = mclient.get_qubit_info('qubit_ef_info')
vspec = instruments['vspec']
awg1 = instruments['AWG1']
va_lo_5_10 = instruments['va_lo_5_10']
cavity_brick = instruments['cavity_brick'] #4-8 GHz brick
qubit_brick = instruments['qubit_brick'] #vector generator
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']
from pulseseq import pulselib
import matplotlib as mpl
from matplotlib import gridspec
import matplotlib.pyplot as plt
import logging
from scripts.single_qubit import spectroscopy as spectroscopy
from scripts.jk.single_qubit import temperature as temperature
mpl.rcParams['figure.figsize'] = [6, 4]
n_qubit = 1
ag1 = instruments['ag1']
ag2 = instruments['ag2']
#ag3 = instruments['ag3']
qubit_info = mclient.get_qubit_info('qubit_info') #_{}'.format(n_qubit))
qubit_brick = instruments['qubit_brick'] #_{}'.format(n_qubit)]
qubit_ef_info = mclient.get_qubit_info('qubit_ef_info') #_{}'.format(n_qubit))
filename = 'c:/Data/20170623/CK2Q{}.h5'.format(n_qubit)
mclient.datafile = mclient.datasrv.get_file(filename)
#cavity_info = mclient.get_qubit_info('cavity_info')
#spec_sh = instruments['spec']
awg1 = instruments['AWG1']
#qubit_ef_brick = instruments['qubit_brick']
cavity_brick = instruments['cavity_brick']
#qubit_ef_brick = cavity_brick
#va_lo = instruments['va_lo']
