slic/cristallina
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Post beamtime cleanup

Browse Source
This commit is contained in:
vonka_j
2023-03-15 13:54:26 +01:00
parent 88884f73ae
commit 24a2a465c5
19 changed files with 459 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

187
measurement_scripts/inprints.py
View File

@ -1,17 +1,20 @@
from datetime import datetime
from time import sleep, time
from tracemalloc import start
import numpy as np
#from epics import PV
#from slic.utils import nice_arange
#from slic.devices.general.motor import Motor
import matplotlib.pyplot as plt
import epics
from cristallina import attocube, attenuator
from cristallina import Newport_large, attocube, attenuator
from smaract_device_def import smaract_mini_XYZ
from slic.devices.xoptics.aramis_attenuator import Attenuator
from tqdm import tqdm
attenuator = Attenuator("SAROP31-OATA150", description="Cristallina attenuator OATA150")
from slic.devices.xoptics.kb import KBBase,KBHor,KBVer
from slic.devices.xoptics.kb import KBHor,KBVer
kbHor = KBHor(
"SAROP31-OKBH154",
description="Cristallina horizontal KB mirror"
@ -23,26 +26,58 @@ kbVer = KBVer(
)
do_not_move_benders = True
testing_flag = True
testing_flag = False
pos = np.array([0,0])
# parameters
n_same_holes = 7
attenuations = np.logspace(0,-6,num=7)
KBv_home = [1.5,1.7]
KBh_home = [1.6,1.8]
n_same_holes = 3
attenuations = np.linspace(0.15,0.35,9)#np.linspace(0.1,0.35,11)#np.linspace(0.1,0.35,6)#np.logspace(-3,0,num=7)
KBv_home = [1.3 , 1.6]
KBh_home = [1.4 , 1.7]
# Spacings
between_same_shots = 100
between_same_shots = 150
between_attenuations = 150
between_KB_settings = 500
KBvs = [[1,2],[1,3],[1,2],[1,3],[1,2]]
KBhs = [[1,2],[1,2],[1,2],[1,3],[1,2]]
between_KB_settings = 500#500
### 23.02
def kb_settings_list(best,step,no_steps):
for i in range(no_steps):
if i == 0:
l=[]
l.append([best[0]+i*step,best[1]])
for i in range(no_steps):
if i == 0:
pass
l.append([best[0],best[1]+i*step])
return l
KBvs = kb_settings_list([1.595,1.874],0.05,3)
KBhs = kb_settings_list([1.799000,2.100000],0.05,3)
### 24.02
def kb_settings_list_new(best,step,no_steps_one_way):
l=[]
first = np.array(best) - np.array([step*no_steps_one_way,step*no_steps_one_way])
for i in range(no_steps_one_way*2+1):
l.append([first[0]+i*step,first[1]+i*step])
return l
KBvs = kb_settings_list_new([1.595,1.874],0.0075,3)
KBhs = kb_settings_list_new([1.799000,2.100000],0.0075,3)
# Time estimates for total time calculation (time in seconds)
t_kb_change = 30
t_shot = 5
t_atten_change = 20
t_shot = 4
t_atten_change = 10
# Choose motor stage (set true for smaract_stage_xyz, false if attocubes)
smaract_stage = True
# Change to mm from um if smaract stage selected
if smaract_stage:
between_same_shots = between_same_shots/1000
between_attenuations = between_attenuations/1000
between_KB_settings = between_KB_settings/1000
def shoot(pos=pos,testing=testing_flag):
if testing:
@ -50,7 +85,8 @@ def shoot(pos=pos,testing=testing_flag):
return pos
else:
print(f'Shot at: {pos}')
#epics.caput("SAR-CCTA-ESC:seq0Ctrl-Start-I",1)
sleep(2)
epics.caput("SAR-CCTA-ESC:seq0Ctrl-Start-I",1)
pass
def change_benders(bender_1,bender_2,KB = None,do_not_move_benders = do_not_move_benders):
@ -65,11 +101,12 @@ def change_benders(bender_1,bender_2,KB = None,do_not_move_benders = do_not_move
kbHor.bend1.set_target_value(KBh_home[0]).wait()
sleep(1)
kbHor.bend2.set_target_value(KBh_home[1]).wait()
sleep(1)
else:
kbVer.bend1.set_target_value(KBv_home[0]).wait()
sleep(1)
kbVer.bend2.set_target_value(KBv_home[1]).wait()
sleep(1)
if do_not_move_benders:
print(f'Bender 1 to: {bender_1}')
@ -82,10 +119,12 @@ def change_benders(bender_1,bender_2,KB = None,do_not_move_benders = do_not_move
kbHor.bend1.set_target_value(bender_1).wait()
sleep(1)
kbHor.bend2.set_target_value(bender_2).wait()
sleep(1)
else:
kbVer.bend1.set_target_value(bender_1).wait()
sleep(1)
kbVer.bend2.set_target_value(bender_2).wait()
sleep(1)
def check_KB_value(KB):
@ -105,7 +144,10 @@ def move_x_rel(distance,testing=testing_flag,pos=pos):
pos = pos + np.array([distance,0])
return pos
else:
attocube.X.set_target_value(distance, relative=True).wait()
if smaract_stage:
smaract_mini_XYZ.x.mvr(distance).wait()
else:
attocube.X.set_target_value(distance, relative=True).wait()
pos = pos + np.array([distance,0])
return pos
@ -114,7 +156,10 @@ def move_y_rel(distance,testing=testing_flag,pos=pos):
pos = pos + np.array([0,distance])
return pos
else:
attocube.Y.set_target_value(distance, relative=True).wait()
if smaract_stage:
smaract_mini_XYZ.y.mvr(distance).wait()
else:
attocube.Y.set_target_value(distance, relative=True).wait()
pos = pos + np.array([0,distance])
return pos
@ -123,65 +168,89 @@ def move_x(value,testing=testing_flag,pos=pos):
pos[0]=value
return pos
else:
attocube.X.set_target_value(value, relative=False).wait()
if smaract_stage:
smaract_mini_XYZ.x.mv(value).wait()
else:
attocube.X.set_target_value(value, relative=False).wait()
return [value,pos[1]]
def move_y(value,testing=testing_flag,pos=pos):
if testing == True:
pos[1]=value
return pos
else:
attocube.Y.set_target_value(value, relative=False).wait()
if smaract_stage:
smaract_mini_XYZ.y.mv(value).wait()
else:
attocube.Y.set_target_value(value, relative=False).wait()
return [pos[0],value]
def move(target_pos,testing=True,pos=pos):
if testing == True:
pos = target_pos
return pos
pass
else:
attocube.X.set_target_value(target_pos[0]).wait()
attocube.Y.set_target_value(target_pos[1]).wait()
if smaract_stage:
smaract_mini_XYZ.x.mv(target_pos[0]).wait()
smaract_mini_XYZ.y.mv(target_pos[1]).wait()
else:
attocube.X.set_target_value(target_pos[0]).wait()
attocube.Y.set_target_value(target_pos[1]).wait()
pos = target_pos
return pos
def make_attenuations(attenuations,testing=testing_flag,pos=pos):
def get_original_position(testing=testing_flag):
if testing == True:
original_position = pos
else:
original_position = [attocube.X.get_current_value(),attocube.Y.get_current_value()]
if smaract_stage:
original_position = [smaract_mini_XYZ.x.get_current_value(),smaract_mini_XYZ.y.get_current_value()]
else:
original_position = [attocube.X.get_current_value(),attocube.Y.get_current_value()]
return original_position
def set_attenuation(value):
attenuator.set_transmission(value)
sleep(1)
while attenuator.motors.any_is_moving():
sleep(1)
return value
def make_attenuations(attenuations,testing=testing_flag,pos=pos):
original_position = get_original_position(testing=testing)
# Make all attenuations
for attenuation in attenuations:
print(f'Setting attenuation to: {attenuation}')
if testing_flag != True:
attenuator.trans1st(attenuation).wait()
if testing:
print('Testing: no attenuator change')
else:
set_attenuation(attenuation)
print('Making same shots')
make_same_shots(n_same_holes,pos=pos)
make_same_shots(n_same_holes,pos=pos,testing=testing)
pos = move_y_rel(between_attenuations,pos=pos,testing=testing)
# Return back to where you started
if testing == True:
pos = original_position
else:
attocube.X.set_target_value(original_position, relative=False)
pos = move(original_position, testing=testing)
return pos
def make_same_shots(n_same_holes,testing=testing_flag,pos=pos):
if testing == True:
original_position = pos
else:
original_position = [attocube.X.get_current_value(),attocube.Y.get_current_value()]
original_position = get_original_position(testing=testing)
# Make holes
for shot in range(n_same_holes):
sleep(1)
shoot(pos=pos)
shoot(pos=pos,testing=testing)
pos = move_x_rel(between_same_shots,pos=pos,testing=testing)
# Return back to where you started
move(original_position)
move(original_position,testing=testing)
def estimate_total_time(KBhs=KBhs,KBvs=KBvs,attenuations=attenuations,n_same_holes=n_same_holes,t_kb_change=t_kb_change,t_atten_change=t_atten_change,t_shot=t_shot):
total_time = len(KBhs)*len(KBvs)*(t_kb_change+len(attenuations)*(t_atten_change+n_same_holes*t_shot) )
total_time = len(KBhs)*len(KBvs)*( t_kb_change+len(attenuations)*(t_atten_change+n_same_holes*t_shot) )
print(f'Total time estimate: {(total_time/60):.1f} minutes or {(total_time/60/60):.1f} hours')
return total_time
@ -189,41 +258,59 @@ def estimate_total_time(KBhs=KBhs,KBvs=KBvs,attenuations=attenuations,n_same_hol
if testing_flag == True:
starting_x_pos = pos[0]
else:
starting_x_pos = attocube.X.get_current_value()
if smaract_stage:
starting_x_pos = smaract_mini_XYZ.x.get_current_value()
else:
starting_x_pos = attocube.X.get_current_value()
def make_everything(KBvs,KBhs,attenuations,n_same_holes,testing=testing_flag,pos=pos):
# The actual loop to make inprints
for i,KBv in enumerate(KBvs):
change_benders(KBv[0],KBv[1],KB = 'v')
def make_everything(KBvs,KBhs,attenuations,n_same_holes,testing=testing_flag,pos=pos,do_not_move_benders=True):
# The loop to make inprints
for i,KBv in enumerate(tqdm(KBvs)):
change_benders(KBv[0],KBv[1],KB = 'v',do_not_move_benders=do_not_move_benders)
for ind,KBh in enumerate(KBhs):
change_benders(KBh[0],KBh[1],KB = 'h')
print(f'Progress so far: KBv loop: {i+1}/{len(KBvs)}. KBh loop:{ind+1}/{len(KBhs)}')
make_attenuations(attenuations,pos=pos)
make_attenuations(attenuations,pos=pos,testing=testing)
print(f'Moving to a new KBh setting')
# Move to the last shot of the same shot + the spacing between KB settings
pos = move_x_rel(between_KB_settings+between_same_shots*(n_same_holes-1),pos=pos)
pos = move_x_rel(between_KB_settings+between_same_shots*(n_same_holes-1),pos=pos,testing=testing)
print('KBh set done, returning to starting_x_pos')
# Move to the last shot of the same shot + the spacing between KB settings
pos = move_x(starting_x_pos,pos=pos)
pos = move_x(starting_x_pos,pos=pos,testing=testing)
print('#################################################################################')
print('Moving to a new KBv setting')
# Move to the last shot of the same shot + the spacing between KB settings
pos = move_y_rel(between_KB_settings+between_attenuations*(len(attenuations)-1),pos=pos)
pos = move_y_rel(between_KB_settings+between_attenuations*(len(attenuations)-1),pos=pos,testing=testing)
print('Inprints are done')
print(f'Total time estimate: {(total_time/60):.1f} minutes or {(total_time/60/60):.1f} hours')
set_attenuation(1e-6)
status_pv = PV('SF-OP:ESC-MSG:STATUS')
status_pv.put(0)
# print(f'Total time estimate: {(total_time/60):.1f} minutes or {(total_time/60/60):.1f} hours')
# To do:
# Fix movement of the attocubes in real time
# Load lut files into the controller and check that x is x and y is y
def make_z_scan(z_list,n_same_holes,attenuations,vertical_spacing=0.150):
original_position = get_original_position(testing=False)
for attenuation in attenuations:
set_attenuation(attenuation)
for z in z_list:
Newport_large.mv(z).wait()
sleep(1)
make_same_shots(n_same_holes,testing=False)
move_y_rel(vertical_spacing,testing=False)
move(original_position,testing=False)
sleep(1)
move_x_rel(1,testing=False)