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)