#turn on magnet stepping in Z
#Change mode to step for normal operation
mom.set_mode('Z_axis', 'gnd')
# start: define B-field and position by first ESR measurement
DESR_msmt.darkesr(
'magnet_' + 'Z_axis_' + 'msm1',
ms='msm',
range_MHz=range_fine,
pts=pts_fine,
reps=reps_fine,
freq=(f0m_temp) * 1e9, # - N_hyperfine,
pulse_length=8e-6,
ssbmod_amplitude=0.0015,
mw_switch=False) #0.0025
f0m_temp, u_f0m_temp = dark_esr_auto_analysis.analyze_dark_esr_double()
f0m_temp = f0m_temp # + N_hyperfine*1e-9
delta_f0m_temp = f0m_temp * 1e6 - current_f_msm1 * 1e-3
# start to list all the measured values
iterations = 0
iterations_list.append(iterations)
f0m.append(f0m_temp)
u_f0m.append(u_f0m_temp)
delta_f0m.append(delta_f0m_temp)
d_steps.append(
int(
round(
mt.steps_to_frequency(freq=f0m_temp * 1e9,
freq_id=current_f_msm1,
ms='plus'))))
# Measure B-field
darkesr('magnet_Zpos_optimize_init',
range_MHz=coarse_range,
pts=coarse_pts,
reps=coarse_reps,
power=coarse_amplitude,
MW_power=coarse_MW_power,
pulse_length=coarse_pulse_length)
# Do the fitting, returns in MHz, input in GHz
if only_fine == False:
f0_temp, u_f0_temp = dark_esr_auto_analysis.analyze_dark_esr(
current_f_msm1 * 1e-9,
qt.exp_params['samples'][SAMPLE]['N_HF_frq'] * 1e-9)
else:
f0_temp, u_f0_temp = dark_esr_auto_analysis.analyze_dark_esr_double(
do_plot=True)
delta_f0_temp = -f0_temp * 1e6 + current_f_msm1 * 1e-3 # in kHz
# Magnet start position
Start_position = magnet_Z_scanner.GetPosition()
# List all the measured values
iterations = 0
f0.append(f0_temp)
u_f0.append(u_f0_temp)
delta_f0.append(delta_f0_temp)
magnet_postion_list.append(Start_position)
temperature = (temperature_sensor.get_readlastval() -
100) / 0.385 # better to be here
temperature_list.append(temperature)
def optimize_magnetic_field():
safemode = False # If True then manual confirmation is needed befor each magnet movement
optimization_target = 15 # Target difference frequency in kHz , first (03.08) was 10 then 7 then 10 again
field_gradient = 0.100
only_fine = False
### Settings for the first coarse steps
coarse_range = 7.5 #Common: 10 MHz
coarse_pts = 101 #Common: 121
coarse_reps = 750 #Common: 500
coarse_amplitude = 0.08
coarse_pulse_length = 3e-6
coarse_MW_power = -1
### Settings for the fine steps
fine_range = 0.600
fine_pts = 81
fine_reps = 2000
fine_amplitude = 0.08/3
fine_pulse_length = 9e-6
fine_MW_power = -1
coarse_range = fine_range
coarse_pts = fine_pts
coarse_reps = fine_reps
coarse_pulse_length = fine_pulse_length
coarse_amplitude = fine_amplitude
coarse_MW_power = fine_MW_power
## Run optimizor ##############
GreenAOM.set_power(10e-6)
counters.set_is_running(True)
optimiz0r.optimize(dims=['x','y','z'], int_time=300)
GreenAOM.set_power(10e-6)
counters.set_is_running(True)
optimiz0r.optimize(dims=['x','y','z'], int_time=300)
name = 'SSRO_calib'
ssrocalibration(name)
### SSRO Analysis
ssro_analysis.ssrocalib()
#########################################
f0 = []; u_f0 = []; delta_f0 =[]; iterations_list =[]; magnet_postion_list =[]; fit_failed_list=[]
darkesr('magnet_optimize_init', range_MHz=coarse_range, pts=coarse_pts, reps=coarse_reps,
power= coarse_amplitude, MW_power = coarse_MW_power, pulse_length=coarse_pulse_length)
# Do the fitting, returns in MHz, input in GHz
f0_temp, u_f0_temp = dark_esr_auto_analysis.analyze_dark_esr_double(do_plot=True)
delta_f0_temp = -f0_temp*1e6+current_f_msm1*1e-3 # in kHz
# Magnet start position
Start_position = magnet_Z_scanner.GetPosition()
# List all the measured values
iterations = 0
f0.append(f0_temp)
u_f0.append(u_f0_temp)
delta_f0.append(delta_f0_temp)
magnet_postion_list.append(Start_position)
while abs(delta_f0_temp) > optimization_target:
## Determine new postition
current_position = magnet_Z_scanner.GetPosition()
delta_position = delta_f0_temp/field_gradient*1e-6
move_to_position = current_position + delta_position
print 'Target frequency =' + str(current_f_msm1)
print 'Measured frequency = ' + str(f0_temp) + ' GHz +/- ' + str(u_f0_temp*1e6) + ' kHz'
print 'Difference = ' + str(delta_f0_temp) + ' kHz'
print 'Current magnet position = ' + str(current_position) + ' mm'
print 'Move to position ' + str(move_to_position) + ' mm'
print 'By ' + str(delta_position*1e6) + 'nm'
# if u_f0_temp*1e6 > 15:
# print 'Uncertainty larger than 15 kHz, fit failed'
# fit_failed = 1
# else:
# fit_failed = 0
# fit_failed_list.append(fit_failed)
## Actually move the magnet
if u_f0_temp*1e6 < 15:
## Limit the maximum movement range
if move_to_position < 0.042 or move_to_position > 0.072:
print 'movement is going out of range, abort!!!'
break
print 'Target frequency =' + str(current_f_msm1)
print 'Measured frequency = ' + str(f0_temp) + ' GHz +/- ' + str(u_f0_temp*1e6) + ' kHz'
print 'Difference = ' + str(delta_f0_temp) + ' kHz'
print 'Current magnet position = ' + str(current_position) + ' mm'
print 'Move to position ' + str(move_to_position) + ' mm'
print 'By ' + str((move_to_position-current_position)*1e6) + 'nm'
if safemode == True:
print '\a\a\a'
ri = raw_input ('move magnet? (y/n)')
if str(ri) != 'y':
break
## Actually move the magnet
magnet_Z_scanner.MoveRelative(delta_position)
print 'moving magnet...'
else:
print 'Uncertainty larger than 15 kHz, fit failed'
break
print '--------------------------------'
print 'press q to stop measurement loop'
print '--------------------------------'
qt.msleep(2)
if (msvcrt.kbhit() and (msvcrt.getch() == 'q')) or abs(move_to_position-current_position) < 0.000025:
break
darkesr('magnet_optimize_step_' + str(iterations), range_MHz=fine_range, pts=fine_pts, reps=fine_reps,
power = fine_amplitude, MW_power = fine_MW_power, pulse_length=fine_pulse_length)
f0_temp, u_f0_temp = dark_esr_auto_analysis.analyze_dark_esr_double(do_plot=True)
delta_f0_temp = -f0_temp*1e6+current_f_msm1*1e-3
iterations += 1
def fit_B_msmt_loop(older_than=None, newer_than=None):
f0m = []
u_f0m = []
#f0p = [] ;u_f0p = []
# Bx_field_measured = []
# Bz_field_measured = []
# f_centre_list = []; f_diff_list=[]
timestamp_list = []
# f_centre_error_list= []
it_list = []
# f_diff_error_list = []
absolute_time_list = []
temperature_list = []
magnet_position_list = []
#msm
print 'start'
older_than_SSRO = older_than
print older_than, newer_than
iteration = 0
while toolbox.latest_data(contains='magnet_scanner_calib_fine',
older_than=older_than,
newer_than=newer_than,
raise_exc=False) != False:
print 'ITERATION ' + str(iteration)
## Find the data folder
### This was needed for some of the meaurements where both a fine and a coarse measurement was done, THT 160725
# timestamp,folder = toolbox.latest_data(contains='magnet_msm1_coarse', older_than=older_than, newer_than=newer_than,return_timestamp = True)
# older_than = str(int(timestamp)-1)
timestamp, folder = toolbox.latest_data(
contains='magnet_scanner_calib_fine',
older_than=older_than,
newer_than=newer_than,
return_timestamp=True)
print 'm folder ' + folder
## Load the data ##
ssro_calib_folder = toolbox.latest_data(
contains='AdwinSSRO_SSROCalibration', older_than=older_than_SSRO)
a = sequence.SequenceAnalysis(folder)
a.get_sweep_pts()
a.get_readout_results('ssro')
a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder)
f0m_temp, u_f0m_temp = dark_esr_auto_analysis.analyze_dark_esr_double(
do_plot=True, add_folder=folder)
# #msp
# folder = toolbox.latest_data(contains='msmt_msp_', older_than=older_than, newer_than=newer_than,)
# print folder
# a = sequence.SequenceAnalysis(folder)
# a.get_sweep_pts()
# a.get_readout_results('ssro')
# a.get_electron_ROC(ssro_calib_folder=ssro_calib_folder)
# f0p_temp,u_f0p_temp = dark_esr_auto_analysis.analyze_dark_esr(None, 2.196*1e-3, add_folder = folder )
# print f0p_temp >0 and f0m_temp >0
# if f0p_temp >0 and f0m_temp >0:
# Bz_measured, Bx_measured = amt.get_B_field(msm1_freq=f0m_temp*1e9, msp1_freq=f0p_temp*1e9, u_msm1_freq =u_f0m_temp ,u_msp1_freq=u_f0p_temp)
# f_centre = (f0m_temp+f0p_temp)/2
# f_centre_error = np.sqrt(u_f0m_temp**2+u_f0p_temp**2)/2
# f_diff = (f_centre-ZFS*1e-9)*1e6
# f_diff_error = f_centre_error*1e6
f0m.append(f0m_temp)
u_f0m.append(u_f0m_temp)
# f0p.append(f0p_temp)
# u_f0p.append(u_f0p_temp)
# f_centre_list.append(f_centre)
# f_centre_error_list.append(f_centre_error)
# f_diff_list.append(f_diff)
# f_diff_error_list.append(f_diff_error)
# Bx_field_measured.append(Bx_measured)
# Bz_field_measured.append(Bz_measured)
timestamp_list.append(timestamp)
it_list.append(iteration)
### Get the temperature data
temperature = (a.g.attrs['temp'] - 100) / 0.385
temperature_list.append(temperature)
magnet_position = (a.g.attrs['magnet_position'])
magnet_position_list.append(magnet_position)
absolute_time = int(timestamp[-2:]) + int(timestamp[-4:-2]) * 60 + int(
timestamp[-6:-4]) * 60**2 + int(timestamp[6:8]) * (60**2) * 24
absolute_time_list.append(absolute_time)
older_than = str(int(timestamp) - 1)
print 'older than: ' + older_than
iteration = iteration + 1
it_list = np.linspace(0, len(it_list) - 1, len(it_list))
outfile = TemporaryFile()
np.savez(
'test_B_field_meas',
f0m=f0m,
u_f0m=u_f0m,
# f0p=f0p,
# u_f0p=u_f0p,
# f_centre_list=f_centre_list,
# f_centre_error_list=f_centre_error_list,
# f_diff_list=f_diff_list,
# f_diff_error_list=f_diff_error_list,
# Bx_field_measured=Bx_field_measured,
# Bz_field_measured=Bz_field_measured,
timestamp_list=timestamp_list,
absolute_time_list=absolute_time_list,
it_list=it_list,
temperature_list=temperature_list,
magnet_position_list=magnet_position_list)
from analysis.lib.fitting import fit,esr
ZFS = 2.877623
f0m = []; u_f0m = [];
f0p = []; u_f0p = [];
f_centre = []
f_diff = []
timestamp = '20141220_140000'
k_list = np.linspace(0,20,21)
for k in range(len(k_list)):
timestamp, folder = toolbox.latest_data('PulsarDarkESR_magnet_msm1', older_than = timestamp, return_timestamp = True)
print folder
f0m_temp, u_f0m_temp = dark_esr_auto_analysis.analyze_dark_esr_double(timestamp = timestamp)
timestamp, folder = toolbox.latest_data('PulsarDarkESR_magnet_msp1', older_than = timestamp, return_timestamp = True)
f0p_temp, u_f0p_temp = dark_esr_auto_analysis.analyze_dark_esr_double(timestamp = timestamp)
f_centre_temp = (f0m_temp+f0p_temp)/2
f_diff_temp = (f_centre_temp-ZFS)*1e6
print timestamp
f0m.append(f0m_temp)
u_f0m.append(u_f0m_temp)
f0p.append(f0p_temp)
u_f0p.append(u_f0p_temp)
f_centre.append(f_centre_temp)
f_diff.append(f_diff_temp)
def auto_z_magnet_optimize():
######################
## Input parameters ##
######################
safemode = False
maximum_magnet_step_size = 50
opimization_target = 10 # target difference in kHz (or when 0 magnet steps are required)
### for the remainder of the steps
range_fine = 0.4
pts_fine = 51
reps_fine = 100
###########
## Start ##
###########
#create the data lists
d_steps = [0]
f0 = [0]
u_f0 = [0]
delta_f0 = [0]
iterations_list = [0]
#turn on magnet stepping in Z
mom.set_mode('Z_axis', 'stp')
# start: define B-field and position by first ESR measurement
DESR_msmt.darkesr(
'magnet_' + 'Z_axis_' + 'msm1',
ms='msm',
range_MHz=range_fine,
pts=pts_fine,
reps=reps_fine,
freq=f0_temp * 1e9, # - N_hyperfine,
pulse_length=8e-6,
ssbmod_amplitude=0.0025)
f0_temp, u_f0_temp = dark_esr_auto_analysis.analyze_dark_esr_double(
do_ROC=False, do_plot=False)
f0_temp = f0_temp # + N_hyperfine*1e-9
delta_f0_temp = f0_temp * 1e6 - current_f_msm1 * 1e-3
# start to list all the measured values
iterations = 0
iterations_list.append(iterations)
f0.append(f0_temp)
u_f0.append(u_f0_temp)
delta_f0.append(delta_f0_temp)
d_steps.append(
int(
round(
mt.steps_to_frequency(freq=f0_temp * 1e9,
freq_id=current_f_msm1,
ms='plus'))))
print 'Measured frequency = ' + str(f0_temp) + ' GHz +/- ' + str(
u_f0_temp * 1e6) + ' kHz'
print 'Difference = ' + str(delta_f0_temp) + ' kHz'
while abs(delta_f0_temp) > opimization_target:
iterations += 1
print 'move magnet in Z with ' + str(d_steps[iterations]) + ' steps'
if abs(d_steps[iterations]) > maximum_magnet_step_size:
print 'd_steps>+/-00, step only 50 steps!'
if d_steps[iterations] > 0:
d_steps[iterations] = maximum_magnet_step_size
if d_steps[iterations] < 0:
d_steps[iterations] = -1 * maximum_magnet_step_size
elif d_steps[iterations] == 0:
print 'Steps = 0 optimization converted'
break
if safemode == True:
ri = raw_input('move magnet? (y/n)')
if str(ri) == 'y':
mom.step('Z_axis', d_steps[iterations])
else:
break
else:
mom.step('Z_axis', d_steps[iterations])
DESR_msmt.darkesr(
'fine_optimize_magnet_' + 'Z_axis_' + 'msm1',
ms='msm',
range_MHz=range_fine,
pts=pts_fine,
reps=reps_fine,
freq=f0_temp * 1e9, # - N_hyperfine,
pulse_length=8e-6,
ssbmod_amplitude=0.0025)
f0_temp, u_f0_temp, folder = dark_esr_auto_analysis.analyze_dark_esr_double(
do_ROC=False, ret_folder=True, do_plot=False)
f0_temp = f0_temp # + N_hyperfine*1e-9
delta_f0_temp = f0_temp * 1e6 - current_f_msm1 * 1e-3
d_steps.append(
int(
round(
mt.steps_to_frequency(freq=f0_temp * 1e9,
freq_id=current_f_msm1,
ms='plus'))))
f0.append(f0_temp)
u_f0.append(u_f0_temp)
delta_f0.append(delta_f0_temp)
print 'Measured frequency = ' + str(f0_temp) + ' GHz +/- ' + str(
u_f0_temp * 1e6) + ' kHz'
print 'Difference = ' + str(f0_temp * 1e6 -
current_f_msm1 * 1e-3) + ' kHz'
iterations_list.append(iterations)
total_d_steps = np.sum(d_steps)
#create a file to save data to --> what is a good way to save this?
d = qt.Data(name='magnet_auto_Z_optimization_overview')
d.add_coordinate('iteration')
d.add_value('frequency [GHz]')
d.add_value('frequency error [GHz]')
d.add_value('frequency difference [GHz]')
d.add_value('number of steps')
d.create_file()
filename = d.get_filepath()[:-4]
print iterations_list
print f0
print u_f0
print delta_f0
print d_steps
d.add_data_point(iterations_list, f0, u_f0, delta_f0, d_steps)
d.close_file()
print 'Z position fine optimization finished, stepped the magnet ' + str(
total_d_steps) + ' in ' + str(iterations + 1) + ' iterations'
qt.msleep(1)
stools.turn_off_all_lt2_lasers()
GreenAOM.set_power(20e-6)
optimiz0r.optimize(dims=['x', 'y', 'z'])
darkesr(SAMPLE_CFG,
range_MHz=repeat_range,
pts=repeat_pts,
reps=repeat_reps,
power=repeat_power,
pulse_length=repeat_pulse_length)
#Determine frequency and B-field --> this fit programme returns in MHz, needs input GHz
f0_temp, u_f0_temp = dark_esr_auto_analysis.analyze_dark_esr_double(
current_f_msm1 * 1e-9,
qt.exp_params['samples'][SAMPLE]['N_HF_frq'] * 1e-9)
delta_f0_temp = f0_temp * 1e6 - current_f_msm1 * 1e-3
f0.append(f0_temp)
u_f0.append(u_f0_temp)
delta_f0.append(delta_f0_temp)
iterations_list.append(iterations)
print 'Measured frequency = ' + str(f0_temp) + ' GHz +/- ' + str(
u_f0_temp * 1e6) + ' kHz'
print 'Difference = ' + str(f0_temp * 1e6 -
current_f_msm1 * 1e-3) + ' kHz'
# To cleanly exit the optimization
print '--------------------------------'
break
#ms=-1 fine
DESR_msmt.darkesr(
'magnet_' + 'msm1',
ms='msm',
range_MHz=range_fine,
pts=pts_fine,
reps=reps_fine,
freq=f0m_temp * 1e9, # - N_hyperfine,
pulse_length=9e-6,
ssbmod_amplitude=0.08 / 3,
mw_power=-1,
mw_switch=True)
f0m_temp, u_f0m_temp = dark_esr_auto_analysis.analyze_dark_esr_double(
do_plot=save_plots)
f0m_temp = f0m_temp # + N_hyperfine*1e-9
#ms=+1 fine
DESR_msmt.darkesr(
'magnet_' + 'msp1',
ms='msp',
range_MHz=range_fine,
pts=pts_fine,
reps=reps_fine,
freq=f0p_temp * 1e9, # + N_hyperfine,
pulse_length=9e-6,
ssbmod_amplitude=0.08 / 3,
mw_power=-1,
mw_switch=True)