def __init__(self, name, coordinates=[], values=[], dev=''): self._name = name self._dev = dev self._plots = {} if dev: self._data = qt.Data(name='%s_%s' % (name, dev)) else: self._data = qt.Data(name=name) self.create_file( ) #_data.create_file(settings_file=False) # we don't want heavy 1 MB files to be created alongside of the data file self._coords = [] self._vals = [] if type(coordinates) is list or type(coordinates) is tuple: for coord in coordinates: self._coords.append(coord) self._data.add_coordinate(coord) else: self._coords.append(str(coordinates)) self._data.add_coordinate(str(coordinates)) if type(values) is list or type(values) is tuple: for val in values: self._vals.append(val) self._data.add_value(val) else: self._vals.append(str(values)) self._data.add_value(str(values))
def main(): if not debug_mode: initialize_hh() generate_sequence() repetitions = par_reps hh_measurement_time = int(1e3 * 60 * par_meas_time) #ms qt.mstart() cr_stats = qt.Data(name='Statistics_cr_checks') cr_stats.add_coordinate('repetition nr') cr_stats.add_value('lt1_cr_below threshold') cr_stats.add_value('lt1_cr_checks') cr_stats.add_value('lt2_cr_below_threshold') cr_stats.add_value('lt2_cr_checks') cr_stats.add_value('tpqi_starts') cr_stats.add_value('lt1_repump_cts') cr_stats.add_value('lt2_repump_cts') cr_stats.add_value('lt1_triggers_received') cr_stats.add_value('lt2_triggers_sent') cr_stats.add_value('lt1_oks_sent') cr_stats.add_value('lt2_oks_received') cr_stats.create_file() histogram_summed = zeros((par_range_sync, par_range_g2)) hist_roi_summed = zeros(par_range_g2) for idx in arange(repetitions): if msvcrt.kbhit(): kb_char = msvcrt.getch() if kb_char == "q": break print 'Starting measurement cycle', idx, 'current time:', time.strftime( '%H:%M', time.localtime()) [histogram, hist_ch0, hist_ch1, hist_ch1_long, hist_roi] = measurement_cycle(hh_measurement_time) print_save_cr_check_info(cr_stats, idx) if not debug_mode: histogram_summed += histogram hist_roi_summed += hist_roi print 'Finished measurement cycle', idx, 'start saving' data = qt.Data(name='interference' + "_" + str(idx)) data.add_coordinate('dt') data.add_coordinate('sync') data.add_value('counts') save_and_plot_data(data, histogram, histogram_summed, hist_ch0, hist_ch1, hist_ch1_long, hist_roi, hist_roi_summed) print 'Data saving cycle', idx, 'completed' qt.msleep(1) cr_stats.close_file() qt.mend() end_measuring()
def test_hh(): qt.mstart() initialize_hh() hharp.StartMeas(int(1e3 * 60 * 2)) [histogram,hist_ch0,hist_ch1,hist_ch1_long] = hharp.get_T3_pulsed_g2_2DHistogram_v2( binsize_T3 = par_binsize_T3, binsize_sync=par_binsize_sync, range_sync=par_range_sync, binsize_g2=par_binsize_g2, range_g2=par_range_g2, sync_period = par_sync_period, ) data = qt.Data(name='interference test_hh') data.add_coordinate('dt') data.add_coordinate('sync') data.add_value('counts') cr_stats = qt.Data(name = 'Statistics_cr_checks') cr_stats.add_coordinate('repetition nr') cr_stats.add_value('lt1_cr_succes_percentage') cr_stats.add_value('lt1_cr_checks') cr_stats.add_value('lt2_cr_succes_percentage') cr_stats.add_value('lt2_cr_checks') cr_stats.add_value('tpqi_starts') save_and_plot_data(data,histogram,histogram,hist_ch0,hist_ch1,hist_ch1_long) qt.mend() optimize()
def main(): initialize_hh() generate_sequence() # configure measurement repetitions = 4 hh_measurement_time = int(1e3 * 60 * 15) #ms qt.mstart() cr_stats = qt.Data(name='Statistics_cr_checks') cr_stats.add_coordinate('repetition nr') cr_stats.add_value('lt1_cr_succes_percentage') cr_stats.add_value('lt1_cr_checks') cr_stats.add_value('lt2_cr_succes_percentage') cr_stats.add_value('lt2_cr_checks') cr_stats.add_value('tpqi_starts') cr_stats.add_value('lt1_repump_cts') cr_stats.add_value('lt2_repump_cts') cr_stats.add_value('lt1_triggers_received') cr_stats.add_value('lt2_triggers_sent') cr_stats.add_value('lt1_oks_sent') cr_stats.add_value('lt2_oks_received') cr_stats.create_file() histogram_summed = zeros((par_range_sync, par_range_g2)) for idx in arange(repetitions): if msvcrt.kbhit() and msvcrt.getch() == "q": break print 'Starting measurement cycle', idx, 'current time:', time.strftime( '%H:%M', time.localtime()) [histogram, hist_ch0, hist_ch1, hist_ch1_long] = measurement_cycle(hh_measurement_time) print_save_cr_check_info(cr_stats, idx) print shape(histogram) histogram_summed += histogram print 'Finished measurement cycle', idx, 'start saving' data = qt.Data(name='interference' + str(idx)) data.add_coordinate('dt') data.add_coordinate('sync') data.add_value('counts') save_and_plot_data(data, histogram, histogram_summed, hist_ch0, hist_ch1, hist_ch1_long) print 'Data saving cycle', idx, 'completed' qt.msleep(1) if not optimize(): break print 'Optimisation step', idx, ' completed' cr_stats.close_file() qt.mend()
def optimize_z(z_range=0.4, nr_pts=5, green_power=100e-6): z_current = mos.get_z() zs = np.linspace(z_current - z_range / 2., z_current + z_range / 2., nr_pts) SN = np.zeros(nr_pts) green_aom.set_power(green_power) for i, z in enumerate(zs): print i, z mos.set_z(z) SN[i] = get_signal_to_noise() if (msvcrt.kbhit() and msvcrt.getch() == 'q'): break d = qt.Data(name='z_optimization_sn') d.add_coordinate('z (um)') d.add_value('SN') d.create_file() filename = d.get_filepath()[:-4] d.add_data_point(zs, SN) d.close_file() print filename fitargs = (np.min(SN), np.max(SN), zs[np.argmax(SN)], 0.1) gaussian_fit_SN = fit.fit1d(zs, SN, common.fit_gauss_pos, *fitargs, do_print=False, ret=True) p0 = gaussian_fit_SN['params_dict'] #qt.plot(zs,SN,name='sn_measurement_z',clear=True) zp = np.linspace(min(zs), max(zs), 100) # p_c = qt.plot(zp,gaussian_fit_SN['fitfunc'](zp), name='SN_vs_z') # p_c.save_png(filename+'.png') # p_c = qt.Plot2D(d, 'bO-', coorddim=0, name='z_optimization_sn', valdim=1, clear=True) # p_c.save_png(filename+'.png') print p0 if gaussian_fit_SN['success']: print 'z0', p0['x0'] if (p0['x0'] < min(zs)) or (p0['x0'] > max(zs)): 'optimum out of scan range. setting to max point: ', zs[np.argmax( SN)] mos.set_z(zs[np.argmax(SN)]) else: 'optimize succeeded. new z:', p0['x0'] mos.set_z(p0['x0']) #return gaussian_fit_SN else: 'fit failed, setting back to intial positon', z_current mos.set_z(z_current)
def main(): initialize_hh() generate_sequence() # configure measurement repetitions = 3 * 6 hh_measurement_time = int(1e3 * 60 * 20) qt.mstart() histogram = zeros((200, 2000)) for idx in arange(repetitions): if msvcrt.kbhit() and msvcrt.getch() == "q": break print 'Starting measurement cycle', idx histogram += measurement_cycle(hh_measurement_time) print 'Finished measurement cycle', idx, 'start saving' data = qt.Data(name='interference' + str(idx)) data.add_coordinate('dt') data.add_coordinate('sync') data.add_value('counts') save_and_plot_data(data, histogram) print 'Data saving cycle', idx, 'completed' qt.msleep(1) if not optimize(): break print 'Optimisation step', idx, ' completed' qt.mend() optimize()
def __init__(self,DAQ): self.DAQ = DAQ self.current_bias = False self.voltage_bias = False self.data = qt.Data(name=name) def set_current_bias(self): self.current_bias = True self.voltage_bias = False # current bias self.A_per_V = 2e-5 self.V_amp = 1e3 self.I_div = 1 self.V_divider = 1 # current bias range: Imin = 135.e-6 Imax = 137.e-6 data.add_coordinate('I [A]') if mw_scan: data.add_coordinate('f [Hz]') elif mag_scan: data.add_coordinate('I [mA]') else: data.add_coordinate('empty') data.add_value('V [V]')
def mstart(runtime): qt.mstart() #filename = 'values1_test' data = qt.Data(name='test_file1') data.add_coordinate('time [s]') data.add_value(rigol.get_function()[1:-1] + ' e-12') data.create_file() x_vec = 0 #runtime = 5 plot = qt.Plot2D(data, name='test_file1', coorddim=0, valdim=1) print 'Measure ' + rigol.get_function()[1:-1] sleep(2.00) rigol.set_disp_off() tstart = time() while x_vec < runtime: x_vec = time() - tstart y_vec = float(rigol.value()[13:]) * 1e12 data.add_data_point(x_vec, y_vec) sleep(0.01) #wait 10 usec print x_vec, y_vec data.close_file() qt.mend() rigol.set_disp_on() print 'finished'
def start(self): self._t0 = time.time() self.set_is_running(True) self._value = 0 self._time = 0 self._integral = 0 self._prev_value = 0 self._prev_prev_value = 0 self._prev_time = 0 self._dat = qt.Data(name=self._name) self._dat.add_coordinate('time') self._dat.add_value('frequency') self._dat.add_value('setpoint') self._dat.add_value('control parameter') self._dat.create_file() self._plt = qt.Plot2D(self._dat, 'r-', name=self._name, coorddim=0, valdim=1, maxpoints=100, clear=True) self._plt.add(self._dat, 'b-', coorddim=0, valdim=2, maxpoints=100) if not (self._get_stabilizor == None): self._stabilizor_value = self._get_stabilizor() self.get_control_parameter() gobject.timeout_add(int(self._read_interval * 1e3), self._update)
def plot_scan(name, x, y, fit_func=None): dat = qt.Data(name='DM_sweep_curve_' + name) dat.create_file() dat.add_coordinate('Voltage [percentage of V max]') dat.add_value('Counts [Hz]') if fit_func != None: dat.add_value('Fit') fd = fit_func(x) plt = qt.Plot2D(dat, 'rO', name='Optimization curve', coorddim=0, valdim=1, clear=True) plt.add_data(dat, coorddim=0, valdim=2) plt.set_plottitle(dat.get_time_name()) if fit_func != None: dat.add_data_point(x, y, fd) else: dat.add_data_point(x, y) plt.set_legend(False) plt.save_png(dat.get_filepath()[:-3] + '.png') dfp = dat.get_filepath() dat.close_file() return dfp
def start(self): self._t0 = time.time() self.set_is_running(True) self._value = 0 self._time = 0 self._integral = 0 self._prev_value = 0 self._prev_time = 0 self._dat = qt.Data(name=self._name) self._dat.add_coordinate('time') self._dat.add_value('frequency') self._dat.add_value('setpoint') self._dat.add_value('control parameter') self._dat.create_file() self._plt = qt.Plot2D(self._dat, 'kO', name=self._name, coorddim=0, valdim=1, maxpoints=100, clear=True) self._plt.add(self._dat, 'b-', coorddim=0, valdim=2, maxpoints=100) # self._thread = ControlThread() # self._thread.instrument = qt.instruments[self._name] # self._thread.interval = self.get_read_interval() # self._thread.start() # gobject.timeout_add(int(self._read_interval*1e3), self._update)
def createdatafile(settings): # Next a new data object is made. # The file will be placed in the folder: # <datadir>/<datestamp>/<timestamp>_testmeasurement/ # and will be called: # <timestamp>_testmeasurement.dat # to find out what 'datadir' is set to, type: qt.config.get('datadir') global data data = qt.Data(name=settings['filename']) # Now you provide the information of what data will be saved in the # datafile. A distinction is made between 'coordinates', and 'values'. # Coordinates are the parameters that you sweep, values are the # parameters that you readout (the result of an experiment). This # information is used later for plotting purposes. # Adding coordinate and value info is optional, but recommended. # If you don't supply it, the data class will guess your data format. for idx in range(settings['number_of_sweeps']): data.add_coordinate(name=label_array[idx]) for idx in range(3): if settings['input'][idx] != 0: data.add_value(name=settings['inputlabel'][idx]) else: data.add_value(name='no measurement')
def No_B_field(): append = '_Vb%smV' % Vb_start + '_Vg%sV' % Vg_start #+'_B8T' data = qt.Data(name=filename + append) tstr = strftime('%H%M%S_', data._localtime) data.add_coordinate('Vb (mV)') #parameter to step data.add_coordinate('Vg (V)') #parameter to sweep data.add_value('I (nA)') #parameter to readout data.create_file(settings_file=False) plot2d = qt.Plot2D(data, coorddim=1, valdim=2, traceofs=0) plot3d = qt.Plot3D(data, coorddims=(0, 1), valdim=2) for Vb in Vb_vec: ramp(vi, 'Vb', 0, bias_step_init, bias_time) ramp(vi, 'Vg', 0, gate_step_init, gate_time) qt.msleep(300) ramp(vi, 'Vg', Vg_start, gate_step_init, gate_time) ramp(vi, 'Vb', Vb, bias_step_init, bias_time) qt.msleep(0.05) for Vg in Vg_vec: ramp(vi, 'Vg', Vg, gate_step, gate_time) qt.msleep(0.05) I = vm.get_readval() / IV_gain * unit data.add_data_point(Vb, Vg, I) data.new_block() spyview_process(data, Vg_start, Vg_stop, Vb) plot3d.save_png(filepath=directory + '\\' + tstr + filename + append) data.close_file()
def save_2D_data(self, timename='t (ns)', sweepname='sweep_value', ret=False): x, y, z = self._get_p7889_data() xx, yy = np.meshgrid(x, y) d = qt.Data(name=self.save_filebase) d.add_coordinate(timename) d.add_coordinate(sweepname) d.add_value('counts') p = qt.plot3(d, name='2D_Histogram', clear=True) p.reset() d.create_file() for i, row in enumerate(z): d.add_data_point(xx[i, :], yy[i, :], row) d.new_block() d.close_file() self.save_folder = d.get_dir() self.timestamp = d.get_time_name()[:6] self.save_filebase = d.get_time_name() # p.reset() # qt.msleep(0.1) p.save_png(os.path.join(self.save_folder, self.save_filebase)) if ret: return x, y, z
def B_field(): append = '_Vb%smV' % Vb_start + '_Vg%sV' % Vg_start + '_B%sT' % abs( B_stop) #to do: for loop for B_vec data = qt.Data(name=filename + '_G{0:.0e}'.format(IV_gain)) data.add_coordinate('Vg (V)') #parameter to step data.add_coordinate('Vb (mV)') #parameter to sweep data.add_value('I (nA)') #parameter to readout data.create_file(settings_file=False) plot2d = qt.Plot2D(data, coorddim=1, valdim=2, traceofs=0) plot3d = qt.Plot3D(data, coorddims=(0, 1), valdim=2) for B in B_vec: ramp_B(B) for Vg in Vg_vec: ramp(vi, 'Vb', Vb_start, bias_step_init, bias_time) ramp(vi, 'Vg', Vg, gate_step, gate_time) qt.msleep(0.010) for Vb in Vb_vec: ramp(vi, 'Vb', Vb, bias_step, bias_time) qt.msleep(0.025) I = vm.get_readval() / IV_gain * unit data.add_data_point(Vg, Vb, I) qt.msleep(0.005) data.new_block() spyview_process(data, Vb_start, Vb_stop, Vg) plot3d.save_png(filepath=directory + '\\' + filename + '_G{0:.0e}'.format(IV_gain)) data.new_block() data.new_block() data.close_file()
def run(self, autoconfig=True, setup=True): if autoconfig: self.autoconfig() if setup: self.setup() self.dat = qt.Data(name=self.name + '_data') #, inmem=True, infile=False ) self.dat.add_coordinate('Voltage [V]') self.dat.add_coordinate('Frequency [GHz]') self.dat.add_value('Counts [Hz]') self.dat.create_file( filepath=os.path.splitext(self.h5data.filepath())[0] + '.dat') self.plt = qt.Plot2D(self.dat, 'r-', name='laser_scan', coorddim=1, valdim=2, clear=True) if self.params['plot_voltage']: self.plt.add_data(self.dat, coorddim=1, valdim=0, right=True) self.start_adwin_process(stop_processes=['counter']) qt.msleep(1) self.start_keystroke_monitor('abort', timer=False) prev_px_clock = 0 aborted = False while self.adwin_process_running(): self._keystroke_check('abort') if self.keystroke('abort') in ['q', 'Q']: print 'aborted.' aborted = True self.stop_keystroke_monitor('abort') break px_clock = self.adwin_var('pixel_clock') start = prev_px_clock + 1 length = px_clock - prev_px_clock if length > 0: f = self.adwin_var(('laser_frequencies', start, length)) valid_range = f > -3000 v = self.adwin_var(('voltages', start, length)) cs = self.adwin_var(('counts', start, length)) c = (cs[0] + cs[1]) / (self.params['pixel_time'] * 1.e-6) if np.sum(valid_range) > 1: self.dat.add_data_point(v[valid_range], f[valid_range], c[valid_range]) prev_px_clock = px_clock qt.msleep(0.2) self.plt.update() try: self.stop_keystroke_monitor('abort') except KeyError: pass # means it's already stopped self.stop_adwin_process() return not (aborted)
def do_set_recording(self, val): if not self._recording and val: self._recording = val self._T0 = time.time() self._data = qt.Data(name=self._name) self._data.add_coordinate('time') self._data.add_value('level He1') self._data.add_value('level He2') self._data.add_value('temperature_lt2') self._data.add_value('He1 consumption') self._data.add_value('He2 consumption') if self._monitor_lt1: self._data.add_value('temperature_lt1_A') self._data.add_value('temperature_lt1_B') self._data.create_file() self._plt = qt.Plot2D(self._data, 'ro', name=self._name, coorddim=0, valdim=1, clear=True) self._plt.add(self._data, 'bo', coorddim=0, valdim=2) self._plt.add(self._data, 'k-', coorddim=0, valdim=3, right=True) if self._monitor_lt1: self._plt.add(self._data, 'g-', coorddim=0, valdim=6, right=True) self._plt.add(self._data, 'y+', coorddim=0, valdim=7, right=True) self._plt.set_xlabel('time (hours)') self._plt.set_ylabel('filling level (cm)') self._plt.set_y2label('T (K)') self._plt_rates = qt.Plot2D(self._data, 'ro', name=self._name + '_He_consumption', coorddim=0, valdim=4, clear=True) self._plt_rates.add(self._data, 'bo', coorddim=0, valdim=5) self._plt_rates.set_xlabel('time (hours)') self._plt_rates.set_ylabel('consumption (cm/h)') self._rate_update_interval = 1 # hours self._rate_times = [] self._rate_levels1 = [] self._rate_levels2 = [] elif self._recording and not val: self._recording = val self._data.close_file()
def _create_data_plots(self,name): qtdata = qt.Data(name = name) qtdata.add_coordinate('Degrees') qtdata.add_value('Counts') dataplot = qt.Plot2D(qtdata, 'rO', name = name, coorddim = 0, valdim = 1, clear = True) dataplot.add(qtdata, 'b-', coorddim = 0, valdim = 2) return qtdata, dataplot
def calibrate(self, steps): # calibration values in uW rng = arange(0,steps) x = zeros(steps,dtype = float) y = zeros(steps,dtype = float) self.apply_voltage(0) self._ins_pm.set_wavelength(self._wavelength*1e9) time.sleep(2) bg = self._ins_pm.get_power() print 'background power: %.4f uW' % (bg*1e6) time.sleep(2) V_max = self.get_V_max() V_min = self.get_V_min() if V_max + V_min < 0: rng=flipud(rng) for a in rng: x[a] = a*(V_max-V_min)/float(steps-1)+V_min self.apply_voltage(x[a]) time.sleep(1) y[a] = self._ins_pm.get_power() - bg print 'measured power at %.2f V: %.4f uW' % \ (a*(V_max-V_min)/float(steps-1)+V_min, y[a]*1e6) #x= x*(V_max-V_min)/float(steps-1)+V_min a, xc, k = copysign(max(y), V_max + V_min), copysign(.5, V_max + V_min), copysign(5., V_max + V_min) fitres = fit.fit1d(x,y, common.fit_AOM_powerdependence, a, xc, k, do_print=True, do_plot=False, ret=True) fd = zeros(len(x)) if type(fitres) != type(False): p1 = fitres['params_dict'] self.set_cal_a(p1['a']) self.set_cal_xc(p1['xc']) self.set_cal_k(p1['k']) fd = fitres['fitdata'] else: print 'could not fit calibration curve!' dat = qt.Data(name= 'aom_calibration_'+self._name+'_'+\ self._cur_controller) dat.add_coordinate('Voltage [V]') dat.add_value('Power [W]') dat.add_value('fit') dat.create_file() plt = qt.Plot2D(dat, 'rO', name='aom calibration', coorddim=0, valdim=1, clear=True) plt.add_data(dat, coorddim=0, valdim=2) dat.add_data_point(x,y,fd) dat.close_file() plt.save_png(dat.get_filepath()+'png') self.save_cfg() print (self._name+' calibration finished')
def check_triggering(): jitterDetected = False remote_helper = qt.instruments['remote_measurement_helper'] remote_helper.set_is_running(True) pharp = qt.instruments['PH_300'] pharp.OpenDevice() pharp.start_histogram_mode() pharp.ClearHistMem() pharp.set_Range(4) # 64 ps binsize pharp.set_CFDLevel0(50) pharp.set_CFDLevel1(50) qt.msleep(1) pharp.StartMeas(int(4 * 1e3)) #10 second measurement qt.msleep(0.5) print 'starting PicoHarp measurement' while pharp.get_MeasRunning(): if (msvcrt.kbhit() and msvcrt.getch() == 'q'): print 'q pressed, quitting current run' pharp.StopMeas() break hist = pharp.GetHistogram() print 'PicoHarp measurement finished' print '-------------------------------' ret = '' ret = ret + str(hist[hist > 0]) peaks = np.where(hist > 0)[0] * pharp.get_Resolution() / 1000. ret = ret + '\n' + str(peaks) print ret peak_loc = 489.85 #489.45#BH28-12-2015 removed 5 cm piece eom lt3 if len(peaks) > 1: peaks_width = peaks[-1] - peaks[0] peak_max = np.argmax(hist) * pharp.get_Resolution() / 1000. if (peaks_width) > .5: ret = ret + '\n' + 'JITTERING!! Execute check_awg_triggering with a reset' jitterDetected = True elif (peak_max < peak_loc - 0.25) or (peak_max > peak_loc + 0.25): ret = ret + '\n' + 'Warning peak max at unexpected place, PEAK WRONG' jitterDetected = True else: ret = ret + '\n' + 'No Jitter detected' ret = ret + '\n peak width: {:.2f} ns'.format(peaks_width) ret = ret + '\npeak loc at {:.2f} ns'.format(peak_max) ret = ret + '\ntotal counts in hist: {}'.format(sum(hist)) print ret d = qt.Data(name='AWG jitter check') d.create_file() d.close_file() fp = d.get_filepath() f = open(fp, 'a') f.write(ret) f.close() remote_helper.set_data_path(fp) remote_helper.set_measurement_name(ret) remote_helper.set_is_running(False) return jitterDetected
def _update(self): if not self._is_running: return False new_raw_value = self.get_value() if new_raw_value > self._max_value or new_raw_value < self._min_value or abs( new_raw_value - self._values[-1]) < self._min_value_deviation: return True self._values.append(new_raw_value) while len(self._values) > self._floating_avg_pts: self._values = self._values[1:] self._read_counter = self._read_counter + 1 current_avg_value = np.mean(self._values) self._error = self._setpoint - current_avg_value if np.abs(self._error) < 10. * self.get_fine_value_threshold(): new_raw_value_fine = self._get_val_fine() if new_raw_value_fine > self._max_value or new_raw_value_fine < self._min_value: pass elif self._fine_setpoint == 0: if np.abs(self._error) < 1. * self.get_fine_value_threshold(): self._fine_setpoint = new_raw_value_fine else: self._error = self._fine_setpoint - new_raw_value_fine else: self._fine_setpoint = 0 pval = self._P * self._error dval = self._D * (current_avg_value - self._derivator) self._derivator = current_avg_value ival = self._I * self._integrator self._integrator = self._integrator + self._error self._time = time.time() - self._t0 if self.get_do_save_data(): try: self._dat.add_data_point(self._time, new_raw_value, current_avg_value, self._setpoint, self._control_parameter) except NameError: self._dat = qt.Data(name=self._name) self._dat.add_coordinate('time') self._dat.add_value('raw frequency') self._dat.add_value('avg frequency') self._dat.add_value('setpoint') self._dat.add_value('control parameter') new_control_parameter = self._control_parameter + pval + dval + ival if not self._try_set_control_parameter(new_control_parameter): print 'Could not set control parameter, quit.' return False return True
def example3(x_vec=numpy.linspace(0,10,10), y_vec=numpy.linspace(0,10,50)): ''' To run the function type in the terminal: measure_module.example3() ''' qt.mstart() data = qt.Data(name='testmeasurement') data.add_coordinate('x') data.add_coordinate('y') data.add_value('z1') data.add_value('z2') data.add_value('z3') data.create_file() plot2d_1 = qt.Plot2D(data, name='2D_1', coorddim=1, valdim=2) plot2d_2 = qt.Plot2D(data, name='2D_2', coorddim=1, valdim=2, maxtraces=1) plot2d_3 = qt.Plot2D(data, name='2D_3', coorddim=1, valdim=2, maxtraces=1) plot2d_3.add_data(data, coorddim=1, valdim=3, maxtraces=1) plot2d_3.add_data(data, coorddim=1, valdim=4, maxtraces=1) plot2d_4 = qt.Plot2D(data, name='2D_4', coorddim=1, valdim=2, mintime=0.3) plot2d_5 = qt.Plot2D(data, name='2D_5', coorddim=1, valdim=2, autoupdate=False) plot3d_1 = qt.Plot3D(data, name='3D_1', style='image') plot3d_2 = qt.Plot3D(data, name='3D_2', style='image', coorddims=(1,0), valdim=4) for x in x_vec: for y in y_vec: z1 = numpy.sin(x+y) z2 = numpy.cos(x+y) z3 = numpy.sin(x+2*y) data.add_data_point(x, y, z1, z2, z3) if z1>0: plot2d_5.update() qt.msleep(0.1) data.new_block() plot2d_1.save_png() plot2d_1.save_gp() plot3d_2.save_png() plot3d_2.save_gp() data.close_file() qt.mend()
def save_spectrum(self, ret=False): spec = andor.get_spectrum() specd = qt.Data(name='spectrum') specd.add_value('Counts') specd.create_file() specd.add_data_point(spec) specd.close_file() qt.plot(specd, name='saved_spectrum', clear=True) if ret: return spec
def _create_data(self, x_vector, x_coordinate, x_parameter, y_vector, y_coordinate, y_parameter, z_vector, z_coordinate, z_parameter, bwd=False): '''Generate the data file, spyview .meta file and copy scan scripts.''' qt.Data.set_filename_generator(self._generator) data = qt.Data(name=self._filename) self._coolabels = [ '%s_(%s)' % (x_parameter, x_coordinate), '%s_(%s)' % (y_parameter, y_coordinate), '%s_(%s)' % (z_parameter, z_coordinate) ] (xstart, xend) = (x_vector[-1], x_vector[0]) if bwd else (x_vector[0], x_vector[-1]) data.add_coordinate(self._coolabels[0], size=len(x_vector), start=xstart, end=xend) data.add_coordinate(self._coolabels[1], size=len(y_vector), start=y_vector[0], end=y_vector[-1]) data.add_coordinate(self._coolabels[2], size=len(z_vector), start=z_vector[0], end=z_vector[-1]) for i in self._vallabels: data.add_value(i) #add value labels data.create_file() #Create data file SpyView(data).write_meta_file() #Create meta.txt file for spyview qscan_file_path = sys._getframe().f_code.co_filename qscan_copyto_path = os.path.join(data._dir, os.path.split(qscan_file_path)[1]) if not os.path.isfile(qscan_copyto_path): print 'Copy file:', qscan_file_path copyfile(qscan_file_path, qscan_copyto_path) to_script_path = "%s\\%s_%s.py" % (data._dir, self._filename, str(self._generator._counter - 1)) if os.path.isfile(this_file_path): copyfile(this_file_path, to_script_path) else: f = open(to_script_path, 'w') f.write( this_file_path ) #It's a code string if the function is called by more_scan() f.close() data._file.flush() return data
def save_spectrum(self, ret=False): spec = winspec.get_spectrum() specd = qt.Data(name='spectrum') specd.add_coordinate('Wavelength', units='nm') specd.add_value('Counts') specd.create_file() specd.add_data_point(spec) specd.close_file() qt.plot(specd, name='saved_spectrum', clear=True) if ret: return spec
def _update(self): if not self._is_running: return False elapsed = time.time() - self._t0 if elapsed < self._ramp_time: scale_fact = elapsed / self._ramp_time else: scale_fact = 1.0 new_raw_value = self.get_value() if new_raw_value > self._max_value or new_raw_value < self._min_value or abs( new_raw_value - self._values[-1]) < self._min_value_deviation: return True self._values.append(new_raw_value) while len(self._values) > self._floating_avg_pts: self._values = self._values[1:] self._read_counter = self._read_counter + 1 current_avg_value = numpy.mean(self._values) self._error = self._setpoint - current_avg_value pval = self._P * self._error dval = self._D * (current_avg_value - self._derivator) self._derivator = current_avg_value ival = self._I * self._integrator self._integrator = self._integrator + self._error self._time = time.time() - self._t0 if self.get_do_save_data(): try: self._dat.add_data_point(self._time, new_raw_value, current_avg_value, self._setpoint, self._control_parameter) except NameError: self._dat = qt.Data(name=self._name) self._dat.add_coordinate('time') self._dat.add_value('raw frequency') self._dat.add_value('avg frequency') self._dat.add_value('setpoint') self._dat.add_value('control parameter') new_control_parameter = self._control_parameter + scale_fact * ( pval + dval + ival) if not self._try_set_control_parameter(new_control_parameter): print 'Could not set control parameter, quit.' return False return True
def _create_datafile(self): print 'Create dataset' # Initialize data file self._dat = qt.Data(name=self._name) # Create time column self._dat.add_coordinate('time') # Create columns for each function self._function_names = [] for i in np.arange(len(self._function_list)): current_function = self._function_list[i] self._function_names.append(current_function.__name__) self._dat.add_value(current_function.__name__)
def full_measure2d(coordinate, value, measure_fn, measure_args): #set up data object and plot: qt.mstart() out = measure_fn(*measure_args) #actual measurement data = qt.Data(name=measure_args[5]) data.add_coordinate('frequency [MHz]') data.add_value('magnitude [dBm]') data.create_file() plot2d = qt.Plot2D(data, name='measure2D') data.add_data_point(out[0], out[1]) data.close_file() qt.mend() return out
def start(self): if not self._is_running: self._t0 = time.time() for p in self._monitor_pars: n = self._monitor_pars[p]['name'] self._monitor_pars[p]['data'] = qt.Data( name='{}_Par{}_{}'.format(self.name, p, n)) self._monitor_pars[p]['data'].add_coordinate('time') self._monitor_pars[p]['data'].add_value('value') self._monitor_pars[p]['plot'] = qt.Plot2D( self._monitor_pars[p]['data'], name='Par{}_{}'.format(p, n), coorddim=0, valdim=1, maxpoints=100, clear=True) for fp in self._monitor_fpars: n = self._monitor_fpars[fp]['name'] self._monitor_fpars[fp]['data'] = qt.Data( name='{}_FPar{}_{}'.format(self.name, fp, n)) self._monitor_fpars[fp]['data'].add_coordinate('time') self._monitor_fpars[fp]['data'].add_value('value') self._monitor_fpars[fp]['plot'] = qt.Plot2D( self._monitor_fpars[fp]['data'], name='FPar{}_{}'.format(fp, n), coorddim=0, valdim=1, maxpoints=100, clear=True) self._is_running = True gobject.timeout_add(int(self._update_interval * 1e3), self._update)
def _create_data(self, xpnt, xlbl, xchan, ypnt, ylbl, ychan, zpnt, zlbl, zchan): '''Generate the data file, spyview .meta file, and copy the .py scan script.''' qt.Data.set_filename_generator(self._generator) data = qt.Data(name=self._filename) #qtlab data object setpoint_label_x = ['%s_(%s)' % (i, j) for i, j in zip(xchan, xlbl)] setpoint_label_y = ['%s_(%s)' % (i, j) for i, j in zip(ychan, ylbl)] setpoint_label_z = ['%s_(%s)' % (i, j) for i, j in zip(zchan, zlbl)] setpoint_labels = [ setpoint_label_x[0], setpoint_label_y[0], setpoint_label_z[0] ] getpoint_labels = self._vallabels[:] #be careful, use list[:] to hard copy! if len(setpoint_label_x) > 1: getpoint_labels += setpoint_label_x[1:] if len(setpoint_label_y) > 1: getpoint_labels += setpoint_label_y[1:] if len(setpoint_label_z) > 1: getpoint_labels += setpoint_label_z[1:] for i, j in zip(setpoint_labels, [xpnt, ypnt, zpnt]): _ = j[0] data.add_coordinate(i, size=len(_), start=_[0], end=_[-1]) for i in getpoint_labels: data.add_value(i) data.create_file() #Create data file SpyView(data).write_meta_file() #Create meta.txt file for spyview data._file.flush() #copy this file if not copied before qscan_file_path = sys._getframe().f_code.co_filename qscan_copyto_path = os.path.join(data._dir, os.path.split(qscan_file_path)[1]) if not os.path.isfile(qscan_copyto_path): print 'Copy file:', qscan_file_path copyfile(qscan_file_path, qscan_copyto_path) #copy and rename scan script to_script_path = "%s\\%s_%s.py" % (data._dir, self._filename, str(self._generator._counter - 1)) if os.path.isfile(this_file_path): copyfile(this_file_path, to_script_path) else: f = open(to_script_path, 'w') f.write( this_file_path ) #It's a code string if the function is called by more_scan() f.close() return data