def __init__(self, config_file=None):
QObject.__init__(self)
self.config_file = config_file
self.instruments = InstrumentManager(self.config_file)
self.params = DictProxy("threadParameter")
self.connect(
self.params, SIGNAL("threadParameterChanged"),
lambda n, v: self.emit(SIGNAL("threadParameterChanged"), n, v))
self.plots = ManagerProxy("plotMethodCalled")
self.gui = ManagerProxy("guiMethodCalled")
self._aborted = False
def write_Tek70001_sequence(self, awg, path, file_prefix, upload=False, **kwargs):
waveforms = [self.waveforms[waveform['name']] for waveform in awg['waveforms']]
# markers=[self.markers[marker['name']] for marker in awg['markers']]
if upload:
tek7 = InstrumentManager()[awg['name']]
for waveform in waveforms:
write_Tek70001_sequence(waveform, path, file_prefix, awg=tek7)
tek7.prep_experiment()
tek7.run()
else:
tek7 = None
def __init__(self,expt_path=None,instrument_manager=None):
if instrument_manager is None:
instrument_manager=InstrumentManager()
self.im=instrument_manager
self.expt_path=expt_path
self.filament=self.im['filament']
self.srs=self.im['SRS']
self.na=self.im['NWA']
self.fridge=self.im['FRIDGE']
def __init__(self, config_file=None):
QObject.__init__(self)
self.config_file = config_file
self.instruments = InstrumentManager(self.config_file)
self.params = DictProxy("threadParameter")
self.connect(self.params, SIGNAL("threadParameterChanged"),
lambda n,v: self.emit(SIGNAL("threadParameterChanged"), n, v))
self.plots = ManagerProxy("plotMethodCalled")
self.gui = ManagerProxy("guiMethodCalled")
self._aborted = False
def write_Tek5014_sequence(self, awg, path, file_prefix, upload=False):
waveforms = [
self.waveforms[waveform['name']] for waveform in awg['waveforms']
]
markers = [self.markers[marker['name']] for marker in awg['markers']]
write_Tek5014_file(waveforms, markers,
os.path.join(path, file_prefix + '.awg'), self.name)
if upload:
im = InstrumentManager()
im[awg['name']].pre_load()
# print "Sequence preloaded"
im[awg['name']].load_sequence_file(os.path.join(
path, file_prefix + '.awg'),
force_reload=True)
print("Sequence file uploaded")
im[awg['name']].prep_experiment()
def write_Tek70001_sequence(self, awg, path, file_prefix, upload=False):
waveforms = [
self.waveforms[waveform['name']] for waveform in awg['waveforms']
]
# markers=[self.markers[marker['name']] for marker in awg['markers']]
if upload:
tek7 = InstrumentManager()[awg['name']]
for waveform in waveforms:
write_Tek70001_sequence(waveform, path, file_prefix, awg=tek7)
tek7.prep_experiment()
tek7.run()
else:
tek7 = None
self.sacm.get_rf_power(e.frequency, e.lower_bound))
except Exception as e:
print(e)
"""unlock sweep by enabling the sweep button"""
self.sweeping[0] = False
self.sweeping[1] = True
self.lo.set_frequency(original_frequency)
time.sleep(0.1)
if __name__ == '__main__':
import pickle
from slab.instruments import InstrumentManager
cfg_path = "sa_suite.cfg"
im = InstrumentManager(cfg_path)
app = QApplication(sys.argv)
#sa = im['SA']
sa = SpectrumAnalyzer(protocol='serial',
address='2',
query_sleep=0.05,
lo_offset=10.57e6)
#sacm = SACalibrationManager(pickle.load(open('10dBm_cali.data')))
sacm = SACalibrationManager(pickle.load(open('10dBm_LMS_cali.data')))
#lo = E8257D(address='rfgen1.circuitqed.com')
lo = im['LO']
rf = im['RF']
rf.set_frequency(7e9)
# +13dBm LO to drive IQB0618
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 13 10:41:58 2012
@author: Dave
"""
"""
To do this test you have to first start the nameserver
and an InstrumentManager server
#To start a nameserver (if one isn't already present)
python -m Pyro4.naming -n hostname
#To start InstrumentManager Server
im = InstrumentManager(r'c:\_Lib\python\slab\instruments\instrument.cfg')
im.serve_instruments()
"""
from slab.instruments import InstrumentManager
im=InstrumentManager()
print(list(im.keys()))
print(im['echo'].echo('This is a test'))
print(im['random'].random())
#print im['FRIDGE'].get_status()
def __init__(
self,
msmtname,
datapath,
scriptname,
scriptpath=r'S:\_Data\141224 - M011 Helium Channels v4\experiment_M011_HeliumChannels'
):
self.im = InstrumentManager()
#self.plotter = LivePlotClient()
# ############################################
# ### SETTINGS FOR THE PATH, SAVING ETC. #####
# ############################################
self.datapath = datapath
self.msmtname = msmtname
self.scriptname = scriptname
self.scriptpath = scriptpath
# ############################################
################ NWA SETTINGS ###############
#############################################
self.na_cfg = {
'na_power': -30,
'na_ifbw': 1000,
'na_start': 4.0E9,
'na_stop': 8.0E9,
'na_sweep_pts': 1601,
'na_avgs': 20,
'na_delay': 0,
'na_power_threshold': 0
}
self.sa_cfg = {
'sa_center': 500E3,
'sa_span': 1000E3,
'sa_resbw': None,
'sa_vidbw': 1E3,
'sa_sweep_pts': 1601,
'sa_avgs': 10,
'sa_remote': False
}
self.labbrick_cfg = {'lb_freq': 7.785E9, 'lb_power': -30}
self.jpa_cfg = {'flux_bias_limit': 2E-3}
#self.jpa_bias = im['JPA_bias']
#self.na = im['NWA']
#self.fridge = im['FRIDGE']
#self.heman = im['heman']
#self.lb = im['labbrick']
#self.sa = im['SA']
#Hacky solution to get the spectrum analyzer to work
#from slab.instruments import E4440
#self.sa = E4440("E4440", address="192.168.14.152")
self.today = time.strftime('%y%m%d')
self.timestamp = time.strftime('%H%M%S')
def initiate_instrument(self, name, cfg_name):
im = InstrumentManager()
setattr(self, name, im[cfg_name])
return True
plt.plot(np.array(offsets), np.array(op))
plt.autoscale()
plt.show()
def remove_frequency(cali_data, frequency):
for dp in cali_data:
if dp[0] == frequency:
cali_data.remove(dp)
return cali_data
if __name__ =='__main__':
import pickle
import numpy as np
from slab.instruments import InstrumentManager
im = InstrumentManager("sa_calibration.cfg")
#rf = E8257D(address='rfgen2.circuitqed.com')
#lo = E8257D(address='rfgen1.circuitqed.com')
rf = im['RF']
lo = im['LO']
sa = im['SA']
"""
for f in np.arange(5e9,10e9,0.1e9):
lo.set_frequency(f)
time.sleep(0.05)
rf.set_frequency(f+0.05e9)
time.sleep(0.1)
print str(lo.get_frequency())+', '+str(rf.get_frequency())
#print str(lo.get_settings())+', '+str(rf.get_settings())
def load_into_awg(self, filename, awg_name=None):
# filename is where to build the sequence file
# create AWG data file
awgdata = dict()
key_names = ['ch12', 'ch34']
for i in range(1, 5):
for j in range(1, 3):
key_names.append('ch{0}m{1}'.format(i, j))
for i in range(len(key_names)):
awgdata[key_names[i]] = dict()
awgdata[key_names[i]]['wfLib'] = dict()
awgdata[key_names[i]]['linkList'] = list()
# add wf's to awgdata
# analog
# This goes through all the waveforms and combines channels 1 and 2 and 3 and 4
for i in range(2):
data_key = 'ch{0}{1}'.format(2 * i + 1, 2 * i + 2)
for j in range(self.sequence_length):
awgdata[data_key]['wfLib'][str(j)] = self.waveforms[
2 * i][j] + (self.waveforms[2 * i + 1][j]) * 1j
#create sequence
for j in range(self.sequence_length):
awgdata[data_key]['linkList'].append(list())
awgdata[data_key]['linkList'][j].append(
namedtuple('a', 'key isTimeAmp length repeat'))
awgdata[data_key]['linkList'][j][0].key = "{0:g}".format(
(j + 1) %
self.sequence_length) #go to next waveform (or beginning)
awgdata[data_key]['linkList'][j][0].key = "{0:g}".format(
(j) %
self.sequence_length) #go to next waveform (or beginning)
awgdata[data_key]['linkList'][j][0].isTimeAmp = False
for i in range(4):
for j in range(2):
marker_key = 'ch{0}m{1}'.format(i + 1, j + 1)
for k in range(self.sequence_length):
awgdata[marker_key]['wfLib'][str(
k)] = self.markers[i][j][k]
#create sequence
for k in range(self.sequence_length):
awgdata[marker_key]['linkList'].append(list())
awgdata[marker_key]['linkList'][k].append(
namedtuple('a', 'key isTimeAmp length repeat'))
awgdata[marker_key]['linkList'][k][0].key = "{0:g}".format(
(k) % self.sequence_length)
awgdata[marker_key]['linkList'][k][0].isTimeAmp = False
#lp.plot_y('debug',array(awgdata['ch12']['wfLib']['100'],dtype=float))
write_Tek_file(awgdata, filename, 'seq1', None, False)
#load the file into the TEK
if awg_name is not None:
im = InstrumentManager()
awg = im[awg_name]
awg.pre_load()
awg.load_sequence_file(filename)
awg.write('inst:sel ' + str(channel) + '; volt:ampl ' +
str(amplitude / 1.0e3))
awg.write('inst:sel ' + str(channel) + '; function:shape SIN;')
awg.write('inst:sel ' + str(channel) + '; SIN:phase ' + str(phase))
awg.write('inst:sel ' + str(channel) + '; frequency ' + str(frequency))
awg.write('inst:sel ' + str(channel) + '; volt:offset' + str(offset))
def get_power_at(sa, lo, frequency):
lo.set_frequency(frequency + sa.lo_offset)
return sa.get_avg_power()
if __name__ == '__main__':
#awg = AWG81180A(name='awg', address='GPIB::04::INSTR')
im = InstrumentManager("ssm_optimization.cfg")
awg = im['AWG']
#sa = SpectrumAnalyzer(protocol='serial', port=2)
#Agilent analog waveform generator
#sacm = SACalibrationManager(pickle.load(open('10dBm_cali.data')))
sa = im['SA']
rf = im['RF']
lo = im['LO']
sacm = SACalibrationManager(pickle.load(open('10dBm_cali.data')))
#arbitrary setup parameters
c_freq = 7e9
m_freq = 0.1e9
m_amp = 0.1
class DataThread(QObject):
def __init__(self, config_file=None):
QObject.__init__(self)
self.config_file = config_file
self.instruments = InstrumentManager(self.config_file)
self.params = DictProxy("threadParameter")
self.connect(
self.params, SIGNAL("threadParameterChanged"),
lambda n, v: self.emit(SIGNAL("threadParameterChanged"), n, v))
self.plots = ManagerProxy("plotMethodCalled")
self.gui = ManagerProxy("guiMethodCalled")
self._aborted = False
def run_on_instrument_manager(inst_name, method_name, args, kwargs):
try:
getattr(self.instrument_manager[inst_name], method_name)(*args,
**kwargs)
except Exception as e:
self.emit("instrumentMethodFailed", (str(e), ))
def set_param(self, name, value):
self.params.set_nosignal(name, value)
def save_experimental_settings(self):
filename = str(QFileDialog.getSaveFileName())
self.instruments.save_settings(filename)
def save_all_settings(self):
filename = str(QFileDialog.getSaveFileName())
# save_settings does not currently (11/13) process params meaningfully
self.instruments.save_settings(filename, params=self.params)
def load_settings(self):
filename = QFileDialog.getOpenFileName(filter="*.cfg")
self.instruments.load_config_file(filename)
def list_instruments(self):
for key, inst in self.instruments.items():
self.msg(key + inst.name)
def get_local_params(self):
self.emit(SIGNAL("localParams"), self.params)
def msg(self, *args):
self.emit(SIGNAL("msg"), *args)
def status(self, s):
self.emit(SIGNAL("status"), s)
def progress(self, val, tot):
self.emit(SIGNAL("progress"), (val, tot))
def abort(self):
self._aborted = True
def aborted(self):
if self._aborted:
self._aborted = False
return True
else:
return False
def run_sweep(self, whichStack):
self.msg("Sweeping...")
params = Bunch(self.params)
if whichStack[params.sweep1] == 0:
prange = list(
range(params.sweep1_start_int, params.sweep1_stop_int,
params.sweep1_step_int))
else:
prange = np.arange(params.sweep1_start_float,
params.sweep1_stop_float,
params.sweep1_step_float)
self.msg(prange)
if params.sweep2_enabled:
raise NotImplementedError
actions = params.actions.splitlines()
for p in prange:
self.msg(params.sweep1 + "=" + str(p))
for action in actions:
self.params[params.sweep1] = p
try:
if self.params["abort_sweep"]:
self.params["abort_sweep"] = False
return
except:
pass
getattr(self, action)()
self.msg("Done")
def run_data_thread(self, method, *args):
if DEBUG:
print(method, "running")
self.msg(method)
self.msg(args)
getattr(self, method)(*args)
self.emit(SIGNAL(method + "done"))
from slab import *
from slab.datamanagement import SlabFile
from numpy import *
import os
from instruments.PNAX import N5242A
from slab.instruments import InstrumentManager
from slab.instruments import Alazar, AlazarConfig
from slab.instruments import InstrumentManager
from liveplot import LivePlotClient
#from slab.instruments import N5242A
from slab.dsfit import fithanger_new_withQc
im = InstrumentManager()
#plotter = LivePlotClient()
dcflux = im['YOKO2']
nwa = im['PNAX']
# nwa = N5242A("N5242A", address="192.168.14.249", timeout=10.)
#drive = im['RF3']
print('Deviced Connected')
expt_path = os.getcwd() + '\data'
# initial NWA configuration values
ifbw = 20
read_power = -65.0
probe_power = -20.0
center = 4.35e9
def main():
expt_path = "S:\\_Data\\120425 - 50nm Nb 20um resonator with crystal on top of first 2\\spin echo\\"
config = "instruments.cfg"
#datapath='S:\\_Data\\'
prefix = "test_dynamic"
#datapath=make_datapath(expt_path,prefix)
sweep_pts = 1601
ifbw = 1e3
Freqs = linspace(5.79125e9 - 2e6, 5.79125e9 + 2e6, 100)
im = InstrumentManager(expt_path + config)
RF1 = im['RF1']
#RF2=im['RF2']
RF2 = im['LB1']
#na=im['NWA']
RF1.set_output(True)
RF2.set_output(True)
RF1.set_mod(True)
RF2.set_mod(False)
RF1.set_power(12)
RF2.set_power(0)
print("Configure NA")
# na.set_default_state()
# na.set_power(-20)
# na.set_ifbw(ifbw)
# na.set_span(0.)
# na.set_sweep_points(1)
IFfreq = 1e6
#na.set_center_frequency(2.5703e9)
#RF2.set_frequency(2.5703e9+IFfreq)
config = {
'clock_edge': 'rising',
'trigger_delay': 0,
'ch1_filter': False,
'ch1_enabled': True,
'samplesPerRecord': 50048,
'bufferCount': 1,
'trigger_edge1': 'rising',
'trigger_edge2': 'rising',
'ch2_range': 4,
'clock_source': 'internal',
'trigger_level2': 1.0,
'trigger_level1': 1.0,
'ch2_coupling': 'DC',
'trigger_coupling': 'DC',
'ch2_filter': False,
'trigger_operation': 'or',
'ch1_coupling': 'AC',
'trigger_source2': 'disabled',
'trigger_source1': 'external',
'recordsPerBuffer': 1,
'sample_rate': 1000000,
'timeout': 5000,
'ch1_range': 4,
'ch2_enabled': False,
'recordsPerAcquisition': 1
}
print("Configuring card")
scope_settings = AlazarConfig(config)
card = Alazar(scope_settings)
card.configure(scope_settings)
print("go")
print("Taking %d data points." % len(Freqs))
print("|" + (" " * (len(Freqs) / 10)) + " |")
print("|", end=' ')
#figure(1)
tpts, ch1_pts, ch2_pts = card.acquire_avg_data()
#fig1=FigureClient(xlabel='Time',ylabel='Amplitude',title='Scope')
#fig2=FigureClient(xlabel='Time',ylabel='Amplitude',title='S21')
#fig3=FigureClient(xlabel='Time',ylabel='Amplitude',title='S21')
win = ScriptPlotWin(grid_x=2)
scope_plot = win.add_linePlot(title="Scope")
S21_plot_1 = win.add_linePlot(title="S21 1")
S21_plot_2 = win.add_linePlot(title="S21 2")
win.go()
Amps = []
freqs = []
for ind, ff in enumerate(Freqs):
if mod(ind, len(Freqs) / 10.) == 0: print("-", end=' ')
RF1.set_frequency(ff)
RF2.set_frequency(ff + IFfreq)
# na.set_center_frequency(ff)
#print "freq=%f" % ff
#time.sleep(1.15)
tpts, ch1_pts, ch2_pts = card.acquire_avg_data()
#fig1.update_plot((tpts,ch1_pts))
scope_plot.send((tpts, ch1_pts))
dtpts, amp1pts, phi1pts, amp2pts, phi2pts = digital_homodyne(
tpts, ch1_pts, ch2_pts, IFfreq, AmpPhase=True)
#print "A1: %f, Phi1: %f, A2: %f, Phi2: %f" % card.heterodyne(tpts,ch1_pts,ch2_pts,IFfreq)
#A1= heterodyne(tpts,ch1_pts,ch2_pts,IFfreq)[0]
freqs.append(ff / 1e9)
Amps.append(mean(amp1pts))
#fig2.update_plot((dtpts,amp1pts))
#fig3.update_plot((array(freqs),array(Amps)))
S21_plot_1.send((dtpts, amp1pts))
S21_plot_2.send((array(freqs), array(Amps)))
print("|")
class DataThread(QObject):
def __init__(self, config_file=None):
QObject.__init__(self)
self.config_file = config_file
self.instruments = InstrumentManager(self.config_file)
self.params = DictProxy("threadParameter")
self.connect(self.params, SIGNAL("threadParameterChanged"),
lambda n,v: self.emit(SIGNAL("threadParameterChanged"), n, v))
self.plots = ManagerProxy("plotMethodCalled")
self.gui = ManagerProxy("guiMethodCalled")
self._aborted = False
def run_on_instrument_manager(inst_name, method_name, args, kwargs):
try: getattr(self.instrument_manager[inst_name], method_name)(*args, **kwargs)
except Exception as e: self.emit("instrumentMethodFailed", (str(e),))
def set_param(self, name, value):
self.params.set_nosignal(name, value)
def save_experimental_settings(self):
filename = str(QFileDialog.getSaveFileName())
self.instruments.save_settings(filename)
def save_all_settings(self):
filename = str(QFileDialog.getSaveFileName())
# save_settings does not currently (11/13) process params meaningfully
self.instruments.save_settings(filename, params=self.params)
def load_settings(self):
filename = QFileDialog.getOpenFileName(filter="*.cfg")
self.instruments.load_config_file(filename)
def list_instruments(self):
for key, inst in self.instruments.items():
self.msg(key + inst.name)
def get_local_params(self):
self.emit(SIGNAL("localParams"), self.params)
def msg(self, *args):
self.emit(SIGNAL("msg"), *args)
def status(self, s):
self.emit(SIGNAL("status"), s)
def progress(self, val, tot):
self.emit(SIGNAL("progress"), (val, tot))
def abort(self):
self._aborted = True
def aborted(self):
if self._aborted:
self._aborted = False
return True
else:
return False
def run_sweep(self, whichStack):
self.msg("Sweeping...")
params = Bunch(self.params)
if whichStack[params.sweep1] == 0:
prange = list(range(params.sweep1_start_int,
params.sweep1_stop_int, params.sweep1_step_int))
else:
prange = np.arange(params.sweep1_start_float,
params.sweep1_stop_float, params.sweep1_step_float)
self.msg(prange)
if params.sweep2_enabled:
raise NotImplementedError
actions = params.actions.splitlines()
for p in prange:
self.msg(params.sweep1 + "=" + str(p))
for action in actions:
self.params[params.sweep1] = p
try:
if self.params["abort_sweep"]:
self.params["abort_sweep"] = False
return
except: pass
getattr(self, action)()
self.msg("Done")
def run_data_thread(self, method, *args):
if DEBUG:
print(method, "running")
self.msg(method)
self.msg(args)
getattr(self, method)(*args)
self.emit(SIGNAL(method + "done"))
def run_seq_experiment(expt_name, lp_enable=True, **kwargs):
seq_exp = SequentialExperiment(lp_enable)
prefix = expt_name.lower()
data_file = get_data_filename(prefix)
if expt_name.lower() == 'frequency_stabilization':
frequency_stabilization(seq_exp)
if expt_name.lower() == 'ef_frequency_calibration':
ef_frequency_calibration(seq_exp)
if expt_name.lower() == 'pulse_calibration':
pulse_calibration(seq_exp, phase_exp=kwargs['phase_exp'])
if expt_name.lower() == 'ef_pulse_calibration':
# ef_frequency_calibration(seq_exp)
ef_pulse_calibration(seq_exp)
if expt_name.lower() == 'repeated_ef_ramsey':
#ef_pulse_calibration(seq_exp)
for i in arange(15):
frequency_stabilization(seq_exp)
seq_exp.run('EF_Ramsey', expt_kwargs={'update_config': False})
if expt_name.lower() == 'sequential_single_qubit_rb':
for i in arange(32):
# if i %4 == 0:
# frequency_stabilization(seq_exp)
# pulse_calibration(seq_exp,phase_exp=True)
# seq_exp.run('randomized_benchmarking_phase_offset',{"data_file":data_file})
seq_exp.run('randomized_benchmarking_phase_offset')
if expt_name.lower() == 'rabi_sweep':
drive_freq_pts = arange(4.75e9, 4.9e9, 0.5e6)
for ii, drive_freq in enumerate(drive_freq_pts):
seq_exp.run('rabi_sweep',
expt_kwargs={
"drive_freq": drive_freq,
"data_file": data_file
})
if expt_name.lower() == 'ef_rabi_sweep':
ef_freq_pts = arange(4.525e9, 4.535e9, 0.2e6)
for ii, ef_freq in enumerate(ef_freq_pts):
seq_exp.run('ef_rabi_sweep',
expt_kwargs={
"ef_freq": ef_freq,
"data_file": data_file
})
if expt_name.lower() == 't1_rho_sweep':
amp_list = np.logspace(-3, 0, 15)
for amp in amp_list:
seq_exp.run('T1rho',
expt_kwargs={
'amp': amp,
"data_file": data_file
})
#seq_exp.run('T1')
if expt_name.lower() == 'echo_spectroscopy':
number_list = array(
[1, 2, 4, 6, 8, 10, 12, 16, 20, 26, 36, 45, 55, 65, 75])
for ii, number in enumerate(number_list):
# if ii%5 is 0:
# frequency_stabilization(seq_exp)
# pulse_calibration(seq_exp)
seq_exp.run('spin_echo', expt_kwargs={'number': number})
if expt_name.lower() == 'pulse_probe_amp_sweep':
# alist = logspace(-3,0,10)
alist = linspace(0.15, 1.0, 10)
for a in alist:
# seq_exp.run('pulse_probe_iq', {'amp':a,"data_file":data_file})
seq_exp.run('pulse_probe_iq', expt_kwargs={'amp': a})
if expt_name.lower() == 'qubit_temperature_measurement':
vary_dict = {"ef_rabi": {"averages": 5000}}
seq_exp.run('ef_rabi',
vary_dict=vary_dict,
expt_kwargs={
'ge_pi': True,
'data_file': data_file
})
vary_dict = {"ef_rabi": {"averages": 20000}}
seq_exp.run('ef_rabi',
vary_dict=vary_dict,
expt_kwargs={
'ge_pi': False,
'data_file': data_file
})
if expt_name.lower() == 'resonator_temperature_measurement':
print(
"NOTE: Make sure that the drive attenuation is small enough to resolve number split peak"
)
seq_exp.run('pulse_probe_iq', expt_kwargs={'data_file': data_file})
if expt_name.lower() == 'sequential_t1':
number = 5
for i in arange(number):
seq_exp.run('T1', expt_kwargs={'data_file': data_file})
if expt_name.lower() == 'sequential_ramsey':
number = 5
for i in arange(number):
seq_exp.run('Ramsey', expt_kwargs={'data_file': data_file})
if expt_name.lower() == 'coherence_and_qubit_temperature':
# Only works if the number of points are the same for all experiments
seq_exp.run('T1', expt_kwargs={'data_file': data_file})
seq_exp.run('Ramsey', expt_kwargs={'data_file': data_file})
vary_dict = {"ef_rabi": {"averages": 5000}}
seq_exp.run('ef_rabi',
vary_dict=vary_dict,
expt_kwargs={
'ge_pi': True,
'data_file': data_file
})
vary_dict = {"ef_rabi": {"averages": 20000}}
seq_exp.run('ef_rabi',
vary_dict=vary_dict,
expt_kwargs={
'ge_pi': False,
'data_file': data_file
})
if expt_name.lower() == 'sequential_qp_pumping':
numberlist = arange(0, 20, 2)
delaylist = arange(1000, 20000, 2000)
for delay in delaylist:
for number in numberlist:
vary_dict = {
"qp_pumping": {
"number_pump_pulses": number,
"pump_delay": delay
},
"expt_trigger": {
"period_ns": number * delay + 350000
}
}
seq_exp.run('qp_pumping',
vary_dict=vary_dict,
expt_kwargs={'data_file': data_file})
if expt_name.lower() == 'sequential_qp_pumping_vs_pulse_number':
numberlist = arange(0, 21, 2)
delay = 500
for number in numberlist:
vary_dict = {
"qp_pumping": {
"number_pump_pulses": number,
"pump_delay": delay
},
"expt_trigger": {
"period_ns": 400000
}
}
seq_exp.run('qp_pumping',
vary_dict=vary_dict,
expt_kwargs={'data_file': data_file})
if expt_name.lower() == 'dispersive_shift_calibration_res_spec':
seq_exp.run('vacuum_rabi',
vary_dict={"vacuum_rabi": {
"pi_pulse": False
}},
expt_kwargs={'data_file': data_file})
seq_exp.run('vacuum_rabi',
vary_dict={"vacuum_rabi": {
"pi_pulse": True
}},
expt_kwargs={'data_file': data_file})
if expt_name.lower() == 'single_tone_read_power_sweep':
powerlist = arange(-31.5, 0.0, 1.0)
for p in powerlist:
seq_exp.run('vacuum_rabi',
vary_dict={"readout": {
"dig_atten": p
}},
expt_kwargs={'data_file': data_file})
if expt_name.lower() == 'bluesideband_spectrum_vs_power':
amplist = arange(0.1, 1.1,
0.1) # rough calibration gave delta_{AC} = 60a**2 MHz
for ii, a in enumerate(amplist):
start = 58e6 * a**2 - 15e6 #-695e6
stop = 58e6 * a**2 + 15e6 #-695e6
step = 100e4
vary_dict = {
"pulse_probe_iq": {
"start": start,
"stop": stop,
"step": step
}
}
seq_exp.run('pulse_probe_iq',
vary_dict=vary_dict,
expt_kwargs={
'amp': a,
'data_file': data_file
})
if expt_name.lower() == 'dispersive_shift_weak_measurment':
im = InstrumentManager()
rf = im['RF5']
frequency = 7082519722.31
powerlist = arange(0, 20, 1)
rf.set_output(False)
seq_exp.run('Ramsey', expt_kwargs={'data_file': data_file})
rf.set_output(True)
for ii, pow in enumerate(powerlist):
rf.set_power(pow)
rf.set_frequency(frequency)
seq_exp.run('Ramsey', expt_kwargs={'data_file': data_file})
awg.write('inst:sel ' + str(channel) + '; OUTPUT ' + str(int(output)))
def get_power(awg, channel):
return float(awg.query('inst:sel ' + str(channel) + '; POW ?'))
def set_sin(awg, channel, intensity, frequency, phase=0.0):
awg.write('inst:sel ' + str(channel) + '; pow ' + str(intensity) +
'; function:shape SIN; SIN:phase ' + str(phase) +
'; frequency ' + str(frequency))
if __name__ == '__main__':
#awg = AWG81180A(name='awg', address='GPIB::04::INSTR')
im = InstrumentManager("offset_optimization.cfg")
awg = im['AWG']
#sa = SpectrumAnalyzer(protocol='serial', port=2)
#Agilent analog waveform generator
#sacm = SACalibrationManager(pickle.load(open('10dBm_cali.data')))
#sacm = SACalibrationManager(pickle.load(open('10dBm_LMS_cali.data')))
sa = im['SA']
rf = im['RF']
lo = im['LO']
rf.set_frequency(6e9)
rf.set_power(-3)
lo.set_frequency(6e9 + sa.lo_offset)
lo.set_power(10)