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 take_data(self): print('take_data() in HistogramHetero') 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 ### het_IFreqList = array([self.cfg['readout']['heterodyne_freq']]) avgPerAcquisition = int(min(self.cfg[self.expt_cfg_name]['averages'], 100)) numAcquisition = int(np.ceil(self.cfg[self.expt_cfg_name]['averages'] / 100)) 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']) # (channel, atten, freq, g/e/f, average) ss_cos_data_all = zeros((2, len(attenpts), len(freqpts), 3, avgPerAcquisition * numAcquisition) ) ss_sin_data_all = zeros((2, len(attenpts), len(freqpts), 3, avgPerAcquisition * numAcquisition) ) for xx, atten in enumerate(attenpts): try: # im = InstrumentManager() # atten2 = im['atten2'] # atten2.set_attenuator(atten) self.readout_atten.set_attenuator(atten) print(atten, "Digital atten:") #, self.readout_atten.get_attenuator()) time.sleep(0.5) atten2 = None except: print("Digital attenuator not loaded.") # pump_freqs = arange(6.90e9, 7.04e9, 4e6) # pump_powers = arange(-6.0, -5, 0.2) # # self.im['RF6'].set_power( pump_powers[(atten % 5)] ) # print("TWPA Pump power:", pump_powers[(atten % 5)]) # self.im['RF6'].set_frequency( pump_freqs[int(atten/5)] ) # print("TWPA Pump freq:", pump_freqs[int(atten/5)]) # # try: # self.readout_atten.set_attenuator(16.0) # # print("Digital atten:", atten) # except: # print("Digital attenuator not loaded.") # (ch1/2, exp_pts, heterodyne_freq, cos/sin, all averages) ss_data = zeros((2, len(self.expt_pts), len(het_IFreqList), 2, avgPerAcquisition * numAcquisition)) 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) 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]) # reshape to fit into histogram data # index: (ch1/2, hetero_freqs(0), cos / sin, avgs, freqpts(exp seq), g/e/f) 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), int(self.pulse_sequence.sequence_length/3), 3)) # (channel, hetero_freqs(0), cos/sin, freqpts(exp seq), g/e/f, average) single_data = np.transpose(single_data, (0, 1, 2, 4, 5, 3)) # (channel, atten, freqpts, g/e/f, average) ss_cos_data_all[:, xx, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)] = single_data[:, 0, 0, :, :, :] ss_sin_data_all[:, xx, :, :, (ii * avgPerAcquisition):((ii + 1) * avgPerAcquisition)] = single_data[:, 0, 1, :, :, :] # this needs to stay here self.slab_file = self.datafile(data_file=self.data_file) with self.slab_file as f: f.add('attenpts', attenpts) f.add('freqpts', freqpts) f.add('het_IFreqList', het_IFreqList) f.add('ss_cos_data_ch1', ss_cos_data_all[0]) f.add('ss_cos_data_ch2', ss_cos_data_all[1]) f.add('ss_sin_data_ch1', ss_sin_data_all[0]) f.add('ss_sin_data_ch2', ss_sin_data_all[1]) f.append_line('single_record1', single_record1) f.append_line('single_record2', single_record2) f.close() ### # 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() # close Alazar and release buffer adc.close()
def take_data(self): print('take_data() in HistogramHetero') 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 ### het_IFreqList = array([self.cfg['readout']['heterodyne_freq']]) avgPerAcquisition = int( min(self.cfg[self.expt_cfg_name]['averages'], 100)) numAcquisition = int( np.ceil(self.cfg[self.expt_cfg_name]['averages'] / 100)) 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']) # (channel, atten, freq, g/e/f, average) ss_cos_data_all = zeros((2, len(attenpts), len(freqpts), 3, avgPerAcquisition * numAcquisition)) ss_sin_data_all = zeros((2, len(attenpts), len(freqpts), 3, avgPerAcquisition * numAcquisition)) for xx, atten in enumerate(attenpts): try: self.readout_atten.set_attenuator(atten) print("Digital atten:", atten) except: print("Digital attenuator not loaded.") # (ch1/2, exp_pts, heterodyne_freq, cos/sin, all averages) ss_data = zeros((2, len(self.expt_pts), len(het_IFreqList), 2, avgPerAcquisition * numAcquisition)) 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) 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]) # reshape to fit into histogram data # index: (ch1/2, hetero_freqs(0), cos / sin, avgs, freqpts(exp seq), g/e/f) single_data = np.reshape( single_data, (single_data.shape[0], single_data.shape[1], single_data.shape[2], self.cfg['alazar']['recordsPerAcquisition'] / self.pulse_sequence.sequence_length, self.pulse_sequence.sequence_length / 3, 3)) # (channel, hetero_freqs(0), cos/sin, freqpts(exp seq), g/e/f, average) single_data = np.transpose(single_data, (0, 1, 2, 4, 5, 3)) # (channel, atten, freqpts, g/e/f, average) ss_cos_data_all[:, xx, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)] = single_data[:, 0, 0, :, :, :] ss_sin_data_all[:, xx, :, :, (ii * avgPerAcquisition):( (ii + 1) * avgPerAcquisition)] = single_data[:, 0, 1, :, :, :] # this needs to stay here self.slab_file = self.datafile(data_file=self.data_file) with self.slab_file as f: f.add('attenpts', attenpts) f.add('freqpts', freqpts) f.add('het_IFreqList', het_IFreqList) f.add('ss_cos_data_ch1', ss_cos_data_all[0]) f.add('ss_cos_data_ch2', ss_cos_data_all[1]) f.add('ss_sin_data_ch1', ss_sin_data_all[0]) f.add('ss_sin_data_ch2', ss_sin_data_all[1]) f.append_line('single_record1', single_record1) f.append_line('single_record2', single_record2) f.close() ### # 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() # close Alazar and release buffer adc.close()
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()