def go(self): if self.liveplot_enabled: self.plotter.clear() print "Prep Instruments" self.readout.set_frequency(self.cfg['readout']['frequency']) self.readout.set_power(self.cfg['readout']['power']) self.readout.set_ext_pulse(mod=True) self.readout_shifter.set_phase(self.cfg['readout']['start_phase'] + self.cfg['readout']['phase_slope'] * ( self.cfg['readout']['frequency'] - self.cfg['readout']['bare_frequency']), self.cfg['readout']['frequency']) self.drive.set_frequency(self.cfg['qubit']['frequency'] - self.cfg['pulse_info'][self.pulse_type]['iq_freq']) self.drive.set_power(self.cfg['drive']['power']) self.drive.set_ext_pulse(mod=True) self.drive.set_output(True) self.readout_atten.set_attenuator(self.cfg['readout']['dig_atten']) try: self.cfg['freq_flux']['flux']=self.extra_args['flux'] except: pass try: self.cfg['freq_flux']['freq_flux_slope']=self.extra_args['freq_flux_slope'] except: pass try: self.cfg['freq_flux']['flux_offset']+=self.extra_args['flux_offset'] except: pass if self.cfg['freq_flux']['current']: self.flux_volt.ramp_current(self.cfg['freq_flux']['flux']) elif self.cfg['freq_flux']['voltage']: self.flux_volt.ramp_volt(self.cfg['freq_flux']['flux']) self.awg.set_amps_offsets(self.cfg['cal']['iq_amps'], self.cfg['cal']['iq_offsets']) if self.pre_run is not None: self.pre_run() if self.adc==None: print "Prep Card" adc = Alazar(self.cfg['alazar']) else: adc = self.adc expt_data = None current_data = None for ii in tqdm(arange(max(1, self.cfg[self.expt_cfg_name]['averages'] / 100))): tpts, ch1_pts, ch2_pts = adc.acquire_avg_data_by_record(prep_function=self.awg_prep, start_function=self.awg.run, excise=self.cfg['readout']['window']) mag = sqrt(ch1_pts**2+ch2_pts**2) if not self.cfg[self.expt_cfg_name]['use_pi_calibration']: if expt_data is None: if self.cfg['readout']['channel']==1: expt_data = ch1_pts elif self.cfg['readout']['channel']==2: expt_data = ch2_pts else: if self.cfg['readout']['channel']==1: expt_data = (expt_data * ii + ch1_pts) / (ii + 1.0) elif self.cfg['readout']['channel']==2: expt_data = (expt_data * ii + ch2_pts) / (ii + 1.0) else: if self.cfg['readout']['channel']==1: zero_amp = mean(ch1_pts[-2]) pi_amp = mean(ch1_pts[-1]) current_data= (ch1_pts[:-2]-zero_amp)/(pi_amp-zero_amp) elif self.cfg['readout']['channel']==2: zero_amp = mean(ch2_pts[-2]) pi_amp = mean(ch2_pts[-1]) current_data= (ch2_pts[:-2]-zero_amp)/(pi_amp-zero_amp) if expt_data is None: expt_data = current_data else: expt_data = (expt_data * ii + current_data) / (ii + 1.0) expt_avg_data = mean(expt_data, 1) if self.liveplot_enabled: self.plotter.plot_z(self.prefix + ' Data', expt_data.T) self.plotter.plot_xy(self.prefix + ' XY', self.pulse_sequence.expt_pts, expt_avg_data) # print ii * min(self.cfg[self.expt_cfg_name]['averages'], 100) if self.data_file != None: self.slab_file = SlabFile(self.data_file) else: self.slab_file = self.datafile() with self.slab_file as f: f.add('expt_2d', expt_data) f.add('expt_avg_data', expt_avg_data) f.add('expt_pts', self.expt_pts) f.close() if self.post_run is not None: self.post_run(self.expt_pts, expt_avg_data)
def take_data(self): #### if self.cfg["visdom_plot_livedata"]: viz = visdom.Visdom() assert viz.check_connection(), "Visdom server not connected!" # added two environments "seq_builder.json", and "live_plot.json" in C:\Users\slab\.visdom eid = "live_plot" viz.close(win=None, env=eid) win1 = viz.line( X=np.arange(0, 1), Y=np.arange(0, 1), env=eid, opts=dict(height=400, width=700, title='expt_avg_data', showlegend=True, xlabel='expt_pts')) win2 = viz.line( X=np.arange(0, 1), Y=np.arange(0, 1), env=eid, opts=dict(height=400, width=700, title='expt_avg_data2', showlegend=True, xlabel='expt_pts')) win3 = viz.line( X=np.arange(0, 1), Y=np.arange(0, 1), env=eid, opts=dict(height=400, width=700, title='single_record (of only first run)', showlegend=True, xlabel='time ns')) win4 = viz.scatter(X=array([[1,2,3],[1,2,3]]).transpose(), env=eid, opts=dict(height=400, width=700, title='g/e/f cal single shot', showlegend=True, xlabel='')) #### if self.pre_run is not None: self.pre_run() TEST_REDPITAYA = False if TEST_REDPITAYA: self.awg_run() if not TEST_REDPITAYA: if self.adc == None: print("Prep Card") adc = Alazar(self.cfg['alazar']) else: adc = self.adc # debug_alazer = False # if debug_alazer: # # # save raw time trace, 100 runs only # tpts, single_data1, single_data2 = adc.acquire_singleshot_data2() # # self.slab_file = self.datafile(data_file=self.data_file) # with self.slab_file as f: # f.add('tpts', tpts) # f.add('single_data1', single_data1) # f.add('single_data2', single_data2) # f.close() # # # hack for post_run # expt_avg_data = self.expt_pts # # else: if not self.cfg['readout']['save_single-shot_data']: expt_data = None current_data = None for ii in tqdm(arange(max(1, self.cfg[self.expt_cfg_name]['averages'] / 100))): tpts, ch1_pts, ch2_pts = adc.acquire_avg_data_by_record(prep_function=self.awg_prep, start_function=self.awg_run, excise=self.cfg['readout']['window']) if not self.cfg[self.expt_cfg_name]['use_pi_calibration']: if expt_data is None: if self.cfg['readout']['channel'] == 1: expt_data = ch1_pts elif self.cfg['readout']['channel'] == 2: expt_data = ch2_pts else: if self.cfg['readout']['channel'] == 1: expt_data = (expt_data * ii + ch1_pts) / (ii + 1.0) elif self.cfg['readout']['channel'] == 2: expt_data = (expt_data * ii + ch2_pts) / (ii + 1.0) if self.cfg['readout']['heterodyne_freq'] == 0: # homodyne expt_avg_data = mean(expt_data, 1) else: # heterodyne heterodyne_freq = self.cfg['readout']['heterodyne_freq'] # ifft by numpy default has the correct 1/N normalization expt_data_fft_amp = np.abs(np.fft.ifft(expt_data)) hetero_f_ind = int(round(heterodyne_freq * tpts.size * 1e-9)) # position in ifft # todo: do the proper sum here # expt_avg_data = np.average(expt_data_fft_amp[:, (hetero_f_ind - 1):(hetero_f_ind + 1)], axis=1) expt_avg_data = expt_data_fft_amp[:, hetero_f_ind] else: # average first, then divide by pi_calibration values if expt_data is None: if self.cfg['readout']['channel'] == 1: expt_data = ch1_pts[:-2] zero_amp_curr = mean(ch1_pts[-2]) pi_amp_curr = mean(ch1_pts[-1]) elif self.cfg['readout']['channel'] == 2: expt_data = ch2_pts[:-2] zero_amp_curr = mean(ch2_pts[-2]) pi_amp_curr = mean(ch2_pts[-1]) zero_amp = zero_amp_curr pi_amp = pi_amp_curr else: if self.cfg['readout']['channel'] == 1: expt_data = (expt_data * ii + ch1_pts[:-2]) / (ii + 1.0) zero_amp_curr = mean(ch1_pts[-2]) pi_amp_curr = mean(ch1_pts[-1]) elif self.cfg['readout']['channel'] == 2: expt_data = (expt_data * ii + ch2_pts[:-2]) / (ii + 1.0) zero_amp_curr = mean(ch2_pts[-2]) pi_amp_curr = mean(ch2_pts[-1]) zero_amp = (zero_amp * ii + zero_amp_curr) / (ii + 1.0) pi_amp = (pi_amp * ii + pi_amp_curr) / (ii + 1.0) # todo: add heterodyne with pi_cal expt_avg_data = mean((expt_data - zero_amp) / (pi_amp - zero_amp), 1) # self.slab_file = self.datafile(data_file=self.data_file) with self.slab_file as f: f.add('expt_2d', expt_data) f.add('expt_avg_data', expt_avg_data) f.add('expt_pts', self.expt_pts) # save pi_cal amps, to be able to monitor fluctuations if self.cfg[self.expt_cfg_name]['use_pi_calibration']: f.append_pt('zero_amps', zero_amp_curr) f.append_pt('pi_amps', pi_amp_curr) f.close() else: # here saves all single shot data if self.prefix == 'Vacuum_Rabi': print('vacuum_rabi') het_IFreqList = [self.cfg['readout']['heterodyne_freq']] het_read_freq_list = [0] elif self.cfg['readout']['is_multitone_heterodyne']: het_carrier_freq = self.cfg['readout']['heterodyne_carrier_freq'] het_read_freq_list = array(self.cfg['readout']['heterodyne_freq_list']) het_IFreqList = het_read_freq_list - het_carrier_freq else: het_carrier_freq = self.readout_freq - self.cfg['readout']['heterodyne_freq'] het_read_freq_list = array([self.readout_freq]) het_IFreqList = het_read_freq_list - het_carrier_freq avgPerAcquisition = int(min(self.cfg[self.expt_cfg_name]['averages'], 100)) numAcquisition = int(np.ceil(self.cfg[self.expt_cfg_name]['averages'] / 100)) # (ch1/2, exp_pts, heterodyne_freq, cos/sin, all averages) ss_data = zeros((2, len(self.expt_pts), len(het_IFreqList), 2, avgPerAcquisition * numAcquisition)) # (ch1/2, heterodyne_freq, cos/sin, all averages) ss_cal_g = zeros((2, len(het_IFreqList), 2, avgPerAcquisition * numAcquisition)) ss_cal_e = zeros((2, len(het_IFreqList), 2, avgPerAcquisition * numAcquisition)) ss_cal_f = zeros((2, len(het_IFreqList), 2, avgPerAcquisition * numAcquisition)) if self.cfg['readout']['save_trajectory_data']: # (ch1/2, exp_pts, heterodyne_freq, cos/sin, all averages, traj) traj_data = zeros((2, len(self.expt_pts), len(het_IFreqList), 2, avgPerAcquisition * numAcquisition, self.cfg['readout']['pts_per_traj'])) # (ch1/2, heterodyne_freq, cos/sin, all averages, traj) traj_cal_g = zeros((2, len(het_IFreqList), 2, avgPerAcquisition * numAcquisition, self.cfg['readout']['pts_per_traj'])) traj_cal_e = zeros((2, len(het_IFreqList), 2, avgPerAcquisition * numAcquisition, self.cfg['readout']['pts_per_traj'])) traj_cal_f = zeros((2, len(het_IFreqList), 2, avgPerAcquisition * numAcquisition, self.cfg['readout']['pts_per_traj'])) for ii in tqdm(arange(numAcquisition)): if not self.cfg['readout']['is_hetero_phase_ref']: # single_data1/2: index: (hetero_freqs, cos/sin, all_seqs) single_data1, single_data2, single_record1, single_record2 = \ adc.acquire_singleshot_heterodyne_multitone_data(het_IFreqList, prep_function=self.awg_prep, start_function=self.awg_run, excise=self.cfg['readout']['window']) # saving the raw time traces # single_data1, single_data2, single_record1, single_record2 = \ # adc.acquire_singleshot_heterodyne_multitone_data(het_IFreqList, prep_function=self.awg_prep, # start_function=self.awg_run, # excise=None, save_raw_data=True) elif self.cfg['readout']['save_trajectory_data']: excise = [ 0, self.cfg['readout']['window'][1] ] single_data1, single_data2, single_record1, single_record2, single_traj1, single_traj2= \ adc.acquire_singleshot_heterodyne_multitone_data_phase_ref_save_traj(het_IFreqList, self.cfg['readout'][ 'hetero_phase_ref_freq'], prep_function=self.awg_prep, start_function=self.awg_run, excise=excise, isCompensatePhase=True, save_raw_data=False, pts_per_traj=self.cfg['readout']['pts_per_traj']) else: # single_data1/2: index: (hetero_freqs, cos/sin, all_seqs) single_data1, single_data2, single_record1, single_record2 = \ adc.acquire_singleshot_heterodyne_multitone_data_phase_ref(het_IFreqList, self.cfg['readout']['hetero_phase_ref_freq'], prep_function=self.awg_prep, start_function=self.awg_run, excise=self.cfg['readout']['window'], isCompensatePhase=True, save_raw_data=False) single_data = array([single_data1, single_data2]) # index: (ch1/2, hetero_freqs, cos / sin, avgs, seq(exp_pts)) single_data = np.reshape(single_data, (single_data.shape[0], single_data.shape[1], single_data.shape[2], int(self.cfg['alazar'][ 'recordsPerAcquisition'] / self.pulse_sequence.sequence_length), self.pulse_sequence.sequence_length)) # index: (ch1/2, exp_pts, hetero_freqs, cos / sin, avgs) single_data = np.transpose(single_data, (0, 4, 1, 2, 3)) if (self.cfg[self.expt_cfg_name]['use_g-e-f_calibration']): ss_data[:, :, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)] = single_data[:, 0:-3] ss_cal_g[:, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)] = single_data[:, -3] ss_cal_e[:, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)] = single_data[:, -2] ss_cal_f[:, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)] = single_data[:, -1] elif (self.cfg[self.expt_cfg_name]['use_pi_calibration']): ss_data[:, :, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)] = single_data[:, 0:-2] ss_cal_g[:, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)] = single_data[:, -2] ss_cal_e[:, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)] = single_data[:, -1] else: ss_data[:, :, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)] = single_data[:, :] #### if self.cfg['readout']['save_trajectory_data']: # index: (hetero_freqs, cos/sin, all_seqs, traj) single_traj = array([single_traj1, single_traj2]) # index: (ch1/2, hetero_freqs, cos / sin, avgs, seq(exp_pts), traj) single_traj = np.reshape(single_traj, (single_traj.shape[0], single_traj.shape[1], single_traj.shape[2], self.cfg['alazar']['recordsPerAcquisition'] / self.pulse_sequence.sequence_length, self.pulse_sequence.sequence_length, single_traj.shape[-1])) # index: (ch1/2, exp_pts, hetero_freqs, cos / sin, avgs, traj) single_traj = np.transpose(single_traj, (0, 4, 1, 2, 3, 5)) # print single_traj.shape if (self.cfg[self.expt_cfg_name]['use_g-e-f_calibration']): traj_data[:, :, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition), :] = single_traj[ :, 0:-3, :] traj_cal_g[:, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition), :] = single_traj[:, -3, :] traj_cal_e[:, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition), :] = single_traj[:, -2, :] traj_cal_f[:, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition), :] = single_traj[:, -1, :] elif (self.cfg[self.expt_cfg_name]['use_pi_calibration']): traj_data[:, :, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition), :] = single_traj[ :, 0:-2, :] traj_cal_g[:, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition), :] = single_traj[:, -2, :] traj_cal_e[:, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition), :] = single_traj[:, -1, :] else: traj_data[:, :, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition), :] = single_traj[ :, :, :] #### # old way for easy plotting # only calculate for 1st het_readout_freq if het_IFreqList[0] == 0: # take cos of ch1/ch2 expt_avg_data = mean(ss_data[0, :, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) expt_avg_data2 = mean(ss_data[1, :, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) if self.cfg[self.expt_cfg_name]['use_pi_calibration']: zero_amp_avg = mean(ss_cal_g[0, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) zero_amp_avg2 = mean(ss_cal_g[1, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) pi_amp_avg = mean(ss_cal_e[0, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) pi_amp_avg2 = mean(ss_cal_e[1, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) zero_amp_curr = mean( ss_cal_g[0, 0, 0, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)], -1) zero_amp_curr2 = mean( ss_cal_g[1, 0, 0, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)], -1) pi_amp_curr = mean( ss_cal_e[0, 0, 0, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)], -1) pi_amp_curr2 = mean( ss_cal_e[1, 0, 0, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)], -1) expt_avg_data = (expt_avg_data - zero_amp_avg) / (pi_amp_avg - zero_amp_avg) expt_avg_data2 = (expt_avg_data2 - zero_amp_avg2) / (pi_amp_avg2 - zero_amp_avg2) else: # take cos/sin of ch1 expt_avg_data = mean(ss_data[0, :, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) expt_avg_data2 = mean(ss_data[0, :, 0, 1, 0:((ii + 1) * avgPerAcquisition)], -1) if self.cfg[self.expt_cfg_name]['use_pi_calibration']: zero_amp_avg = mean(ss_cal_g[0, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) zero_amp_avg2 = mean(ss_cal_g[0, 0, 1, 0:((ii + 1) * avgPerAcquisition)], -1) pi_amp_avg = mean(ss_cal_e[0, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) pi_amp_avg2 = mean(ss_cal_e[0, 0, 1, 0:((ii + 1) * avgPerAcquisition)], -1) zero_amp_curr = mean( ss_cal_g[0, 0, 0, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)], -1) zero_amp_curr2 = mean( ss_cal_g[0, 0, 1, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)], -1) pi_amp_curr = mean( ss_cal_e[0, 0, 0, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)], -1) pi_amp_curr2 = mean( ss_cal_e[0, 0, 1, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)], -1) expt_avg_data = (expt_avg_data - zero_amp_avg) / (pi_amp_avg - zero_amp_avg) expt_avg_data2 = (expt_avg_data2 - zero_amp_avg2) / (pi_amp_avg2 - zero_amp_avg2) # this needs to stay here # if self.data_file != None: # self.slab_file = SlabFile(self.data_file) # else: # self.slab_file = self.datafile() self.slab_file = self.datafile(data_file=self.data_file) with self.slab_file as f: f.add('ss_data', ss_data[:, :, :, :, 0:((ii + 1) * avgPerAcquisition)]) f.add('single_record1', single_record1) f.add('single_record2', single_record2) if (self.cfg[self.expt_cfg_name]['use_pi_calibration']): f.add('ss_cal_g', ss_cal_g[:, :, :, 0:((ii + 1) * avgPerAcquisition)]) f.add('ss_cal_e', ss_cal_e[:, :, :, 0:((ii + 1) * avgPerAcquisition)]) if (self.cfg[self.expt_cfg_name]['use_g-e-f_calibration']): f.add('ss_cal_g', ss_cal_g[:, :, :, 0:((ii + 1) * avgPerAcquisition)]) f.add('ss_cal_e', ss_cal_e[:, :, :, 0:((ii + 1) * avgPerAcquisition)]) f.add('ss_cal_f', ss_cal_f[:, :, :, 0:((ii + 1) * avgPerAcquisition)]) if self.cfg['readout']['save_trajectory_data']: f.add('traj_data', traj_data[:, :, :, :, 0:((ii + 1) * avgPerAcquisition), :]) if (self.cfg[self.expt_cfg_name]['use_pi_calibration']): f.add('traj_cal_g', traj_cal_g[:, :, :, 0:((ii + 1) * avgPerAcquisition), :]) f.add('traj_cal_e', traj_cal_e[:, :, :, 0:((ii + 1) * avgPerAcquisition), :]) if (self.cfg[self.expt_cfg_name]['use_g-e-f_calibration']): f.add('traj_cal_g', traj_cal_g[:, :, :, 0:((ii + 1) * avgPerAcquisition), :]) f.add('traj_cal_e', traj_cal_e[:, :, :, 0:((ii + 1) * avgPerAcquisition), :]) f.add('traj_cal_f', traj_cal_f[:, :, :, 0:((ii + 1) * avgPerAcquisition), :]) f.add('expt_avg_data', expt_avg_data.flatten()) f.add('expt_avg_data2', expt_avg_data2.flatten()) f.add('expt_pts', self.expt_pts) f.add('het_read_freq_list', het_read_freq_list) if self.cfg[self.expt_cfg_name]['use_pi_calibration']: f.append_pt('zero_amps', zero_amp_curr) f.append_pt('pi_amps', pi_amp_curr) f.append_pt('zero_amps2', zero_amp_curr2) f.append_pt('pi_amps2', pi_amp_curr2) f.close() #### if self.cfg["visdom_plot_livedata"]: viz.updateTrace(X=self.expt_pts, Y=expt_avg_data, env=eid, win=win1, append=False) viz.updateTrace(X=self.expt_pts, Y=expt_avg_data2, env=eid, win=win2, append=False) # if (self.cfg[self.expt_cfg_name]['use_pi_calibration']): # # f_idx = 0 # viz.scatter(X=array([ss_cal_g[0, f_idx, 0, :],ss_cal_g[0, f_idx, 1, :]]).transpose(), # Y=None, env=eid, win=win4, name='test') # # if (self.cfg[self.expt_cfg_name]['use_g-e-f_calibration']): # pass if ii==0: viz.updateTrace(X=array(range(len(single_record1))), Y=single_record2, env=eid, win=win3, name='2', append=False) viz.updateTrace(X=array(range(len(single_record1))), Y=single_record1, env=eid, win=win3, name='1', append=False) #### if self.post_run is not None: self.post_run(self.expt_pts, expt_avg_data) if self.cfg['stop_awgs'] == True: self.awg_prep() print('stop_awg = True, seqs stopped.') else: print('stop_awg = False, seqs left running.') # closes Alazar card and releases buffer adc.close()
def go(self): if self.liveplot_enabled: self.plotter.clear() print("Prep Instruments") self.readout.set_frequency(self.cfg['readout']['frequency']) self.readout.set_power(self.cfg['readout']['power']) self.readout.set_ext_pulse(mod=True) # self.readout_shifter.set_phase(self.cfg['readout']['start_phase'] + self.cfg['readout']['phase_slope'] * ( # self.cfg['readout']['frequency'] - self.cfg['readout']['bare_frequency']), self.cfg['readout']['frequency']) self.drive.set_frequency( self.cfg['qubit']['frequency'] - self.cfg['pulse_info'][self.pulse_type]['iq_freq']) self.drive.set_power(self.cfg['drive']['power']) self.drive.set_ext_pulse(mod=True) self.drive.set_output(True) self.readout_atten.set_attenuator(self.cfg['readout']['dig_atten']) self.trigger.set_period(self.trigger_period) try: self.cfg['freq_flux']['flux'] = self.extra_args['flux'] except: pass try: self.cfg['freq_flux']['freq_flux_slope'] = self.extra_args[ 'freq_flux_slope'] except: pass try: self.cfg['freq_flux']['flux_offset'] += self.extra_args[ 'flux_offset'] except: pass if self.cfg['freq_flux']['current']: try: self.flux_volt.ramp_current(self.cfg['freq_flux']['flux']) except: pass elif self.cfg['freq_flux']['voltage']: try: self.flux_volt.ramp_volt(self.cfg['freq_flux']['flux']) except: pass self.awg.set_amps_offsets(self.cfg['cal']['iq_amps'], self.cfg['cal']['iq_offsets']) if self.pre_run is not None: self.pre_run() if self.adc == None: print("Prep Card") adc = Alazar(self.cfg['alazar']) else: adc = self.adc expt_data = None current_data = None for ii in tqdm( arange(max(1, self.cfg[self.expt_cfg_name]['averages'] / 100))): tpts, ch1_pts, ch2_pts = adc.acquire_avg_data_by_record( prep_function=self.awg_prep, start_function=self.awg.run, excise=self.cfg['readout']['window']) ### to skip the first 100 averages data point, because we saw a weird ramp in the RF output if ii == 0: time.sleep(0.1) continue mag = sqrt(ch1_pts**2 + ch2_pts**2) if not self.cfg[self.expt_cfg_name]['use_pi_calibration']: if expt_data is None: if self.cfg['readout']['channel'] == 1: expt_data = ch1_pts elif self.cfg['readout']['channel'] == 2: expt_data = ch2_pts else: if self.cfg['readout']['channel'] == 1: expt_data = (expt_data * ii + ch1_pts) / (ii + 1.0) elif self.cfg['readout']['channel'] == 2: expt_data = (expt_data * ii + ch2_pts) / (ii + 1.0) expt_avg_data = mean(expt_data, 1) else: if expt_data is None: if self.cfg['readout']['channel'] == 1: expt_data = ch1_pts elif self.cfg['readout']['channel'] == 2: expt_data = ch2_pts else: if self.cfg['readout']['channel'] == 1: expt_data = (expt_data * ii + ch1_pts) / (ii + 1.0) elif self.cfg['readout']['channel'] == 2: expt_data = (expt_data * ii + ch2_pts) / (ii + 1.0) expt_avg_data = mean(expt_data, 1) expt_avg_data = (expt_avg_data[:-2] - expt_avg_data[-2]) / ( expt_avg_data[-1] - expt_avg_data[-2]) # temporary hack. Alazar card seems to shift two data points (problem disappeared after reboot computer) # expt_avg_data = np.concatenate((expt_avg_data[2:],expt_avg_data[:2])) # if self.cfg[self.expt_cfg_name]['use_pi_calibration']: # expt_avg_data = (expt_avg_data[:-2]-expt_avg_data[-2])/(expt_avg_data[-1]-expt_avg_data[-2]) # else: # if self.cfg['readout']['channel']==1: # zero_amp = mean(ch1_pts[-2]) # pi_amp = mean(ch1_pts[-1]) # current_data= (ch1_pts[:-2]-zero_amp)/(pi_amp-zero_amp) # elif self.cfg['readout']['channel']==2: # zero_amp = mean(ch2_pts[-2]) # pi_amp = mean(ch2_pts[-1]) # current_data= (ch2_pts[:-2]-zero_amp)/(pi_amp-zero_amp) # if expt_data is None: # expt_data = current_data # else: # expt_data = (expt_data * ii + current_data) / (ii + 1.0) # expt_avg_data = mean(expt_data, 1) if self.liveplot_enabled: self.plotter.plot_z(self.prefix + ' Data', expt_data.T) self.plotter.plot_xy(self.prefix + ' XY', self.pulse_sequence.expt_pts, expt_avg_data) # print ii * min(self.cfg[self.expt_cfg_name]['averages'], 100) if self.data_file == None: self.slab_file = self.datafile() with self.slab_file as f: f.add('expt_2d', expt_data) f.add('expt_avg_data', expt_avg_data) f.add('expt_pts', self.expt_pts) f.close() if self.data_file != None: self.slab_file = SlabFile(self.data_file) with self.slab_file as f: f.append_line('expt_avg_data', expt_avg_data) f.append_line('expt_pts', self.expt_pts) f.close() if not self.adc_predefined: adc.close() if self.post_run is not None: self.post_run(self.expt_pts, expt_avg_data)
def take_data(self): #### if self.cfg["visdom_plot_livedata"]: viz = visdom.Visdom() assert viz.check_connection(), "Visdom server not connected!" # added two environments "seq_builder.json", and "live_plot.json" in C:\Users\slab\.visdom eid = "live_plot" viz.close(win=None, env=eid) win1 = viz.line(X=np.arange(0, 1), Y=np.arange(0, 1), env=eid, opts=dict(height=400, width=700, title='expt_avg_data', showlegend=True, xlabel='expt_pts')) win2 = viz.line(X=np.arange(0, 1), Y=np.arange(0, 1), env=eid, opts=dict(height=400, width=700, title='expt_avg_data2', showlegend=True, xlabel='expt_pts')) win3 = viz.line(X=np.arange(0, 1), Y=np.arange(0, 1), env=eid, opts=dict( height=400, width=700, title='single_record (of only first run)', showlegend=True, xlabel='time ns')) #### if self.pre_run is not None: self.pre_run() TEST_REDPITAYA = False if TEST_REDPITAYA: self.awg_run() if not TEST_REDPITAYA: if self.adc == None: print("Prep Card") adc = Alazar(self.cfg['alazar']) else: adc = self.adc # debug_alazer = False # if debug_alazer: # # # save raw time trace, 100 runs only # tpts, single_data1, single_data2 = adc.acquire_singleshot_data2() # # self.slab_file = self.datafile(data_file=self.data_file) # with self.slab_file as f: # f.add('tpts', tpts) # f.add('single_data1', single_data1) # f.add('single_data2', single_data2) # f.close() # # # hack for post_run # expt_avg_data = self.expt_pts # # else: if not self.cfg['readout']['save_single-shot_data']: expt_data = None current_data = None for ii in tqdm( arange( max(1, self.cfg[self.expt_cfg_name]['averages'] / 100))): tpts, ch1_pts, ch2_pts = adc.acquire_avg_data_by_record( prep_function=self.awg_prep, start_function=self.awg_run, excise=self.cfg['readout']['window']) if not self.cfg[self.expt_cfg_name]['use_pi_calibration']: if expt_data is None: if self.cfg['readout']['channel'] == 1: expt_data = ch1_pts elif self.cfg['readout']['channel'] == 2: expt_data = ch2_pts else: if self.cfg['readout']['channel'] == 1: expt_data = (expt_data * ii + ch1_pts) / (ii + 1.0) elif self.cfg['readout']['channel'] == 2: expt_data = (expt_data * ii + ch2_pts) / (ii + 1.0) if self.cfg['readout']['heterodyne_freq'] == 0: # homodyne expt_avg_data = mean(expt_data, 1) else: # heterodyne heterodyne_freq = self.cfg['readout'][ 'heterodyne_freq'] # ifft by numpy default has the correct 1/N normalization expt_data_fft_amp = np.abs(np.fft.ifft(expt_data)) hetero_f_ind = int( round(heterodyne_freq * tpts.size * 1e-9)) # position in ifft # todo: do the proper sum here # expt_avg_data = np.average(expt_data_fft_amp[:, (hetero_f_ind - 1):(hetero_f_ind + 1)], axis=1) expt_avg_data = expt_data_fft_amp[:, hetero_f_ind] else: # average first, then divide by pi_calibration values if expt_data is None: if self.cfg['readout']['channel'] == 1: expt_data = ch1_pts[:-2] zero_amp_curr = mean(ch1_pts[-2]) pi_amp_curr = mean(ch1_pts[-1]) elif self.cfg['readout']['channel'] == 2: expt_data = ch2_pts[:-2] zero_amp_curr = mean(ch2_pts[-2]) pi_amp_curr = mean(ch2_pts[-1]) zero_amp = zero_amp_curr pi_amp = pi_amp_curr else: if self.cfg['readout']['channel'] == 1: expt_data = (expt_data * ii + ch1_pts[:-2]) / (ii + 1.0) zero_amp_curr = mean(ch1_pts[-2]) pi_amp_curr = mean(ch1_pts[-1]) elif self.cfg['readout']['channel'] == 2: expt_data = (expt_data * ii + ch2_pts[:-2]) / (ii + 1.0) zero_amp_curr = mean(ch2_pts[-2]) pi_amp_curr = mean(ch2_pts[-1]) zero_amp = (zero_amp * ii + zero_amp_curr) / (ii + 1.0) pi_amp = (pi_amp * ii + pi_amp_curr) / (ii + 1.0) # todo: add heterodyne with pi_cal expt_avg_data = mean( (expt_data - zero_amp) / (pi_amp - zero_amp), 1) # self.slab_file = self.datafile(data_file=self.data_file) with self.slab_file as f: f.add('expt_2d', expt_data) f.add('expt_avg_data', expt_avg_data) f.add('expt_pts', self.expt_pts) # save pi_cal amps, to be able to monitor fluctuations if self.cfg[self.expt_cfg_name]['use_pi_calibration']: f.append_pt('zero_amps', zero_amp_curr) f.append_pt('pi_amps', pi_amp_curr) f.close() else: # here saves all single shot data if self.prefix == 'Vacuum_Rabi': print('vacuum_rabi') het_IFreqList = [self.cfg['readout']['heterodyne_freq']] het_read_freq_list = [0] elif self.cfg['readout']['is_multitone_heterodyne']: het_carrier_freq = self.cfg['readout'][ 'heterodyne_carrier_freq'] het_read_freq_list = array( self.cfg['readout']['heterodyne_freq_list']) het_IFreqList = het_read_freq_list - het_carrier_freq else: het_carrier_freq = self.readout_freq - self.cfg['readout'][ 'heterodyne_freq'] het_read_freq_list = array([self.readout_freq]) het_IFreqList = het_read_freq_list - het_carrier_freq avgPerAcquisition = int( min(self.cfg[self.expt_cfg_name]['averages'], 100)) numAcquisition = int( np.ceil(self.cfg[self.expt_cfg_name]['averages'] / 100)) # (ch1/2, exp_pts, heterodyne_freq, cos/sin, all averages) ss_data = zeros((2, len(self.expt_pts), len(het_IFreqList), 2, avgPerAcquisition * numAcquisition)) # (ch1/2, heterodyne_freq, cos/sin, all averages) ss_cal_g = zeros((2, len(het_IFreqList), 2, avgPerAcquisition * numAcquisition)) ss_cal_e = zeros((2, len(het_IFreqList), 2, avgPerAcquisition * numAcquisition)) ss_cal_f = zeros((2, len(het_IFreqList), 2, avgPerAcquisition * numAcquisition)) if self.cfg['readout']['save_trajectory_data']: # (ch1/2, exp_pts, heterodyne_freq, cos/sin, all averages, traj) traj_data = zeros( (2, len(self.expt_pts), len(het_IFreqList), 2, avgPerAcquisition * numAcquisition, self.cfg['readout']['pts_per_traj'])) # (ch1/2, heterodyne_freq, cos/sin, all averages, traj) traj_cal_g = zeros((2, len(het_IFreqList), 2, avgPerAcquisition * numAcquisition, self.cfg['readout']['pts_per_traj'])) traj_cal_e = zeros((2, len(het_IFreqList), 2, avgPerAcquisition * numAcquisition, self.cfg['readout']['pts_per_traj'])) traj_cal_f = zeros((2, len(het_IFreqList), 2, avgPerAcquisition * numAcquisition, self.cfg['readout']['pts_per_traj'])) for ii in tqdm(arange(numAcquisition)): if not self.cfg['readout']['is_hetero_phase_ref']: # single_data1/2: index: (hetero_freqs, cos/sin, all_seqs) single_data1, single_data2, single_record1, single_record2 = \ adc.acquire_singleshot_heterodyne_multitone_data(het_IFreqList, prep_function=self.awg_prep, start_function=self.awg_run, excise=self.cfg['readout']['window']) # saving the raw time traces # single_data1, single_data2, single_record1, single_record2 = \ # adc.acquire_singleshot_heterodyne_multitone_data(het_IFreqList, prep_function=self.awg_prep, # start_function=self.awg_run, # excise=None, save_raw_data=True) elif self.cfg['readout']['save_trajectory_data']: excise = [0, self.cfg['readout']['window'][1]] single_data1, single_data2, single_record1, single_record2, single_traj1, single_traj2= \ adc.acquire_singleshot_heterodyne_multitone_data_phase_ref_save_traj(het_IFreqList, self.cfg['readout'][ 'hetero_phase_ref_freq'], prep_function=self.awg_prep, start_function=self.awg_run, excise=excise, isCompensatePhase=True, save_raw_data=False, pts_per_traj=self.cfg['readout']['pts_per_traj']) else: # single_data1/2: index: (hetero_freqs, cos/sin, all_seqs) single_data1, single_data2, single_record1, single_record2 = \ adc.acquire_singleshot_heterodyne_multitone_data_phase_ref(het_IFreqList, self.cfg['readout']['hetero_phase_ref_freq'], prep_function=self.awg_prep, start_function=self.awg_run, excise=self.cfg['readout']['window'], isCompensatePhase=True, save_raw_data=False) single_data = array([single_data1, single_data2]) # index: (ch1/2, hetero_freqs, cos / sin, avgs, seq(exp_pts)) single_data = np.reshape( single_data, (single_data.shape[0], single_data.shape[1], single_data.shape[2], int(self.cfg['alazar']['recordsPerAcquisition'] / self.pulse_sequence.sequence_length), self.pulse_sequence.sequence_length)) # index: (ch1/2, exp_pts, hetero_freqs, cos / sin, avgs) single_data = np.transpose(single_data, (0, 4, 1, 2, 3)) if (self.cfg[self.expt_cfg_name]['use_g-e-f_calibration']): ss_data[:, :, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)] = single_data[:, 0:-3] ss_cal_g[:, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)] = single_data[:, -3] ss_cal_e[:, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)] = single_data[:, -2] ss_cal_f[:, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)] = single_data[:, -1] elif (self.cfg[self.expt_cfg_name]['use_pi_calibration']): ss_data[:, :, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)] = single_data[:, 0:-2] ss_cal_g[:, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)] = single_data[:, -2] ss_cal_e[:, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)] = single_data[:, -1] else: ss_data[:, :, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)] = single_data[:, :] #### if self.cfg['readout']['save_trajectory_data']: # index: (hetero_freqs, cos/sin, all_seqs, traj) single_traj = array([single_traj1, single_traj2]) # index: (ch1/2, hetero_freqs, cos / sin, avgs, seq(exp_pts), traj) single_traj = np.reshape( single_traj, (single_traj.shape[0], single_traj.shape[1], single_traj.shape[2], self.cfg['alazar']['recordsPerAcquisition'] / self.pulse_sequence.sequence_length, self.pulse_sequence.sequence_length, single_traj.shape[-1])) # index: (ch1/2, exp_pts, hetero_freqs, cos / sin, avgs, traj) single_traj = np.transpose(single_traj, (0, 4, 1, 2, 3, 5)) # print single_traj.shape if (self.cfg[self.expt_cfg_name] ['use_g-e-f_calibration']): traj_data[:, :, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition), :] = single_traj[:, 0:-3, :] traj_cal_g[:, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition), :] = single_traj[:, -3, :] traj_cal_e[:, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition), :] = single_traj[:, -2, :] traj_cal_f[:, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition), :] = single_traj[:, -1, :] elif (self.cfg[self.expt_cfg_name] ['use_pi_calibration']): traj_data[:, :, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition), :] = single_traj[:, 0:-2, :] traj_cal_g[:, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition), :] = single_traj[:, -2, :] traj_cal_e[:, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition), :] = single_traj[:, -1, :] else: traj_data[:, :, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition), :] = single_traj[:, :, :] #### # old way for easy plotting # only calculate for 1st het_readout_freq if het_IFreqList[0] == 0: # take cos of ch1/ch2 expt_avg_data = mean( ss_data[0, :, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) expt_avg_data2 = mean( ss_data[1, :, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) if self.cfg[self.expt_cfg_name]['use_pi_calibration']: zero_amp_avg = mean( ss_cal_g[0, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) zero_amp_avg2 = mean( ss_cal_g[1, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) pi_amp_avg = mean( ss_cal_e[0, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) pi_amp_avg2 = mean( ss_cal_e[1, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) zero_amp_curr = mean( ss_cal_g[0, 0, 0, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)], -1) zero_amp_curr2 = mean( ss_cal_g[1, 0, 0, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)], -1) pi_amp_curr = mean( ss_cal_e[0, 0, 0, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)], -1) pi_amp_curr2 = mean( ss_cal_e[1, 0, 0, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)], -1) expt_avg_data = (expt_avg_data - zero_amp_avg) / ( pi_amp_avg - zero_amp_avg) expt_avg_data2 = (expt_avg_data2 - zero_amp_avg2 ) / (pi_amp_avg2 - zero_amp_avg2) else: # take cos/sin of ch1 expt_avg_data = mean( ss_data[0, :, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) expt_avg_data2 = mean( ss_data[0, :, 0, 1, 0:((ii + 1) * avgPerAcquisition)], -1) if self.cfg[self.expt_cfg_name]['use_pi_calibration']: zero_amp_avg = mean( ss_cal_g[0, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) zero_amp_avg2 = mean( ss_cal_g[0, 0, 1, 0:((ii + 1) * avgPerAcquisition)], -1) pi_amp_avg = mean( ss_cal_e[0, 0, 0, 0:((ii + 1) * avgPerAcquisition)], -1) pi_amp_avg2 = mean( ss_cal_e[0, 0, 1, 0:((ii + 1) * avgPerAcquisition)], -1) zero_amp_curr = mean( ss_cal_g[0, 0, 0, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)], -1) zero_amp_curr2 = mean( ss_cal_g[0, 0, 1, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)], -1) pi_amp_curr = mean( ss_cal_e[0, 0, 0, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)], -1) pi_amp_curr2 = mean( ss_cal_e[0, 0, 1, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)], -1) expt_avg_data = (expt_avg_data - zero_amp_avg) / ( pi_amp_avg - zero_amp_avg) expt_avg_data2 = (expt_avg_data2 - zero_amp_avg2 ) / (pi_amp_avg2 - zero_amp_avg2) # this needs to stay here # if self.data_file != None: # self.slab_file = SlabFile(self.data_file) # else: # self.slab_file = self.datafile() self.slab_file = self.datafile(data_file=self.data_file) with self.slab_file as f: f.add( 'ss_data', ss_data[:, :, :, :, 0:((ii + 1) * avgPerAcquisition)]) f.add('single_record1', single_record1) f.add('single_record2', single_record2) if (self.cfg[self.expt_cfg_name]['use_pi_calibration'] ): f.add( 'ss_cal_g', ss_cal_g[:, :, :, 0:((ii + 1) * avgPerAcquisition)]) f.add( 'ss_cal_e', ss_cal_e[:, :, :, 0:((ii + 1) * avgPerAcquisition)]) if (self.cfg[self.expt_cfg_name] ['use_g-e-f_calibration']): f.add( 'ss_cal_g', ss_cal_g[:, :, :, 0:((ii + 1) * avgPerAcquisition)]) f.add( 'ss_cal_e', ss_cal_e[:, :, :, 0:((ii + 1) * avgPerAcquisition)]) f.add( 'ss_cal_f', ss_cal_f[:, :, :, 0:((ii + 1) * avgPerAcquisition)]) if self.cfg['readout']['save_trajectory_data']: f.add( 'traj_data', traj_data[:, :, :, :, 0:((ii + 1) * avgPerAcquisition), :]) if (self.cfg[self.expt_cfg_name] ['use_pi_calibration']): f.add( 'traj_cal_g', traj_cal_g[:, :, :, 0:((ii + 1) * avgPerAcquisition), :]) f.add( 'traj_cal_e', traj_cal_e[:, :, :, 0:((ii + 1) * avgPerAcquisition), :]) if (self.cfg[self.expt_cfg_name] ['use_g-e-f_calibration']): f.add( 'traj_cal_g', traj_cal_g[:, :, :, 0:((ii + 1) * avgPerAcquisition), :]) f.add( 'traj_cal_e', traj_cal_e[:, :, :, 0:((ii + 1) * avgPerAcquisition), :]) f.add( 'traj_cal_f', traj_cal_f[:, :, :, 0:((ii + 1) * avgPerAcquisition), :]) f.add('expt_avg_data', expt_avg_data.flatten()) f.add('expt_avg_data2', expt_avg_data2.flatten()) f.add('expt_pts', self.expt_pts) f.add('het_read_freq_list', het_read_freq_list) if self.cfg[self.expt_cfg_name]['use_pi_calibration']: f.append_pt('zero_amps', zero_amp_curr) f.append_pt('pi_amps', pi_amp_curr) f.append_pt('zero_amps2', zero_amp_curr2) f.append_pt('pi_amps2', pi_amp_curr2) f.close() #### if self.cfg["visdom_plot_livedata"]: viz.updateTrace(X=self.expt_pts, Y=expt_avg_data, env=eid, win=win1, append=False) viz.updateTrace(X=self.expt_pts, Y=expt_avg_data2, env=eid, win=win2, append=False) if ii == 0: viz.updateTrace(X=array(range( len(single_record1))), Y=single_record2, env=eid, win=win3, name='2', append=False) viz.updateTrace(X=array(range( len(single_record1))), Y=single_record1, env=eid, win=win3, name='1', append=False) #### if self.post_run is not None: self.post_run(self.expt_pts, expt_avg_data) if self.cfg['stop_awgs'] == True: self.awg_prep() print('stop_awg = True, seqs stopped.') else: print('stop_awg = False, seqs left running.') # closes Alazar card and releases buffer adc.close()
def go(self): # if self.liveplot_enabled: # self.plotter.clear() print("Prep Instruments") try: self.readout.set_frequency(self.readout_freq) self.readout.set_power(self.cfg['readout']['power']) self.readout.set_ext_pulse(mod=True) self.readout.set_output(True) except: print("No readout found.") try: self.readout_shifter.set_phase(self.cfg['readout']['start_phase'] + self.cfg['readout']['phase_slope'] * ( self.cfg['readout']['frequency'] - self.cfg['readout']['bare_frequency']), self.cfg['readout']['frequency']) except: print("Digital phase shifter not loaded.") try: self.drive.set_frequency(self.cfg['qubit']['frequency'] - self.cfg['pulse_info'][self.pulse_type]['iq_freq']) self.drive.set_power(self.cfg['drive']['power']) self.drive.set_ext_pulse(mod=False) self.drive.set_output(True) except: print("No drive found") try: self.flux_drive.set_frequency(self.cfg['sidebands']['blue'] + self.cfg['flux_pulse_info'][self.pulse_type]['iq_freq']) self.flux_drive.set_power(self.cfg['drive']['power']) self.flux_drive.set_ext_pulse(mod=False) self.flux_drive.set_output(False) except: print("No flux drive found") try: self.readout_atten.set_attenuator(self.cfg['readout']['dig_atten']) except: print("Digital attenuator not loaded.") try: self.cfg['freq_flux']['flux']=self.extra_args['flux'] except: pass try: self.cfg['freq_flux']['freq_flux_slope']=self.extra_args['freq_flux_slope'] except: pass try: self.cfg['freq_flux']['flux_offset']+=self.extra_args['flux_offset'] except: pass try: if self.cfg['freq_flux']['current']: self.flux_volt.ramp_current(self.cfg['freq_flux']['flux']) elif self.cfg['freq_flux']['voltage']: self.flux_volt.ramp_volt(self.cfg['freq_flux']['flux']) except: print("Voltage source not loaded.") try: self.awg.set_amps_offsets(self.cfg['cal']['iq_amps'], self.cfg['cal']['iq_offsets']) except: print("self.awg not loaded.") if self.pre_run is not None: self.pre_run() # What is this for? TEST_REDPITAYA = False if TEST_REDPITAYA: self.awg_run() if not TEST_REDPITAYA: if self.cfg['readout']['adc'] == 'redpitaya': print("Using Red Pitaya ADC") if not self.cfg[self.expt_cfg_name]['use_pi_calibration']: num_experiments = len(self.pulse_sequence.expt_pts) else: num_experiments = len(self.pulse_sequence.expt_pts) + 2 testing_redpitaya = False if not testing_redpitaya: expt_avg_data_raw1, expt_avg_data_raw2 = setup_redpitaya_adc(num_experiments=num_experiments, window=self.cfg['readout']['window'], shots=self.cfg[self.expt_cfg_name]['averages'], plot_data=self.cfg['readout']['plot'],start_function=self.awg_run,stop_function=self.awg_prep) if self.cfg['readout']['channel'] == 1: expt_avg_data_raw = expt_avg_data_raw1 else: expt_avg_data_raw = expt_avg_data_raw2 ## This is for testing the redpitaya behaviour if testing_redpitaya: correct_counter = 0 repeat = 100 for ii in range(repeat): expt_avg_data_raw = setup_redpitaya_adc(num_experiments=num_experiments, window=self.cfg['readout']['window'], shots=self.cfg[self.expt_cfg_name]['averages'], plot_data=False,start_function=self.awg_run,stop_function=self.awg_prep()) if ((expt_avg_data_raw[1:] - expt_avg_data_raw[:-1]) > 0).all(): correct_counter += 1 print("correct percent: " + str(correct_counter / float(repeat))) if self.cfg[self.expt_cfg_name]['use_pi_calibration']: zero_amp = expt_avg_data_raw[-2] pi_amp = expt_avg_data_raw[-1] expt_avg_data = (expt_avg_data_raw[:-2] - zero_amp) / (pi_amp - zero_amp) # #saves pi calibration data # expt_avg_data = expt_avg_data_raw else: expt_avg_data = expt_avg_data_raw print(shape(expt_avg_data)) expt_avg_data = expt_avg_data.flatten() print(shape(expt_avg_data)) if self.data_file != None: self.slab_file = SlabFile(self.data_file) with self.slab_file as f: f.append_line('expt_avg_data', expt_avg_data) f.append_line('expt_pts', self.expt_pts) f.close() else: self.slab_file = self.datafile() with self.slab_file as f: f.add('expt_avg_data', expt_avg_data) f.add('expt_pts', self.expt_pts) f.close() else: if self.adc==None: print("Prep Card") adc = Alazar(self.cfg['alazar']) else: adc = self.adc expt_data = None current_data = None for ii in tqdm(arange(max(1, self.cfg[self.expt_cfg_name]['averages'] / 100))): tpts, ch1_pts, ch2_pts = adc.acquire_avg_data_by_record(prep_function=self.awg_prep, start_function=self.awg_run, excise=self.cfg['readout']['window']) mag = sqrt(ch1_pts**2+ch2_pts**2) if not self.cfg[self.expt_cfg_name]['use_pi_calibration']: if expt_data is None: if self.cfg['readout']['channel']==1: expt_data = ch1_pts elif self.cfg['readout']['channel']==2: expt_data = ch2_pts else: if self.cfg['readout']['channel']==1: expt_data = (expt_data * ii + ch1_pts) / (ii + 1.0) elif self.cfg['readout']['channel']==2: expt_data = (expt_data * ii + ch2_pts) / (ii + 1.0) else: if self.cfg['readout']['channel']==1: zero_amp = mean(ch1_pts[-2]) pi_amp = mean(ch1_pts[-1]) current_data= (ch1_pts[:-2]-zero_amp)/(pi_amp-zero_amp) elif self.cfg['readout']['channel']==2: zero_amp = mean(ch2_pts[-2]) pi_amp = mean(ch2_pts[-1]) current_data= (ch2_pts[:-2]-zero_amp)/(pi_amp-zero_amp) if expt_data is None: expt_data = current_data else: expt_data = (expt_data * ii + current_data) / (ii + 1.0) expt_avg_data = mean(expt_data, 1) # if self.liveplot_enabled: # self.plotter.plot_z(self.prefix + ' Data', expt_data.T) # self.plotter.plot_xy(self.prefix + ' XY', self.pulse_sequence.expt_pts, expt_avg_data) # print ii * min(self.cfg[self.expt_cfg_name]['averages'], 100) if self.data_file != None: self.slab_file = SlabFile(self.data_file) else: self.slab_file = self.datafile() with self.slab_file as f: f.add('expt_2d', expt_data) f.add('expt_avg_data', expt_avg_data) f.add('expt_pts', self.expt_pts) f.close() # if self.data_file != None: # self.slab_file = SlabFile(self.data_file) # with self.slab_file as f: # f.append_line('expt_avg_data', expt_avg_data) # f.append_line('expt_pts', self.expt_pts) # f.close() if self.post_run is not None: self.post_run(self.expt_pts, expt_avg_data)
def go(self): #self.plotter.clear() print("Prep Instruments") self.readout.set_frequency(self.cfg['readout']['frequency']) self.readout.set_power(self.cfg['readout']['power']) self.readout.set_ext_pulse(mod=True) self.drive.set_frequency(self.cfg['qubit']['frequency'] - self.cfg['pulse_info'][self.pulse_type]['iq_freq']) self.drive.set_power(self.cfg[self.expt_cfg_name]['power']) self.drive.set_ext_pulse(mod=True) self.drive.set_output(True) self.awg.set_amps_offsets(self.cfg['cal']['iq_amps'], self.cfg['cal']['iq_offsets']) print("Prep Card") adc = Alazar(self.cfg['alazar']) attenpts = arange(self.cfg[self.expt_cfg_name]['atten_start'], self.cfg[self.expt_cfg_name]['atten_stop'], self.cfg[self.expt_cfg_name]['atten_step']) freqpts = arange(self.cfg[self.expt_cfg_name]['freq_start'], self.cfg[self.expt_cfg_name]['freq_stop'], self.cfg[self.expt_cfg_name]['freq_step']) num_bins = self.cfg[self.expt_cfg_name]['num_bins'] for xx, atten in enumerate(attenpts): self.im.atten.set_attenuator(atten) max_contrast_data_ch1 = zeros(len(freqpts)) max_contrast_data_ch2 = zeros(len(freqpts)) #self.plotter.clear('max contrast') print("atten at: %s" %atten) for yy, freq in enumerate(freqpts): self.readout.set_frequency(freq) #self.readout_shifter.set_phase(self.cfg['readout']['start_phase'] , freq) # self.readout_shifter.set_phase((self.cfg['readout']['start_phase'] + self.cfg['readout']['phase_slope'] * (freq - self.cfg['readout']['frequency']))%360, freq) tpts, ch1_pts, ch2_pts = adc.acquire_avg_data_by_record(prep_function=self.awg.stop_and_prep, start_function=self.awg.run,excise=self.cfg['readout']['window']) # self.plotter.plot_z("current",ch1_pts) # with self.datafile() as f: # f.append('time_trace', ch1_pts) ss_data = zeros((len(self.expt_pts), num_bins)) sss_data = zeros((len(self.expt_pts), num_bins)) ss1, ss2 = adc.acquire_singleshot_data(prep_function=self.awg.stop_and_prep, start_function=self.awg.run, excise=self.cfg['readout']['window']) #with self.datafile() as f: # f.append_line('ss1', ss1) # f.append_line('ss2', ss2) ss1 = reshape(ss1, (int(self.cfg['alazar']['recordsPerAcquisition'] / len(self.expt_pts)), len(self.expt_pts))).T histo_range = (ss1.min() / 1.05, ss1.max() * 1.05) for jj, ss in enumerate(ss1): sshisto, ssbins = np.histogram(ss, bins=num_bins, range=histo_range) ss_data[jj] += sshisto sss_data[jj] = cumsum(ss_data[[jj]]) # self.plotter.plot_xy('histogram %d' % jj, ssbins[:-1], ss_data[jj]) # self.plotter.plot_xy('cum histo %d' % jj, ssbins[:-1], sss_data[jj]) max_contrast_data_ch1[yy] = abs(((sss_data[0] - sss_data[1]) / ss_data[0].sum())).max() ss2 = reshape(ss2, (int(self.cfg['alazar']['recordsPerAcquisition'] / len(self.expt_pts)), len(self.expt_pts))).T histo_range = (ss2.min() / 1.05, ss2.max() * 1.05) for jj, ss in enumerate(ss2): sshisto, ssbins = np.histogram(ss, bins=num_bins, range=histo_range) ss_data[jj] += sshisto sss_data[jj] = cumsum(ss_data[[jj]]) #self.plotter.plot_xy('histogram %d' % jj, ssbins[:-1], ss_data[jj]) #self.plotter.plot_xy('cum histo %d' % jj, ssbins[:-1], sss_data[jj]) #self.plotter.plot_xy('contrast', ssbins[:-1], abs(sss_data[0] - sss_data[1]) / ss_data[0].sum()) max_contrast_data_ch2[yy] = abs(((sss_data[0] - sss_data[1]) / ss_data[0].sum())).max() #self.plotter.append_xy('max contrast', freq, max_contrast_data[yy]) if len(attenpts)>1: print("plotting max contrast 2") pass # self.plotter.append_z('max contrast 2', max_contrast_data, start_step=( # (attenpts[0], attenpts[1] - attenpts[0]),(freqpts[0] / 1.0e9, (freqpts[1] - freqpts[0]) / 1.0e9))) with self.datafile() as f: f.append_pt('atten', atten) f.append_line('freq', freqpts) f.append_line('max_contrast_data_ch1', max_contrast_data_ch1) f.append_line('max_contrast_data_ch2', max_contrast_data_ch2)
def go(self): # if self.liveplot_enabled: # self.plotter.clear() print("Prep Instruments") try: self.readout.set_frequency(self.readout_freq) self.readout.set_power(self.cfg['readout']['power']) self.readout.set_ext_pulse(mod=True) self.readout.set_output(True) except: print("No readout found.") try: self.readout_shifter.set_phase( self.cfg['readout']['start_phase'] + self.cfg['readout']['phase_slope'] * (self.cfg['readout']['frequency'] - self.cfg['readout']['bare_frequency']), self.cfg['readout']['frequency']) except: print("Digital phase shifter not loaded.") try: self.drive.set_frequency( self.cfg['qubit']['frequency'] - self.cfg['pulse_info'][self.pulse_type]['iq_freq']) self.drive.set_power(self.cfg['drive']['power']) self.drive.set_ext_pulse(mod=False) self.drive.set_output(True) except: print("No drive found") try: self.flux_drive.set_frequency( self.cfg['sidebands']['blue'] + self.cfg['flux_pulse_info'][self.pulse_type]['iq_freq']) self.flux_drive.set_power(self.cfg['drive']['power']) self.flux_drive.set_ext_pulse(mod=False) self.flux_drive.set_output(False) except: print("No flux drive found") try: self.readout_atten.set_attenuator(self.cfg['readout']['dig_atten']) except: print("Digital attenuator not loaded.") try: self.cfg['freq_flux']['flux'] = self.extra_args['flux'] except: pass try: self.cfg['freq_flux']['freq_flux_slope'] = self.extra_args[ 'freq_flux_slope'] except: pass try: self.cfg['freq_flux']['flux_offset'] += self.extra_args[ 'flux_offset'] except: pass try: if self.cfg['freq_flux']['current']: self.flux_volt.ramp_current(self.cfg['freq_flux']['flux']) elif self.cfg['freq_flux']['voltage']: self.flux_volt.ramp_volt(self.cfg['freq_flux']['flux']) except: print("Voltage source not loaded.") try: self.awg.set_amps_offsets(self.cfg['cal']['iq_amps'], self.cfg['cal']['iq_offsets']) except: print("self.awg not loaded.") if self.pre_run is not None: self.pre_run() # What is this for? TEST_REDPITAYA = False if TEST_REDPITAYA: self.awg_run() if not TEST_REDPITAYA: if self.cfg['readout']['adc'] == 'redpitaya': print("Using Red Pitaya ADC") if not self.cfg[self.expt_cfg_name]['use_pi_calibration']: num_experiments = len(self.pulse_sequence.expt_pts) else: num_experiments = len(self.pulse_sequence.expt_pts) + 2 testing_redpitaya = False if not testing_redpitaya: expt_avg_data_raw1, expt_avg_data_raw2 = setup_redpitaya_adc( num_experiments=num_experiments, window=self.cfg['readout']['window'], shots=self.cfg[self.expt_cfg_name]['averages'], plot_data=self.cfg['readout']['plot'], start_function=self.awg_run, stop_function=self.awg_prep) if self.cfg['readout']['channel'] == 1: expt_avg_data_raw = expt_avg_data_raw1 else: expt_avg_data_raw = expt_avg_data_raw2 ## This is for testing the redpitaya behaviour if testing_redpitaya: correct_counter = 0 repeat = 100 for ii in range(repeat): expt_avg_data_raw = setup_redpitaya_adc( num_experiments=num_experiments, window=self.cfg['readout']['window'], shots=self.cfg[self.expt_cfg_name]['averages'], plot_data=False, start_function=self.awg_run, stop_function=self.awg_prep()) if ((expt_avg_data_raw[1:] - expt_avg_data_raw[:-1]) > 0).all(): correct_counter += 1 print("correct percent: " + str(correct_counter / float(repeat))) if self.cfg[self.expt_cfg_name]['use_pi_calibration']: zero_amp = expt_avg_data_raw[-2] pi_amp = expt_avg_data_raw[-1] expt_avg_data = (expt_avg_data_raw[:-2] - zero_amp) / (pi_amp - zero_amp) # #saves pi calibration data # expt_avg_data = expt_avg_data_raw else: expt_avg_data = expt_avg_data_raw print(shape(expt_avg_data)) expt_avg_data = expt_avg_data.flatten() print(shape(expt_avg_data)) if self.data_file != None: self.slab_file = SlabFile(self.data_file) with self.slab_file as f: f.append_line('expt_avg_data', expt_avg_data) f.append_line('expt_pts', self.expt_pts) f.close() else: self.slab_file = self.datafile() with self.slab_file as f: f.add('expt_avg_data', expt_avg_data) f.add('expt_pts', self.expt_pts) f.close() else: if self.adc == None: print("Prep Card") adc = Alazar(self.cfg['alazar']) else: adc = self.adc expt_data = None current_data = None for ii in tqdm( arange( max(1, self.cfg[self.expt_cfg_name]['averages'] / 100))): tpts, ch1_pts, ch2_pts = adc.acquire_avg_data_by_record( prep_function=self.awg_prep, start_function=self.awg_run, excise=self.cfg['readout']['window']) mag = sqrt(ch1_pts**2 + ch2_pts**2) if not self.cfg[self.expt_cfg_name]['use_pi_calibration']: if expt_data is None: if self.cfg['readout']['channel'] == 1: expt_data = ch1_pts elif self.cfg['readout']['channel'] == 2: expt_data = ch2_pts else: if self.cfg['readout']['channel'] == 1: expt_data = (expt_data * ii + ch1_pts) / (ii + 1.0) elif self.cfg['readout']['channel'] == 2: expt_data = (expt_data * ii + ch2_pts) / (ii + 1.0) else: if self.cfg['readout']['channel'] == 1: zero_amp = mean(ch1_pts[-2]) pi_amp = mean(ch1_pts[-1]) current_data = (ch1_pts[:-2] - zero_amp) / (pi_amp - zero_amp) elif self.cfg['readout']['channel'] == 2: zero_amp = mean(ch2_pts[-2]) pi_amp = mean(ch2_pts[-1]) current_data = (ch2_pts[:-2] - zero_amp) / (pi_amp - zero_amp) if expt_data is None: expt_data = current_data else: expt_data = (expt_data * ii + current_data) / (ii + 1.0) expt_avg_data = mean(expt_data, 1) # if self.liveplot_enabled: # self.plotter.plot_z(self.prefix + ' Data', expt_data.T) # self.plotter.plot_xy(self.prefix + ' XY', self.pulse_sequence.expt_pts, expt_avg_data) # print ii * min(self.cfg[self.expt_cfg_name]['averages'], 100) if self.data_file != None: self.slab_file = SlabFile(self.data_file) else: self.slab_file = self.datafile() with self.slab_file as f: f.add('expt_2d', expt_data) f.add('expt_avg_data', expt_avg_data) f.add('expt_pts', self.expt_pts) f.close() # if self.data_file != None: # self.slab_file = SlabFile(self.data_file) # with self.slab_file as f: # f.append_line('expt_avg_data', expt_avg_data) # f.append_line('expt_pts', self.expt_pts) # f.close() if self.post_run is not None: self.post_run(self.expt_pts, expt_avg_data)
def go(self): # self.plotter.clear() print("Prep Instruments") self.readout.set_output(True) self.readout.set_power(self.cfg['readout']['power']) if (self.cfg[self.expt_cfg_name]['pulsed']): self.readout.set_ext_pulse(mod=True) else: self.readout.set_ext_pulse(mod=False) if (self.cfg[self.expt_cfg_name]['pi_pulse']): self.drive.set_output(True) self.drive.set_ext_pulse(mod=True) else: self.drive.set_output(False) self.drive.set_ext_pulse(mod=False) # self.drive.set_ext_pulse(mod=False) self.readout_atten.set_attenuator(self.cfg['readout']['dig_atten']) self.awg.set_amps_offsets(self.cfg['cal']['iq_amps'], self.cfg['cal']['iq_offsets']) self.awg.run() print("Prep Card") adc = Alazar(self.cfg['alazar']) self.tek2 = InstrumentManager()["TEK2"] self.slab_file = self.datafile() with self.slab_file as f: f.append_line('expt_pts', self.expt_pts) f.close() for freq in self.expt_pts: self.readout.set_frequency(freq) self.readout_shifter.set_phase((self.cfg['readout']['start_phase'] + self.cfg['readout']['phase_slope'] * (freq - self.cfg['readout']['frequency']))%360, freq) # print self.readout_shifter.get_phase() ## taking data expt_data_1 = None expt_data_2 = None for ii in tqdm(arange(max(1, self.cfg[self.expt_cfg_name]['averages'] / 10000))): tpts, ch1_pts, ch2_pts = adc.acquire_avg_data_by_record(prep_function=self.awg_prep, start_function=self.awg.run, excise=self.cfg['readout']['window']) mag = sqrt(ch1_pts**2+ch2_pts**2) if expt_data_1 is None: expt_data_1 = ch1_pts expt_data_2 = ch2_pts else: expt_data_1 = (expt_data_1 * ii + ch1_pts) / (ii + 1.0) expt_data_2 = (expt_data_2 * ii + ch2_pts) / (ii + 1.0) expt_avg_data_1 = mean(expt_data_1, 1) expt_avg_data_2 = mean(expt_data_2, 1) # if self.liveplot_enabled: # self.plotter.plot_z(self.prefix + ' Data', expt_data.T) # self.plotter.plot_xy(self.prefix + ' XY', array([0,1]), expt_avg_data) # print ii * min(self.cfg[self.expt_cfg_name]['averages'], 100) self.slab_file = self.datafile() with self.slab_file as f: f.append_line('expt_avg_data_1', expt_avg_data_1) f.append_line('expt_avg_data_2', expt_avg_data_2) f.close()
def go(self): if self.liveplot_enabled: self.plotter.clear() print("Prep Instruments") self.readout.set_frequency(self.cfg['readout']['frequency']) self.readout.set_power(self.cfg['readout']['power']) self.readout.set_ext_pulse(mod=True) self.drive.set_frequency( self.cfg['qubit']['frequency'] - self.cfg['pulse_info'][self.pulse_type]['iq_freq']) self.drive.set_power(self.cfg[self.expt_cfg_name]['power']) self.drive.set_ext_pulse(mod=False) self.drive.set_output(True) try: self.awg.set_amps_offsets(self.cfg['cal']['iq_amps'], self.cfg['cal']['iq_offsets']) except: print("self.awg not loaded.") print("Prep Card") adc = Alazar(self.cfg['alazar']) attenpts = arange(self.cfg[self.expt_cfg_name]['atten_start'], self.cfg[self.expt_cfg_name]['atten_stop'], self.cfg[self.expt_cfg_name]['atten_step']) freqpts = arange(self.cfg[self.expt_cfg_name]['freq_start'], self.cfg[self.expt_cfg_name]['freq_stop'], self.cfg[self.expt_cfg_name]['freq_step']) num_bins = self.cfg[self.expt_cfg_name]['num_bins'] for xx, atten in enumerate(attenpts): #self.im.atten.set_attenuator(atten) try: self.readout_atten.set_attenuator(atten) except: print("Digital attenuator not loaded.") max_contrast_data = zeros(len(freqpts)) if self.liveplot_enabled: self.plotter.clear('max contrast') for yy, freq in enumerate(freqpts): self.readout.set_frequency(freq) #self.readout_shifter.set_phase(self.cfg['readout']['start_phase'] , freq) self.readout_shifter.set_phase( (self.cfg['readout']['start_phase'] + self.cfg['readout']['phase_slope'] * (freq - self.cfg['readout']['frequency'])) % 360, freq) #tpts, ch1_pts, ch2_pts = adc.acquire_avg_data_by_record(prep_function=self.awg.stop_and_prep, start_function=self.awg.run,excise=None) tpts, ch1_pts, ch2_pts = adc.acquire_avg_data_by_record( prep_function=self.awg_prep, start_function=self.awg_run, excise=self.cfg['readout']['window']) if self.liveplot_enabled: self.plotter.plot_z("current", ch1_pts) # with self.datafile() as f: # f.append('time_trace', ch1_pts) ss_data = zeros((len(self.expt_pts), num_bins)) sss_data = zeros((len(self.expt_pts), num_bins)) # ss1, ss2 = adc.acquire_singleshot_data(prep_function=None, start_function=None, # excise=self.cfg['readout']['window']) ss1, ss2 = adc.acquire_singleshot_data( prep_function=self.awg_prep, start_function=self.awg_run, excise=self.cfg['readout']['window']) ss1 = reshape(ss1, (self.cfg['alazar']['recordsPerAcquisition'] / len(self.expt_pts), len(self.expt_pts))).T histo_range = (ss1.min() / 1.5, ss1.max() * 1.5) for jj, ss in enumerate(ss1): sshisto, ssbins = np.histogram(ss, bins=num_bins, range=histo_range) ss_data[jj] += sshisto sss_data[jj] = cumsum(ss_data[[jj]]) if self.liveplot_enabled: self.plotter.plot_xy('histogram %d' % jj, ssbins[:-1], ss_data[jj]) self.plotter.plot_xy('cum histo %d' % jj, ssbins[:-1], sss_data[jj]) if self.liveplot_enabled: self.plotter.plot_xy( 'contrast', ssbins[:-1], abs(sss_data[0] - sss_data[1]) / ss_data[0].sum()) max_contrast_data[yy] = abs( ((sss_data[0] - sss_data[1]) / ss_data[0].sum())).max() if self.liveplot_enabled: self.plotter.append_xy('max contrast', freq, max_contrast_data[yy]) if len(attenpts) > 1: if self.liveplot_enabled: print("plotting max contrast 2") self.plotter.append_z( 'max contrast 2', max_contrast_data, start_step=((attenpts[0], attenpts[1] - attenpts[0]), (freqpts[0] / 1.0e9, (freqpts[1] - freqpts[0]) / 1.0e9))) with self.datafile() as f: f.append_pt('atten', atten) f.append_line('freq', freqpts) f.append_line('max_contrast_data', max_contrast_data) f.close()
def go(self): if self.liveplot_enabled: self.plotter.clear() print("Prep Instruments") self.readout.set_frequency(self.cfg['readout']['frequency']) self.readout.set_power(self.cfg['readout']['power']) self.readout.set_ext_pulse(mod=True) # self.readout_shifter.set_phase(self.cfg['readout']['start_phase'] + self.cfg['readout']['phase_slope'] * ( # self.cfg['readout']['frequency'] - self.cfg['readout']['bare_frequency']), self.cfg['readout']['frequency']) self.drive.set_frequency(self.cfg['qubit']['frequency'] - self.cfg['pulse_info'][self.pulse_type]['iq_freq']) self.drive.set_power(self.cfg['drive']['power']) self.drive.set_ext_pulse(mod=True) self.drive.set_output(True) self.readout_atten.set_attenuator(self.cfg['readout']['dig_atten']) self.trigger.set_period(self.trigger_period) try: self.cfg['freq_flux']['flux']=self.extra_args['flux'] except: pass try: self.cfg['freq_flux']['freq_flux_slope']=self.extra_args['freq_flux_slope'] except: pass try: self.cfg['freq_flux']['flux_offset']+=self.extra_args['flux_offset'] except: pass if self.cfg['freq_flux']['current']: try: self.flux_volt.ramp_current(self.cfg['freq_flux']['flux']) except:pass elif self.cfg['freq_flux']['voltage']: try: self.flux_volt.ramp_volt(self.cfg['freq_flux']['flux']) except: pass self.awg.set_amps_offsets(self.cfg['cal']['iq_amps'], self.cfg['cal']['iq_offsets']) if self.pre_run is not None: self.pre_run() if self.adc==None: print("Prep Card") adc = Alazar(self.cfg['alazar']) else: adc = self.adc expt_data = None current_data = None for ii in tqdm(arange(max(1, self.cfg[self.expt_cfg_name]['averages'] / 100))): tpts, ch1_pts, ch2_pts = adc.acquire_avg_data_by_record(prep_function=self.awg_prep, start_function=self.awg.run, excise=self.cfg['readout']['window']) ### to skip the first 100 averages data point, because we saw a weird ramp in the RF output if ii == 0: time.sleep(0.1) continue mag = sqrt(ch1_pts**2+ch2_pts**2) if not self.cfg[self.expt_cfg_name]['use_pi_calibration']: if expt_data is None: if self.cfg['readout']['channel']==1: expt_data = ch1_pts elif self.cfg['readout']['channel']==2: expt_data = ch2_pts else: if self.cfg['readout']['channel']==1: expt_data = (expt_data * ii + ch1_pts) / (ii + 1.0) elif self.cfg['readout']['channel']==2: expt_data = (expt_data * ii + ch2_pts) / (ii + 1.0) expt_avg_data = mean(expt_data, 1) else: if expt_data is None: if self.cfg['readout']['channel']==1: expt_data = ch1_pts elif self.cfg['readout']['channel']==2: expt_data = ch2_pts else: if self.cfg['readout']['channel']==1: expt_data = (expt_data * ii + ch1_pts) / (ii + 1.0) elif self.cfg['readout']['channel']==2: expt_data = (expt_data * ii + ch2_pts) / (ii + 1.0) expt_avg_data = mean(expt_data, 1) expt_avg_data = (expt_avg_data[:-2]-expt_avg_data[-2])/(expt_avg_data[-1]-expt_avg_data[-2]) # temporary hack. Alazar card seems to shift two data points (problem disappeared after reboot computer) # expt_avg_data = np.concatenate((expt_avg_data[2:],expt_avg_data[:2])) # if self.cfg[self.expt_cfg_name]['use_pi_calibration']: # expt_avg_data = (expt_avg_data[:-2]-expt_avg_data[-2])/(expt_avg_data[-1]-expt_avg_data[-2]) # else: # if self.cfg['readout']['channel']==1: # zero_amp = mean(ch1_pts[-2]) # pi_amp = mean(ch1_pts[-1]) # current_data= (ch1_pts[:-2]-zero_amp)/(pi_amp-zero_amp) # elif self.cfg['readout']['channel']==2: # zero_amp = mean(ch2_pts[-2]) # pi_amp = mean(ch2_pts[-1]) # current_data= (ch2_pts[:-2]-zero_amp)/(pi_amp-zero_amp) # if expt_data is None: # expt_data = current_data # else: # expt_data = (expt_data * ii + current_data) / (ii + 1.0) # expt_avg_data = mean(expt_data, 1) if self.liveplot_enabled: self.plotter.plot_z(self.prefix + ' Data', expt_data.T) self.plotter.plot_xy(self.prefix + ' XY', self.pulse_sequence.expt_pts, expt_avg_data) # print ii * min(self.cfg[self.expt_cfg_name]['averages'], 100) if self.data_file == None: self.slab_file = self.datafile() with self.slab_file as f: f.add('expt_2d', expt_data) f.add('expt_avg_data', expt_avg_data) f.add('expt_pts', self.expt_pts) f.close() if self.data_file != None: self.slab_file = SlabFile(self.data_file) with self.slab_file as f: f.append_line('expt_avg_data', expt_avg_data) f.append_line('expt_pts', self.expt_pts) f.close() if not self.adc_predefined: adc.close() if self.post_run is not None: self.post_run(self.expt_pts, expt_avg_data)
def go(self): # self.plotter.clear() print("Prep Instruments") self.readout.set_output(True) self.readout.set_power(self.cfg['readout']['power']) if (self.cfg[self.expt_cfg_name]['pulsed']): self.readout.set_ext_pulse(mod=True) else: self.readout.set_ext_pulse(mod=False) if (self.cfg[self.expt_cfg_name]['pi_pulse']): self.drive.set_output(True) self.drive.set_ext_pulse(mod=True) else: self.drive.set_output(False) self.drive.set_ext_pulse(mod=False) # self.drive.set_ext_pulse(mod=False) self.readout_atten.set_attenuator(self.cfg['readout']['dig_atten']) self.awg.set_amps_offsets(self.cfg['cal']['iq_amps'], self.cfg['cal']['iq_offsets']) self.awg.run() print("Prep Card") adc = Alazar(self.cfg['alazar']) self.tek2 = InstrumentManager()["TEK2"] self.slab_file = self.datafile() with self.slab_file as f: f.append_line('expt_pts', self.expt_pts) f.close() for freq in self.expt_pts: self.readout.set_frequency(freq) self.readout_shifter.set_phase( (self.cfg['readout']['start_phase'] + self.cfg['readout']['phase_slope'] * (freq - self.cfg['readout']['frequency'])) % 360, freq) # print self.readout_shifter.get_phase() ## taking data expt_data_1 = None expt_data_2 = None for ii in tqdm( arange( max(1, self.cfg[self.expt_cfg_name]['averages'] / 10000))): tpts, ch1_pts, ch2_pts = adc.acquire_avg_data_by_record( prep_function=self.awg_prep, start_function=self.awg.run, excise=self.cfg['readout']['window']) mag = sqrt(ch1_pts**2 + ch2_pts**2) if expt_data_1 is None: expt_data_1 = ch1_pts expt_data_2 = ch2_pts else: expt_data_1 = (expt_data_1 * ii + ch1_pts) / (ii + 1.0) expt_data_2 = (expt_data_2 * ii + ch2_pts) / (ii + 1.0) expt_avg_data_1 = mean(expt_data_1, 1) expt_avg_data_2 = mean(expt_data_2, 1) # if self.liveplot_enabled: # self.plotter.plot_z(self.prefix + ' Data', expt_data.T) # self.plotter.plot_xy(self.prefix + ' XY', array([0,1]), expt_avg_data) # print ii * min(self.cfg[self.expt_cfg_name]['averages'], 100) self.slab_file = self.datafile() with self.slab_file as f: f.append_line('expt_avg_data_1', expt_avg_data_1) f.append_line('expt_avg_data_2', expt_avg_data_2) f.close()