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
