def run(self):
flip_time = 26.1778
N = 50
data = np.zeros((3,N))
for i in range(N):
fre = 400.+0.001*i - 0.001*N/2
temp = self.run_sequence(flip_time,fre)
data[0,i]=fre
# accuracy
data[1,i]=temp[0]
# count
data[2,i]=temp[1]
print("\nAccuracy:%.1f%%" % (temp[0]))
print('Photon Count:%d' % temp[1])
print('Frequency:%.4f' % fre)
np.save('microwave',data)
save_file(data,__file__[:-3])
plt.figure(1)
ax1 = plt.subplot(121)
ax1.bar(data[0],data[1],width=0.001/2)
ax1.legend('efficiency')
ax2 = plt.subplot(122)
ax2.bar(data[0],data[2],width=0.001/2)
ax2.legend('count')
plt.show()
def run(self):
self.pre_set()
pmt_on()
init_fre = 236.1
lock_point = 871.034654
scan_step = 0.001 * 5
rabi_time = 40
N = 100
run_times = 200
amp = 0.5
file_name = 'data\\Rabi_AOM_Fre_Scan' + 'amp=' + str(
amp) + 'rabi_time=' + str(rabi_time) + 'fre=' + str(
init_fre) + '-' + str(float(init_fre + N * scan_step)) + '.csv'
file = open(file_name, 'w+')
file.close()
data = np.zeros((4, N))
data[0, :] = np.linspace(init_fre, init_fre + scan_step * (N - 1), N)
for i in trange(N):
AOM_435 = init_fre + scan_step * i # - 0.001*N/2
# wait for 871 to be locked
while not is_871_locked(lock_point):
print('Laser is locking...')
time.sleep(3)
# change AOM frequency
code = "conda activate base && python dds.py " + str(
AOM_435) + ' ' + str(amp)
os.system(code)
# run detection and save data
temp = self.run_sequence(rabi_time, run_times)
# print information
data_item = [AOM_435, temp[0], temp[1], wl_871]
data[:, i] = data_item
# write data
content = str(data[0, i])+','+str(data[1, i]) + \
','+str(data[2, i])+','+str(data[3, i])+'\n'
file_write(file_name, content)
print_info(data_item)
print('\n')
file.close()
save_file(data, file_name[5:-4])
curr.off()
# plot figures
plt.figure(1)
x1 = data[0, :]
y1 = data[1, :]
plt.plot(x1, y1)
plt.show()
def run(self):
# dds_435 = dds_controller()
# flip_time = 75
# microwave_fre = 400.0
init_time = 1.
time_interval = 0.5
N = 40
data = np.zeros((3,N))
for i in range(N):
pumping_time = init_time+time_interval*i
# pumping_time = 15.0
temp = self.run_sequence(pumping_time)
data[0,i]=pumping_time
data[1,i]=temp[0]*2
data[2,i]=temp[1]
print("%d/%d" %((i+1),N))
print('cout:%d\neffiency:%d%%' % (temp[1],temp[0]))
save_file(data,__file__[:-3])
plt.figure(1)
ax1 = plt.subplot(121)
ax1.plot(data[0],data[1])
ax1.set_title('Detection Effiency')
ax2 = plt.subplot(122)
ax2.plot(data[0],data[2])
ax2.set_title('Detection Count')
plt.show()
def run(self):
init_time = 30
time_interval = 2
N = 30
data = np.zeros((3, N))
for i in range(N):
microwave_time = init_time + i * time_interval - N / 2 * time_interval
#microwave_time = init_time + i*time_interval
temp = self.run_sequence(microwave_time)
data[0, i] = microwave_time
# accuracy
data[1, i] = temp[0]
# count
data[2, i] = temp[1]
print("\nAccuracy:%.1f%%" % (temp[0]))
print('Photon Count:%d' % temp[1])
print('microwave time:%d' % microwave_time)
np.save('microwave', data)
save_file(data, __file__[:-3])
plt.figure(1)
ax1 = plt.subplot(121)
ax1.bar(data[0], data[1], width=time_interval / 2)
ax1.legend('efficiency')
ax2 = plt.subplot(122)
ax2.bar(data[0], data[2], width=time_interval / 2)
ax2.legend('count')
plt.show()
def run(self):
widgets = ['Progress: ',Percentage(), ' ', Bar('#'),' ', Timer(),
' ', ETA(), ' ']
microwave_time =34
time_interval = 100
N = 100
pbar = ProgressBar(widgets=widgets, maxval=10*N).start()
data = np.zeros((3,N))
# print(__file__)
for i in range(N):
delay_time = time_interval*i
temp = self.run_sequence(microwave_time,delay_time)
data[0,i] = delay_time
# accuracy
data[1,i]=temp[0]
# count
data[2,i]=temp[1]
print("\nAccuracy:%.1f%%" % (temp[0]))
print('Photon Count:%d' % temp[1])
print('microwave time:%d' % microwave_time)
pbar.update(10 * i + 1)
print('\n')
pbar.finish()
np.save('microwave',data)
save_file(data,__file__[:-3])
plt.figure(1)
ax1 = plt.subplot(121)
ax1.bar(data[0],data[1],width=time_interval/2)
ax1.legend('efficiency')
ax2 = plt.subplot(122)
ax2.bar(data[0],data[2],width=time_interval/2)
ax2.legend('count')
plt.figure(2)
ax3 = plt.subplot(121)
ax3.plot(data[0],data[1])
ax3.legend('efficiency')
ax4=plt.subplot(122)
ax4.plot(data[0],data[2])
ax4.legend('count')
plt.show()
def run(self):
self.pre_set()
repeat_time = 1000
data = [None] * repeat_time
for i in range(repeat_time):
t1 = time.time()
temp_data = self.run_sequence()
t2 = time.time()
print("\nAccuracy:%.1f%%" % (temp_data[0]))
print('Photon Count:%d' % temp_data[1])
print('Costed time:%.1fs' % (t2 - t1))
data[i] = temp_data[0]
save_file(data, __file__[:-3])
def run(self):
init_time = 0
time_interval = 1
N = 50
data = np.zeros((3, N))
for i in range(N):
microwave_time = init_time + i * time_interval
#microwave_time = init_time + i*time_interval
temp = self.run_sequence(microwave_time)
data[0, i] = microwave_time
# accuracy
data[1, i] = temp[0]
# count
data[2, i] = temp[1]
print("\nAccuracy:%.1f%%" % (temp[0]))
print('Photon Count:%d' % temp[1])
print('microwave time:%d' % microwave_time)
np.save('microwave', data)
save_file(data, __file__[:-3])
plt.figure(1)
ax1 = plt.subplot(121)
ax1.bar(data[0], data[1], width=time_interval / 2)
ax1.legend('efficiency')
ax2 = plt.subplot(122)
ax2.bar(data[0], data[2], width=time_interval / 2)
ax2.legend('count')
# fit function
"""
popt, pcov = curve_fit(fit_func, data[0], data[1])
print("b:%s,b:%s,c:%s" % tuple(popt))
plt.figure(2)
plt.plot(data[0], data[1],'bo', label='intial data')
xdata = np.linspace(init_time, init_time+time_interval*N,50*N)
plt.plot(xdata, fit_func(xdata, *popt), 'r-',
label='fit:a=%5.3f, b=%5.3f, c=%5.3f' % tuple(popt))
plt.legend()
"""
plt.show()
def run(self):
self.pre_set()
pmt_on()
center_370_wavelength = 369.526100
laser_scan_step = -0.000001
N = 60
init_370_wavelength = center_370_wavelength - laser_scan_step * N / 2
data = np.zeros((3, N))
time_now = time.strftime("%Y-%m-%d-%H-%M")
file_name = 'data\\' + str(init_370_wavelength) + '-' + str(
init_370_wavelength +
N * laser_scan_step) + '-' + time_now + '.csv'
file = open(file_name, 'w+')
file.close()
for i in range(N):
wavelength_370 = init_370_wavelength + i * laser_scan_step
laser_lock_370.lock(wavelength_370)
laser_lock_370.lock_on()
while not is_locked(wavelength_370):
time.sleep(5)
print('wait for 370 to be locked')
temp = self.run_sequence()
data[:, i] = [wavelength_370, temp[0], temp[1]]
content = str(wavelength_370) + ',' + \
str(temp[0]) + ',' + str(temp[1])+'\n'
file_write(file_name, content)
print('Count:%d\nEffiency:%.1f%%' % (temp[1], temp[0]))
file.close()
save_file(data, __file__[:-3])
laser_lock_370.lock(369.526100)
laser_lock_370.lock_on()
while not is_locked(369.526100):
time.sleep(2)
print('Set back to initial frequency')
def run(self):
flip_time = 460
N = 50
data = np.zeros((3, N))
for i in range(N):
fre = 400. + 0.001 * i - 0.001 * N / 2
temp = self.run_sequence(flip_time, fre)
data[0, i] = fre
# accuracy
data[1, i] = temp[0]
# count
data[2, i] = temp[1]
print("\nAccuracy:%.1f%%" % (temp[0]))
print('Photon Count:%d' % temp[1])
print('Frequency:%.4f' % fre)
np.save('microwave', data)
save_file(data, __file__[:-3])
def run(self):
pmt_on()
init_fre = 80
lock_point = 871.034927
N = 3000
widgets = [
'Progress: ',
Percentage(), ' ',
Bar('#'), ' ',
Timer(), ' ',
ETA(), ' '
]
pbar = ProgressBar(widgets=widgets, maxval=10 * N).start()
file_name = 'data\\'+str(init_fre)+'-' + \
str(float(init_fre+N*0.005))+'.csv'
file = open(file_name, 'w+')
file.close()
rescan_file_name = 'data\\rescan' + \
str(init_fre)+'-'+str(float(init_fre+N*0.005))+'.csv'
rescan_file = open(rescan_file_name, 'w+')
rescan_file.close()
manual_rescan_file_name = 'data\\manual_rescan' + \
str(init_fre)+'-'+str(float(init_fre+N*0.005))+'.csv'
manual_rescan_file = open(manual_rescan_file_name, 'w+')
manual_rescan_file.close()
data = np.zeros((4, N))
data[0, :] = np.linspace(init_fre, init_fre + 0.005 * (N - 1), N)
plt.figure(1)
fig1 = plt.subplot(211)
line1, = fig1.plot(data[0, 0:0], data[1, 0:0])
fig2 = plt.subplot(212)
line2, = fig2.plot(data[0, 0:0], data[2, 0:0])
for i in range(N):
AOM_435 = init_fre + 0.005 * i # - 0.001*N/2
# wait for 871 to be locked
while not is_871_locked(lock_point):
time.sleep(5)
# change AOM frequency
code = "conda activate base && python dds.py " + str(AOM_435)
os.system(code)
# run detection and save data
temp = self.run_sequence()
# print information
data_item = [AOM_435, temp[0] * 2, temp[1], wm.get_data()[0]]
data[:, i] = data_item
"""
line1.set_xdata(data[0, 0:i])
line1.set_ydata(data[1, 0:i])
line2.set_xdata(data[0, 0:i])
line2.set_ydata(data[2, 0:i])
fig1.relim()
fig1.autoscale_view(True, True, True)
fig2.relim()
fig2.autoscale_view(True, True, True)
"""
# write data
content = str(data[0, i])+','+str(data[1, i]) + \
','+str(data[2, i])+','+str(data[3, i])+'\n'
file_write(file_name, content)
print_info(data_item)
pbar.update(10 * i + 1)
print('\n')
# rescan at most n times when effiency is less than 80%
rescan_time = 0
temp_data = []
if 2 * temp[0] < 80:
while rescan_time < 5:
# check if there is ion
time.sleep(0.5)
shutter_370.on()
time.sleep(0.5)
shutter_370.off()
time.sleep(0.2)
temp1 = self.run_sequence()
temp_data.append(list(temp1))
rescan_time += 1
print('rescan:%d, effiency:%d' %
(rescan_time, 2 * temp1[0]))
print('\n')
if rescan_time == 5:
# print('saveing data')
temp_data = np.array(temp_data, dtype=np.int)
effiencies = temp_data[:, 0]
if 2 * effiencies.mean() < 80:
manual_rescan_content = str(AOM_435) + '\n'
file_write(manual_rescan_file_name, manual_rescan_content)
rescan_content = str(AOM_435)
for k in range(5):
rescan_content = rescan_content + ',' + str(
2 * effiencies[k])
rescan_content = rescan_content + '\n'
file_write(rescan_file_name, rescan_content)
"""
plt.draw()
plt.pause(1e-8)
"""
# update figure
# line1.set_xdata(data[0,0:i])
file.close()
rescan_file.close()
manual_rescan_file.close()
save_file(data, __file__[:-3])
line1.set_xdata(data[0, :])
line1.set_ydata(data[1, :])
line2.set_xdata(data[0, :])
line2.set_ydata(data[2, :])
fig1.relim()
fig1.autoscale_view(True, True, True)
fig2.relim()
fig2.autoscale_view(True, True, True)
plt.show()
def run(self):
init_fre = 241.6
stop_fre = 242.0
DDS_AMP = 0.8
lock_point = 871.034636
scan_step = 0.001
rabi_time = 100.0
N = int((stop_fre - init_fre) / scan_step)
run_times = 200
file_name = 'data\\Rabi_AOM_fre_Scan'+str(init_fre)+'-'+\
str(float(init_fre+N*scan_step))+'.csv'
file = open(file_name, 'w+')
file.close()
data = np.zeros((4, N))
data[0, :] = np.linspace(init_fre, init_fre + scan_step * (N - 1), N)
for i in trange(N):
AOM_435 = init_fre + scan_step * i # - 0.001*N/2
DDS.set_frequency(port=0,
frequency=AOM_435,
amplitude=DDS_AMP,
phase=0)
# wait for 871 to be locked
while not is_871_locked(lock_point):
print('Laser is locking...')
time.sleep(3)
# change AOM frequency
"""
code = "conda activate base && python dds.py " + str(AOM_435)
os.system(code)
"""
# run detection and save data
temp = self.run_sequence(rabi_time, run_times)
# print information
data_item = [AOM_435, temp[0], temp[1], wl_871]
data[:, i] = data_item
# write data
content = str(data[0, i])+','+str(data[1, i]) + \
','+str(data[2, i])+','+str(data[3, i])+'\n'
file_write(file_name, content)
print_info(data_item)
print('\n')
min_index = data[1, :].argmin(axis=0)
register_frequency(data[0, min_index], data[1, min_index])
file.close()
save_file(data, file_name[5:-4])
# plot figures
plt.figure(1)
x1 = data[0, :]
y1 = data[1, :]
plt.plot(x1, y1)
plt.show()
def run(self):
# AOM_435 MicroMotion = 228.4915
# AOM_435 Red Phonon Sideband 239.0195
# AOM_435 = 239.965-22.52968/2
t1 = time.time()
AOM_435 = 241.909
DDS_AMP = 0.8
DDS.set_frequency(frequency=AOM_435, amplitude=DDS_AMP)
lock_point = 871.034636
init_value = 0.0
scan_step = 3
N = 50
run_times = 200
file_name = 'data\\Rabi_AOM_Time_Scan'+str(init_value)+'-'+\
str(float(init_value+N*scan_step))+'.csv'
file = open(file_name, 'w+')
file.close()
data = np.zeros((4, N))
data[0, :] = np.linspace(init_value, init_value + scan_step * (N - 1),
N)
# drive AOM
# scab iteration
for i in trange(N):
scan_value = init_value + scan_step * i # - 0.001*N/2
# wait for 871 to be locked
while not is_871_locked(lock_point):
print('Laser is locking...')
time.sleep(3)
# run detection and save data
temp = self.run_sequence(scan_value, run_times)
# print information
data_item = [scan_value, temp[0], temp[1], wl_871]
data[:, i] = data_item
# write data
content = str(data[0, i])+','+str(data[1, i]) + \
','+str(data[2, i])+','+str(data[3, i])+'\n'
file_write(file_name, content)
print_info(data_item)
file.close()
save_file(data, file_name[5:-4])
curr.off()
t2 = time.time()
print("Time costed:%s" % (t2 - t1))
# plot figures
plt.figure(1)
x1 = data[0, :]
y1 = data[1, :]
plt.plot(x1, y1)
plt.show()
def run(self):
self.pre_set()
pmt_on()
shutter_370.off()
center_fre = 260
scan_step = 0.1
fre_width = 1
N = int(fre_width / scan_step)
init_fre = center_fre - N / 2 * scan_step
# init_fre = 342.57
lock_point = 871.034694
widgets = [
'Progress: ',
Percentage(), ' ',
Bar('#'), ' ',
Timer(), ' ',
ETA(), ' '
]
pbar = ProgressBar(widgets=widgets, maxval=10 * N).start()
file_name = 'data\\'+str(lock_point)[5::]+'-'+str(init_fre)+'-' + \
str(float(init_fre+N*scan_step))+'.csv'
file = open(file_name, 'w+')
file.close()
data = np.zeros((4, N))
data[0, :] = np.linspace(init_fre, init_fre + scan_step * (N - 1), N)
x_data = list(range(100))
y_data1 = [None] * 100
y_data2 = [None] * 100
"""
plt.figure(1)
fig1 = plt.subplot(211)
line1, = fig1.plot(x_data,y_data1)
show_data1 = 'Effiency:0'
txt1 = fig1.text(0.8,0.8,show_data1 ,verticalalignment = 'center', \
transform=fig1.transAxes)
fig2 = plt.subplot(212)
line2, = fig2.plot(x_data,y_data2)
show_data2 = 'Count:0'
txt2 = fig2.text(0.8,0.8,show_data2,verticalalignment = 'center', \
transform=fig2.transAxes)
"""
for i in range(N):
AOM_435 = init_fre + scan_step * i # - 0.001*N/2
# wait for 871 to be locked
while not is_871_locked(lock_point):
time.sleep(5)
# change AOM frequency
code = "conda activate base && python dds.py " + str(AOM_435)
os.system(code)
time.sleep(0.1)
# run detection and save data
temp = self.run_sequence()
if temp[0] < 50:
ccd_on()
time.sleep(0.7)
if not has_ion():
costed_time = 0
while not has_ion() and costed_time < 300:
shutter_370.on()
time.sleep(5)
costed_time += 5
shutter_370.off()
time.sleep(0.5)
temp = self.run_sequence()
else:
pmt_on()
y_data1 = y_data1[1::] + [temp[0]]
y_data2 = y_data2[1::] + [temp[1]]
# print information
data_item = [AOM_435, temp[0], temp[1], wm.get_data()[0]]
data[:, i] = data_item
# write data
content = str(data[0, i])+','+str(data[2, i]) + \
','+str(data[1, i])+','+str(data[3, i])+'\n'
file_write(file_name, content)
print_info(data_item)
pbar.update(10 * i + 1)
print('\n')
shutter_370.on()
file.close()
save_file(data, __file__[:-3])
def run(self):
# AOM_435 MicroMotion = 228.4915
# AOM_435 Red Phonon Sideband 239.0195
# AOM_435 Blue Sideband
AOM_435 = 239.912
AOM_435_RED_SIDEBAND = 238.381
lock_point = 871.034644
init_value = 0
scan_step = 1
N = 500
run_times = 200
amp = 0.9
cooling_time = 40
cooling_cycles = 200
self.pre_set()
pmt_on()
file_name = 'data\\Carrier_After_Cooling'+str(init_value)+'-'+\
str(float(init_value+N*scan_step))+'.csv'
file = open(file_name, 'w+')
file.close()
data = np.zeros((4, N))
data[0, :] = np.linspace(init_value, init_value + scan_step * (N - 1),
N)
# SIDEBAND COOLING
code = "conda activate base && python dds.py " + \
str(AOM_435_RED_SIDEBAND) + ' ' + str(amp)
os.system(code)
# satrt cooling
self.sidebandcooling(cooling_time, cooling_cycles)
# scan to test if carrier becomes better
# scan iteration
code = "conda activate base && python dds.py " + \
str(AOM_435) + ' ' + str(amp)
os.system(code)
for i in trange(N):
"""
#SIDEBAND COOLING
code = "conda activate base && python dds.py " + \
str(AOM_435_RED_SIDEBAND) + ' ' + str(amp)
os.system(code)
# satrt cooling
self.sidebandcooling(cooling_time, cooling_cycles)
"""
code = "conda activate base && python dds.py " + \
str(AOM_435) + ' ' + str(amp)
os.system(code)
scan_value = init_value + scan_step * i # - 0.001*N/2
# wait for 871 to be locked
while not is_871_locked(lock_point):
print('Laser is locking...')
time.sleep(3)
# run detection and save data
temp = self.run_sequence(scan_value)
# print information
data_item = [scan_value, temp[0], temp[1], wl_871]
data[:, i] = data_item
# write data
content = str(data[0, i])+','+str(data[1, i]) + \
','+str(data[2, i])+','+str(data[3, i])+'\n'
file_write(file_name, content)
print_info(data_item)
file.close()
save_file(data, file_name[5:-4])
curr.off()
# plot figures
plt.figure(1)
x1 = data[0, :]
y1 = data[1, :]
plt.plot(x1, y1)
plt.show()
def run(self):
self.pre_set()
pmt_on()
init_fre = 235.467
lock_point = 871.034658
scan_step = 0.0005
rabi_time = 100
N = 20
center_fre = init_fre + N * scan_step / 2
run_times = 200
sleep_time = 5
M = 2000
time_now = time.strftime("%Y-%m-%d-%H-%M")
file_name = 'data\\435_long_term' + time_now + '.csv'
file = open(file_name, 'w+')
file.close()
t0 = time.time()
all_data = np.zeros((3, M))
for j in range(M):
data = np.zeros((4, N))
data[0, :] = np.linspace(init_fre, init_fre + scan_step * (N - 1),
N)
init_fre = center_fre - N * scan_step / 2
for i in trange(N):
AOM_435 = init_fre + scan_step * i # - 0.001*N/2
# wait for 871 to be locked
while not is_871_locked(lock_point):
print('Laser is locking...')
time.sleep(3)
# change AOM frequency
code = "conda activate base && python dds.py " + str(AOM_435)
os.system(code)
# run detection and save data
temp = self.run_sequence(rabi_time, run_times)
if temp[0] < 5:
reload_ion()
pmt_on()
# print information
data_item = [AOM_435, temp[0], temp[1], wl_871]
data[:, i] = data_item
print_info(data_item)
t1 = time.time()
delta_t = t1 - t0
# get the min value of effiency
ydata = data[1, :]
min_ind = ydata.argmin(axis=0)
# judge if it is the random value
"""
if min_ind > 0 and min_ind < N-1:
if ydata[min_ind -1] < 50 and ydata[min_ind+1]<50:
center_fre = data[0,:][min_ind]
"""
# save data
all_data[0, j] = delta_t
all_data[1, j] = data[0, :][min_ind]
all_data[2, j] = ydata[min_ind]
content = str(delta_t) + ',' + str(
data[0, :][min_ind]) + ',' + str(ydata[min_ind]) + '\n'
file_write(file_name, content)
time.sleep(sleep_time)
file.close()
save_file(all_data, file_name[5:-4])
def run(self):
self.pre_set()
pmt_on()
shutter_370.off()
scan_step = 0.000001
# fre_width = 1
# N = int(fre_width/scan_step)
N = 8000
init_fre = 871.034000
# init_fre = 342.57
# lock_point = 871.034694
widgets = [
'Progress: ',
Percentage(), ' ',
Bar('#'), ' ',
Timer(), ' ',
ETA(), ' '
]
pbar = ProgressBar(widgets=widgets, maxval=10 * N).start()
file_name = 'data\\'+str(init_fre)[5::]+'-'+str(init_fre)+'-' + \
str(float(init_fre+N*scan_step))+'.csv'
file = open(file_name, 'w+')
file.close()
data = np.zeros((4, N))
data[0, :] = np.linspace(init_fre, init_fre + scan_step * (N - 1), N)
x_data = list(range(100))
y_data1 = [None] * 100
y_data2 = [None] * 100
"""
plt.figure(1)
fig1 = plt.subplot(211)
line1, = fig1.plot(x_data,y_data1)
show_data1 = 'Effiency:0'
txt1 = fig1.text(0.8,0.8,show_data1 ,verticalalignment = 'center', \
transform=fig1.transAxes)
fig2 = plt.subplot(212)
line2, = fig2.plot(x_data,y_data2)
show_data2 = 'Count:0'
txt2 = fig2.text(0.8,0.8,show_data2,verticalalignment = 'center', \
transform=fig2.transAxes)
"""
for i in range(N):
# lock 871
fre_871 = init_fre + i * scan_step
wm.lock(1, fre_871)
time.sleep(0.1)
# run detection and save data
temp = self.run_sequence()
# check state when detection effiency < 50
if temp[0] < 3 * 50:
ccd_on()
time.sleep(0.7)
# reload ion
if not has_ion():
costed_time = 0
curr.on()
while not has_ion() and costed_time < 300:
shutter_370.on()
time.sleep(5)
costed_time += 5
shutter_370.off()
time.sleep(0.5)
temp = self.run_sequence()
else:
curr.off()
pmt_on()
y_data1 = y_data1[1::] + [temp[0]]
y_data2 = y_data2[1::] + [temp[1]]
# print information
data_item = [fre_871, temp[0] / 3, temp[1], wm.get_data()[0]]
data[:, i] = data_item
# write data
content = str(data[0, i])+','+str(data[2, i]) + \
','+str(data[1, i])+','+str(data[3, i])+'\n'
file_write(file_name, content)
print_info(data_item)
pbar.update(10 * i + 1)
print('\n')
shutter_370.on()
file.close()
save_file(data, __file__[:-3])
for release in check_changes_info:
if release.get_num_entries_added(
) > 0 or release.get_num_entries_updated() > 0:
changed_releases_info.append(release)
if changed_releases_info:
tweet(format_tweet.entry_changes(changed_releases_info))
# new updates should be tweeted last, after all of the other tweets
if new_releases_info:
tweet(format_tweet.new_updates(list(new_releases_info), stored_data))
# if there was a new major release
for key, value in latest_versions.items():
for release in new_releases_info:
if release.get_name() in (f"{key} {value[0]}", f"{key} {value[0]}.0"):
tweet(
format_tweet.yearly_report(all_releases, key, value[0],
stored_data))
elif key == "macOS":
if release.get_name() in (
f"{key} {value[1]} {value[0]}",
f"{key} {value[1]} {value[0]}.0",
):
tweet(
format_tweet.yearly_report(all_releases, key, value[0],
stored_data))
save_file(stored_data, midnight)
def run(self):
self.pre_set()
pmt_on()
init_fre = 235.485
lock_point = 871.034663
scan_step = 0.0001
init_amp = 0.045
M = 5
amp_step = 0.005
init_rabi_time = 8000
rabi_time_step = 500
N = 100
run_times = 200
plt.figure(figsize=(16, 10))
for j in trange(M):
amp = init_amp - j * amp_step
rabi_time = init_rabi_time + rabi_time_step * j
file_name = 'data\\435_width_iteration_scan_amp='+str(amp)+ 'rabi_time=' + str(rabi_time)+ 'fre '+str(init_fre)+'-'+\
str(float(init_fre+N*scan_step))+'.csv'
file = open(file_name, 'w+')
file.close()
data = np.zeros((4, N))
data[0, :] = np.linspace(init_fre, init_fre + scan_step * (N - 1),
N)
for i in range(N):
AOM_435 = init_fre + scan_step * i # - 0.001*N/2
# wait for 871 to be locked
while not is_871_locked(lock_point):
print('Laser is locking...')
time.sleep(3)
# change AOM frequency
code = "conda activate base && python dds.py " + str(
AOM_435) + " " + str(amp)
print(code)
os.system(code)
# run detection and save data
temp = self.run_sequence(rabi_time, run_times)
# print information
data_item = [AOM_435, temp[0], temp[1], wl_871]
data[:, i] = data_item
# write data
content = str(data[0, i])+','+str(data[1, i]) + \
','+str(data[2, i])+','+str(data[3, i])+'\n'
file_write(file_name, content)
print_info(data_item)
print('\n')
file.close()
save_file(data, file_name[5:-4])
ax_label = 'amp=' + str(amp) + ' rabi=' + str(rabi_time) + 'us'
ax = plt.subplot(1, 5, j + 1)
ax.plot(data[0, :], data[1, :], label=ax_label)
ax.legend()
# plot figures
fig_name = 'data\\435_width_iteration_scan_amp='+ '-'+str(amp)+'-'+str(init_amp)+'rabi_time=' + str(rabi_time)+ 'fre '+str(init_fre)+'-'+\
str(float(init_fre+N*scan_step))+'.pdf'
plt.savefig(fig_name)
plt.show()
def run(self):
self.pre_set()
pmt_on()
# aom frequnecy is interms of MHz
init_aom_fre = 210
stop_aom_fre = 240
aom_scan_step = 50 / 1000 # 50kHz
aom_N = int((stop_aom_fre - init_aom_fre) / aom_scan_step)
# laser_frequency is interms of MHz
laser_scan_step = -(stop_aom_fre - init_aom_fre)
init_laser_fre = 344.179520 * 10**6
laser_N = 2
N = laser_N * aom_N
# calculate min and max frequency
min_fre = init_laser_fre - 2 * 240
max_fre = init_laser_fre - 2 * 240 + laser_N * laser_scan_step
# progressbar
widgets = [
'Progress: ',
Percentage(), ' ',
Bar('#'), ' ',
Timer(), ' ',
ETA(), ' '
]
pbar = ProgressBar(widgets=widgets, maxval=10 * N).start()
# save file
time_now = time.strftime("%Y-%m-%d-%H-%M")
file_name = 'data\\' + str(min_fre) + '-' + str(
max_fre) + '-' + time_now + '.csv'
file = open(file_name, 'w+')
file.close()
rescan_file_name = 'data\\rescan-' + str(min_fre) + '-' + str(
max_fre) + '-' + time_now + '.csv'
rescan_file = open(rescan_file_name, 'w+')
rescan_file.close()
manual_rescan_file_name = 'data\\manual-rescan-' + \
str(min_fre)+'-'+str(max_fre)+'-'+time_now+'.csv'
manual_rescan_file = open(manual_rescan_file_name, 'w+')
manual_rescan_file.close()
# save data
data = np.zeros((4, N))
data[0, :] = np.linspace(min_fre, max_fre, N)
x_data = list(range(100))
y_data1 = [None] * 100
y_data2 = [None] * 100
"""
plt.figure(1)
fig1 = plt.subplot(211)
line1, = fig1.plot(x_data,y_data1)
show_data1 = 'Effiency:0'
txt1 = fig1.text(0.8,0.8,show_data1 ,verticalalignment = 'center', \
transform=fig1.transAxes)
fig2 = plt.subplot(212)
line2, = fig2.plot(x_data,y_data2)
show_data2 = 'Count:0'
txt2 = fig2.text(0.8,0.8,show_data2,verticalalignment = 'center', \
transform=fig2.transAxes)
"""
for i in range(laser_N):
fre_871 = init_laser_fre + i * laser_scan_step
# convert MHz in to THz
laser_871_lock.lock(fre_871 / 10**6)
laser_871_lock.lock_on()
# wait for 871 to be locked
while not is_871_locked(fre_871 / 10**6):
print('wait for 871 to be locked ...')
time.sleep(1)
for j in range(aom_N):
index = i * aom_N + j
AOM_435 = init_aom_fre + aom_scan_step * j
# change AOM frequency
code = "conda activate base && python dds.py " + str(AOM_435)
os.system(code)
# run detection and save data
temp = self.run_sequence()
y_data1 = y_data1[1::] + [temp[0]]
y_data2 = y_data2[1::] + [temp[1]]
# print information
data_item = [AOM_435, temp[0], temp[1], wm.get_data()[0]]
data[:, index] = data_item
# write data
content = str(data[0, index])+','+str(data[1, index]) + \
','+str(data[2, index])+','+str(data[3, index])+','+str(fre_871)+'\n'
file_write(file_name, content)
#
print('coming to line 298')
print_info(data_item)
pbar.update(10 * index + 1)
print('\n')
# rescan at most n times when effiency is less than 80%
rescan_time = 0
temp_data = []
if temp[0] < 90:
while rescan_time < 5:
# check if there is ion
ccd_on()
time.sleep(0.5)
# there is ion try to cool the ion
if has_ion():
shutter_370.on()
time.sleep(0.5)
shutter_370.off()
pmt_on()
time.sleep(0.2)
temp1 = self.run_sequence()
temp_data.append(list(temp1))
rescan_time += 1
print('rescan:%d, effiency:%d' %
(rescan_time, temp1[0]))
print('\n')
# there is no ion reload ion
else:
reload_ion()
pmt_on()
if rescan_time == 5:
# print('saveing data')
temp_data = np.array(temp_data, dtype=np.int)
effiencies = temp_data[:, 0]
counts = temp_data[:, 1]
rescan_content = str(AOM_435)
for k in range(5):
rescan_content = rescan_content + ',' + str(
effiencies[k])
for kk in range(5):
rescan_content = rescan_content + ',' + str(counts[kk])
rescan_content = rescan_content + ',' + str(fre_871) + '\n'
file_write(rescan_file_name, rescan_content)
if effiencies.mean() < 90:
file_write(manual_rescan_file_name, rescan_content)
# update figure
# line1.set_xdata(data[0,0:index])
file.close()
rescan_file.close()
manual_rescan_file.close()
save_file(data, __file__[:-3])
def run(self):
# dds_435 = dds_controller()
# flip_time = 75
# microwave_fre = 400.0
self.pre_set()
wm = wlm_web()
init_fre = 103
lock_point = 871.034931
N = 4000
# progressbar
widgets = ['Progress: ',Percentage(), ' ', Bar('#'),' ', Timer(),
' ', ETA(), ' ']
pbar = ProgressBar(widgets=widgets, maxval=10*N).start()
file_name = 'data\\'+str(init_fre)+'-'+str(float(init_fre+N*0.0005))+'.csv'
file = open(file_name,'w+')
file.close()
data = np.zeros((4,N))
for i in range(N):
file = open(file_name,'a')
AOM_435 =init_fre+0.0005*i #- 0.001*N/2
wl_871 = wm.get_data()[0]
is_871_locked = abs(wl_871-lock_point) < 0.000004
while not is_871_locked:
time.sleep(5)
wl_871 = wm.get_data()[0]
is_871_locked = abs(wl_871-lock_point) < 0.000004
code = "conda activate base && python dds.py " + str(AOM_435)
os.system(code)
temp = self.run_sequence()
data[0,i]=AOM_435
# accuracy
data[1,i]=temp[0]*2
# count
data[2,i]=temp[1]
data[3,i]=wm.get_data()[0]
print("Accuracy:%.1f%%" % (temp[0]*2))
print('Photon Count:%d' % temp[1])
pbar.update(10*i+1)
print('\n')
content =str(data[0,i])+','+str(data[1,i])+','+str(data[2,i])+','+str(data[3,i])+'\n'
# print(content)
file.write(content)
file.close()
np.save('microwave',data)
file.close()
save_file(data,__file__[:-3])
plt.figure(1)
ax1 = plt.subplot(121)
ax1.plot(data[0],data[1])
ax2 = plt.subplot(122)
ax2.plot(data[0],data[2])
plt.show()
def run(self):
self.pre_set()
pmt_on()
init_fre = 239.68
sideband_fre1 = 228.38
carrier_fre = 239.7
sideband_fre2 = 250.8
lock_point = 871.034662
scan_step = 0.001 / 2
rabi_time = 200
scan_times = 200 * 2
N = 3 * scan_times
run_times = 200
file_name = 'data\\Rabi_AOM_fre_Scan'+str(init_fre)+'-'+\
str(float(init_fre+N*scan_step))+'.csv'
file = open(file_name, 'w+')
file.close()
data = np.zeros((4, N))
data[0, :] = np.linspace(init_fre, init_fre + scan_step * (N - 1), N)
for i in trange(N):
if i < scan_times:
init_fre = sideband_fre1
elif i < scan_times * 2:
init_fre = carrier_fre - scan_times * scan_step
else:
init_fre = sideband_fre2 - 2 * scan_times * scan_step
AOM_435 = init_fre + scan_step * i # - 0.001*N/2
# wait for 871 to be locked
while not is_871_locked(lock_point):
print('Laser is locking...')
time.sleep(3)
# change AOM frequency
code = "conda activate base && python dds.py " + str(AOM_435)
os.system(code)
# run detection and save data
temp = self.run_sequence(rabi_time, run_times)
# print information
data_item = [AOM_435, temp[0], temp[1], wl_871]
data[:, i] = data_item
# write data
content = str(data[0, i])+','+str(data[1, i]) + \
','+str(data[2, i])+','+str(data[3, i])+'\n'
file_write(file_name, content)
print_info(data_item)
print('\n')
min_index = data[1, :].argmin(axis=0)
register_frequency(data[0, min_index], data[1, min_index])
file.close()
save_file(data, file_name[5:-4])
# plot figures
plt.figure(1)
x1 = data[0, :scan_times]
y1 = data[1, :scan_times]
x2 = data[0, scan_times:2 * scan_times]
y2 = data[1, scan_times:2 * scan_times]
x3 = data[0, 2 * scan_times:]
y3 = data[1, 2 * scan_times:]
ax1 = plt.subplot(131)
ax2 = plt.subplot(132)
ax3 = plt.subplot(133)
ax1.plot(x1, y1)
ax2.plot(x2, y2)
ax3.plot(x3, y3)
plt.show()
def run(self):
self.pre_set()
pmt_on()
init_fre = 210
lock_point = 871.034661
scan_step = 0.01
N = 5000
widgets = ['Progress: ', Percentage(), ' ', Bar('#'), ' ',
Timer(), ' ', ETA(), ' ']
pbar = ProgressBar(widgets=widgets, maxval=10*N).start()
file_name = 'data\\'+str(lock_point)[5::]+'-'+str(init_fre)+'-' + \
str(float(init_fre+N*scan_step))+'.csv'
file = open(file_name, 'w+')
file.close()
rescan_file_name = 'data\\rescan' + str(lock_point)[5::]+'-' + \
str(init_fre)+'-'+str(float(init_fre+N*scan_step))+'.csv'
rescan_file = open(rescan_file_name, 'w+')
rescan_file.close()
manual_rescan_file_name = 'data\\manual_rescan' + str(lock_point)[5::]+'-' + \
str(init_fre)+'-'+str(float(init_fre+N*scan_step))+'.csv'
manual_rescan_file = open(manual_rescan_file_name, 'w+')
manual_rescan_file.close()
data = np.zeros((4, N))
data[0, :] = np.linspace(init_fre, init_fre+scan_step*(N-1), N)
x_data = list(range(100))
y_data1 = [None]*100
y_data2 = [None]*100
"""
plt.figure(1)
fig1 = plt.subplot(211)
line1, = fig1.plot(x_data,y_data1)
show_data1 = 'Effiency:0'
txt1 = fig1.text(0.8,0.8,show_data1 ,verticalalignment = 'center', \
transform=fig1.transAxes)
fig2 = plt.subplot(212)
line2, = fig2.plot(x_data,y_data2)
show_data2 = 'Count:0'
txt2 = fig2.text(0.8,0.8,show_data2,verticalalignment = 'center', \
transform=fig2.transAxes)
"""
for i in trange(N):
AOM_435 = init_fre+scan_step*i # - 0.001*N/2
# wait for 871 to be locked
while not is_871_locked(lock_point):
print('Laser is locking...')
time.sleep(3)
# change AOM frequency
code = "conda activate base && python dds.py " + str(AOM_435)
os.system(code)
# run detection and save data
temp = self.run_sequence()
y_data1 = y_data1[1::]+[temp[0]]
y_data2 = y_data2[1::]+[temp[1]]
# print information
data_item = [AOM_435, temp[0], temp[1], wl_871]
data[:, i] = data_item
# write data
content = str(data[0, i])+','+str(data[1, i]) + \
','+str(data[2, i])+','+str(data[3, i])+'\n'
file_write(file_name, content)
print_info(data_item)
pbar.update(10*i+1)
print('\n')
# rescan at most n times when effiency is less than 80%
rescan_time = 0
temp_data = []
# there may multi
# ple ion
if temp[1] > 800:
if has_ion() > 1:
reload_ion()
pmt_on()
if temp[0] < 70:
while rescan_time < 5:
# check if there is ion
ccd_on()
time.sleep(0.8)
# there is ion try to cool the ion
if has_ion():
shutter_370.on()
time.sleep(0.5)
shutter_370.off()
pmt_on()
time.sleep(0.2)
temp1 = self.run_sequence()
temp_data.append(list(temp1))
rescan_time += 1
print('rescan:%d, effiency:%d' %
(rescan_time, temp1[0]))
print('\n')
# there is no ion reload ion
else:
reload_ion()
pmt_on()
if rescan_time == 5:
# print('saveing data')
temp_data = np.array(temp_data, dtype=np.int)
effiencies = temp_data[:, 0]
counts = temp_data[:, 1]
rescan_content = str(AOM_435)
for k in range(5):
rescan_content = rescan_content+','+str(effiencies[k])
for kk in range(5):
rescan_content = rescan_content+','+str(counts[kk])
rescan_content = rescan_content + '\n'
file_write(rescan_file_name, rescan_content)
if effiencies.mean() < 90:
file_write(manual_rescan_file_name, rescan_content)
# update figure
# line1.set_xdata(data[0,0:i])
file.close()
rescan_file.close()
manual_rescan_file.close()
save_file(data, __file__[:-3])
curr.off()
