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']