def save(self):
self.dataset.clear()
log_to_screen(DEBUG)
save_params = self.save_Settings.widget.get()
t = save_params['sleep time']
file_name = save_params['name']
chnl = 1
time_0 = self.vna.day * 3600 * 24 + self.vna.hours * 3600 + self.vna.minutes * 60 + self.vna.seconds
while (1):
power = self.vna.marker_Y[chnl].magnitude
time_now = self.vna.day * 3600 * 24 + self.vna.hours * 3600 + self.vna.minutes * 60 + self.vna.seconds
delta_time = time_now - time_0
with open(
'D:/MW data/test/20190923/JTWPA/scan_1/save/{}.txt'.format(
file_name), 'a') as file:
write_str = '%f %f\n' % (power, delta_time)
file.write(write_str)
self.vna.save_csv(
'D:/MW data/test/20190923/JTWPA/scan_1/save/{}.csv'.format(
delta_time))
#self.vna.save_csv_second('D:/MW data/test/20190813/JTWPA/scan_1/phase/{}.csv'.format(delta_time))
time.sleep(t)
return
def marker(self):
self.dataset.clear()
log_to_screen(DEBUG)
marker_params = self.Analyzer_Marker_Settings.widget.get()
chnl = marker_params['channel']
stat = marker_params['state']
self.analyzer.marker[chnl]=stat
def set_vna_marker(self):
self.dataset.clear()
log_to_screen(DEBUG)
vna_marker_params = self.VNA_Marker_Settings.widget.get()
chnl = vna_marker_params['channel']
stat = vna_marker_params['state']
self.vna.marker[chnl] = stat
def up_0(self, value):
self.dataset.clear()
log_to_screen(DEBUG)
offset = value * Hz
frequency_start = 5122.612 * MHz
frequency_stop = 5122.612 * MHz + offset
frequency_step = offset / 100
self.source.output = 1
self.source.power = 9
self.source.Trigger_Setting = 9
self.source.Ext_FM_Type = 1
self.source.Ext_FM_Deviation = 200000 * Hz
self.source.frequency = frequency_start
time.sleep(5)
with open('D:/MW data/test/20190909/offset/1/{}.txt'.format(value),
'a') as file:
write_str = '%f %f %f %f %f\n' % (0, 0, 0, 0, 0)
file.write(write_str)
while (self.source.frequency < frequency_stop):
buffer_D = self.lockin.Data_Four
part = buffer_D.split(',')
XValue = part[0]
YValue = part[1]
RValue = part[2]
thetaValue = part[3]
with open('D:/MW data/test/20190909/offset/1/{}.txt'.format(value),
'a') as file:
write_str = '%s %s %s %s %f\n' % (
part[0], part[1], part[2], part[3],
self.source.frequency.magnitude)
file.write(write_str)
a = np.loadtxt(
'D:/MW data/test/20190909/offset/1/{}.txt'.format(value))
self.X_s = a[1:, 0]
self.Y_s = a[1:, 1]
self.R_s = a[1:, 2]
self.theta_s = a[1:, 3]
self.time_s = a[1:, 4]
values = {
't': self.time_s,
'Y': self.Y_s,
'R': self.R_s,
'X': self.X_s,
'theta': self.theta_s,
}
self.Record_data_time.acquire(values)
self.source.frequency = self.source.frequency + frequency_step
return
def set(self):
self.dataset.clear()
log_to_screen(DEBUG)
freq_params = self.Frequency_Settings.widget.get()
# amp_params = self.Frequency_Settings.widget.get()
span = freq_params['frequency span']
center = freq_params['center freq']
self.spa.freq_span = span
self.spa.freq_cent = center
def set_analyzer_amp(self):
self.dataset.clear()
log_to_screen(DEBUG)
analyzer_amp_params = self.Analyzer_Amplitude_Settings.widget.get()
ref = analyzer_amp_params['ref level']
scale = analyzer_amp_params['scale']
self.analyzer.ref_level = ref*dBm
self.analyzer.Y_scale = scale*dBm
def noise(self, value):
self.dataset.clear()
log_to_screen(DEBUG)
frequency_center = 5104.1 * MHz
self.source.output = 1
self.source.Trigger_Setting = 9
self.source.Ext_FM_Type = 1
self.source.Ext_FM_Deviation = 180000 * Hz
self.lockin.Internal_Frequency = value * Hz
self.source.frequency = frequency_center
time.sleep(5)
t = 0
with open('D:/MW data/test/20190907/noise/1/{}.txt'.format(value),
'a') as file:
write_str = '%f %f %f %f %f\n' % (0, 0, 0, 0, 0)
file.write(write_str)
while (t < 600):
buffer_D = self.lockin.Data_Four
part = buffer_D.split(',')
XValue = part[0]
YValue = part[1]
RValue = part[2]
thetaValue = part[3]
with open('D:/MW data/test/20190907/noise/1/{}.txt'.format(value),
'a') as file:
write_str = '%s %s %s %s %f\n' % (part[0], part[1], part[2],
part[3], t)
file.write(write_str)
a = np.loadtxt(
'D:/MW data/test/20190907/noise/1/{}.txt'.format(value))
self.X_s = a[1:, 0]
self.Y_s = a[1:, 1]
self.R_s = a[1:, 2]
self.theta_s = a[1:, 3]
self.time_s = a[1:, 4]
values = {
't': self.time_s,
'Y': self.Y_s,
'R': self.R_s,
'X': self.X_s,
'theta': self.theta_s,
}
self.Record_data_time.acquire(values)
time.sleep(0.1)
t = t + 0.2
return
def set_source_stb(self):
self.dataset.clear()
log_to_screen(DEBUG)
source_stb_params = self.Source_Stability_Settings.widget.get()
pll = source_stb_params['pll pump current']
spc = source_stb_params['channel spacing']
self.source.PLL_charge_pump_current=pll
self.source.channel_spacing=spc
def set_vna_freq(self):
self.dataset.clear()
log_to_screen(DEBUG)
vna_freq_params = self.VNA_Frequency_Settings.widget.get()
span = vna_freq_params['frequency span']
center = vna_freq_params['center freq']
self.vna.freq_span = span
self.vna.freq_cent = center
def save(self):
self.dataset.clear()
log_to_screen(DEBUG)
save_params = self.Save_Settings.widget.get()
t = save_params['sleep time']
count = save_params['file count']
for x in range(count):
self.spa.savefile(x)
time.sleep(t)
def set_freq(self):
self.dataset.clear()
log_to_screen(DEBUG)
freq_params = self.Source_Frequency_Settings.widget.get()
key = freq_params['output state']
freq = freq_params['frequency']
self.source.output = key
self.source.frequency = freq
print('Setting source done!')
def set_freq(self):
self.dataset.clear()
log_to_screen(DEBUG)
freq_params = self.Analyzer_Frequency_Settings.widget.get()
span = freq_params['frequency span']
center = freq_params['center freq']
self.analyzer.freq_span = span
self.analyzer.freq_cent = center
print('Setting frequency done!')
def sweep_frequency(self):
self.dataset.clear()
log_to_screen(DEBUG)
sweep_frequency_params = self.Sweep_frequency_Settings.widget.get()
mk_freq = sweep_frequency_params['marker frequency']
fr_low = sweep_frequency_params['start frequency']
fr_high = sweep_frequency_params['stop frequency']
fr_stp = sweep_frequency_params['step']
t_stp = sweep_frequency_params['step time']
pw = sweep_frequency_params['sweep power']
name = sweep_frequency_params['txt name']
t = sweep_frequency_params['sleep time']
chnl = sweep_frequency_params['marker channel']
self.vna.marker[chnl] = 'ON'
self.vna.marker_X[chnl] = mk_freq
self.source.sweep_lower = fr_low
self.source.sweep_upper = fr_high
self.source.sweep_size = fr_stp
self.source.sweep_step_time = t_stp
self.source.power = pw
self.source.sweep_power_high = pw
self.source.sweep_power_low = pw
self.source.sweep_run = 0
time.sleep(5)
self.source.output = 1
self.source.sweep_run = 1
time_0 = self.vna.day * 3600 * 24 + self.vna.hours * 3600 + self.vna.minutes * 60 + self.vna.seconds
while (int(self.source.sweep_run) != 0):
power = self.vna.marker_Y[chnl].magnitude
frequency = self.source.frequency.magnitude
time_now = self.vna.day * 3600 * 24 + self.vna.hours * 3600 + self.vna.minutes * 60 + self.vna.seconds
delta_time = time_now - time_0
self.freqs.append(frequency)
self.powers.append(power)
with open(
'D:/MW data/test/20191008/JTWPA/frequency sweep/scan_5/{}.txt'
.format(name), 'a') as file:
write_str = '%f %f\n' % (frequency, power)
file.write(write_str)
self.vna.save_csv('D:/20191008/{}.csv'.format(delta_time))
#self.vna.save_csv_second('D:/MW data/test/20190813/JTWPA/scan_1/phase/{}.csv'.format(delta_time))
time.sleep(t)
return
def set(self):
self.dataset.clear()
log_to_screen(DEBUG)
freq_params = self.Frequency_Settings.widget.get()
# amp_params = self.Frequency_Settings.widget.get()
span = freq_params['frequency span']
center = freq_params['center freq']
# ref = amp_params['ref level']
self.spa.freq_span = span
self.spa.freq_cent = center
# self.spa.ref_level = ref
#self.spa.freq_star = start
print('set frequency span to {}'.format(span))
print('set center frequency to {}'.format(center))
def sweep_power_frequency(self):
self.dataset.clear()
log_to_screen(DEBUG)
sweep_pw_fr_params = self.Sweep_Power_and_Frequency_Settings.widget.get(
)
mk_freq = sweep_pw_fr_params['marker frequency']
p_low = sweep_pw_fr_params['start power']
p_high = sweep_pw_fr_params['stop power']
p_stp = sweep_pw_fr_params['step power']
fr_low = sweep_pw_fr_params['start frequency']
fr_high = sweep_pw_fr_params['stop frequency']
fr_stp = sweep_pw_fr_params['step frequency']
stp_t = sweep_pw_fr_params['step time']
name = sweep_pw_fr_params['txt name']
t = sweep_pw_fr_params['sleep time']
chnl = sweep_pw_fr_params['marker channel']
self.vna.marker[chnl] = 'ON'
self.vna.marker_X[chnl] = mk_freq
self.source.sweep_lower = fr_low
self.source.sweep_upper = fr_high
self.source.sweep_size = fr_stp
self.source.sweep_step_time = stp_t
self.source.Trigger_Setting = 0
self.source.output = 1
pw_count = (p_high - p_low) / p_stp
self.source.sweep_run = 0
time.sleep(5)
for pw_point in range(int(pw_count)):
pw_current_value = p_low + pw_point * p_stp
self.source.sweep_power_low = pw_current_value
self.source.sweep_power_high = pw_current_value
self.source.sweep_run = 1
while (int(self.source.sweep_run) != 0):
#self.vna.marker_peak_search[chnl]
S = self.vna.marker_Y[chnl].magnitude
frequency = self.source.frequency.magnitude
power = float(self.source.power)
with open(
'D:/MW data/test/20191008/JTWPA/scan_1/freq and pw/{}.txt'
.format(name), 'a') as file:
write_str = '%f %f %f\n' % (frequency, power, S)
file.write(write_str)
time.sleep(t)
return
def set_source_freq(self):
self.dataset.clear()
log_to_screen(DEBUG)
source_freq_params = self.Source_Frequency_Settings.widget.get()
stat = source_freq_params['output state']
pw = source_freq_params['power']
freq = source_freq_params['frequency']
run = source_freq_params['sweep state']
self.source.output=stat
self.source.frequency=freq
self.source.power = pw
self.source.sweep_run = run
print('Setting frequency done!')
def main():
import logging
import sys
from lantz.log import log_to_screen
log_to_screen(logging.CRITICAL)
res_name = sys.argv[1]
with BK9129b(res_name) as inst:
print(inst.idn)
inst.remote()
inst.channel = 2
print(inst.channel)
print(inst.current[1])
print(inst.voltage[1])
inst.state = True
print(inst.state)
inst.voltage_limit = 1.23
print(inst.voltage_limit)
def sweep_power(self):
self.dataset.clear()
log_to_screen(DEBUG)
sweep_pw_params = self.Sweep_power_Settings.widget.get()
freq = sweep_pw_params['sweep frequency']
mk_freq = sweep_pw_params['marker frequency']
pw_low = sweep_pw_params['start power']
pw_high = sweep_pw_params['stop power']
pw_stp = sweep_pw_params['step power']
name = sweep_pw_params['txt name']
t = sweep_pw_params['sleep time']
chnl = sweep_pw_params['marker channel']
self.vna.marker[chnl] = 'ON'
self.vna.marker_X[chnl] = mk_freq
self.source.frequency = freq
self.source.output = 1
self.source.Trigger_Setting = 0
time_0 = self.vna.day * 3600 * 24 + self.vna.hours * 3600 + self.vna.minutes * 60 + self.vna.seconds
pw_count = int((pw_high - pw_low) / pw_stp)
for p in range(0, pw_count):
self.source.power = pw_low + p * pw_stp
amplitude = self.vna.marker_Y[chnl].magnitude
frequency = self.source.frequency.magnitude
time_now = self.vna.day * 3600 * 24 + self.vna.hours * 3600 + self.vna.minutes * 60 + self.vna.seconds
delta_time = time_now - time_0
with open(
'D:/MW data/test/20191008/JTWPA/power sweep/scan4/{}.txt'.
format(name), 'a') as file:
write_str = '%f %f %s\n' % (frequency, amplitude,
self.source.power)
file.write(write_str)
self.vna.save_csv('D:/20191008/{}.csv'.format(delta_time))
#self.vna.save_csv_second('D:/MW data/test/20190813/JTWPA/scan_1/phase/{}.csv'.format(delta_time))
time.sleep(t)
return
def main():
import logging
import sys
from lantz.log import log_to_screen
log_to_screen(logging.CRITICAL)
res_name = sys.argv[1]
fmt_str = "{:<20}|{:>20}"
axis = 1
with Agilis(res_name) as inst:
inst.channel = 1
print(fmt_str.format("Device version", inst.version))
print(fmt_str.format("Current channel", inst.channel))
amplitudes = inst.step_amplitude[axis]
print(fmt_str.format("- Step amplitude", amplitudes[0]))
print(fmt_str.format("+ Step amplitude", amplitudes[1]))
print(inst.calibrate(1))
print(inst.calibrate(2))
inst.channel = 2
print(inst.calibrate(1))
print(inst.calibrate(2))
def sweep_frequency(self):
self.dataset.clear()
log_to_screen(DEBUG)
sweep_frequency_params = self.Sweep_frequency_Settings.widget.get()
chnl = sweep_frequency_params['marker channel']
mk_freq = sweep_frequency_params['marker frequency']
fr_low = sweep_frequency_params['start frequency']
fr_high = sweep_frequency_params['stop frequency']
fr_stp = sweep_frequency_params['step']
t_stp = sweep_frequency_params['step time']
pw = sweep_frequency_params['sweep power']
name = sweep_frequency_params['txt name']
self.vna.marker[chnl] = 'ON'
self.vna.marker_X[chnl] = mk_freq
self.source.sweep_lower=fr_low
self.source.sweep_upper=fr_high
self.source.sweep_size=fr_stp
self.source.sweep_step_time=t_stp
self.source.power=pw
self.source.output=1
self.source.sweep_run=1
while(int(self.source.sweep_run)!=0):
power=self.vna.marker_Y[chnl].magnitude
frequency=self.source.frequency.magnitude
self.freqs.append(frequency)
self.powers.append(power)
values = {
'x': np.asarray(self.freqs),
'y': np.asarray(self.powers),
}
self.startpulse.acquire(values)
# with open('D:/MW data/test/20190808/frequency sweep/{}.txt'.format(name),'a') as file:
# write_str='%f %f\n'%(frequency,power)
# file.write(write_str)
return
def set(self):
self.dataset.clear()
log_to_screen(DEBUG)
freq_params = self.Frequency_Settings.widget.get()
# amp_params = self.Frequency_Settings.widget.get()
span = freq_params['frequency span']
center = freq_params['center freq']
# ref = amp_params['ref level']
# span=3000000
# center=5000000
self.spa.freq_span = span
self.spa.freq_cent = center
# self.spa.ref_level = ref
# self.spa.freq_star = start
# span=1e6
# self.spa.freq_span = span
# freqstart=4e9+span/2
# freqstop=7e9-span/2
# nstep=(freqstop-freqstart)/span+1
# print("number of steps are {}".format(nstep))
# print('the loop')
# for x in range(0,3000):
# try:
# self.spa.freq_cent = freqstart+x*span
# except:
# print('failed')
# Need to figure out why doesn't the for loop work with number as arguments
# print('set frequency span to {}'.format(span))
# print('set center frequency to {}'.format(center))
print('done!')
for x in range(1, 20):
self.spa.savefile(x)
time.sleep(30)
def main():
import logging
import sys
from lantz.log import log_to_screen
log_to_screen(logging.CRITICAL)
res_name = sys.argv[1]
with XPSQ8(res_name) as inst:
value = inst._xps.GroupJogParametersGet(inst._socket_id, 'Group1.Pos',
1)
ret = inst._xps.GroupJogParametersSet(inst._socket_id, 'Group2.Pos', [
-0.0,
], [
1.0,
])
print(ret)
value = inst._xps.GroupJogParametersGet(inst._socket_id, 'Group2.Pos',
1)
print(value)
return
positions = np.linspace(-12.5, 12.5, 20)
for val in positions:
print(val)
inst.abs_position['Group1.Pos'] = val
print(inst.abs_position['Group1.Pos'])
@Feat
def voltage(self):
return self.query('VSET1?')
def set_voltage(self, value):
self.write('VSET1:{}'.format(value))
def set_output(self, value):
self.write('OUT{}'.format(value))
if __name__ == '__main__':
from time import sleep
from lantz import Q_
from lantz.log import log_to_screen, DEBUG
log_to_screen(DEBUG)
with GPD3303S('ASRL22::INSTR') as inst:
print('The identification of this instrument is:' + inst.idn)
print('The voltage of this instrument is:' + inst.voltage)
inst.set_voltage(12)
print('The voltage of this instrument is:' + inst.voltage)
inst.set_output(1)
sleep(2)
inst.set_output(0)
def initialize(self):
log_to_screen(DEBUG)
print('initializing move...')
self.attocube = ANC350()
self.attocube.initialize()
return
parser = argparse.ArgumentParser()
parser.add_argument('--debug', help='Send debug output to screen',
action='store_true')
args = parser.parse_args()
from lantz.log import LOGGER, DEBUG
LOGGER.setLevel(DEBUG)
import logging
fh = logging.FileHandler('esp300.log', mode='w')
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
fh.setLevel(DEBUG)
LOGGER.addHandler(fh)
if args.debug:
from lantz.log import log_to_screen
log_to_screen(DEBUG)
from lantz import Q_
from time import sleep
with ESP300('GPIB0::3::INSTR') as inst:
for axis in inst.axes:
print('Axis {:d}'.format(axis))
print('ID: ' + inst.ID[axis])
print('Position: {:f}'.format(inst.position[axis]))
print('Target Position: {:f}'.format(inst.target_position[axis]))
print('Velocity: {:f}'.format(inst.velocity[axis]))
print('Target Velocity: {:f}'.format(inst.target_velocity[axis]))
print('Position: {:f}'.format(inst.position[1]))
print('Moving 1um')
inst.maximum_velocity[1] = Q_(400,'um/s')
inst.target_velocity[1] = Q_(200,'um/s')
# 1. LD OFF
self.ld_state = 0
# 2. Wait
while (abs(self.ld_current.m) > current_error.m):
pass
# 1. TEC OFF
self.tec_state = 0
if __name__ == '__main__':
import logging
import sys
from lantz.log import log_to_screen
log_to_screen(logging.CRITICAL)
#res_name = sys.argv[1]
res_names = [
'USB0::0x1313::0x804F::SERIALNUMBER::INSTR',
'USB0::0x1313::0x804F::SERIALNUMBER::INSTR'
]
print('update res_names!')
fmt_str = "{:<30}|{:>30}"
on_time = 20
for resource in res_names:
with CLD101XLP(resource) as inst:
def Record_data_time(self):
self.dataset.clear()
log_to_screen(DEBUG)
record_cavity_params = self.Record_cavity_Settings.widget.get()
f_cent = record_cavity_params['center frequency']
f_span = record_cavity_params['span']
t = record_cavity_params['sleep time in second']
stop = record_cavity_params['stop time in second']
name = record_cavity_params['txt name']
v_chnl = 1
l_chnl = 2
r_chnl = 3
time_0 = self.vna.day*3600*24+self.vna.hours*3600+self.vna.minutes*60+self.vna.seconds
#while(self.vna.day*3600*24+self.vna.hours*3600+self.vna.minutes*60+self.vna.seconds-time_0 <= stop):
while(1):
# self.vna.freq_cent = f_cent
# self.vna.freq_span = f_span
self.vna.auto_scale()
self.vna.auto_scale_second()
self.vna.marker[v_chnl] = 'ON'
self.vna.marker[l_chnl] = 'ON'
self.vna.marker[r_chnl] = 'ON'
self.vna.marker_second[v_chnl] = 'ON'
self.vna.marker_second[l_chnl] = 'ON'
self.vna.marker_second[r_chnl] = 'ON'
self.vna.marker_peak_search[v_chnl]
max_value = self.vna.marker_Y[v_chnl]
A_0 = self.vna.marker_Y[v_chnl].magnitude
self.vna.marker_min_search[v_chnl]
min_value = self.vna.marker_Y[v_chnl]
A_1 = self.vna.marker_Y[v_chnl].magnitude
target = (max_value + min_value)/2
A = A_0 - A_1
portion = 10**((A_1 - A_0)/20)
self.vna.target_value[l_chnl] = target
self.vna.target_value[r_chnl] = target
self.vna.marker_min_search[l_chnl]
self.vna.marker_target_left_search[l_chnl]
self.vna.marker_min_search[r_chnl]
self.vna.marker_target_right_search[r_chnl]
half = self.vna.marker_X[r_chnl].magnitude - self.vna.marker_X[l_chnl].magnitude
larger = (portion*half + half)/2
smaller = half - larger
time_now = self.vna.day*3600*24+self.vna.hours*3600+self.vna.minutes*60+self.vna.seconds
delta_time = time_now-time_0
power = self.vna.marker_Y[v_chnl].magnitude
frequency = self.vna.marker_X[v_chnl].magnitude
start_field = 240
ramp_rate = 0.2/60
field = start_field + delta_time*ramp_rate
Q = frequency/half
Q_smaller = frequency/larger
Q_larger = frequency/smaller
self.vna.marker_peak_search_second[r_chnl]
self.vna.marker_min_search_second[l_chnl]
L_x = self.vna.marker_X_second[l_chnl].magnitude
L_y = self.vna.marker_Y_second[l_chnl].magnitude
R_x = self.vna.marker_X_second[r_chnl].magnitude
R_y = self.vna.marker_Y_second[r_chnl].magnitude
delta_x = R_x - L_x
delta_y = R_y - L_y
self.vna.marker_X_second[v_chnl]=(L_x+R_x)/2*Hz
self.times.append(delta_time)
self.freqs.append(frequency)
self.Qs.append(Q)
self.Qis.append(Q_smaller)
self.Qes.append(Q_larger)
self.dips.append(A)
values = {
't': self.times,
'f': self.freqs,
'Q': self.Qs,
'Qi': self.Qis,
'Qe': self.Qes,
'dip': self.dips,
}
self.Record_data_time.acquire(values)
with open('D:/MW data/test/20190810/cavity/scan_5/YZscan/scan10/{}.txt'.format(name),'a') as file:
write_str='%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n'%(frequency,power,delta_time,A,half,Q,Q_smaller,Q_larger,L_x,L_y,R_x,R_y,field,delta_x,delta_y)
file.write(write_str)
self.vna.save_csv('D:/MW data/test/20190810/cavity/scan_5/YZscan/scan10/amplitude/{}.csv'.format(field))
self.vna.save_csv_second('D:/MW data/test/20190810/cavity/scan_5/YZscan/scan10/phase/{}.csv'.format(field))
time.sleep(t)
return
