Skip to content
Snippets Groups Projects
Commit 6d3f5ff0 authored by rodolakis's avatar rodolakis
Browse files

changed iex_vpu

parent dcbaab0c
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
iexcode.egg-info/SOURCES.txt
+ 1
− 0
View file @ 6d3f5ff0
......@@ -23,6 +23,7 @@ iexcode/instruments/Lakeshore_335.py
iexcode/instruments/Logfile.py
iexcode/instruments/MPA.py
iexcode/instruments/Motors.py
iexcode/instruments/Octupole.py
iexcode/instruments/Scienta.py
iexcode/instruments/VLS_PGM.py
iexcode/instruments/__init__.py
......
iexcode/cheatsheet.txt
+ 12
− 3
View file @ 6d3f5ff0
......@@ -99,10 +99,19 @@ BL_mda_filepath => returns the file path in mda scanRecord
get_all => gets relavent pv values
#IEX_VPU: undulator functions
ID_calc_SP => calculate the set point for maximum flux
ID_wait_for_permission => waits for security access
ID_get_all => gets ID_mode, ID_QP_ratio, ID_sp, ID_rbv
ID_off => turns off the ID
ID_start => turns on the ID
ID_restart => turns off the ID and then turns it on with the same set point
ID_energy_range => return max/min for a given mode
ID_ready => looks at the two busy records
ID_off/on => turns off/on the ID
ID_power_status => returns off/on
ID_start => turns on the ID in a given mode
ID_switch_mode => changes the ID mode
ID_get/set => gets rbv / sets val in keV
ID_energy_set => set calibrated energy in eV
ID_rbv_get
#kappa_angle_calcs:
fourc2kappa => converts between four-circle angles and kappa angles
......
iexcode/instruments/IEX_VPU.py
+ 91
− 112
View file @ 6d3f5ff0
......@@ -16,14 +16,36 @@ IDcal_path="/home/beams22/29IDUSER/Documents/User_Macros/Macros_29id/IEX_Diction
################################ ID limits and calibration ##############################
##############################################################################################################
def ID_calc_SP(mono_grating,ID_mode,hv_eV,QP_ratio): # Mode = state (0=RCP,1=LCP,2=V,3=H)
pv = 'ID29:'
pvs={'AccessSecurity':pv+'AccessSecurity.VAL',
'mode_rbv':pv+'ActualMode',
'mode_val':pv+'DesiredMode.VAL',
'check_ready':pv+'feedback.VAL',
'check_busy':pv+'BusyRecord',
'busy_reset':pv+'Busy.VAL',
'main_power':pv+'Main_on_off.VAL',
'energy_rbv':pv+'Energy.VAL',
'energy_sp':pv+'EnergySet.VAL',
'start_ramp':pv+'StartRamp.VAL',
'energy_eV_rbv':pv+'EnergyRBV',
'energy_eV_sp':pv+'EnergyScanSet.VAL',
'scan_eV_rbv':pv+'EnergyScanSeteV',
'scan_eV_val':pv+'EnergySetRBV',
'table_dir':pv+'TableDirection',
'By_q':pv+'ByqRdbk',
'Bx_q':pv+'BxqRdbk',
'Vcoil':pv+'ByRdbk.VAL',
'Hcoil':pv+'BxRdbk.VAL',
'QP_ratio':pv+'QuasiRatio.RVAL',}
def ID_calc_eV(mono_grating,ID_mode,hv_eV,QP_ratio): # Mode = state (0=RCP,1=LCP,2=V,3=H)
"""Calculate the ID SP for a given polarization mode and energy;
with Mode = 0 (RCP),1 (LCP), 2 (V), 3 (H)
Previously: ID_Calc
"""
"""
if type(ID_mode)== str:
ID_state=ID_state_mode(ID_mode)
try:
......@@ -32,7 +54,7 @@ def ID_calc_SP(mono_grating,ID_mode,hv_eV,QP_ratio): # Mode = state (0=RCP,1=
except KeyError:
message_string='Not a valid ID mode!'+"\nValid Modes: "+str(ID_mode_list())
print_warning_message(message_string)
ID=caget("ID29:EnergySeteV")
ID=caget(pvs['energy_rbv'])
return round(ID,1)
##############################################################################################################
......@@ -48,7 +70,7 @@ def ID_wait_for_permission():
Previously: WaitForPermission
"""
while True:
ID_Access=caget("ID29:AccessSecurity.VAL")
ID_Access=caget(pvs['AccessSecurity'])
if (ID_Access!=0):
print("Checking ID permission, please wait..."+dateandtime())
sleep(30)
......@@ -66,8 +88,8 @@ def ID_get_all(verbose=False):
vals={
"ID_mode":ID_mode_get(verbose=False),
"ID_QP_ratio":ID_QP_ratio_get(verbose=False),
"ID_sp":ID_SP_get_eV(verbose=False),
"ID_rbv":ID_rbv_get_eV(verbose=False)
"ID_sp":caget(pvs['energy_sp']),
"ID_rbv":ID_get_eV(verbose=False)
}
if verbose:
......@@ -82,14 +104,12 @@ def ID_energy_range(ID_mode=None):
Previously: ID_Range
"""
if ID_mode == None:
ID_state=caget("ID29:ActualMode")
ID_state=caget(pvs['mode_rbv'])
else:
ID_state = ID_state_mode(ID_mode)
# RCP,LCP, V , H , HN
ID_min_SP = [400,400,440,250,250]
ID_max_SP = 3800
#hv_min=[390,390,430,245,245]
ID_min_SP = [.400,.400,.440,.250,.250]
ID_max_SP = 3.800
return ID_min_SP[ID_state],ID_max_SP
def ID_mode_list():
......@@ -120,14 +140,14 @@ def ID_state_get():
"""
Returns the current ID state
"""
ID_state = caget("ID29:ActualMode")
ID_state = caget(pvs['mode_rbv'])
return ID_state
def ID_mode_get(verbose=True):
"""
Returns the current ID mode
"""
ID_state = caget("ID29:ActualMode")
ID_state =ID_state_get()
ID_mode = ID_mode_list()[ID_state]
if verbose:
......@@ -138,7 +158,7 @@ def ID_mode_set(ID_mode):
"""
writes the desired mode to the correct ID pv
"""
caput("ID29:DesiredMode.VAL",ID_mode,wait=True,timeout=18000) # RCP
caput(pvs['mode_val'],ID_mode,wait=True,timeout=18000) # RCP
def ID_ready(verbose=True):
......@@ -148,13 +168,13 @@ def ID_ready(verbose=True):
Previously: ID_Ready
"""
while True:
RBV=caget("ID29:Energy.VAL")
checkready=caget("ID29:feedback.VAL")
checkbusy=caget("ID29:BusyRecord")
RBV=caget(pvs['energy_rbv'])
checkready=caget(pvs['check_ready'])
checkbusy=caget(pvs['check_busy'])
if (checkready!="Ready") or (RBV < 3.7):
sleep(2)
elif ((checkready=="Ready") and (RBV > 3.7)) and (checkbusy=="Busy"):
caput("ID29:Busy.VAL",0)
caput(pvs['busy_reset'],0)
else:
if verbose:
print("ID Ready")
......@@ -164,7 +184,7 @@ def ID_power_status():
"""
gets if the ID power supplies are On or Off
"""
ID_OnOff=caget('ID29:Main_on_off.VAL')
ID_OnOff=caget(pvs['main_power'])
if ID_OnOff == 1:
return 'Off'
elif ID_OnOff == 0:
......@@ -175,7 +195,7 @@ def ID_off(verbose=True):
waits for permission then turns on the main coils OFF
"""
ID_wait_for_permission()
caput("ID29:Main_on_off.VAL",1,wait=True,timeout=18000)
caput(pvs['main_power'],1,wait=True,timeout=18000)
sleep(5)
if verbose:
print("ID is now off")
......@@ -185,12 +205,13 @@ def ID_on(verbose=True):
"""
waits for permission then turns on the main coils On
"""
ID_wait_for_permission()
if verbose:
print("Starting ID - "+dateandtime())
caput("ID29:EnergySet.VAL",3.8)
caput("ID29:Main_on_off.VAL",0,wait=True,timeout=18000)
caput(pvs['energy_sp'],3.8)
caput(pvs['main_power'],0,wait=True,timeout=18000)
def ID_start(ID_mode='RCP',QP_ratio=None, verbose=True):
"""
......@@ -241,58 +262,40 @@ def ID_switch_mode(ID_mode):
except:
print_warning_message("Not a valid ID mode")
def ID_SP_get(verbose=False):
"""
returns the ID setpoint in keV
"""
ID_SP = caget("ID29:EnergyScanSet.VAL")
if verbose:
print("ID_SP: ", ID_SP)
return ID_SP
def ID_SP_get_eV(verbose=False):
"""
returns the ID setpoint in eV
"""
ID_SP = ID_SP_get(verbose=False)
if verbose:
print("ID_SP: ", ID_SP)
return ID_SP
def ID_rbv_get(verbose=False):
def ID_get(verbose=False):
"""
returns the readback value for the
"""
ID_RBV = caget("ID29:EnergyRBV")
ID_RBV = caget(pvs['energy_rbv'])
if verbose:
print("ID_RBV: ", ID_RBV)
return ID_RBV
def ID_rbv_get_eV(verbose=False):
def ID_get_eV(verbose=False):
"""
returns the readback value for the
"""
ID_RBV = ID_rbv_get(verbose=False)
ID_RBV = ID_get(verbose=False)*1000
if verbose:
print("ID_RBV: ", ID_RBV)
return ID_RBV
def ID_SP_set(hv_eV,verbose=True):
def ID_set(keV,verbose=True):
"""
"Sets the ID set point to a specific value (hv(eV)) which will not likely be optimum"
Previously: SetID_Raw
"""
def _ID_write_SP_proc(keV):
caput("ID29:EnergyScanSet.VAL",keV,wait=True,timeout=18000)
caput(pvs['energy_sp'],keV,wait=True,timeout=18000)
sleep(0.5)
caput("ID29:EnergyScanSet.VAL",(keV+0.001),wait=True,timeout=18000)
caput('ID29:StartRamp.VAL',1)
caput(pvs['start_ramp'],1)
def _ID_bw_ok(ID_SP):
ID_bw = ID_SP*0.095
ID_diff = abs(ID_rbv_get()-ID_SP)
def _ID_bw_ok(keV,verbose=False):
ID_SP = caget(pvs['energy_sp'])
ID_bw = ID_SP * 0.095
ID_diff = abs(ID_get()-keV)
if ID_diff > ID_bw:
return False
else:
......@@ -304,56 +307,31 @@ def ID_SP_set(hv_eV,verbose=True):
#checking if desired is with allowed range, if not printing the nearest allowed value
ID_max,ID_min = ID_energy_range()
ID_SP=min(max(hv_eV,ID_min),ID_max)*1.0
if hv_eV < ID_min or hv_eV > ID_max:
if keV < ID_min or keV > ID_max:
message_string="Set point out of BL energy range \nPlease select a different energy."
message_string+="\nClosest allowed value is "+str(ID_SP)
message_string+="\nClosest allowed value is "+str(min(max(keV,ID_min),ID_max))
print_warning_message(message_string)
else:
#desired energy is within range
ID_SP_RBV=round(caget("ID29:EnergySet.VAL"),3)*1000
ID_RBV=caget("ID29:EnergyRBV")
if ID_SP == ID_SP_RBV:
#ID is already at the SP energy
if verbose:
print("ID SET : "+"%.1f" % ID_SP, "eV")
print("ID RBV : "+"%.1f" % ID_RBV, "eV")
print(caget('ID29:TableDirection',as_string=True))
else:
# ID not at energy
ready = ID_ready(verbose=False)
if ready:
#set the energy
_ID_write_SP_proc(ID_SP/1000)
while not ID_ready(verbose=False):
sleep(20)
#is ID within some bandwidth
if _ID_bw_ok(ID_SP) == False:
sleep(20)
if _ID_bw_ok(ID_SP) == False:
print("\nID RBV : "+"%.1f" % ID_RBV, "eV")
ID_start(ID_mode_get())
if ID_ready(verbose=False):
#set the energy
_ID_write_SP_proc(ID_SP/1000)
if verbose:
print("\nID SET : "+"%.1f" % ID_SP, "eV")
print("ID RBV : "+"%.1f" % ID_RBV, "eV")
print(caget('ID29:TableDirection',as_string=True))
if ID_QP_ratio_get()[0] < 100:
#check ratio
Byq=caget("ID29:ByqRdbk")
Vcoil=caget("ID29:ByRdbk.VAL")
ratio=Byq/Vcoil
ratio_RBV=caget("ID29:QuasiRatio.RVAL")
if verbose:
print("QP ratio =", round(ratio,3)*100,"%")
print("QP RBV =", ratio_RBV,"%")
_ID_write_SP_proc(keV)
# ID not at energy
ready = ID_ready(verbose=False)
if ready:
#set the energy
_ID_write_SP_proc(ID_SP/1000)
while not ID_ready(verbose=False):
sleep(20)
#is ID within some bandwidth
if _ID_bw_ok(ID_SP,verbose=verbose):
if verbose:
ID_SP = caget(pvs['energy_sp'])
ID_RBV = ID_get()
print("ID SET : "+"%.1f" % ID_SP, "eV")
print("ID RBV : "+"%.1f" % ID_RBV, "eV")
print(caget(pvs['table_dir'],as_string=True))
else:
ID_QP_ratio_get(verbose)
def ID_energy_set(hv_eV,QP_ratio=None):
"""
......@@ -366,8 +344,8 @@ def ID_energy_set(hv_eV,QP_ratio=None):
"""
ID_mode = ID_mode_list()[ID_state_get()]
mono_grating = mono_grating_get()
ID_SP = ID_calc_SP(mono_grating,ID_mode,hv_eV,QP_ratio)
ID_SP_set(ID_SP)
keV = ID_calc_eV(mono_grating,ID_mode,hv_eV,QP_ratio)/1000.0
ID_set(keV)
def ID_QP_ratio_get(verbose=True):
......@@ -376,13 +354,14 @@ def ID_QP_ratio_get(verbose=True):
calculate the QP ratio
"""
Byq=caget("ID29:ByqRdbk")
Vcoil=caget("ID29:ByRdbk.VAL")
ratio_calc=Byq/Vcoil
ratio_RBV=caget("ID29:QuasiRatio.RVAL")
Byq=caget(pvs['By_q'])
Vcoil=caget(pvs['Vcoil'])
ratio_calc=round(Byq/Vcoil,3)*100
ratio_RBV=caget(pvs['QP_ratio'])
if verbose:
print("QP ratio =", round(ratio_RBV,3)*100,"%")
print("QP RBV =", ratio_RBV,"%")
print("QP calculated ratio =", ratio_calc ,"%")
if abs(ratio_RBV-ratio_calc)>1:
message_string="QP RBV and QP calc do not agree \nCheck Interlocks"
......@@ -479,9 +458,9 @@ def ID_scan_pvs():
"""
returns the rbv and val for scanning
"""
val_pv="ID29:EnergyScanSeteV"
rbv_pv="ID29:EnergySetRBV"
return val_pv, rbv_pv
val_pv=pvs['scan_eV_val']
rbv_pv=pvs['scan_eV_rbv']
return rbv_pv, val_pv
def ID_scan_fillin(mda,scan_dim,start,stop,step,**kwargs):
"""
......@@ -491,7 +470,7 @@ def ID_scan_fillin(mda,scan_dim,start,stop,step,**kwargs):
"""
#Setting up the ScanRecord for ID in Table mode
val_pv, rbv_pv = ID_scan_pvs()
mda.fillin(scan_dim,val_pv,rbv_pv,start,stop,step,**kwargs)
mda.fillin(scan_dim,rbv_pv,val_pv,start,stop,step,**kwargs)
def ID_scan_fillin_table(mda,scan_dim,ID_array,**kwargs):
......@@ -501,8 +480,8 @@ def ID_scan_fillin_table(mda,scan_dim,ID_array,**kwargs):
**kwargs => scanRecord.fillin kwargs
"""
#Setting up the ScanRecord for ID in Table mode
val_pv, rbv_pv = ID_scan_pvs()
mda.fillin.table(scan_dim,val_pv,rbv_pv,ID_array,**kwargs)
rbv_pv, val_pv = ID_scan_pvs()
mda.fillin.table(scan_dim,rbv_pv,val_pv,ID_array,**kwargs)
##############################################################################################################
############################## ID direction table ##############################
......
iexcode/instruments/IEX_VPU_backup.py 0 → 100644
+ 544
− 0
View file @ 6d3f5ff0
from os import path
from math import *
from time import sleep
import numpy.polynomial.polynomial as poly
from epics import caget, caput
from iexcode.instruments.userCalcs import userCalcOut_clear
from iexcode.instruments.utilities import dateandtime, print_warning_message, read_dict
from iexcode.instruments.VLS_PGM import mono_grating_get
from iexcode.instruments.shutters import main_shutter_open
IDcal_path="/home/beams22/29IDUSER/Documents/User_Macros/Macros_29id/IEX_Dictionaries"
##############################################################################################################
################################ ID limits and calibration ##############################
##############################################################################################################
def ID_calc_SP(mono_grating,ID_mode,hv_eV,QP_ratio): # Mode = state (0=RCP,1=LCP,2=V,3=H)
"""Calculate the ID SP for a given polarization mode and energy;
with Mode = 0 (RCP),1 (LCP), 2 (V), 3 (H)
Previously: ID_Calc
"""
if type(ID_mode)== str:
ID_state=ID_state_mode(ID_mode)
try:
K=ID_coef(mono_grating,ID_state,hv_eV,QP_ratio)
ID=poly.polyval(hv_eV,K)
except KeyError:
message_string='Not a valid ID mode!'+"\nValid Modes: "+str(ID_mode_list())
print_warning_message(message_string)
ID=caget("ID29:EnergySeteV")
return round(ID,1)
##############################################################################################################
################################ ID Functions ##############################
##############################################################################################################
def ID_wait_for_permission():
"""
Monitors the ID permissions and waits for the ID to be in User Mode and then breaks
Checks the status every 30 seconds
Previously: WaitForPermission
"""
while True:
ID_Access=caget("ID29:AccessSecurity.VAL")
if (ID_Access!=0):
print("Checking ID permission, please wait..."+dateandtime())
sleep(30)
else:
print("ID now in user mode -"+dateandtime())
break
##############################################################################################################
def ID_get_all(verbose=False):
"""
returns dictionary with: ID_Mode, ID_QP_ratio, ID_SP, ID_RBV
Previously: Get_energy
"""
vals={
"ID_mode":ID_mode_get(verbose=False),
"ID_QP_ratio":ID_QP_ratio_get(verbose=False),
"ID_sp":ID_SP_get_eV(verbose=False),
"ID_rbv":ID_rbv_get_eV(verbose=False)
}
if verbose:
print(" ID SP : "+"%.2f" % vals["ID_sp"] , "eV ID mode : "+vals["ID_mode"])
print(" ID RBV : "+"%.2f" % vals['ID_rbv'], "eV QP mode : "+str(vals['ID_QP_ratio']) +" %")
return vals
def ID_energy_range(ID_mode=None):
"""
Returns the ID_min_SP, ID_max_SP for a given ID mode
Previously: ID_Range
"""
if ID_mode == None:
ID_state=caget("ID29:ActualMode")
else:
ID_state = ID_state_mode(ID_mode)
# RCP,LCP, V , H , HN
ID_min_SP = [400,400,440,250,250]
ID_max_SP = 3800
#hv_min=[390,390,430,245,245]
return ID_min_SP[ID_state],ID_max_SP
def ID_mode_list():
"""
returns the ID_mode_List
current mode =
"""
return ["RCP", "LCP", "V", "H", "HN"]
def ID_state_mode(ID_mode):
"""
Returns the state number if mode is a string
Returns the mode string if mode is an int or float
Previously: ID_State2Mode(which,mode)
"""
try:
ID_mode = ID_mode.upper()
ID_state =ID_mode_list().index(ID_mode)
return ID_state
except:
message_string='Not a valid ID mode!'+"\nValid Modes: "+str(ID_mode_list())
print_warning_message(message_string)
def ID_state_get():
"""
Returns the current ID state
"""
ID_state = caget("ID29:ActualMode")
return ID_state
def ID_mode_get(verbose=True):
"""
Returns the current ID mode
"""
ID_state = caget("ID29:ActualMode")
ID_mode = ID_mode_list()[ID_state]
if verbose:
print('ID mode: '+ID_mode)
return ID_mode
def ID_mode_set(ID_mode):
"""
writes the desired mode to the correct ID pv
"""
caput("ID29:DesiredMode.VAL",ID_mode,wait=True,timeout=18000) # RCP
def ID_ready(verbose=True):
"""
check both the read and busy pv every 2 seconds
Previously: ID_Ready
"""
while True:
RBV=caget("ID29:Energy.VAL")
checkready=caget("ID29:feedback.VAL")
checkbusy=caget("ID29:BusyRecord")
if (checkready!="Ready") or (RBV < 3.7):
sleep(2)
elif ((checkready=="Ready") and (RBV > 3.7)) and (checkbusy=="Busy"):
caput("ID29:Busy.VAL",0)
else:
if verbose:
print("ID Ready")
return True
def ID_power_status():
"""
gets if the ID power supplies are On or Off
"""
ID_OnOff=caget('ID29:Main_on_off.VAL')
if ID_OnOff == 1:
return 'Off'
elif ID_OnOff == 0:
return 'On'
def ID_off(verbose=True):
"""
waits for permission then turns on the main coils OFF
"""
ID_wait_for_permission()
caput("ID29:Main_on_off.VAL",1,wait=True,timeout=18000)
sleep(5)
if verbose:
print("ID is now off")
def ID_on(verbose=True):
"""
waits for permission then turns on the main coils On
"""
ID_wait_for_permission()
if verbose:
print("Starting ID - "+dateandtime())
caput("ID29:EnergySet.VAL",3.8)
caput("ID29:Main_on_off.VAL",0,wait=True,timeout=18000)
def ID_start(ID_mode='RCP',QP_ratio=None, verbose=True):
"""
waits for ID permission and then
starts ID with a specific polarization
mode = \"H\", \"V\", \"RCP\" or \"LCP\"
QP ratio if specified
"""
#turns on if ID is off
if ID_power_status =='Off':
ID_on()
#set QP
if ID_ready():
ID_QP_mode_set(QP_ratio,verbose)
#set ID mode
if ID_ready():
ID_mode_set(ID_mode, verbose)
#opens the main shutter
if ID_ready():
main_shutter_open()
if verbose:
print('ID is now on, please set your energy')
def ID_switch_mode(ID_mode):
"""
Change ID polarization; which = 'H', 'V', 'RCP' or 'LCP'
if ID_mode = current mode then does nothing
WARNING: Does not set the energy
Previously Switch_IDMode
"""
ID_wait_for_permission()
main_shutter_open()
ID_state = ID_state_get()
try:
if ID_state_mode(ID_mode) != ID_state:
print("Turning ID off...")
ID_off(verbose=True)
sleep(10)
print("Switching ID mode, please wait...")
ID_mode_set(ID_mode)
ID_ready()
print("ID Mode:",ID_mode)
except:
print_warning_message("Not a valid ID mode")
def ID_SP_get(verbose=False):
"""
returns the ID setpoint in keV
"""
ID_SP = caget("ID29:EnergyScanSet.VAL")
if verbose:
print("ID_SP: ", ID_SP)
return ID_SP
def ID_SP_get_eV(verbose=False):
"""
returns the ID setpoint in eV
"""
ID_SP = ID_SP_get(verbose=False)
if verbose:
print("ID_SP: ", ID_SP)
return ID_SP
def ID_rbv_get(verbose=False):
"""
returns the readback value for the
"""
ID_RBV = caget("ID29:EnergyRBV")
if verbose:
print("ID_RBV: ", ID_RBV)
return ID_RBV
def ID_rbv_get_eV(verbose=False):
"""
returns the readback value for the
"""
ID_RBV = ID_rbv_get(verbose=False)
if verbose:
print("ID_RBV: ", ID_RBV)
return ID_RBV
def ID_SP_set(hv_eV,verbose=True):
"""
"Sets the ID set point to a specific value (hv(eV)) which will not likely be optimum"
Previously: SetID_Raw
"""
def _ID_write_SP_proc(keV):
caput("ID29:EnergyScanSet.VAL",keV,wait=True,timeout=18000)
sleep(0.5)
caput("ID29:EnergyScanSet.VAL",(keV+0.001),wait=True,timeout=18000)
caput('ID29:StartRamp.VAL',1)
def _ID_bw_ok(ID_SP):
ID_bw = ID_SP*0.095
ID_diff = abs(ID_rbv_get()-ID_SP)
if ID_diff > ID_bw:
return False
else:
return True
#checking permissions and opening the main shutter
ID_wait_for_permission()
main_shutter_open()
#checking if desired is with allowed range, if not printing the nearest allowed value
ID_max,ID_min = ID_energy_range()
ID_SP=min(max(hv_eV,ID_min),ID_max)*1.0
if hv_eV < ID_min or hv_eV > ID_max:
message_string="Set point out of BL energy range \nPlease select a different energy."
message_string+="\nClosest allowed value is "+str(ID_SP)
print_warning_message(message_string)
else:
#desired energy is within range
ID_SP_RBV=round(caget("ID29:EnergySet.VAL"),3)*1000
ID_RBV=caget("ID29:EnergyRBV")
if ID_SP == ID_SP_RBV:
#ID is already at the SP energy
if verbose:
print("ID SET : "+"%.1f" % ID_SP, "eV")
print("ID RBV : "+"%.1f" % ID_RBV, "eV")
print(caget('ID29:TableDirection',as_string=True))
else:
# ID not at energy
ready = ID_ready(verbose=False)
if ready:
#set the energy
_ID_write_SP_proc(ID_SP/1000)
while not ID_ready(verbose=False):
sleep(20)
#is ID within some bandwidth
if _ID_bw_ok(ID_SP) == False:
ID_QP_ratio_get print("QP ratio =", round(ratio,3)*100,"%")
print("QP RBV =", ratio_RBV,"%")
def ID_energy_set(hv_eV,QP_ratio=None):
"""
Sets optimum ID set point for hv(eV) (max intensity)
and opens the main shutter
Note that QP is generally not calibrated
Previously: SetID
"""
ID_mode = ID_mode_list()[ID_state_get()]
mono_grating = mono_grating_get()
ID_SP = ID_calc_SP(mono_grating,ID_mode,hv_eV,QP_ratio)
ID_SP_set(ID_SP)
def ID_QP_ratio_get(verbose=True):
"""
gets the read back for the QP ratio
calculate the QP ratio
"""
Byq=caget("ID29:ByqRdbk")
Vcoil=caget("ID29:ByRdbk.VAL")
ratio_calc=Byq/Vcoil
ratio_RBV=caget("ID29:QuasiRatio.RVAL")
if verbose:
print("QP ratio =", round(ratio_RBV,3)*100,"%")
print("QP RBV =", ratio_RBV,"%")
if abs(ratio_RBV-ratio_calc)>1:
message_string="QP RBV and QP calc do not agree \nCheck Interlocks"
print_warning_message(message_string)
return ratio_RBV, ratio_calc
def ID_QP_mode_set(QP_ratio=None,verbose=True):
"""
switched to QP mode, if not currently in
sets the QP ratio (QP ratio min is 70) and polarization (ID mode)
WARNING: you will need to set the polarization and mode afterward
Previously: Switch_IDQP
"""
#checking if above the minimum allowed value
QP_min = 70
if QP_ratio < QP_min:
message_string="QP ratio is too small, setting it to minimum allowed value ("+str(QP_min)+")"
print_warning_message(message_string)
QP_ratio=max(70,QP_ratio)
if QP_ratio != None:
#checking to see if already in specified QP
ratio_RBV, ratio_calc = ID_QP_ratio_get()
#not the same ratio
if ratio_RBV != QP_ratio:
ID_off()
caput("ID29:QuasiRatioIn.C",QP_ratio)
ID_on()
sleep(15)
def ID_coef(grt,ID_state,hv_eV,QP_ratio): # Mode = state (0=RCP,1=LCP,2=V,3=H);
"""Return the ID coeff for a given polarization mode and energy;
with Mode = 0 (RCP),1 (LCP), 2 (V), 3 (H).
Current coefficient dictionary:
/home/beams22/29IDUSER/Documents/User_Macros/Macros_29id/IEX_Dictionaries/Dict_IDCal.txt
Previously: ID_Coef
"""
if QP_ratio == None:
QP_ratio = ID_QP_ratio_get()[0]
def ListRange(grt,ID_state,IDdict): # extract the list of break pts for a given mode/grt
tmp_list=[]
for item in (IDdict[grt][ID_state]):
tmp_list.append(item[0])
return tmp_list
def FindRange(hv_eV,range_list): # returns the index for the corresponding range
B = [x - hv_eV for x in range_list]
#print(B)
index = [i for (i, x) in enumerate(B) if x > 0]
#print(index)
return(index[0])
if QP_ratio < 100:
if isinstance(QP_ratio,float) or isinstance(QP_ratio,int):
QP_ratio=str(floor(QP_ratio))
dictfile='Dict_IDCal_QP'+QP_ratio+'.txt'
error_msg="calibration curve might not exist for this QP value"
else:
print('invalid QP value')
return
else:
dictfile='Dict_IDCal.txt'
error_msg=""
try:
IDcal_fpath = path.join(IDcal_path,dictfile)
ID_function=read_dict(IDcal_fpath)
except KeyError:
print("Unable to read dictionary "+dictfile+" ; "+error_msg)
try:
Lrange = ListRange(grt,ID_state,ID_function)
Erange = FindRange(hv_eV,Lrange)
K = ID_function[grt][ID_state][Erange][1]
return K
except KeyError:
print("WARNING: PLease select one of the following: "+str(ID_mode_list()))
def ID_scan_pvs():
"""
returns the rbv and val for scanning
"""
val_pv="ID29:EnergyScanSeteV"
rbv_pv="ID29:EnergySetRBV"
return val_pv, rbv_pv
def ID_scan_fillin(mda,scan_dim,start,stop,step,**kwargs):
"""
fills in the scanRecord for scanning the ID set point
**kwargs => scanRecord.fillin kwargs
"""
#Setting up the ScanRecord for ID in Table mode
val_pv, rbv_pv = ID_scan_pvs()
mda.fillin(scan_dim,val_pv,rbv_pv,start,stop,step,**kwargs)
def ID_scan_fillin_table(mda,scan_dim,ID_array,**kwargs):
"""
fills in the scanRecord for scanning the ID set point
**kwargs => scanRecord.fillin kwargs
"""
#Setting up the ScanRecord for ID in Table mode
val_pv, rbv_pv = ID_scan_pvs()
mda.fillin.table(scan_dim,val_pv,rbv_pv,ID_array,**kwargs)
##############################################################################################################
############################## ID direction table ##############################
##############################################################################################################
def ID_Table():
"""
Previously: ID_Table
"""
table = caget("ID29:TableDirection") # up = 1 , down = 0
By = caget("ID29:ByPolaritySet") # pos = 1, neg = 0
mode = ID_mode_get()
if By > 0:
print("\nBy > 0")
if table == 1: # By=1, table = 1 => -1 => A=B
print("table = up")
ID_direction = -1
elif table == 0: # By=1, table = 0 => +1 => A#B
print("table = down")
ID_direction = 1
elif By <= 0:
print("\nBy < 0")
if table == 1: # By=0, table = 1 => +1 => A=B
print("table = up")
ID_direction = 1
elif table == 0: # By=0, table = 0 => -1 => A#B
print("table = down")
ID_direction = -1
if mode == "H" and mode == "RCP":
if By > 0 and table == 0:
print_warning_message("will do a long hysteresis if decreasing energy !!!")
# if Mode == "HN" and Mode == "LCP":
# if By = 0 and table == 1:
# print "WARNING: will do a long hysteresis if decreasing energy !!!"
print("ID direction", ID_direction)
return ID_direction
def ID_table_userCalcOut():
"""
# Work in progress
Previously:ID_Table_CalcOut
"""
n=4
userCalcOut_clear("b",n)
pvstr="29idb:userCalcOut"+str(n)
caput(pvstr+".DESC","ID_Table")
table="ID29:TableDirection" # up = 1 , down = 0
By="ID29:ByPolaritySet" # pos = 1, neg = 0
caput(pvstr+".INPA",table+" CP NMS")
caput(pvstr+".INPB",By+" CP NMS")
caput(pvstr+".CALC$","A#B")
caput(pvstr+".OOPT","On Change")
caput(pvstr+".DOPT","Use CALC")
\ No newline at end of file
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment