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()
Beispiel #2
0
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.")
Beispiel #4
0
while (cont == 'y'):
    if sandbox != 'y':

        #import current state
        #Get initial quad values
        #~ q1_init, q2_init, q3_init, q4_init= GetQuads()

        #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 q1 *1/2, q2 nom
        SetMagnet(quad_pair[0], q0_init / 2)
        SetMagnet(quad_pair[1], q1_init)
        pos_1 = GetBeamPos(all_nom_im, viewer)
        pk_1 = pos_1[2]  # CHANGED FROM 6 BY F. MONTES

        if (count_iter == 0):
            init_peak = pk_1

        if (count_iter > 0 and pk_1 < init_peak * 0.05):
            print("Beam off viewer. Skipping iteration.")
            distance = 1000
        else:

            sleep(
                5
            )  #might need to increase this if the jumps in current are big
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}%"
        )
'''
#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.")

cont = input("Once magnets have settled, enter 'y' to continue...")

if (cont != 'y'):
    print("Exiting...")
    exit()

#'''
Beispiel #7
0
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}%")
Beispiel #8
0
        sleep(2)

        #take picture with q8 2/3 and q9 2/3
        SetQuads(q1_init, q2_init * 3 / 2, q3_init, q4_init)
        #SetMagnet('q2', 90.0) #q2_init/2)
        #SetMagnet('q1', q1_init)
        #~ SetMagnet('q8', q8_init*2/3)
        #~ SetMagnet('q9', q9_init*2/3)
        pos_2 = GetBeamPos(q1q2_half_im, viewer)
        sleep(10)
        q2_half_im = SaveIm('q2_3-2', viewer)
        sleep(2)

        #take picture with all at zero
        SetQuads(q1_init, q2_init, q3_init, q4_init)
        SetMagnet('q6', q6_init * 3 / 2)
        #SetMagnet('q2', q2_init)
        pos_3 = GetBeamPos(q2_half_im, viewer)
        sleep(10)  #might need to increase this if the jumps in current are big
        all_zero_im = SaveIm('q6half', viewer)
        sleep(2)

        #return quads to original values
        SetQuads(q1_init, q2_init, q3_init, q4_init)
        SetMagnet('q6', q6_init)
        #SetMagnet('q8', q8_init)
        #~ SetMagnet('q9', q9_init)
        pos_4 = GetBeamPos(all_zero_im, viewer)

        pk_1 = pos_1[2:4]
        pk_2 = pos_2[2:4]
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()
if (cont != 'y'):
    print("Exiting...")
    exit()
#'''
#match Hall probe readings
#matchHall()
#'''

#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])
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.")

cont= input("Once magnets have settled, enter 'y' to continue...")

if (cont != 'y'):
    print("Exiting...")
Beispiel #11
0
    #print(m)

    # Find next point
    model = GPModel(optimize_restarts=1, verbose=True)
    model.model = m
    #acq = AcquisitionEI(model, space, jitter = 1)
    acq = AcquisitionLCB(model, space, exploration_weight=2)
    alpha_full = acq.acquisition_function(X_grid)
    magnet_values = X_grid[np.argmin(alpha_full), :]

    print("New quad current values:\n")
    for i, q in enumerate(magnet_list):
        print(f"{q}: {magnet_values[i]:.2f}A\n")
        if sandbox != 'y':
            #set new quad currents
            SetMagnet(q, magnet_values[i])

####################
    """#############"""
    ####################

    #continue or not
    if (tbl == 'y' or count % 10 == 0):
        cont = input("Continue? y/n ")
        if (cont == 'n' and sandbox == 'y'):
            exit()

##########################
##########################

print("Adjusting quads...")
Beispiel #12
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
        #~ all_zero_im= SaveIm('allZero', viewer)
        #~ sleep(2)

        #take picture with q8 2/3 and q9 nom
        #~ SetQuads(q1_init/2, q2_init/2, 0, 0)
        SetMagnet('q6', q6_init / 2)
        SetMagnet('q9', q9_init)
        pos_1 = GetBeamPos(all_nom_im, viewer)
        sleep(10)
        q6_half_im = SaveIm('q6half', viewer)
        sleep(2)

        #take picture with q8 2/3 and q9 2/3
        #~ SetQuads(0, q2_init/2, 0, 0)
        SetMagnet('q6', q6_init)
        SetMagnet('q9', q9_init / 2)
        pos_2 = GetBeamPos(q6_half_im, viewer)
        sleep(10)
        q9half_im = SaveIm('q9half', viewer)
        sleep(2)
#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
    sleep(10)
    b2_nmr = caget(tlm_reading)

    #~ if (abs(b1_nmr_h - b2_nmr_h) > dNMR):
    if (abs(b1_nmr - b2_nmr) >
Beispiel #14
0
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()
Beispiel #15
0
	magnet_values = X_grid[np.argmin(alpha_full),:]

	print("Min LCB: ", np.argmin(alpha_full), min(alpha_full), X_grid[np.argmin(alpha_full),:])
	print("Max LCB: ", np.argmax(alpha_full), max(alpha_full), X_grid[np.argmax(alpha_full),:])
	
	if (len(magnet_list)==1):
		gp.plot1D(f"GP_results/{'_'.join(magnet_list)}Values_Widths_{timestamp}.txt", timestamp = timestamp, phase_space = q_ps[magnet_list[0]])
	elif (len(magnet_list)==2):
		gp.plot2D(f"GP_results/{'_'.join(magnet_list)}Values_Widths_{timestamp}.txt", magnet_list_2d = magnet_list, timestamp = timestamp, phase_space = q_ps)

	print("New quad current values:\n")
	for i,q in enumerate(magnet_list):
		print(f"{q}: {magnet_values[i]:.2f}A")
		if sandbox != 'y':
			#set new quad currents
			SetMagnet(q, magnet_values[i])
	sleep(7)

    ####################
	"""#############"""
	####################

	#continue or not
	if (tbl == 'y' or count%30 == 0):
		cont= input("Continue? y/n ")
		if (cont == 'n' and sandbox =='y'):
			exit() 

##########################
##########################
'''
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)

        #take picture with q14 *2/3, q15 *9/10
        SetMagnet(quad_pair[0], -40)
        #SetMagnet(quad_pair[1], q1_init*9/10)
        pos_1 = GetBeamPos(all_nom_im, viewer)
        pk_1 = pos_1[2]

        if (count_iter == 0):
            init_peak = pk_1

        if (count_iter > 0 and pk_1 < init_peak * 0.05):
            print("Beam off viewer. Skipping iteration.")
            distance = 1000
        else:
            sleep(
                5
            )  #might need to increase this if the jumps in current are big
            frac_im = SaveIm('Q1frac23Q2frac910', viewer)
Beispiel #17
0
#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
    sleep(10)
    b2_nmr = caget(tlm_reading)

    #~ if (abs(b1_nmr_h - b2_nmr_h) > dNMR):
    if (abs(b1_nmr - b2_nmr) >
Beispiel #18
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
		#~ all_zero_im= SaveIm('allZero', viewer)
		#~ sleep(2)

		#take picture with q8 2/3 and q9 nom
		#~ SetQuads(q1_init/2, q2_init/2, 0, 0)
		SetMagnet('q8', q8_init*2/3)
		SetMagnet('q9', q9_init)
		pos_1= GetBeamPos(all_nom_im, viewer)
		sleep(10)
		q8_2third_im= SaveIm('q82third', viewer)
		sleep(2)

		#take picture with q8 2/3 and q9 2/3
		#~ SetQuads(0, q2_init/2, 0, 0)
		SetMagnet('q8', q8_init)
		SetMagnet('q9', q9_init/2)
		pos_2= GetBeamPos(q8_2third_im, viewer)
		sleep(10)
		q8q9_2third_im= SaveIm('q9half', viewer)
		sleep(2)