def setInitHall(init_hall=0):
b0_hall = GetHall(dipole_pair[0])
b1_hall = GetHall(dipole_pair[1])
overshoot_margin = 0.001
print("Beginning initializing dipoles...")
while ((b0_hall - init_hall) < overshoot_margin
or (b1_hall - init_hall) < overshoot_margin):
diff = max(abs(b0_hall - init_hall), abs(b1_hall - init_hall))
b0_i = GetMagnet(dipole_pair[0])
dI = 0.02
if (diff >= 0.001):
dI = 0.1
elif (diff > 0.00005):
dI = 0.01
# change b0 and compare
SetMagnet(dipole_pair[0], b0_i + dI)
#saving the new actual hall value
sleep(3)
b0_hall = GetHall(dipole_pair[0])
SetMagnet(dipole_pair[1], b0_i + dI)
b1_hall = GetHall(dipole_pair[1])
print(f"Fields: {b0_hall:.6f}, {b1_hall:.6f}")
time1 = CycleMagnet(dipole_pair[0])
time2 = CycleMagnet(dipole_pair[1])
sleep(np.max([time1, time2]) + 30)
cont = input("Once magnets have settled, enter 'y' to continue...")
if (cont != 'y'):
print("Exiting...")
exit()
print("Magnets cycled above initial Hall values.")
while (abs(b0_hall - init_hall) > dHall):
diff = abs(b0_hall - init_hall)
dI = 0.02
#this takes too long if they're really far so I'm gona add this for now
if (diff >= 0.001):
dI = 0.1
elif (diff > 0.00005):
dI = 0.01
b0_i = GetMagnet(dipole_pair[0])
if (b0_hall > init_hall):
# change b0 and compare
SetMagnet(dipole_pair[0], b0_i - dI)
#saving the new actual hall value
sleep(3)
b0_hall = GetHall(dipole_pair[0])
print("B0 set to initial value.")
matchHall()
def matchNMR():
''' Matches the NMR fields by lowering the highest current between B1 and B2 slowly until criteria is met '''
print("Getting the starting NMR probe values...")
#saving the new actual nmr value
#b1
caput(set_probe, b1_probe)
sleep(13)
b1_nmr_h = caget(tlm_reading)
#b2
caput(set_probe, b2_probe)
sleep(13)
b2_nmr_h = caget(tlm_reading)
#using the nmr readback and the i_cset, slowly ramp down as you check that the nmrs are close
dNMR = 0.00001
print("Beginning matching...")
while (abs(b1_nmr_h - b2_nmr_h) > dNMR):
diff = abs(b1_nmr_h - b2_nmr_h)
dI = 0.001
#this takes too long if they're really far so I'm gona add this for now
if (diff >= 0.001):
dI = 0.1
elif (diff > 0.00005):
dI = 0.02 # Changed from 0.01 since this is sometimes the difference between set and RD
b1_i = GetMagnet('b1')
b2_i = GetMagnet('b2')
if (b1_nmr_h > b2_nmr_h):
caput(set_probe, b1_probe)
#decrease b1_nmr_h in small steps until it is dNMR off from b2
# change b1 and compare
SetMagnet('b1', b1_i - dI)
#saving the new actual nmr value
sleep(3)
b1_nmr_h = caget(tlm_reading)
elif (b1_nmr_h < b2_nmr_h):
#go in opposite direction
caput(set_probe, b2_probe)
# change b2 and compare
SetMagnet('b2', b2_i - dI)
#saving the new actual nmr value
sleep(3)
b2_nmr_h = caget(tlm_reading)
print(
f"Fields: {b1_nmr_h:.6f}, {b2_nmr_h:.6f}, dNMR: {((b1_nmr_h - b2_nmr_h)/b1_nmr_h*100):.5f}%"
)
print("Done matching NMR values.")
def matchHall():
b0_hall = GetHall(dipole_pair[0])
b1_hall = GetHall(dipole_pair[1])
print("Beginning matching...")
while (abs(b0_hall - b1_hall) > dHall):
diff = abs(b0_hall - b1_hall)
dI = 0.02
'''
#this takes too long if they're really far so I'm gona add this for now
if (diff >= 0.001):
dI = 0.1
elif (diff > 0.00005):
dI = 0.01
'''
b0_i = GetMagnet(dipole_pair[0])
b1_i = GetMagnet(dipole_pair[1])
if (b0_hall > b1_hall):
# change b0 and compare
SetMagnet(dipole_pair[0], b0_i - dI)
#saving the new actual hall value
sleep(3)
b0_hall = GetHall(dipole_pair[0])
elif (b0_hall < b1_hall):
# change b1 and compare
SetMagnet(dipole_pair[1], b1_i - dI)
#saving the new actual hall value
sleep(3)
b1_hall = GetHall(dipole_pair[1])
print(
f"Fields: {b0_hall:.6f}, {b1_hall:.6f}, dHall: {((b0_hall - b1_hall)/b0_hall*100):.5f}%"
)
print("Done matching Hall values.")
'type': 'continuous',
'domain': (-5, 5)
}, {
'name': 'v31',
'type': 'continuous',
'domain': (-5, 5)
}]
space = Design_space(spaceArray)
np.set_printoptions(precision=2)
count_iter = 0
#list for corrector magnet values
magnet_values = [0 for i in range(len(magnet_list))]
#initial nominal quad values
q0_init, q1_init = GetMagnet(quad_pair[0]), GetMagnet(quad_pair[1])
while (cont == 'y'):
if sandbox != 'y':
#import current state
#Get initial quad values
#~ q1_init, q2_init, q3_init, q4_init= GetQuads()
#Tuning Q14 and Q15
#take picture with all at init values
#~ SetQuads(q1_init, q2_init, q3_init, q4_init)
sleep(3)
all_nom_im = SaveIm('allNom', viewer)
sleep(2)
def scanDipoles(b_small, b_big):
#set number of steps (from previous experience scanning although might need adjustments)
bs_stepsize = small_step
bb_stepsize = big_step
#initial nominal quad values
q0_init, q1_init = GetMagnet(quad_pair[0]), GetMagnet(quad_pair[1])
#q2_init = GetMagnet("q11")
for i in range(total_steps):
print(f"Step {i+1} out of {total_steps} large steps.")
#get initial current of dipoles
bs_init = GetMagnet(b_small)
bb_init = GetMagnet(b_big)
for j in range(0,
int(bb_stepsize / bs_stepsize) + extra_small_step
): ## ADDED TWO MORE STEPS FOR THE FIELDS TO OVERLAP
#changing quads and taking pictures at 4 tunes
#take picture with all at init values
all_nom_im = SaveIm('allNom', viewer)
#take picture with q11 nom, q12 7/6
# SetMagnet(quad_pair[0], q0_init)
SetMagnet(quad_pair[0], 40)
SetMagnet(quad_pair[1], q1_init)
#SetMagnet("q11", q2_init)
pos_1 = GetBeamPos(all_nom_im, viewer)
sleep(
5
) #might need to increase this if the jumps in current are big
all_zero_im = SaveIm('Q11_40', viewer)
#take picture with q11 8/10 and q12 nom
SetMagnet(quad_pair[0], q0_init)
# SetMagnet(quad_pair[1], q1_init-17)
SetMagnet(quad_pair[1], 20)
#SetMagnet("q11", q2_init)
pos_2 = GetBeamPos(all_zero_im, viewer)
sleep(5)
q0_half_im = SaveIm('Q13_20', viewer)
#take picture with q11 *3/4, and q12 *11/12
SetMagnet(quad_pair[0], 52)
SetMagnet(quad_pair[1], 35)
#SetMagnet("q11", 40)
pos_3 = GetBeamPos(q0_half_im, viewer)
sleep(5)
q01_half_im = SaveIm('Q11_52_Q13_35', viewer)
#return quads to original values
SetMagnet(quad_pair[0], q0_init)
SetMagnet(quad_pair[1], q1_init)
#SetMagnet("q11", q2_init)
pos_4 = GetBeamPos(q01_half_im, viewer)
#peak/intensity
#pk_1 = pos_1[2:]
#pk_2 = pos_2[2:]
#pk_3 = pos_3[2:]
#pk_4 = pos_4[2:]
#centroid positions
pos_1 = pos_1[0:2]
pos_2 = pos_2[0:2]
pos_3 = pos_3[0:2]
pos_4 = pos_4[0:2]
#get quadratic distance from centroids
print(
f"Centroids:\n({pos_1[0]:.2f}, {pos_1[1]:.2f})\n({pos_2[0]:.2f}, {pos_2[1]:.2f})\n({pos_3[0]:.2f}, {pos_3[1]:.2f})\n({pos_4[0]:.2f}, {pos_4[1]:.2f})"
)
distance = Dist(pos_1, pos_2, pos_3, pos_4, True)[0]
print(f"Dist= {distance:.5f}")
bs_hall = GetHall(b_small)
bb_hall = GetHall(b_big)
bs_i = GetMagnet(b_small)
bb_i = GetMagnet(b_big)
#save i, hall values and distance to file
f = open(f"{b_small}_{b_big}_Distance_{timestring}.txt", "a+")
f.write(
f'{bs_i:.3f}\t{bb_i:.3f}\t{bs_hall:.7f}\t{bb_hall:.7f}\t{distance:.4f}\t{pos_1[0]:.4f}\t{all_nom_im}\n'
)
f.close()
#ramps down this magnet in small steps multiple of the large step
SetMagnet(b_small, bs_init - bs_stepsize * (j + 1))
#one magnet goes down 0.06 A, the other 0.02 A x 3
#SetMagnet( b_big, bb_init - bb_stepsize)
#####################
#if (abs(bs_hall - bb_hall) > dHall):
#if they are different, match again
matchHall()
#else:
bs_hall = GetHall(b_small)
bb_hall = GetHall(b_big)
print(
f"Fields: {bs_hall:.6f}, {bb_hall:.6f}, dHall: {((bs_hall - bb_hall)/bs_hall*100):.5f}%"
)
print("Done cycling.")
cont= input("Once magnets have settled, enter 'y' to continue...")
if (cont != 'y'):
print("Exiting...")
exit()
'''
#match Hall probe readings
matchHall()
#init_hall= float(input("What should the initial Hall value be?"))
#setInitHall(init_hall)
#get initial values to return two for second scan
b0_init = GetMagnet(dipole_pair[0])
b1_init = GetMagnet(dipole_pair[1])
scanDipoles(dipole_pair[0], dipole_pair[1])
print(f"Done with {dipole_pair[0]} scan.")
#reset dipoles to original currents and cycle
SetMagnet(dipole_pair[0], b0_init)
SetMagnet(dipole_pair[1], b1_init)
#cycle
time1 = CycleMagnet(dipole_pair[0])
time2 = CycleMagnet(dipole_pair[1])
sleep(np.max([time1, time2]))
print("Done cycling.")
def scanDipoles(b_small, b_big):
#set number of steps (from previous experience scanning although might need adjustments)
bs_stepsize = small_step
bb_stepsize = big_step
#initial nominal quad values
q0_init, q1_init = GetMagnet(quad_pair[0]), GetMagnet(quad_pair[1])
for i in range(total_steps):
print(f"Step {i+1} out of {total_steps} large steps.")
#get initial current of dipoles
bs_init = GetMagnet(b_small)
bb_init = GetMagnet(b_big)
#one magnet goes down 0.06 A, the other 0.02 A x 3
SetMagnet( b_big, bb_init - bb_stepsize)
for j in range(0, int(bb_stepsize/bs_stepsize)):
#ramps down this magnet in small steps multiple of the large step
SetMagnet( b_small, bs_init - bs_stepsize*(j+1))
sleep(5)
#changing quads and taking pictures at 4 tunes
#take picture with all at init values
all_nom_im= SaveIm('allNom', viewer)
#take picture with all at zero
SetMagnet(quad_pair[0], 0)
SetMagnet(quad_pair[1], 0)
pos_1= GetBeamPos(all_nom_im, viewer)
sleep(5) #might need to increase this if the jumps in current are big
all_zero_im= SaveIm('allZero', viewer)
#take picture with first quad at half
SetMagnet(quad_pair[0], q0_init/2)
pos_2= GetBeamPos(all_zero_im, viewer)
sleep(5)
q0_half_im= SaveIm('q0half', viewer)
#take picture with second quad at half
SetMagnet(quad_pair[1], q1_init/2)
pos_3= GetBeamPos(q0_half_im, viewer)
sleep(5)
q01_half_im= SaveIm('q01half', viewer)
#return quads to original values
SetMagnet(quad_pair[0], q0_init)
SetMagnet(quad_pair[1], q1_init)
pos_4= GetBeamPos(q01_half_im, viewer)
#peak/intensity
#pk_1 = pos_1[2:]
#pk_2 = pos_2[2:]
#pk_3 = pos_3[2:]
#pk_4 = pos_4[2:]
#centroid positions
pos_1 = pos_1[0:2]
pos_2 = pos_2[0:2]
pos_3 = pos_3[0:2]
pos_4 = pos_4[0:2]
#get quadratic distance from centroids
print(f"Centroids:\n({pos_1[0]:.2f}, {pos_1[1]:.2f})\n({pos_2[0]:.2f}, {pos_2[1]:.2f})\n({pos_3[0]:.2f}, {pos_3[1]:.2f})\n({pos_4[0]:.2f}, {pos_4[1]:.2f})")
distance= Dist(pos_1, pos_2, pos_3, pos_4)
print(f"Dist= {distance:.5f}")
bs_hall = GetHall(b_small)
bb_hall = GetHall(b_big)
bs_i = GetMagnet(b_small)
bb_i = GetMagnet(b_big)
#save i, hall values and distance to file
f= open(f"{b_small}_{b_big}_Distance_{timestring}.txt", "a+")
f.write(f'{bs_i:.3f}\t{bb_i:.3f}\t{bs_hall:.7f}\t{bb_hall:.7f}\t{distance:.4f}\t{pos_1[0]:.4f}\t{all_nom_im}\n')
f.close()
#####################
if (abs(bs_hall - bb_hall) > dHall):
#if they are different, match again
matchHall()
else:
print(f"Fields: {bs_hall:.6f}, {bb_hall:.6f}, dHall: {((bs_hall - bb_hall)/bs_hall*100):.5f}%")
def scanDipoles(b_small, b_big):
#set number of steps (from previous experience scanning although might need adjustments)
bs_stepsize = small_step
bb_stepsize = big_step
#initial nominal quad values
q0_init, q1_init = GetMagnet(quad_pair[0]), GetMagnet(quad_pair[1])
for i in range(total_steps):
print(f"Step {i+1} out of {total_steps} large steps.")
#get initial current of dipoles
bs_init = GetMagnet(b_small)
bb_init = GetMagnet(b_big)
#SetMagnet( b_big, bb_init - bb_stepsize)
SetMagnet(b_small, bs_init - bs_stepsize)
#changing quads and taking pictures at 4 tunes
#take picture with all at init values
all_nom_im = SaveIm('allNom', viewer)
#take picture with q14 nom, q15 *8/11
SetMagnet(quad_pair[0], q0_init)
SetMagnet(quad_pair[1], -15.000)
pos_1 = GetBeamPos(all_nom_im, viewer)
sleep(5) #might need to increase this if the jumps in current are big
all_zero_im = SaveIm('Q15_minus15', viewer)
#take picture with q14 *1/2 and q15 nom
SetMagnet(quad_pair[0], 15.000)
SetMagnet(quad_pair[1], q1_init)
pos_2 = GetBeamPos(all_zero_im, viewer)
sleep(5)
q0_half_im = SaveIm('Q14_15', viewer)
#take picture with q14 zero, and q15 zero
SetMagnet(quad_pair[0], 10.000)
SetMagnet(quad_pair[1], -10.000)
pos_3 = GetBeamPos(q0_half_im, viewer)
sleep(5)
q01_half_im = SaveIm('bothTen', viewer)
#return quads to original values
SetMagnet(quad_pair[0], q0_init)
SetMagnet(quad_pair[1], q1_init)
pos_4 = GetBeamPos(q01_half_im, viewer)
#peak/intensity
#pk_1 = pos_1[2:]
#pk_2 = pos_2[2:]
#pk_3 = pos_3[2:]
#pk_4 = pos_4[2:]
#centroid positions
pos_1 = pos_1[0:2]
pos_2 = pos_2[0:2]
pos_3 = pos_3[0:2]
pos_4 = pos_4[0:2]
#get quadratic distance from centroids
print(
f"Centroids:\n({pos_1[0]:.2f}, {pos_1[1]:.2f})\n({pos_2[0]:.2f}, {pos_2[1]:.2f})\n({pos_3[0]:.2f}, {pos_3[1]:.2f})\n({pos_4[0]:.2f}, {pos_4[1]:.2f})"
)
distance = Dist(pos_1, pos_2, pos_3, pos_4, True)[0]
print(f"Dist= {distance:.5f}")
bs_hall = GetHall(b_small)
bb_hall = GetHall(b_big)
bs_i = GetMagnet(b_small)
bb_i = GetMagnet(b_big)
#save i, hall values and distance to file
f = open(f"{b_small}_{b_big}_Distance_{timestring}.txt", "a+")
f.write(
f'{bs_i:.3f}\t{bb_i:.3f}\t{bs_hall:.7f}\t{bb_hall:.7f}\t{distance:.4f}\t{pos_1[0]:.4f}\t{all_nom_im}\n'
)
f.close()
timestring = (datetime.datetime.now()).strftime("%m-%d_%H_%M")
"""####################################################"""
"""ramp down slowly and analyze steering from Q3 and Q4"""
#go down in small steps and record Dist AND currents (these are reproducible)
#dI = 0.03
dI = 0.01
Dmin = 0
atTune = False
while (atTune == False):
#using the nmr readback and the i_cset, slowly ramp down as you check that the nmrs are close
dNMR = 0.00001
#get Is of dipoles (reproducible)
b1_i = GetMagnet('b1')
b2_i = GetMagnet('b2')
caput(set_probe, b1_probe)
SetMagnet('b1', b1_i - dI)
SetMagnet('b2', b2_i - dI)
sleep(10)
#saving the new actual nmr value
b1_nmr = caget(tlm_reading)
caput(set_probe, b2_probe)
#change b2 and compare
#saving the new actual nmr value
'type': 'continuous',
'domain': (-5, 5)
} for m in magnet_list]
space = Design_space(spaceArray)
np.set_printoptions(precision=2)
#list for corrector magnet values
magnet_values = [0 for i in range(len(magnet_list))]
while (cont == 'y'):
if sandbox != 'y':
#import current state
#Get initial quad values
#~ q1_init, q2_init, q3_init, q4_init= GetQuads()
q6_init = GetMagnet('q6')
q9_init = GetMagnet('q9')
#Tuning Q8 and Q9
#take picture with all at init values
#~ SetQuads(q1_init, q2_init, 0, 0)
#~ sleep(10)
all_nom_im = SaveIm('allNom', viewer)
sleep(2)
#take picture with all at zero
#~ SetQuads(0, 0, 0, 0)
#~ SetMagnet('q8', 0)
#~ SetMagnet('q9', 0)
#~ pos_1= GetBeamPos(all_nom_im, viewer)
#~ sleep(10) #might need to increase this if the jumps in current are big
#getting list of quads to loop through
magnet_list = [x.lstrip().rstrip() for x in quad_list.split(",")]
#magnet_list = ['q1', 'q2', 'q3', 'q4']
timestamp = (datetime.datetime.now()).strftime("%m-%d_%H-%M")
np.set_printoptions(precision=2)
############################
### optimizing quads ###
############################
while (cont == 'y'):
if count == 0:
if sandbox != 'y':
#get inital tune for quads and assign the phase space for each
q_init = {q: GetMagnet(q)
for q in magnet_list} #need this for final scaling
magnet_values = [q_init[q] for q in magnet_list]
q_ps = {
q: [0.85 * q_init[q], 1.15 * q_init[q]]
for q in magnet_list
}
# Creating GP stuff
# Domain is phase space for each corrector magnet in Amps!
spaceArray = [{
'name': q,
'type': 'continuous',
'domain': (q_ps[q][0], q_ps[q][1])
} for q in magnet_list]
space = Design_space(spaceArray)
timestring = (datetime.datetime.now()).strftime("%m-%d_%H_%M")
"""####################################################"""
"""ramp down slowly and analyze steering from Q3 and Q4"""
#go down in small steps and record Dist AND currents (these are reproducible)
#dI = 0.03
dI = 0.01
Dmin = 0
atTune = False
while (atTune == False):
#using the nmr readback and the i_cset, slowly ramp down as you check that the nmrs are close
dNMR = 0.0002
#get Is of dipoles (reproducible)
b1_i = GetMagnet('b1')
b2_i = GetMagnet('b2')
caput(set_probe, b1_probe)
SetMagnet('b1', b1_i - dI)
SetMagnet('b2', b2_i - dI)
sleep(10)
#saving the new actual nmr value
b1_nmr = caget(tlm_reading)
caput(set_probe, b2_probe)
#change b2 and compare
#saving the new actual nmr value
def scanDipoles(b_small, b_big):
#set number of steps (from previous experience scanning although might need adjustments)
bs_stepsize = small_step
bb_stepsize = big_step
#initial nominal quad values
q0_init, q1_init = GetMagnet(quad_pair[0]), GetMagnet(quad_pair[1])
for i in range(total_steps):
print(f"Step {i+1} out of {total_steps} large steps.")
#get initial current of dipoles
bs_init = GetMagnet(b_small)
bb_init = GetMagnet(b_big)
#set NMR teslameter to read B1 probe to save time later
caput(set_probe, b1_probe)
for j in range(0,
int(bb_stepsize / bs_stepsize) +
4): ## ADDED TWO MORE STEPS FOR THE FIELDS TO OVERLAP
#changing quads and taking pictures at 4 tunes
#take picture with all at init values
all_nom_im = SaveIm('allNom', viewer)
#take picture with q8 nom, q9 half
SetMagnet(quad_pair[0], q0_init * 2 / 3)
SetMagnet(quad_pair[1], q1_init)
pos_1 = GetBeamPos(all_nom_im, viewer)
sleep(
5
) #might need to increase this if the jumps in current are big
all_zero_im = SaveIm('Q3_2-3', viewer)
#take picture with q8/2 and q9/2
SetMagnet(quad_pair[0], q0_init)
SetMagnet(quad_pair[1], q1_init * 2 / 3)
pos_2 = GetBeamPos(all_zero_im, viewer)
sleep(5)
q0_half_im = SaveIm('Q4_2-3', viewer)
#take picture with 4/3 q8 and 5/4 q9
SetMagnet(quad_pair[0], q0_init)
SetMagnet(quad_pair[1], -90)
pos_3 = GetBeamPos(q0_half_im, viewer)
sleep(5)
q01_half_im = SaveIm('Q4_neg90', viewer)
#return quads to original values
SetMagnet(quad_pair[0], q0_init)
SetMagnet(quad_pair[1], q1_init)
pos_4 = GetBeamPos(q01_half_im, viewer)
#centroid positions
pos_1 = pos_1[0:2]
pos_2 = pos_2[0:2]
pos_3 = pos_3[0:2]
pos_4 = pos_4[0:2]
#get quadratic distance from centroids
print(
f"Centroids:\n({pos_1[0]:.2f}, {pos_1[1]:.2f})\n({pos_2[0]:.2f}, {pos_2[1]:.2f})\n({pos_3[0]:.2f}, {pos_3[1]:.2f})\n({pos_4[0]:.2f}, {pos_4[1]:.2f})"
)
distance = Dist(pos_1, pos_2, pos_3, pos_4)
print(f"Dist= {distance:.5f}")
#get NMR fields
if (b_small == 'b1'):
#saving the new actual nmr value of B1
bs_nmr = caget(tlm_reading)
#change b2 and compare
#saving the new actual nmr value
caput(set_probe, b2_probe)
sleep(10)
bb_nmr = caget(tlm_reading)
elif (b_small == 'b2'):
#saving the new actual nmr value of B1
bb_nmr = caget(tlm_reading)
#change b2 and compare
#saving the new actual nmr value
caput(set_probe, b2_probe)
sleep(10)
bs_nmr = caget(tlm_reading)
bs_i = GetMagnet(b_small)
bb_i = GetMagnet(b_big)
#save i, hall values and distance to file
f = open(f"{b_small}_{b_big}_Distance_{timestring}.txt", "a+")
f.write(
f'{bs_i:.3f}\t{bb_i:.3f}\t{bs_nmr:.7f}\t{bb_nmr:.7f}\t{distance:.4f}\t{pos_1[0]:.4f}\t{all_nom_im}\n'
)
f.close()
#ramps down this magnet in small steps multiple of the large step
SetMagnet(b_small, bs_init - bs_stepsize * (j + 1))
#this magnet goes down a big step
SetMagnet(b_big, bb_init - bb_stepsize)
#####################
matchNMR()
#UNCOMMENT IF YOU ARE MANUALLY ENTERING MAGNET NAMES
#magnet_list = [x.lstrip().rstrip() for x in quad_list.split(",")]
magnet_list = ['q1', 'q2', 'q3', 'q4', 'q5', 'q6', 'q7', 's1']
timestamp = (datetime.datetime.now()).strftime("%m-%d_%H-%M")
np.set_printoptions(precision=2)
############################
### optimizing quads ###
############################
while (cont == 'y'):
if count == 0 :
if sandbox != 'y':
#get inital tune for quads and assign the phase space for each
q_init = {q : GetMagnet(q) for q in magnet_list} #need this for final scaling
magnet_values = [q_init[q] for q in magnet_list]
# !! PHASE SPACE FOR 1D/not using optimal values, uncomment following line
#q_ps = {q : [ 0.50*q_init[q] , 2.0*q_init[q] ] if q_init[q]>0 else [ 2.0*q_init[q] , 0.5*q_init[q] ] for q in magnet_list }
# !! PHASE SPACE MANUALLY SET, after 1D test, from nominal to optimal
q_ps = { q: [q_init[q]-2.0,q_init[q]+2.0] for q in magnet_list }
# q_ps = {'q1' : [-43.698, -34.5],
# 'q2' : [ 72.684, 75.55],
# 'q3' : [ 81.86, 82.564],
# 'q4' : [-83.13, -72.716],
# 'q5' : [ 47.54, 55.68],
# 'q6' : [ 75.72, 76.18],
# 'q7' : [-26.81, -24.18]
# }
'domain': (9, 13)
}]
space = Design_space(spaceArray)
np.set_printoptions(precision=2)
#list for corrector magnet values
magnet_values = [0 for i in range(len(magnet_list))]
while (cont == 'y'):
if sandbox != 'y':
#import current state
#Get initial quad values
q1_init, q2_init, q3_init, q4_init = GetQuads()
q6_init = GetMagnet("q6")
#q8_init = GetMagnet("q8")
#Tuning Q1 and Q2
#take picture with all at init values
#SetQuads(q1_init, q2_init, q3_init, q4_init)
#~ sleep(10)
all_nom_im = SaveIm('allNom', viewer)
sleep(2)
#take picture with all at zero
#~ SetQuads(0, 0, 0, 0)
#~ SetMagnet('q8', 0)
#~ SetMagnet('q9', 0)
#~ pos_1= GetBeamPos(all_nom_im, viewer)
#spaceArray = [ {'name': m, 'type': 'continuous', 'domain': (-3, 3)} for m in magnet_list ]
spaceArray = [ {'name': 'v13', 'type': 'continuous', 'domain': (-5.0, 1.0)}, {'name': 'v31', 'type': 'continuous', 'domain': (0.3, 5.3)}]
space = Design_space(spaceArray)
np.set_printoptions(precision=2)
#list for corrector magnet values
magnet_values = [0 for i in range(len(magnet_list))]
while (cont == 'y'):
if sandbox != 'y':
#import current state
#Get initial quad values
#~ q1_init, q2_init, q3_init, q4_init= GetQuads()
q8_init = GetMagnet('q8')
q9_init = GetMagnet('q9')
#Tuning Q8 and Q9
#take picture with all at init values
#~ SetQuads(q1_init, q2_init, 0, 0)
#~ sleep(10)
all_nom_im= SaveIm('allNom', viewer)
sleep(2)
#take picture with all at zero
#~ SetQuads(0, 0, 0, 0)
#~ SetMagnet('q8', 0)
#~ SetMagnet('q9', 0)
#~ pos_1= GetBeamPos(all_nom_im, viewer)
#~ sleep(10) #might need to increase this if the jumps in current are big
